Patch set updated for coreboot: 63f00be util: add rmodtool for parsing ELF files to rmdoules
by Aaron Durbin 19 Mar '14
by Aaron Durbin 19 Mar '14
19 Mar '14
Aaron Durbin (adurbin(a)google.com) just uploaded a new patch set to gerrit, which you can find at http://review.coreboot.org/5378
-gerrit
commit 63f00be369380d5993b01bc653fbe4a3729b088c
Author: Aaron Durbin <adurbin(a)chromium.org>
Date: Fri Mar 7 15:11:53 2014 -0600
util: add rmodtool for parsing ELF files to rmdoules
The current implementation of creating rmodules relies
on invoking the linker in a certain manner with the
relocations overlaid on the bss section. It's not really
surprising that the linker doesn't always behave the way
one wants depending on the linker used and the archticture.
Instead, introduce rmodtool which takes an elf file as an
input, parses it, and creates a new elf file in the format
the rmodule loader expects.
Change-Id: I31ac2d327d450ef841c3a7d9740b787278382bef
Signed-off-by: Aaron Durbin <adurbin(a)chromium.org>
---
.gitignore | 1 +
util/cbfstool/Makefile | 30 ++-
util/cbfstool/Makefile.inc | 22 +-
util/cbfstool/rmodtool.c | 106 ++++++++
util/cbfstool/rmodule.c | 628 +++++++++++++++++++++++++++++++++++++++++++++
util/cbfstool/rmodule.h | 30 +++
6 files changed, 801 insertions(+), 16 deletions(-)
diff --git a/.gitignore b/.gitignore
index 96af4a6..b37c195 100644
--- a/.gitignore
+++ b/.gitignore
@@ -59,6 +59,7 @@ util/*/.dependencies
util/*/.test
util/board_status/board-status
util/cbfstool/cbfstool
+util/cbfstool/rmodtool
util/cbmem/.dependencies
util/cbmem/cbmem
util/dumpmmcr/dumpmmcr
diff --git a/util/cbfstool/Makefile b/util/cbfstool/Makefile
index bc49c64..e647c88 100644
--- a/util/cbfstool/Makefile
+++ b/util/cbfstool/Makefile
@@ -8,30 +8,40 @@ CFLAGS += -Wstrict-aliasing -Werror
CFLAGS += -Wshadow
LDFLAGS += -g
-BINARY:=$(obj)/cbfstool
+CBFSTOOL_BINARY:=$(obj)/cbfstool
-COMMON:=cbfstool.o common.o cbfs_image.o compress.o fit.o
-COMMON+=elfheaders.o cbfs-mkstage.o cbfs-mkpayload.o xdr.o
+CBFSTOOL_COMMON:=cbfstool.o common.o cbfs_image.o compress.o fit.o
+CBFSTOOL_COMMON+=elfheaders.o cbfs-mkstage.o cbfs-mkpayload.o xdr.o
# LZMA
-COMMON+=lzma/lzma.o
-COMMON+=lzma/C/LzFind.o lzma/C/LzmaDec.o lzma/C/LzmaEnc.o
+CBFSTOOL_COMMON+=lzma/lzma.o
+CBFSTOOL_COMMON+=lzma/C/LzFind.o lzma/C/LzmaDec.o lzma/C/LzmaEnc.o
-COMMON+=linux_trampoline.o cbfs-payload-linux.o
+CBFSTOOL_COMMON+=linux_trampoline.o cbfs-payload-linux.o
-COMMON:=$(addprefix $(obj)/,$(COMMON))
+CBFSTOOL_COMMON:=$(addprefix $(obj)/,$(CBFSTOOL_COMMON))
-all: dep $(BINARY)
+
+RMODTOOL_BINARY:=$(obj)/rmodtool
+RMODTOOL_COMMON:=rmodtool.o rmodule.o common.o elfheaders.o xdr.o
+
+RMODTOOL_COMMON:=$(addprefix $(obj)/,$(RMODTOOL_COMMON))
+
+all: dep $(CBFSTOOL_BINARY) $(RMODTOOL_BINARY)
$(obj)/%.o: %.c
$(HOSTCC) $(CFLAGS) -c -o $@ $<
clean:
- rm -f $(COMMON) $(BINARY)
+ rm -f $(CBFSTOOL_COMMON) $(CBFSTOOL_BINARY)
+ rm -f $(RMODTOOL_COMMON) $(RMODTOOL_BINARY)
tags:
ctags *.[ch]
-$(obj)/cbfstool:$(COMMON)
+$(obj)/cbfstool:$(CBFSTOOL_COMMON)
+ $(HOSTCC) $(CFLAGS) -o $@ $^
+
+$(obj)/rmodtool:$(RMODTOOL_COMMON)
$(HOSTCC) $(CFLAGS) -o $@ $^
dep:
diff --git a/util/cbfstool/Makefile.inc b/util/cbfstool/Makefile.inc
index c19b7d9..2923938 100644
--- a/util/cbfstool/Makefile.inc
+++ b/util/cbfstool/Makefile.inc
@@ -17,10 +17,16 @@ cbfsobj += LzmaEnc.o
cbfsobj += linux_trampoline.o
cbfsobj += cbfs-payload-linux.o
-CBFSTOOLFLAGS= -g
+rmodobj += rmodtool.o
+rmodobj += rmodule.o
+rmodobj += common.o
+rmodobj += elfheaders.o
+rmodobj += xdr.o
+
+TOOLFLAGS= -g
ifeq ($(shell uname -s | cut -c-7 2>/dev/null), MINGW32)
-CBFSTOOLFLAGS+=-mno-ms-bitfields
+TOOLFLAGS+=-mno-ms-bitfields
endif
$(objutil)/cbfstool:
@@ -28,17 +34,21 @@ $(objutil)/cbfstool:
$(objutil)/cbfstool/%.o: $(top)/util/cbfstool/%.c
printf " HOSTCC $(subst $(objutil)/,,$(@))\n"
- $(HOSTCC) $(CBFSTOOLFLAGS) $(HOSTCFLAGS) -c -o $@ $<
+ $(HOSTCC) $(TOOLFLAGS) $(HOSTCFLAGS) -c -o $@ $<
$(objutil)/cbfstool/%.o: $(top)/util/cbfstool/lzma/%.c
printf " HOSTCC $(subst $(objutil)/,,$(@))\n"
- $(HOSTCC) $(CBFSTOOLFLAGS) $(HOSTCFLAGS) -c -o $@ $<
+ $(HOSTCC) $(TOOLFLAGS) $(HOSTCFLAGS) -c -o $@ $<
$(objutil)/cbfstool/%.o: $(top)/util/cbfstool/lzma/C/%.c
printf " HOSTCC $(subst $(objutil)/,,$(@))\n"
- $(HOSTCC) $(CBFSTOOLFLAGS) $(HOSTCFLAGS) -c -o $@ $<
+ $(HOSTCC) $(TOOLFLAGS) $(HOSTCFLAGS) -c -o $@ $<
$(objutil)/cbfstool/cbfstool: $(objutil)/cbfstool $(addprefix $(objutil)/cbfstool/,$(cbfsobj))
printf " HOSTCC $(subst $(objutil)/,,$(@)) (link)\n"
- $(HOSTCC) $(CBFSTOOLFLAGS) -o $@ $(addprefix $(objutil)/cbfstool/,$(cbfsobj))
+ $(HOSTCC) $(TOOLFLAGS) -o $@ $(addprefix $(objutil)/cbfstool/,$(cbfsobj))
+
+$(objutil)/cbfstool/rmodtool: $(objutil)/cbfstool $(addprefix $(objutil)/cbfstool/,$(rmodobj))
+ printf " HOSTCC $(subst $(objutil)/,,$(@)) (link)\n"
+ $(HOSTCC) $(TOOLFLAGS) -o $@ $(addprefix $(objutil)/cbfstool/,$(rmodobj))
diff --git a/util/cbfstool/rmodtool.c b/util/cbfstool/rmodtool.c
new file mode 100644
index 0000000..1455cd9
--- /dev/null
+++ b/util/cbfstool/rmodtool.c
@@ -0,0 +1,106 @@
+/*
+ * cbfstool, CLI utility for creating rmodules
+ *
+ * Copyright (C) 2014 Google, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <getopt.h>
+#include "common.h"
+#include "rmodule.h"
+
+static const char *optstring = "i:o:vh?";
+static struct option long_options[] = {
+ {"inelf", required_argument, 0, 'i' },
+ {"outelf", required_argument, 0, 'o' },
+ {"verbose", no_argument, 0, 'v' },
+ {"help", no_argument, 0, 'h' },
+ {NULL, 0, 0, 0 }
+};
+
+static void usage(char *name)
+{
+ printf(
+ "rmodtool: utility for creating rmodules\n\n"
+ "USAGE: %s [-h] [-v] <-i|--inelf name> <-o|--outelf name>\n",
+ name
+ );
+}
+
+int main(int argc, char *argv[])
+{
+ int c;
+ struct buffer elfin;
+ struct buffer elfout;
+ const char *input_file = NULL;
+ const char *output_file = NULL;
+
+ if (argc < 3) {
+ usage(argv[0]);
+ return 1;
+ }
+
+ while (1) {
+ int optindex = 0;
+
+ c = getopt_long(argc, argv, optstring, long_options, &optindex);
+
+ if (c == -1)
+ break;
+
+ switch (c) {
+ case 'i':
+ input_file = optarg;
+ break;
+ case 'h':
+ usage(argv[0]);
+ return 1;
+ case 'o':
+ output_file = optarg;
+ break;
+ case 'v':
+ verbose++;
+ break;
+ default:
+ break;
+ }
+ }
+
+ if (input_file == NULL || output_file == NULL) {
+ usage(argv[0]);
+ return 1;
+ }
+
+ if (buffer_from_file(&elfin, input_file)) {
+ ERROR("Couldn't read in file '%s'.\n", input_file);
+ return 1;
+ }
+
+ if (rmodule_create(&elfin, &elfout)) {
+ ERROR("Unable to create rmodule from '%s'.\n", input_file);
+ return 1;
+ }
+
+ if (buffer_write_file(&elfout, output_file)) {
+ ERROR("Unable to write rmodule elf '%s'.\n", output_file);
+ return 1;
+ }
+
+ return 0;
+}
diff --git a/util/cbfstool/rmodule.c b/util/cbfstool/rmodule.c
new file mode 100644
index 0000000..a5730f1
--- /dev/null
+++ b/util/cbfstool/rmodule.c
@@ -0,0 +1,628 @@
+/*
+ ;* Copyright (C) 2014 Google, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "elfparsing.h"
+#include "rmodule.h"
+#include "../../src/include/rmodule-defs.h"
+
+struct rmod_context;
+
+struct arch_ops {
+ int arch;
+ /* Determine if relocation is a valid type for the architecture. */
+ int (*valid_type)(struct rmod_context *ctx, Elf64_Rela *rel);
+ /* Determine if relocation should be emitted. */
+ int (*should_emit)(struct rmod_context *ctx, Elf64_Rela *rel);
+};
+
+struct rmod_context {
+ /* Ops to process relocations. */
+ struct arch_ops *ops;
+
+ /* endian conversion ops */
+ struct xdr *xdr;
+
+ /* Parsed ELF sturcture. */
+ struct parsed_elf pelf;
+ /* Program segment. */
+ Elf64_Phdr *phdr;
+
+ /* Collection of relocation addresses fixup in the module. */
+ Elf64_Xword nrelocs;
+ Elf64_Addr *emitted_relocs;
+
+ /* The following fields are addresses within the linked program. */
+ Elf64_Addr link_addr;
+ Elf64_Addr entry;
+ Elf64_Addr parameters_begin;
+ Elf64_Addr parameters_end;
+ Elf64_Addr bss_begin;
+ Elf64_Addr bss_end;
+ Elf64_Xword size;
+};
+
+/*
+ * Architecture specific support operations.
+ */
+static int valid_reloc_386(struct rmod_context *ctx, Elf64_Rela *rel)
+{
+ int type;
+
+ type = ELF64_R_TYPE(rel->r_info);
+
+ /* Only these 2 relocations are expected to be found. */
+ return (type == R_386_32 || type == R_386_PC32);
+}
+
+static int should_emit_386(struct rmod_context *ctx, Elf64_Rela *rel)
+{
+ int type;
+
+ type = ELF64_R_TYPE(rel->r_info);
+
+ /* R_386_32 relocations are absolute. Must emit these. */
+ return (type == R_386_32);
+}
+
+static struct arch_ops reloc_ops[] = {
+ {
+ .arch = EM_386,
+ .valid_type = valid_reloc_386,
+ .should_emit = should_emit_386,
+ },
+};
+
+/*
+ * Relocation processing loops.
+ */
+
+static int for_each_reloc(struct rmod_context *ctx, int do_emit)
+{
+ Elf64_Half i;
+ struct parsed_elf *pelf = &ctx->pelf;
+
+ for (i = 0; i < pelf->ehdr.e_shnum; i++) {
+ Elf64_Shdr *shdr;
+ Elf64_Rela *relocs;
+ Elf64_Xword nrelocs;
+ Elf64_Xword j;
+
+ relocs = pelf->relocs[i];
+
+ /* No relocations in this section. */
+ if (relocs == NULL)
+ continue;
+
+ shdr = &pelf->shdr[i];
+ nrelocs = shdr->sh_size / shdr->sh_entsize;
+
+ for (j = 0; j < nrelocs; j++) {
+ Elf64_Rela *r = &relocs[j];
+
+ if (!ctx->ops->valid_type(ctx, r)) {
+ ERROR("Invalid reloc type: %u\n",
+ (unsigned int)ELF64_R_TYPE(r->r_info));
+ return -1;
+ }
+
+ if (ctx->ops->should_emit(ctx, r)) {
+ int n = ctx->nrelocs;
+ if (do_emit)
+ ctx->emitted_relocs[n] = r->r_offset;
+ ctx->nrelocs++;
+ }
+ }
+ }
+
+ return 0;
+}
+
+static int find_program_segment(struct rmod_context *ctx)
+{
+ int i;
+ int nsegments;
+ struct parsed_elf *pelf;
+ Elf64_Phdr *phdr;
+
+ pelf = &ctx->pelf;
+
+ /* There should only be a single loadable segment. */
+ nsegments = 0;
+ for (i = 0; i < pelf->ehdr.e_phnum; i++) {
+ if (pelf->phdr[i].p_type != PT_LOAD)
+ continue;
+ phdr = &pelf->phdr[i];
+ nsegments++;
+ }
+
+ if (nsegments != 1) {
+ ERROR("Unexepcted number of loadable segments: %d.\n",
+ nsegments);
+ return -1;
+ }
+
+ INFO("Segment at 0x%0llx, file size 0x%0llx, mem size 0x%0llx.\n",
+ (long long)phdr->p_vaddr, (long long)phdr->p_filesz,
+ (long long)phdr->p_memsz);
+
+ ctx->phdr = phdr;
+
+ return 0;
+}
+
+static int
+filter_relocation_sections(struct rmod_context *ctx)
+{
+ int i;
+ const char *shstrtab;
+ struct parsed_elf *pelf;
+ const Elf64_Phdr *phdr;
+
+ pelf = &ctx->pelf;
+ phdr = ctx->phdr;
+ shstrtab = buffer_get(pelf->strtabs[pelf->ehdr.e_shstrndx]);
+
+ /*
+ * Find all relocation sections that contain relocation entries
+ * for sections that fall within the bounds of the segment. For
+ * easier processing the pointer to the relocation array for the
+ * sections that don't fall within the loadable program are NULL'd
+ * out.
+ */
+ for (i = 0; i < pelf->ehdr.e_shnum; i++) {
+ Elf64_Shdr *shdr;
+ Elf64_Word sh_info;
+ const char *section_name;
+
+ shdr = &pelf->shdr[i];
+
+ /* Ignore non-relocation sections. */
+ if (shdr->sh_type != SHT_RELA && shdr->sh_type != SHT_REL)
+ continue;
+
+ /* Obtain section which relocations apply. */
+ sh_info = shdr->sh_info;
+ shdr = &pelf->shdr[sh_info];
+
+ section_name = &shstrtab[shdr->sh_name];
+ DEBUG("Relocation section found for '%s' section.\n",
+ section_name);
+
+ /* Do not process relocations for debug sections. */
+ if (strstr(section_name, ".debug") != NULL) {
+ pelf->relocs[i] = NULL;
+ continue;
+ }
+
+ /*
+ * If relocations apply to a non program section ignore the
+ * relocations for future processing.
+ */
+ if (shdr->sh_type != SHT_PROGBITS) {
+ pelf->relocs[i] = NULL;
+ continue;
+ }
+
+ if (shdr->sh_addr < phdr->p_vaddr ||
+ ((shdr->sh_addr + shdr->sh_size) >
+ (phdr->p_vaddr + phdr->p_memsz))) {
+ ERROR("Relocations being applied to section %d not "
+ "within segment region.\n", sh_info);
+ return -1;
+ }
+ }
+
+ return 0;
+}
+
+static int vaddr_cmp(const void *a, const void *b)
+{
+ const Elf64_Addr *pa = a;
+ const Elf64_Addr *pb = b;
+
+ if (*pa < *pb)
+ return -1;
+ if (*pa > *pb)
+ return 1;
+ return 0;
+}
+
+static int collect_relocations(struct rmod_context *ctx)
+{
+ int nrelocs;
+
+ /*
+ * The relocs array in the pelf should only contain relocations that
+ * apply to the program. Count the number relocations. Then collect
+ * them into the allocated buffer.
+ */
+ if (for_each_reloc(ctx, 0))
+ return -1;
+
+ nrelocs = ctx->nrelocs;
+ INFO("%d relocations to be emitted.\n", nrelocs);
+ if (!nrelocs) {
+ ERROR("No valid relocations in file.\n");
+ return -1;
+ }
+
+ /* Reset the counter for indexing into the array. */
+ ctx->nrelocs = 0;
+ ctx->emitted_relocs = calloc(nrelocs, sizeof(Elf64_Addr));
+ /* Write out the relocations into the emitted_relocs array. */
+ if (for_each_reloc(ctx, 1))
+ return -1;
+
+ if (ctx->nrelocs != nrelocs) {
+ ERROR("Mismatch counted and emitted relocations: %zu vs %zu.\n",
+ (size_t)nrelocs, (size_t)ctx->nrelocs);
+ return -1;
+ }
+
+ /* Sort the relocations by their address. */
+ qsort(ctx->emitted_relocs, nrelocs, sizeof(Elf64_Addr), vaddr_cmp);
+
+ return 0;
+}
+
+static int
+populate_sym(struct rmod_context *ctx, const char *sym_name, Elf64_Addr *addr,
+ int nsyms, const char *strtab)
+{
+ int i;
+ Elf64_Sym *syms;
+
+ syms = ctx->pelf.syms;
+
+ for (i = 0; i < nsyms; i++) {
+ if (syms[i].st_name == 0)
+ continue;
+ if (strcmp(sym_name, &strtab[syms[i].st_name]))
+ continue;
+ DEBUG("%s -> 0x%llx\n", sym_name, (long long)syms[i].st_value);
+ *addr = syms[i].st_value;
+ return 0;
+ }
+ ERROR("symbol '%s' not found.\n", sym_name);
+ return -1;
+}
+
+static int populate_program_info(struct rmod_context *ctx)
+{
+ int i;
+ const char *strtab;
+ struct parsed_elf *pelf;
+ Elf64_Ehdr *ehdr;
+ int nsyms;
+
+ pelf = &ctx->pelf;
+ ehdr = &pelf->ehdr;
+
+ /* Obtain the string table. */
+ strtab = NULL;
+ for (i = 0; i < ehdr->e_shnum; i++) {
+ if (ctx->pelf.strtabs[i] == NULL)
+ continue;
+ /* Don't use the section headers' string table. */
+ if (i == ehdr->e_shstrndx)
+ continue;
+ strtab = buffer_get(ctx->pelf.strtabs[i]);
+ break;
+ }
+
+ if (strtab == NULL) {
+ ERROR("No string table found.\n");
+ return -1;
+ }
+
+ /* Determine number of symbols. */
+ nsyms = 0;
+ for (i = 0; i < ehdr->e_shnum; i++) {
+ if (pelf->shdr[i].sh_type != SHT_SYMTAB)
+ continue;
+
+ nsyms = pelf->shdr[i].sh_size / pelf->shdr[i].sh_entsize;
+ break;
+ }
+
+ if (populate_sym(ctx, "_module_params_begin", &ctx->parameters_begin,
+ nsyms, strtab))
+ return -1;
+
+ if (populate_sym(ctx, "_module_params_end", &ctx->parameters_end,
+ nsyms, strtab))
+ return -1;
+
+ if (populate_sym(ctx, "_bss", &ctx->bss_begin, nsyms, strtab))
+ return -1;
+
+ if (populate_sym(ctx, "_ebss", &ctx->bss_end, nsyms, strtab))
+ return -1;
+
+ if (populate_sym(ctx, "__rmodule_entry", &ctx->entry, nsyms, strtab))
+ return -1;
+
+ /* Link address is the virtual address of the program segment. */
+ ctx->link_addr = ctx->phdr->p_vaddr;
+
+ /* The program size is the memsz of the program segment. */
+ ctx->size = ctx->phdr->p_memsz;
+
+ return 0;
+}
+
+static int
+add_section(struct elf_writer *ew, struct buffer *data, const char *name,
+ Elf64_Addr addr, Elf64_Word size)
+{
+ Elf64_Shdr shdr;
+ int ret;
+
+ memset(&shdr, 0, sizeof(shdr));
+ if (data != NULL) {
+ shdr.sh_type = SHT_PROGBITS;
+ shdr.sh_flags = SHF_ALLOC | SHF_WRITE | SHF_EXECINSTR;
+ } else {
+ shdr.sh_type = SHT_NOBITS;
+ shdr.sh_flags = SHF_ALLOC;
+ }
+ shdr.sh_addr = addr;
+ shdr.sh_offset = addr;
+ shdr.sh_size = size;
+
+ ret = elf_writer_add_section(ew, &shdr, data, name);
+
+ if (ret)
+ ERROR("Could not add '%s' section.\n", name);
+
+ return ret;
+}
+
+static int
+write_elf(const struct rmod_context *ctx, const struct buffer *in,
+ struct buffer *out)
+{
+ int i;
+ int ret;
+ int bit64;
+ size_t loc;
+ size_t rmod_data_size;
+ struct elf_writer *ew;
+ struct buffer rmod_data;
+ struct buffer rmod_header;
+ struct buffer program;
+ struct buffer relocs;
+ Elf64_Xword total_size;
+ Elf64_Addr addr;
+ Elf64_Ehdr ehdr;
+
+ bit64 = ctx->pelf.ehdr.e_ident[EI_CLASS] == ELFCLASS64;
+
+ /*
+ * 3 sections will be added to the ELF file.
+ * +------------------+
+ * | rmodule header |
+ * +------------------+
+ * | program |
+ * +------------------+
+ * | relocations |
+ * +------------------+
+ */
+
+ /* Create buffer for header and relocations. */
+ rmod_data_size = sizeof(struct rmodule_header);
+ if (bit64)
+ rmod_data_size += ctx->nrelocs * sizeof(Elf64_Addr);
+ else
+ rmod_data_size += ctx->nrelocs * sizeof(Elf32_Addr);
+
+ if (buffer_create(&rmod_data, rmod_data_size, "rmod"))
+ return -1;
+
+ buffer_splice(&rmod_header, &rmod_data,
+ 0, sizeof(struct rmodule_header));
+ buffer_clone(&relocs, &rmod_data);
+ buffer_seek(&relocs, sizeof(struct rmodule_header));
+
+ /* Reset current location. */
+ buffer_set_size(&rmod_header, 0);
+ buffer_set_size(&relocs, 0);
+
+ /* Program contents. */
+ buffer_splice(&program, in, ctx->phdr->p_offset, ctx->phdr->p_filesz);
+
+ /* Create ELF writer with modified entry point. */
+ memcpy(&ehdr, &ctx->pelf.ehdr, sizeof(ehdr));
+ ehdr.e_entry = ctx->entry;
+ ew = elf_writer_init(&ehdr);
+
+ if (ew == NULL) {
+ ERROR("Failed to create ELF writer.\n");
+ buffer_delete(&rmod_data);
+ return -1;
+ }
+
+ /* Write out rmodule_header. */
+ ctx->xdr->put16(&rmod_header, RMODULE_MAGIC);
+ ctx->xdr->put8(&rmod_header, RMODULE_VERSION_1);
+ ctx->xdr->put8(&rmod_header, 0);
+ /* payload_begin_offset */
+ loc = sizeof(struct rmodule_header);
+ ctx->xdr->put32(&rmod_header, loc);
+ /* payload_end_offset */
+ loc += ctx->phdr->p_filesz;
+ ctx->xdr->put32(&rmod_header, loc);
+ /* relocations_begin_offset */
+ ctx->xdr->put32(&rmod_header, loc);
+ /* relocations_end_offset */
+ if (bit64)
+ loc += ctx->nrelocs * sizeof(Elf64_Addr);
+ else
+ loc += ctx->nrelocs * sizeof(Elf32_Addr);
+ ctx->xdr->put32(&rmod_header, loc);
+ /* module_link_start_address */
+ ctx->xdr->put32(&rmod_header, ctx->link_addr);
+ /* module_program_size */
+ ctx->xdr->put32(&rmod_header, ctx->size);
+ /* module_entry_point */
+ ctx->xdr->put32(&rmod_header, ctx->entry);
+ /* parameters_begin */
+ ctx->xdr->put32(&rmod_header, ctx->parameters_begin);
+ /* parameters_end */
+ ctx->xdr->put32(&rmod_header, ctx->parameters_end);
+ /* bss_begin */
+ ctx->xdr->put32(&rmod_header, ctx->bss_begin);
+ /* bss_end */
+ ctx->xdr->put32(&rmod_header, ctx->bss_end);
+ /* padding[4] */
+ ctx->xdr->put32(&rmod_header, 0);
+ ctx->xdr->put32(&rmod_header, 0);
+ ctx->xdr->put32(&rmod_header, 0);
+ ctx->xdr->put32(&rmod_header, 0);
+
+ /* Write the relocations. */
+ for (i = 0; i < ctx->nrelocs; i++) {
+ if (bit64)
+ ctx->xdr->put64(&relocs, ctx->emitted_relocs[i]);
+ else
+ ctx->xdr->put32(&relocs, ctx->emitted_relocs[i]);
+ }
+
+ total_size = 0;
+ addr = 0;
+
+ /*
+ * There are 2 cases to deal with. The program has a large NOBITS
+ * section and the relocations can fit entirely within occupied memory
+ * region for the program. The other is that the relocations increase
+ * the memory footprint of the program if it was loaded directly into
+ * the region it would run. The rmdoule header is a fixed cost that
+ * is considered a part of the program.
+ */
+ total_size += buffer_size(&rmod_header);
+ total_size += ctx->phdr->p_memsz;
+ if (buffer_size(&relocs) + ctx->phdr->p_filesz > total_size) {
+ total_size -= ctx->phdr->p_memsz;
+ total_size += buffer_size(&relocs);
+ total_size += ctx->phdr->p_filesz;
+ }
+
+ ret = add_section(ew, &rmod_header, ".header", addr,
+ buffer_size(&rmod_header));
+ if (ret < 0)
+ goto out;
+ addr += buffer_size(&rmod_header);
+
+ ret = add_section(ew, &program, ".program", addr, ctx->phdr->p_filesz);
+ if (ret < 0)
+ goto out;
+ addr += ctx->phdr->p_filesz;
+
+ ret = add_section(ew, &relocs, ".relocs", addr, buffer_size(&relocs));
+ if (ret < 0)
+ goto out;
+ addr += buffer_size(&relocs);
+
+ if (total_size != addr) {
+ ret = add_section(ew, NULL, ".empty", addr, total_size - addr);
+ if (ret < 0)
+ goto out;
+ }
+
+ /*
+ * Ensure last section has a memory usage that meets the required
+ * total size of the program in memory.
+ */
+
+ ret = elf_writer_serialize(ew, out);
+ if (ret < 0)
+ ERROR("Failed to serialize ELF to buffer.\n");
+
+out:
+ buffer_delete(&rmod_data);
+ elf_writer_destroy(ew);
+
+ return ret;
+}
+
+int rmodule_create(const struct buffer *elfin, struct buffer *elfout)
+{
+ struct rmod_context ctx;
+ struct parsed_elf *pelf;
+ int i;
+ int ret;
+
+ ret = -1;
+ memset(&ctx, 0, sizeof(ctx));
+ pelf = &ctx.pelf;
+
+ if (parse_elf(elfin, pelf, ELF_PARSE_ALL)) {
+ ERROR("Couldn't parse ELF!\n");
+ return -1;
+ }
+
+ /* Only allow executables to be turned into rmodules. */
+ if (pelf->ehdr.e_type != ET_EXEC) {
+ ERROR("ELF is not an executable: %u.\n", pelf->ehdr.e_type);
+ goto out;
+ }
+
+ /* Determine if architecture is supported. */
+ for (i = 0; i < ARRAY_SIZE(reloc_ops); i++) {
+ if (reloc_ops[i].arch == pelf->ehdr.e_machine) {
+ ctx.ops = &reloc_ops[i];
+ break;
+ }
+ }
+
+ if (ctx.ops == NULL) {
+ ERROR("ELF is unsupported arch: %u.\n", pelf->ehdr.e_machine);
+ goto out;
+ }
+
+ /* Set the endian ops. */
+ if (ctx.pelf.ehdr.e_ident[EI_DATA] == ELFDATA2MSB)
+ ctx.xdr = &xdr_be;
+ else
+ ctx.xdr = &xdr_le;
+
+ if (find_program_segment(&ctx))
+ goto out;
+
+ if (filter_relocation_sections(&ctx))
+ goto out;
+
+ if (collect_relocations(&ctx))
+ goto out;
+
+ if (populate_program_info(&ctx))
+ goto out;
+
+ if (write_elf(&ctx, elfin, elfout))
+ goto out;
+
+ ret = 0;
+
+out:
+ free(ctx.emitted_relocs);
+ parsed_elf_destroy(pelf);
+ return ret;
+}
diff --git a/util/cbfstool/rmodule.h b/util/cbfstool/rmodule.h
new file mode 100644
index 0000000..94f8f3d
--- /dev/null
+++ b/util/cbfstool/rmodule.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2014 Google, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ */
+
+#ifndef TOOL_RMODULE_H
+#define TOOL_RMODULE_H
+
+#include "elf.h"
+#include "common.h"
+
+/*
+ * Parse an ELF file within the elfin buffer and fill in the elfout buffer
+ * with a created rmodule in ELF format. Return 0 on success, < 0 on error.
+ */
+int rmodule_create(const struct buffer *elfin, struct buffer *elfout);
+
+#endif /* TOOL_RMODULE_H */
1
0
Patch set updated for coreboot: 2be0da9 rmodules: use rmodtool to create rmdoules
by Aaron Durbin 19 Mar '14
by Aaron Durbin 19 Mar '14
19 Mar '14
Aaron Durbin (adurbin(a)google.com) just uploaded a new patch set to gerrit, which you can find at http://review.coreboot.org/5379
-gerrit
commit 2be0da9ca7b4be8559ab8e46630a3d7824f8fe2e
Author: Aaron Durbin <adurbin(a)chromium.org>
Date: Mon Mar 10 16:13:58 2014 -0500
rmodules: use rmodtool to create rmdoules
Start using the rmodtool for generating rmodules.
rmodule_link() has been changed to create 2 rules:
one for the passed in <name>, the other for creating
<name>.rmod which is an ELF file in the format of
an rmodule.
Since the header is not compiled and linked together
with an rmodule there needs to be a way of marking
which symbol is the entry point. __rmodule_entry is
the symbol used for knowing the entry point. There
was a little churn in SMM modules to ensure an
rmodule entry point symbol takes a single argument.
Change-Id: Ie452ed866f6596bf13f137f5b832faa39f48d26e
Signed-off-by: Aaron Durbin <adurbin(a)chromium.org>
---
Makefile.inc | 6 +-
src/arch/x86/Makefile.inc | 8 ++-
src/arch/x86/boot/Makefile.inc | 1 -
src/arch/x86/boot/ramstage_module_header.c | 24 -------
src/arch/x86/lib/c_start.S | 2 +
src/cpu/intel/haswell/Makefile.inc | 6 +-
src/cpu/intel/haswell/sipi_header.c | 6 --
src/cpu/intel/haswell/sipi_vector.S | 2 +
src/cpu/intel/haswell/smmrelocate.c | 13 +++-
src/cpu/x86/Makefile.inc | 6 +-
src/cpu/x86/sipi_header.c | 6 --
src/cpu/x86/sipi_vector.S | 2 +
src/cpu/x86/smm/Makefile.inc | 6 +-
src/cpu/x86/smm/smm_module_handler.c | 13 +++-
src/cpu/x86/smm/smm_module_header.c | 24 -------
src/cpu/x86/smm/smm_stub.S | 6 +-
src/include/cpu/x86/smm.h | 12 +++-
src/include/rmodule-defs.h | 24 -------
src/include/rmodule.h | 25 +++-----
src/lib/Makefile.inc | 12 ++--
src/lib/rmodule.c | 86 +++++---------------------
src/lib/rmodule.ld | 66 +++-----------------
src/soc/intel/baytrail/cpu.c | 10 ++-
src/vendorcode/google/chromeos/Makefile.inc | 1 +
src/vendorcode/google/chromeos/vboot_wrapper.c | 9 ++-
25 files changed, 115 insertions(+), 261 deletions(-)
diff --git a/Makefile.inc b/Makefile.inc
index 19ba294..fcd680d 100644
--- a/Makefile.inc
+++ b/Makefile.inc
@@ -252,10 +252,14 @@ build-dirs:
#######################################################################
# Build the tools
CBFSTOOL:=$(obj)/cbfstool
+RMODTOOL:=$(obj)/rmodtool
$(CBFSTOOL): $(objutil)/cbfstool/cbfstool
cp $< $@
+$(RMODTOOL): $(objutil)/cbfstool/rmodtool
+ cp $< $@
+
_WINCHECK=$(shell uname -o 2> /dev/null)
STACK=
ifeq ($(_WINCHECK),Msys)
@@ -390,5 +394,5 @@ crosstools-arm: clean-for-update
crossgcc-clean: clean-for-update
$(MAKE) -C util/crossgcc clean
-tools: $(objutil)/kconfig/conf $(objutil)/cbfstool/cbfstool $(objutil)/nvramtool/nvramtool $(objutil)/romcc/romcc $(objutil)/sconfig/sconfig
+tools: $(objutil)/kconfig/conf $(objutil)/cbfstool/cbfstool $(objutil)/cbfstool/rmodtool $(objutil)/nvramtool/nvramtool $(objutil)/romcc/romcc $(objutil)/sconfig/sconfig
diff --git a/src/arch/x86/Makefile.inc b/src/arch/x86/Makefile.inc
index 4b28697..72bea1e 100644
--- a/src/arch/x86/Makefile.inc
+++ b/src/arch/x86/Makefile.inc
@@ -93,7 +93,7 @@ ifneq ($(strip $(call strip_quotes,$(CONFIG_LINUX_INITRD))),)
endif
endif
-$(obj)/coreboot.rom: $(obj)/coreboot.pre $(objcbfs)/coreboot_ram.elf $(CBFSTOOL) $(call strip_quotes,$(COREBOOT_ROM_DEPENDENCIES)) $$(INTERMEDIATE) $$(VBOOT_STUB_ELF)
+$(obj)/coreboot.rom: $(obj)/coreboot.pre $(objcbfs)/coreboot_ram.elf $(CBFSTOOL) $(call strip_quotes,$(COREBOOT_ROM_DEPENDENCIES)) $$(INTERMEDIATE) $$(VBOOT_STUB)
@printf " CBFS $(subst $(obj)/,,$(@))\n"
cp $(obj)/coreboot.pre $@.tmp
$(CBFSTOOL) $@.tmp add-stage -f $(objcbfs)/coreboot_ram.elf -n $(CONFIG_CBFS_PREFIX)/coreboot_ram -c $(CBFS_COMPRESS_FLAG)
@@ -140,7 +140,7 @@ ifeq ($(CONFIG_INCLUDE_CONFIG_FILE),y)
$(CBFSTOOL) $@.tmp add -f $(obj)/config.tmp -n config -t raw; rm -f $(obj)/config.tmp ; fi
endif
ifeq ($(CONFIG_VBOOT_VERIFY_FIRMWARE),y)
- $(CBFSTOOL) $@.tmp add-stage -f $(VBOOT_STUB_ELF) -n $(CONFIG_CBFS_PREFIX)/vboot -c $(CBFS_COMPRESS_FLAG)
+ $(CBFSTOOL) $@.tmp add-stage -f $(VBOOT_STUB) -n $(CONFIG_CBFS_PREFIX)/vboot -c $(CBFS_COMPRESS_FLAG)
endif
ifeq ($(CONFIG_HAVE_REFCODE_BLOB),y)
$(CBFSTOOL) $@.tmp add-stage -f $(CONFIG_REFCODE_BLOB_FILE) -n $(CONFIG_CBFS_PREFIX)/refcode -c $(CBFS_COMPRESS_FLAG)
@@ -205,6 +205,10 @@ ifeq ($(CONFIG_RELOCATABLE_RAMSTAGE),y)
$(eval $(call rmodule_link,$(objcbfs)/coreboot_ram.debug, $(objgenerated)/coreboot_ram.o, $(CONFIG_HEAP_SIZE)))
+# The rmodule_link defintion creates an elf file with .rmod extension.
+$(objcbfs)/coreboot_ram.elf: $(objcbfs)/coreboot_ram.debug.rmod
+ cp $< $@
+
else
$(objcbfs)/coreboot_ram.debug: $(objgenerated)/coreboot_ram.o $(src)/arch/x86/coreboot_ram.ld
diff --git a/src/arch/x86/boot/Makefile.inc b/src/arch/x86/boot/Makefile.inc
index 629c644..79c6417 100644
--- a/src/arch/x86/boot/Makefile.inc
+++ b/src/arch/x86/boot/Makefile.inc
@@ -11,7 +11,6 @@ ramstage-$(CONFIG_GENERATE_ACPI_TABLES) += acpi.c
ramstage-$(CONFIG_GENERATE_SMBIOS_TABLES) += smbios.c
ramstage-$(CONFIG_GENERATE_ACPI_TABLES) += acpigen.c
ramstage-$(CONFIG_HAVE_ACPI_RESUME) += wakeup.S
-ramstage-$(CONFIG_RELOCATABLE_RAMSTAGE) += ramstage_module_header.c
$(obj)/arch/x86/boot/smbios.ramstage.o: $(obj)/build.h
diff --git a/src/arch/x86/boot/ramstage_module_header.c b/src/arch/x86/boot/ramstage_module_header.c
deleted file mode 100644
index b958c16..0000000
--- a/src/arch/x86/boot/ramstage_module_header.c
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
- * This file is part of the coreboot project.
- *
- * Copyright (C) 2013 ChromeOS Authors
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#include <rmodule.h>
-
-extern char _start[];
-
-DEFINE_RMODULE_HEADER(ramstage_module, _start, RMODULE_TYPE_STAGE);
diff --git a/src/arch/x86/lib/c_start.S b/src/arch/x86/lib/c_start.S
index 01ffa7c..faea22d 100644
--- a/src/arch/x86/lib/c_start.S
+++ b/src/arch/x86/lib/c_start.S
@@ -19,6 +19,8 @@ thread_stacks:
.section ".textfirst", "ax", @progbits
.code32
.globl _start
+ .globl __rmodule_entry
+__rmodule_entry:
_start:
cli
lgdt %cs:gdtaddr
diff --git a/src/cpu/intel/haswell/Makefile.inc b/src/cpu/intel/haswell/Makefile.inc
index 60c061d..63c1939 100644
--- a/src/cpu/intel/haswell/Makefile.inc
+++ b/src/cpu/intel/haswell/Makefile.inc
@@ -25,12 +25,12 @@ ramstage-srcs += $(SIPI_BIN)
rmodules-y += sipi_vector.S
rmodules-y += sipi_header.c
-$(SIPI_DOTO): $(dir $(SIPI_ELF))sipi_vector.rmodules.o $(dir $(SIPI_ELF))sipi_header.rmodules.o
+$(SIPI_DOTO): $(dir $(SIPI_ELF))sipi_vector.rmodules.o
$(CC) $(LDFLAGS) -nostdlib -r -o $@ $^
-$(eval $(call rmodule_link,$(SIPI_ELF), $(SIPI_ELF:.elf=.o), 0))
+$(eval $(call rmodule_link,$(SIPI_ELF), $(SIPI_DOTO), 0))
-$(SIPI_BIN): $(SIPI_ELF)
+$(SIPI_BIN): $(SIPI_ELF).rmod
$(OBJCOPY) -O binary $< $@
$(SIPI_BIN).ramstage.o: $(SIPI_BIN)
diff --git a/src/cpu/intel/haswell/sipi_header.c b/src/cpu/intel/haswell/sipi_header.c
deleted file mode 100644
index 846a82d..0000000
--- a/src/cpu/intel/haswell/sipi_header.c
+++ /dev/null
@@ -1,6 +0,0 @@
-#include <rmodule.h>
-
-
-extern void *ap_start;
-
-DEFINE_RMODULE_HEADER(sipi_vector_header, ap_start, RMODULE_TYPE_SIPI_VECTOR);
diff --git a/src/cpu/intel/haswell/sipi_vector.S b/src/cpu/intel/haswell/sipi_vector.S
index 664a9ee..e0abb7c 100644
--- a/src/cpu/intel/haswell/sipi_vector.S
+++ b/src/cpu/intel/haswell/sipi_vector.S
@@ -58,6 +58,8 @@ apic_to_cpu_num:
.text
.code16
.global ap_start
+.global __rmodule_entry
+__rmodule_entry:
ap_start:
cli
xorl %eax, %eax
diff --git a/src/cpu/intel/haswell/smmrelocate.c b/src/cpu/intel/haswell/smmrelocate.c
index 3f4f45a..dfbcf2e 100644
--- a/src/cpu/intel/haswell/smmrelocate.c
+++ b/src/cpu/intel/haswell/smmrelocate.c
@@ -164,11 +164,18 @@ static int bsp_setup_msr_save_state(struct smm_relocation_params *relo_params)
/* The relocation work is actually performed in SMM context, but the code
* resides in the ramstage module. This occurs by trampolining from the default
* SMRAM entry point to here. */
-static void asmlinkage
-cpu_smm_do_relocation(void *arg, int cpu, const struct smm_runtime *runtime)
+static void asmlinkage cpu_smm_do_relocation(void *arg)
{
msr_t mtrr_cap;
- struct smm_relocation_params *relo_params = arg;
+ struct smm_relocation_params *relo_params;
+ const struct smm_module_params *p;
+ const struct smm_runtime *runtime;
+ int cpu;
+
+ p = arg;
+ runtime = p->runtime;
+ relo_params = p->arg;
+ cpu = p->cpu;
if (cpu >= CONFIG_MAX_CPUS) {
printk(BIOS_CRIT,
diff --git a/src/cpu/x86/Makefile.inc b/src/cpu/x86/Makefile.inc
index 277ba48..c0b50c5 100644
--- a/src/cpu/x86/Makefile.inc
+++ b/src/cpu/x86/Makefile.inc
@@ -6,6 +6,7 @@ ramstage-$(CONFIG_PARALLEL_MP) += mp_init.c
ramstage-$(CONFIG_MIRROR_PAYLOAD_TO_RAM_BEFORE_LOADING) += mirror_payload.c
SIPI_ELF=$(obj)/cpu/x86/sipi_vector.elf
+SIPI_RMOD=$(SIPI_ELF).rmod
SIPI_BIN=$(SIPI_ELF:.elf=)
SIPI_DOTO=$(SIPI_ELF:.elf=.o)
@@ -13,14 +14,13 @@ ifeq ($(CONFIG_PARALLEL_MP),y)
ramstage-srcs += $(SIPI_BIN)
endif
rmodules-$(CONFIG_PARALLEL_MP) += sipi_vector.S
-rmodules-$(CONFIG_PARALLEL_MP) += sipi_header.c
-$(SIPI_DOTO): $(dir $(SIPI_ELF))sipi_vector.rmodules.o $(dir $(SIPI_ELF))sipi_header.rmodules.o
+$(SIPI_DOTO): $(dir $(SIPI_ELF))sipi_vector.rmodules.o
$(CC) $(LDFLAGS) -nostdlib -r -o $@ $^
$(eval $(call rmodule_link,$(SIPI_ELF), $(SIPI_ELF:.elf=.o), 0))
-$(SIPI_BIN): $(SIPI_ELF)
+$(SIPI_BIN): $(SIPI_RMOD)
$(OBJCOPY) -O binary $< $@
$(SIPI_BIN).ramstage.o: $(SIPI_BIN)
diff --git a/src/cpu/x86/sipi_header.c b/src/cpu/x86/sipi_header.c
deleted file mode 100644
index 846a82d..0000000
--- a/src/cpu/x86/sipi_header.c
+++ /dev/null
@@ -1,6 +0,0 @@
-#include <rmodule.h>
-
-
-extern void *ap_start;
-
-DEFINE_RMODULE_HEADER(sipi_vector_header, ap_start, RMODULE_TYPE_SIPI_VECTOR);
diff --git a/src/cpu/x86/sipi_vector.S b/src/cpu/x86/sipi_vector.S
index 52b12d0..c08c391 100644
--- a/src/cpu/x86/sipi_vector.S
+++ b/src/cpu/x86/sipi_vector.S
@@ -58,6 +58,8 @@ ap_count:
.text
.code16
.global ap_start
+.global __rmodule_entry
+__rmodule_entry:
ap_start:
cli
xorl %eax, %eax
diff --git a/src/cpu/x86/smm/Makefile.inc b/src/cpu/x86/smm/Makefile.inc
index 8dcd130..bb9c11d 100644
--- a/src/cpu/x86/smm/Makefile.inc
+++ b/src/cpu/x86/smm/Makefile.inc
@@ -21,10 +21,8 @@ ramstage-$(CONFIG_BACKUP_DEFAULT_SMM_REGION) += backup_default_smm.c
ifeq ($(CONFIG_SMM_MODULES),y)
smmstub-y += smm_stub.S
-smmstub-y += smm_module_header.c
smm-y += smiutil.c
-smm-y += smm_module_header.c
smm-y += smm_module_handler.c
ramstage-y += smm_module_loader.c
@@ -40,7 +38,7 @@ $(obj)/cpu/x86/smm/smmstub.o: $$(smmstub-objs)
# Link the SMM stub module with a 0-byte heap.
$(eval $(call rmodule_link,$(obj)/cpu/x86/smm/smmstub.elf, $(obj)/cpu/x86/smm/smmstub.o, 0))
-$(obj)/cpu/x86/smm/smmstub: $(obj)/cpu/x86/smm/smmstub.elf
+$(obj)/cpu/x86/smm/smmstub: $(obj)/cpu/x86/smm/smmstub.elf.rmod
$(OBJCOPY) -O binary $< $@
$(obj)/cpu/x86/smm/smmstub.ramstage.o: $(obj)/cpu/x86/smm/smmstub
@@ -55,7 +53,7 @@ $(obj)/cpu/x86/smm/smm.o: $$(smm-objs) $(LIBGCC_FILE_NAME)
$(eval $(call rmodule_link,$(obj)/cpu/x86/smm/smm.elf, $(obj)/cpu/x86/smm/smm.o, $(CONFIG_SMM_MODULE_HEAP_SIZE)))
-$(obj)/cpu/x86/smm/smm: $(obj)/cpu/x86/smm/smm.elf
+$(obj)/cpu/x86/smm/smm: $(obj)/cpu/x86/smm/smm.elf.rmod
$(OBJCOPY) -O binary $< $@
$(obj)/cpu/x86/smm/smm.ramstage.o: $(obj)/cpu/x86/smm/smm
diff --git a/src/cpu/x86/smm/smm_module_handler.c b/src/cpu/x86/smm/smm_module_handler.c
index 444e335..79863d8 100644
--- a/src/cpu/x86/smm/smm_module_handler.c
+++ b/src/cpu/x86/smm/smm_module_handler.c
@@ -20,6 +20,7 @@
#include <arch/io.h>
#include <console/console.h>
#include <cpu/x86/smm.h>
+#include <rmodule.h>
typedef enum { SMI_LOCKED, SMI_UNLOCKED } smi_semaphore;
@@ -113,8 +114,16 @@ void *smm_get_save_state(int cpu)
return base;
}
-void smm_handler_start(void *arg, int cpu, const struct smm_runtime *runtime)
+void asmlinkage smm_handler_start(void *arg)
{
+ const struct smm_module_params *p;
+ const struct smm_runtime *runtime;
+ int cpu;
+
+ p = arg;
+ runtime = p->runtime;
+ cpu = p->cpu;
+
/* Make sure to set the global runtime. It's OK to race as the value
* will be the same across CPUs as well as multiple SMIs. */
if (smm_runtime == NULL)
@@ -157,6 +166,8 @@ void smm_handler_start(void *arg, int cpu, const struct smm_runtime *runtime)
smi_set_eos();
}
+RMODULE_ENTRY(smm_handler_start);
+
/* Provide a default implementation for all weak handlers so that relocation
* entries in the modules make sense. Without default implementations the
* weak relocations w/o a symbol have a 0 address which is where the modules
diff --git a/src/cpu/x86/smm/smm_module_header.c b/src/cpu/x86/smm/smm_module_header.c
deleted file mode 100644
index 3ee654f..0000000
--- a/src/cpu/x86/smm/smm_module_header.c
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
- * This file is part of the coreboot project.
- *
- * Copyright (C) 2013 ChromeOS Authors
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#include <rmodule.h>
-
-extern char smm_handler_start[];
-
-DEFINE_RMODULE_HEADER(smm_module, smm_handler_start, RMODULE_TYPE_SMM);
diff --git a/src/cpu/x86/smm/smm_stub.S b/src/cpu/x86/smm/smm_stub.S
index 07eb5dc..083cb57 100644
--- a/src/cpu/x86/smm/smm_stub.S
+++ b/src/cpu/x86/smm/smm_stub.S
@@ -61,6 +61,8 @@ fallback_stack_top:
.text
.code16
.global smm_handler_start
+.global __rmodule_entry
+__rmodule_entry:
smm_handler_start:
movl $(smm_relocate_gdt), %ebx
data32 lgdt (%ebx)
@@ -132,11 +134,13 @@ smm_trampoline32:
2:
/* Call into the c-based SMM relocation function with the platform
* parameters. Equivalent to:
- * c_handler(c_handler_params, cpu_num, smm_runtime);
+ * struct arg = { c_handler_params, cpu_num, smm_runtime {;
+ * c_handler(&arg)
*/
push $(smm_runtime)
push %ecx
push c_handler_arg
+ push %esp
mov c_handler, %eax
call *%eax
diff --git a/src/include/cpu/x86/smm.h b/src/include/cpu/x86/smm.h
index 3ab43ff..f63420f 100644
--- a/src/include/cpu/x86/smm.h
+++ b/src/include/cpu/x86/smm.h
@@ -517,14 +517,20 @@ struct smm_runtime {
u8 apic_id_to_cpu[CONFIG_MAX_CPUS];
} __attribute__ ((packed));
-typedef void asmlinkage (*smm_handler_t)(void *arg, int cpu,
- const struct smm_runtime *runtime);
+struct smm_module_params {
+ void *arg;
+ int cpu;
+ const struct smm_runtime *runtime;
+};
+
+/* smm_handler_t is called with arg of smm_module_params pointer. */
+typedef void asmlinkage (*smm_handler_t)(void *);
#ifdef __SMM__
/* SMM Runtime helpers. */
/* Entry point for SMM modules. */
-void smm_handler_start(void *arg, int cpu, const struct smm_runtime *runtime);
+void asmlinkage smm_handler_start(void *params);
/* Retrieve SMM save state for a given CPU. WARNING: This does not take into
* account CPUs which are configured to not save their state to RAM. */
diff --git a/src/include/rmodule-defs.h b/src/include/rmodule-defs.h
index ee2d3f7..4139ef3 100644
--- a/src/include/rmodule-defs.h
+++ b/src/include/rmodule-defs.h
@@ -25,30 +25,6 @@
#define RMODULE_MAGIC 0xf8fe
#define RMODULE_VERSION_1 1
-#define FIELD_ENTRY(x_) ((uint32_t)&x_)
-#define RMODULE_HEADER(entry_, type_) \
-{ \
- .magic = RMODULE_MAGIC, \
- .version = RMODULE_VERSION_1, \
- .type = type_, \
- .payload_begin_offset = FIELD_ENTRY(_payload_begin_offset), \
- .payload_end_offset = FIELD_ENTRY(_payload_end_offset), \
- .relocations_begin_offset = \
- FIELD_ENTRY(_relocations_begin_offset), \
- .relocations_end_offset = \
- FIELD_ENTRY(_relocations_end_offset), \
- .module_link_start_address = \
- FIELD_ENTRY(_module_link_start_addr), \
- .module_program_size = FIELD_ENTRY(_module_program_size), \
- .module_entry_point = FIELD_ENTRY(entry_), \
- .parameters_begin = FIELD_ENTRY(_module_params_begin), \
- .parameters_end = FIELD_ENTRY(_module_params_end), \
- .bss_begin = FIELD_ENTRY(_bss), \
- .bss_end = FIELD_ENTRY(_ebss), \
-}
-
-/* Private data structures below should not be used directly. */
-
/* All fields with '_offset' in the name are byte offsets into the flat blob.
* The linker and the linker script takes are of assigning the values. */
struct rmodule_header {
diff --git a/src/include/rmodule.h b/src/include/rmodule.h
index 2147ab0..d229cf8 100644
--- a/src/include/rmodule.h
+++ b/src/include/rmodule.h
@@ -21,6 +21,7 @@
#include <stdint.h>
#include <stddef.h>
+#include <string.h>
#include <rmodule-defs.h>
enum {
@@ -50,11 +51,6 @@ int rmodule_load_alignment(const struct rmodule *m);
int rmodule_calc_region(unsigned int region_alignment, size_t rmodule_size,
size_t *region_size, int *load_offset);
-#define DEFINE_RMODULE_HEADER(name_, entry_, type_) \
- struct rmodule_header name_ \
- __attribute__ ((section (".module_header"))) = \
- RMODULE_HEADER(entry_, type_)
-
/* Support for loading rmodule stages. This API is only available when
* using dynamic cbmem because it uses the dynamic cbmem API to obtain
* the backing store region for the stage. */
@@ -84,17 +80,12 @@ struct rmodule {
void *relocations;
};
-/* These are the symbols assumed that every module contains. The linker script
- * provides these symbols. */
-extern char _relocations_begin_offset[];
-extern char _relocations_end_offset[];
-extern char _payload_end_offset[];
-extern char _payload_begin_offset[];
-extern char _bss[];
-extern char _ebss[];
-extern char _module_program_size[];
-extern char _module_link_start_addr[];
-extern char _module_params_begin[];
-extern char _module_params_end[];
+#if IS_ENABLED(CONFIG_RELOCATABLE_MODULES)
+/* Rmodules have an entry point of named __rmodule_entry. */
+#define RMODULE_ENTRY(entry_) \
+ void __rmodule_entry(void *) __attribute__((alias (STRINGIFY(entry_))))
+#else
+#define RMODULE_ENTRY(entry_)
+#endif
#endif /* RMODULE_H */
diff --git a/src/lib/Makefile.inc b/src/lib/Makefile.inc
index acd334e..93babd3 100644
--- a/src/lib/Makefile.inc
+++ b/src/lib/Makefile.inc
@@ -133,17 +133,21 @@ ramstage-y += rmodule.c
romstage-$(CONFIG_RELOCATABLE_RAMSTAGE) += rmodule.c
RMODULE_LDSCRIPT := $(src)/lib/rmodule.ld
-RMODULE_LDFLAGS := -nostartfiles -shared -z defs -nostdlib -Bsymbolic -T $(RMODULE_LDSCRIPT)
+RMODULE_LDFLAGS := -nostartfiles -Wl,--emit-relocs -Wl,-z,defs -Wl,-Bsymbolic -Wl,-T,$(RMODULE_LDSCRIPT)
# rmodule_link_rules is a function that should be called with:
# (1) the object name to link
# (2) the dependencies
# (3) heap size of the relocatable module
-# It will create the necessary Make rules.
+# It will create the necessary Make rules to create a rmodule. The resulting
+# rmdoule is named $(1).rmod
define rmodule_link
-$(strip $(1)): $(strip $(2)) $$(RMODULE_LDSCRIPT) $$(obj)/ldoptions
- $$(LD) $$(RMODULE_LDFLAGS) --defsym=__heap_size=$(strip $(3)) -o $$@ $(strip $(2))
+$(strip $(1)): $(strip $(2)) $$(RMODULE_LDSCRIPT) $$(obj)/ldoptions $$(RMODTOOL)
+ $$(CC) $$(CFLAGS) $$(RMODULE_LDFLAGS) -Wl,--defsym=__heap_size=$(strip $(3)) -o $$@ -Wl,--start-group $(strip $(2)) $$(LIBGCC_FILE_NAME) -Wl,--end-group
$$(NM) -n $$@ > $$(basename $$(a)).map
+
+$(strip $(1)).rmod: $(strip $(1))
+ $$(RMODTOOL) -i $$^ -o $$@
endef
endif
diff --git a/src/lib/rmodule.c b/src/lib/rmodule.c
index 2cb70b8..a73e667 100644
--- a/src/lib/rmodule.c
+++ b/src/lib/rmodule.c
@@ -26,44 +26,6 @@
/* Change this define to get more verbose debugging for module loading. */
#define PK_ADJ_LEVEL BIOS_NEVER
-#if CONFIG_ARCH_X86
-/*
- * On X86, the only relocations currently allowed are R_386_RELATIVE which
- * have '0' for the symbol info in the relocation metadata (in r_info).
- * The reason is that the module is fully linked and just has the relocations'
- * locations.
- */
-typedef struct {
- uint32_t r_offset;
- uint32_t r_info;
-} Elf32_Rel;
-
-#define R_386_RELATIVE 8
-
-#define RELOCTION_ENTRY_SIZE sizeof(Elf32_Rel)
-static inline int rmodule_reloc_offset(const void *reloc)
-{
- const Elf32_Rel *rel = reloc;
- return rel->r_offset;
-}
-
-static inline int rmodule_reloc_valid(const void *reloc)
-{
- const Elf32_Rel *rel = reloc;
- return (rel->r_info == R_386_RELATIVE);
-}
-
-static inline void *remodule_next_reloc(const void *reloc)
-{
- const Elf32_Rel *rel = reloc;
- rel++;
- return (void *)rel;
-}
-
-#else
-#error Arch needs to add relocation information support for RMODULE
-#endif
-
static inline int rmodule_is_loaded(const struct rmodule *module)
{
return module->location != NULL;
@@ -71,7 +33,7 @@ static inline int rmodule_is_loaded(const struct rmodule *module)
/* Calculate a loaded program address based on the blob address. */
static inline void *rmodule_load_addr(const struct rmodule *module,
- uint32_t blob_addr)
+ uintptr_t blob_addr)
{
char *loc = module->location;
return &loc[blob_addr - module->header->module_link_start_address];
@@ -151,13 +113,13 @@ static void rmodule_clear_bss(struct rmodule *module)
memset(begin, 0, size);
}
-static inline int rmodule_number_relocations(const struct rmodule *module)
+static inline size_t rmodule_number_relocations(const struct rmodule *module)
{
- int r;
+ size_t r;
r = module->header->relocations_end_offset;
r -= module->header->relocations_begin_offset;
- r /= RELOCTION_ENTRY_SIZE;
+ r /= sizeof(uintptr_t);
return r;
}
@@ -176,51 +138,33 @@ static void rmodule_copy_payload(const struct rmodule *module)
memcpy(module->location, module->payload, module->payload_size);
}
-static inline uint32_t *rmodule_adjustment_location(const struct rmodule *module,
- const void *reloc)
-{
- int reloc_offset;
-
- /* Don't relocate header field entries -- only program relocations. */
- reloc_offset = rmodule_reloc_offset(reloc);
- if (reloc_offset < module->header->module_link_start_address)
- return NULL;
-
- return rmodule_load_addr(module, reloc_offset);
-}
-
static int rmodule_relocate(const struct rmodule *module)
{
- int num_relocations;
- const void *reloc;
- uint32_t adjustment;
+ size_t num_relocations;
+ const uintptr_t *reloc;
+ uintptr_t adjustment;
/* Each relocation needs to be adjusted relative to the beginning of
* the loaded program. */
- adjustment = (uint32_t)rmodule_load_addr(module, 0);
+ adjustment = (uintptr_t)rmodule_load_addr(module, 0);
reloc = module->relocations;
num_relocations = rmodule_number_relocations(module);
- printk(BIOS_DEBUG, "Processing %d relocs with adjust value of 0x%08x\n",
+ printk(BIOS_DEBUG, "Processing %zu relocs. Offset value of 0x%08x\n",
num_relocations, adjustment);
while (num_relocations > 0) {
- uint32_t *adjust_loc;
-
- if (!rmodule_reloc_valid(reloc))
- return -1;
+ uintptr_t *adjust_loc;
/* If the adjustment location is non-NULL adjust it. */
- adjust_loc = rmodule_adjustment_location(module, reloc);
- if (adjust_loc != NULL) {
- printk(PK_ADJ_LEVEL, "Adjusting %p: 0x%08x -> 0x%08x\n",
+ adjust_loc = rmodule_load_addr(module, *reloc);
+ printk(PK_ADJ_LEVEL, "Adjusting %p: 0x%08x -> 0x%08x\n",
adjust_loc, *adjust_loc,
*adjust_loc + adjustment);
*adjust_loc += adjustment;
- }
- reloc = remodule_next_reloc(reloc);
+ reloc++;
num_relocations--;
}
@@ -232,8 +176,8 @@ int rmodule_load_alignment(const struct rmodule *module)
/* The load alignment is the start of the program's linked address.
* The base address where the program is loaded needs to be a multiple
* of the program's starting link address. That way all data alignment
- * in the program is preserved. */
- return module->header->module_link_start_address;
+ * in the program is preserved. Default to 4KiB. */
+ return 4096;
}
int rmodule_load(void *base, struct rmodule *module)
diff --git a/src/lib/rmodule.ld b/src/lib/rmodule.ld
index 0cdbb2f..9222f3b 100644
--- a/src/lib/rmodule.ld
+++ b/src/lib/rmodule.ld
@@ -1,19 +1,15 @@
-OUTPUT_FORMAT("elf32-i386", "elf32-i386", "elf32-i386")
-OUTPUT_ARCH(i386)
-
/*
* This linker script is used to link rmodules (relocatable modules). It
* links at zero so that relocation fixups are easy when placing the binaries
* anywhere in the address space.
*
* NOTE: The program's loadable sections (text, module_params, and data) are
- * packed into the flat blob using the AT directive. The rmodule loader assumes
- * the entire program resides in one contiguous address space. Therefore,
- * alignment for a given section (if required) needs to be done at the end of
- * the preceeding section. e.g. if the data section should be aligned to an 8
- * byte address the text section should have ALIGN(8) at the end of its section.
- * Otherwise there won't be a consistent mapping between the flat blob and the
- * loaded program.
+ * packed into the flat blob. The rmodule loader assumes the entire program
+ * resides in one contiguous address space. Therefore, alignment for a given
+ * section (if required) needs to be done at the end of the preceeding section.
+ * e.g. if the data section should be aligned to an 8 byte address the text
+ * section should have ALIGN(8) at the end of its section. Otherwise there
+ * won't be a consistent mapping between the flat blob and the loaded program.
*/
BASE_ADDRESS = 0x00000;
@@ -22,21 +18,9 @@ SECTIONS
{
. = BASE_ADDRESS;
- .header : AT (0) {
- *(.module_header);
- . = ALIGN(8);
- }
-
- /* Align the start of the module program to a large enough alignment
- * so that any data in the program with an alignement property is met.
- * Essentially, this alignment is the maximum possible data alignment
- * property a program can have. */
- . = ALIGN(4096);
- _module_link_start_addr = .;
- _payload_begin_offset = LOADADDR(.header) + SIZEOF(.header);
-
- .payload : AT (_payload_begin_offset) {
+ .payload : {
/* C code of the module. */
+ _ram_seg = .;
*(.textfirst);
*(.text);
*(.text.*);
@@ -88,9 +72,6 @@ SECTIONS
. = ALIGN(8);
}
- /* _payload_end marks the end of the module's code and data. */
- _payload_end_offset = LOADADDR(.payload) + SIZEOF(.payload);
-
.bss (NOLOAD) : {
/* C uninitialized data of the module. */
_bss = .;
@@ -107,38 +88,11 @@ SECTIONS
_heap = .;
. = . + __heap_size;
_eheap = .;
+ _eram_seg = .;
}
- /* _module_program_size is the total memory used by the program. */
- _module_program_size = _eheap - _module_link_start_addr;
-
- /* coreboot's ramstage uses the _ram_seg and _eram_seg symbols
- * for determining its load location. Provide those to help it out.
- * It's a nop for any non-ramstage rmodule. */
- _ram_seg = _module_link_start_addr;
- _eram_seg = _module_link_start_addr + _module_program_size;
-
- /* The relocation information is linked on top of the BSS section
- * because the BSS section takes no space on disk. The relocation data
- * resides directly after the data section in the flat binary. */
- .relocations ADDR(.bss) : AT (_payload_end_offset) {
- *(.rel.*);
- }
- _relocations_begin_offset = LOADADDR(.relocations);
- _relocations_end_offset = _relocations_begin_offset +
- SIZEOF(.relocations);
-
/DISCARD/ : {
- /* Drop unnecessary sections. Since these modules are linked
- * as shared objects there are dynamic sections. These sections
- * aren't needed so drop them. */
- *(.comment);
- *(.note);
- *(.note.*);
- *(.dynamic);
- *(.dynsym);
- *(.dynstr);
- *(.gnu.hash);
+ /* Drop unnecessary sections. */
*(.eh_frame);
}
}
diff --git a/src/soc/intel/baytrail/cpu.c b/src/soc/intel/baytrail/cpu.c
index 1226e47..c550531 100644
--- a/src/soc/intel/baytrail/cpu.c
+++ b/src/soc/intel/baytrail/cpu.c
@@ -112,11 +112,17 @@ static void adjust_apic_id_map(struct smm_loader_params *smm_params)
runtime->apic_id_to_cpu[i] = mp_get_apic_id(i);
}
-static void asmlinkage
-cpu_smm_do_relocation(void *arg, int cpu, const struct smm_runtime *runtime)
+static void asmlinkage cpu_smm_do_relocation(void *arg)
{
msr_t smrr;
em64t100_smm_state_save_area_t *smm_state;
+ const struct smm_module_params *p;
+ const struct smm_runtime *runtime;
+ int cpu;
+
+ p = arg;
+ runtime = p->runtime;
+ cpu = p->cpu;
if (cpu >= CONFIG_MAX_CPUS) {
printk(BIOS_CRIT,
diff --git a/src/vendorcode/google/chromeos/Makefile.inc b/src/vendorcode/google/chromeos/Makefile.inc
index 007bd57..21e1750 100644
--- a/src/vendorcode/google/chromeos/Makefile.inc
+++ b/src/vendorcode/google/chromeos/Makefile.inc
@@ -51,6 +51,7 @@ VB_INCLUDES += -I$(VB_SOURCE)/firmware/include
INCLUDES += $(VB_INCLUDES)
VBOOT_STUB_ELF = $(obj)/vendorcode/google/chromeos/vbootstub.elf
+VBOOT_STUB = $(VBOOT_STUB_ELF).rmod
VBOOT_STUB_DOTO = $(VBOOT_STUB_ELF:.elf=.o)
# Dependency for the vboot rmodules. Ordering matters.
diff --git a/src/vendorcode/google/chromeos/vboot_wrapper.c b/src/vendorcode/google/chromeos/vboot_wrapper.c
index 66b7cfb..fe3c022 100644
--- a/src/vendorcode/google/chromeos/vboot_wrapper.c
+++ b/src/vendorcode/google/chromeos/vboot_wrapper.c
@@ -24,10 +24,6 @@
#include "vboot_context.h"
#include "vboot_handoff.h"
-static void vboot_wrapper(struct vboot_context *context);
-
-DEFINE_RMODULE_HEADER(vboot_wrapper_header, vboot_wrapper, RMODULE_TYPE_VBOOT);
-
/* Keep a global context pointer around for the callbacks to use. */
static struct vboot_context *gcontext;
@@ -63,12 +59,14 @@ static void parse_component(const struct components *components, int num,
fw->size = (uint32_t)components->entries[num].size;
}
-static void vboot_wrapper(struct vboot_context *context)
+static void vboot_wrapper(void *arg)
{
int i;
VbError_t res;
const struct components *components;
+ struct vboot_context *context;
+ context = arg;
gcontext = context;
VbExDebug("Calling VbInit()\n");
@@ -266,3 +264,4 @@ VbError_t VbExTpmSendReceive(const uint8_t *request, uint32_t request_length,
return VBERROR_SUCCESS;
}
+RMODULE_ENTRY(vboot_wrapper);
1
0
Aaron Durbin (adurbin(a)google.com) just uploaded a new patch set to gerrit, which you can find at http://review.coreboot.org/5394
-gerrit
commit 6584d88263285c3d9d47c387b0048d1388e9229e
Author: Aaron Durbin <adurbin(a)chromium.org>
Date: Thu Mar 13 08:50:00 2014 -0500
regions support
Needs some cleanup work. Compile tested as of now.
Change-Id: I2a78278090ae928468e197ac73d1fb18596bf8cb
Signed-off-by: Aaron Durbin <adurbin(a)chromium.org>
---
src/Kconfig | 7 +
src/arch/x86/boot/smbios.c | 8 +-
src/arch/x86/lib/rom_media.c | 114 +++---
src/cpu/intel/microcode/microcode.c | 38 +-
src/cpu/x86/mirror_payload.c | 38 +-
src/cpu/x86/smm/smm_module_handler.c | 9 +
src/device/pci_device.c | 7 +-
src/device/pci_rom.c | 232 +++++++-----
src/drivers/elog/elog.c | 142 +++-----
src/include/cbfs.h | 120 +++---
src/include/cbfs_core.h | 44 ---
src/include/device/pci_rom.h | 4 +-
src/include/payload_loader.h | 3 +
src/include/region.h | 146 ++++++++
src/include/rmodule.h | 7 +-
src/lib/Makefile.inc | 10 +
src/lib/bootrw_spi_flash_region.c | 138 +++++++
src/lib/cbfs.c | 501 ++++++++++++++++++--------
src/lib/cbfs_boot_region.c | 133 +++++++
src/lib/cbfs_core.c | 224 ------------
src/lib/loaders/cbfs_payload_loader.c | 18 +-
src/lib/loaders/cbfs_ramstage_loader.c | 12 +-
src/lib/loaders/load_and_run_payload.c | 5 +-
src/lib/region.c | 306 ++++++++++++++++
src/lib/rmodule.c | 46 ++-
src/lib/selfboot.c | 113 +++---
src/soc/intel/baytrail/Kconfig | 1 +
src/soc/intel/baytrail/mrc_cache.c | 20 +-
src/soc/intel/baytrail/nvm.c | 27 +-
src/soc/intel/baytrail/romstage/raminit.c | 9 +-
src/soc/intel/baytrail/romstage/romstage.c | 4 +
src/vendorcode/google/chromeos/Makefile.inc | 1 +
src/vendorcode/google/chromeos/chromeos.c | 4 +
src/vendorcode/google/chromeos/fmap.c | 177 +++++----
src/vendorcode/google/chromeos/fmap.h | 25 +-
src/vendorcode/google/chromeos/vboot_loader.c | 47 ++-
36 files changed, 1801 insertions(+), 939 deletions(-)
diff --git a/src/Kconfig b/src/Kconfig
index 531a8c8..b0b8d26 100644
--- a/src/Kconfig
+++ b/src/Kconfig
@@ -1094,3 +1094,10 @@ config REG_SCRIPT
default n
help
Internal option that controls whether we compile in register scripts.
+
+config BOOT_REGION_SPI_FLASH
+ def_bool n
+ depends on ARCH_X86
+ help
+ Use generic SPI flash boot region support. This will provide a
+ function to initialize the read-write boot region.
diff --git a/src/arch/x86/boot/smbios.c b/src/arch/x86/boot/smbios.c
index 0e84acc..0434715 100644
--- a/src/arch/x86/boot/smbios.c
+++ b/src/arch/x86/boot/smbios.c
@@ -27,7 +27,6 @@
#include <device/device.h>
#include <arch/cpu.h>
#include <cpu/x86/name.h>
-#include <cbfs_core.h>
#include <arch/byteorder.h>
#include <elog.h>
#if CONFIG_CHROMEOS
@@ -147,12 +146,7 @@ static int smbios_write_type0(unsigned long *current, int handle)
#endif
{
- const struct cbfs_header *header;
- u32 romsize = CONFIG_ROM_SIZE;
- header = cbfs_get_header(CBFS_DEFAULT_MEDIA);
- if (header != CBFS_HEADER_INVALID_ADDRESS)
- romsize = ntohl(header->romsize);
- t->bios_rom_size = (romsize / 65535) - 1;
+ t->bios_rom_size = (CONFIG_ROM_SIZE / 65535) - 1;
}
t->system_bios_major_release = 4;
diff --git a/src/arch/x86/lib/rom_media.c b/src/arch/x86/lib/rom_media.c
index ed2122c..aa17d64 100644
--- a/src/arch/x86/lib/rom_media.c
+++ b/src/arch/x86/lib/rom_media.c
@@ -18,84 +18,64 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
* MA 02110-1301 USA
*/
-#include <cbfs.h>
+#include <stdint.h>
#include <string.h>
+#include <console/console.h>
+#include <region.h>
-#ifdef LIBPAYLOAD
-# define printk(x...)
-# define init_default_cbfs_media libpayload_init_default_cbfs_media
- extern int libpayload_init_default_cbfs_media(struct cbfs_media *media);
-#else
-# include <console/console.h>
-#endif
-
-// Implementation of memory-mapped ROM media source on X86.
-
-static int x86_rom_open(struct cbfs_media *media) {
- return 0;
+static inline void *get_pointer(offset_t off)
+{
+ const uintptr_t base_address = (uintptr_t)-CONFIG_ROM_SIZE;
+ return (void *)(base_address + off);
}
-static void *x86_rom_map(struct cbfs_media *media, size_t offset, size_t count) {
- void *ptr;
- // Some address (ex, pointer to master header) may be given in memory
- // mapped location. To workaround that, we handle >0xf0000000 as real
- // memory pointer.
-
- if ((uint32_t)offset > (uint32_t)0xf0000000)
- ptr = (void*)offset;
- else
- ptr = (void*)(0 - (uint32_t)media->context + offset);
- return ptr;
+static void *
+boot_mmap(const struct region_device *rdev, offset_t off, size_t size)
+{
+ return get_pointer(off);
}
-static void *x86_rom_unmap(struct cbfs_media *media, const void *address) {
- return NULL;
+static void boot_munmap(const struct region_device *rdev, void *addr)
+{
}
-static size_t x86_rom_read(struct cbfs_media *media, void *dest, size_t offset,
- size_t count) {
- void *ptr = x86_rom_map(media, offset, count);
- memcpy(dest, ptr, count);
- x86_rom_unmap(media, ptr);
- return count;
+static ssize_t
+boot_readat(const struct region_device *rdev, void *buf,
+ offset_t off, size_t size)
+{
+ memcpy(buf, get_pointer(off), size);
+ return size;
}
-static int x86_rom_close(struct cbfs_media *media) {
- return 0;
-}
+static const struct region_device_ops boot_dev_ops = {
+ .mmap = boot_mmap,
+ .munmap = boot_munmap,
+ .readat = boot_readat,
+};
+
+static const struct region_device boot_dev = {
+ .ops = &boot_dev_ops,
+ .region = {
+ .offset = 0,
+ .size = CONFIG_ROM_SIZE,
+ },
+};
-int init_x86rom_cbfs_media(struct cbfs_media *media);
-int init_x86rom_cbfs_media(struct cbfs_media *media) {
- // On X86, we always keep a reference of pointer to CBFS header in
- // 0xfffffffc, and the pointer is still a memory-mapped address.
- // Since the CBFS core always use ROM offset, we need to figure out
- // header->romsize even before media is initialized.
- struct cbfs_header *header = (struct cbfs_header*)
- *(uint32_t*)(0xfffffffc);
- if (CBFS_HEADER_MAGIC != ntohl(header->magic)) {
-#if defined(CONFIG_ROM_SIZE)
- printk(BIOS_ERR, "Invalid CBFS master header at %p\n", header);
- media->context = (void*)CONFIG_ROM_SIZE;
-#else
- return -1;
-#endif
- } else {
- uint32_t romsize = ntohl(header->romsize);
- media->context = (void*)romsize;
-#if defined(CONFIG_ROM_SIZE)
- if (CONFIG_ROM_SIZE != romsize)
- printk(BIOS_INFO, "Warning: rom size unmatch (%d/%d)\n",
- CONFIG_ROM_SIZE, romsize);
-#endif
+void boot_media_initialize(void)
+{
+ rhandle_t rh;
+ const char *bootro_name = BOOTRO_REGION_NAME;
+
+ rh = region_locate(bootro_name);
+
+ /* Already registered. */
+ if (rhandle_valid(rh)) {
+ printk(BIOS_DEBUG, "Already Registered: '%s'\n", bootro_name);
+ return;
}
- media->open = x86_rom_open;
- media->close = x86_rom_close;
- media->map = x86_rom_map;
- media->unmap = x86_rom_unmap;
- media->read = x86_rom_read;
- return 0;
-}
-int init_default_cbfs_media(struct cbfs_media *media) {
- return init_x86rom_cbfs_media(media);
+ rh = region_register(bootro_name, &boot_dev);
+
+ if (!rhandle_valid(rh))
+ printk(BIOS_ERR, "Failed to register '%s'.\n", bootro_name);
}
diff --git a/src/cpu/intel/microcode/microcode.c b/src/cpu/intel/microcode/microcode.c
index 947dfd7..d6753c1 100644
--- a/src/cpu/intel/microcode/microcode.c
+++ b/src/cpu/intel/microcode/microcode.c
@@ -107,28 +107,48 @@ void intel_microcode_load_unlocked(const void *microcode_patch)
#endif
}
+#if !defined(__ROMCC__)
+static void *microcode_locate(u32 *len)
+{
+ const struct cbfs_file_descriptor *fd;
+ void *buf;
+
+ fd = cbfs_open_by_name(cbfs_default_descriptor(), MICROCODE_CBFS_FILE);
+ if (fd == NULL)
+ return NULL;
+
+ /*
+ * The following sequence relies on x86 having a persistent
+ * memory-mapped view of the SPI rom.
+ */
+ *len = cbfs_file_content_size(fd);
+ buf = cbfs_file_map_content(fd, 0, *len);
+ cbfs_file_close(fd);
+
+ return buf;
+}
+#endif
+
const void *intel_microcode_find(void)
{
- struct cbfs_file *microcode_file;
const struct microcode *ucode_updates;
u32 eax, microcode_len;
u32 pf, rev, sig, update_size;
unsigned int x86_model, x86_family;
msr_t msr;
+#if defined(__ROMCC__)
+ struct cbfs_file *file;
-#ifdef __PRE_RAM__
- microcode_file = walkcbfs_head((char *) MICROCODE_CBFS_FILE);
+ file = walkcbfs_head((char *) MICROCODE_CBFS_FILE);
+ microcode_len = ntohl(file->len);
+ ucode_updates = CBFS_SUBHEADER(file);
#else
- microcode_file = cbfs_get_file(CBFS_DEFAULT_MEDIA,
- MICROCODE_CBFS_FILE);
+ ucode_updates = microcode_locate(µcode_len);
#endif
- if (!microcode_file)
+ if (!ucode_updates)
return NULL;
- ucode_updates = CBFS_SUBHEADER(microcode_file);
- microcode_len = ntohl(microcode_file->len);
-
/* CPUID sets MSR 0x8B iff a microcode update has been loaded. */
msr.lo = 0;
msr.hi = 0;
diff --git a/src/cpu/x86/mirror_payload.c b/src/cpu/x86/mirror_payload.c
index edd2641..a6975e1 100644
--- a/src/cpu/x86/mirror_payload.c
+++ b/src/cpu/x86/mirror_payload.c
@@ -30,26 +30,12 @@ void mirror_payload(struct payload *payload)
size_t size;
char *src;
uintptr_t alignment_diff;
- const unsigned long cacheline_size = 64;
- const uintptr_t intra_cacheline_mask = cacheline_size - 1;
- const uintptr_t cacheline_mask = ~intra_cacheline_mask;
+ const unsigned long dword_size = sizeof(uint32_t);
+ const uintptr_t dword_mask = dword_size - 1;
src = payload->backing_store.data;
size = payload->backing_store.size;
- /*
- * Adjust size so that the start and end points are aligned to a
- * cacheline. The SPI hardware controllers on Intel machines should
- * cache full length cachelines as well as prefetch data. Once the
- * data is mirrored in memory all accesses should hit the CPU's cache.
- */
- alignment_diff = (intra_cacheline_mask & (uintptr_t)src);
- size += alignment_diff;
-
- size = ALIGN(size, cacheline_size);
-
- printk(BIOS_DEBUG, "Payload aligned size: 0x%zx\n", size);
-
buffer = bootmem_allocate_buffer(size);
if (buffer == NULL) {
@@ -57,7 +43,18 @@ void mirror_payload(struct payload *payload)
return;
}
- src = (void *)(cacheline_mask & (uintptr_t)src);
+ /*
+ * Do copies in 32-bit aligned reads from backing source.
+ * 1. Do a copy to align the source address.
+ * 2. Do remaining copy.
+ */
+ alignment_diff = dword_mask & (uintptr_t)src;
+ if (alignment_diff != 0) {
+ mempcy(buffer, src, alignment_diff);
+ src += alignment_diff;
+ buffer += alignment_diff;
+ size -= alignment_diff;
+ }
/*
* Note that if mempcy is not using 32-bit moves the performance will
@@ -66,6 +63,9 @@ void mirror_payload(struct payload *payload)
*/
memcpy(buffer, src, size);
- /* Update the payload's backing store. */
- payload->backing_store.data = &buffer[alignment_diff];
+ /*
+ * Update the payload's backing store. May leak resources depending
+ * cbfs stroage source.
+ */
+ payload->backing_store.data = buffer;
}
diff --git a/src/cpu/x86/smm/smm_module_handler.c b/src/cpu/x86/smm/smm_module_handler.c
index 444e335..ffe56c0 100644
--- a/src/cpu/x86/smm/smm_module_handler.c
+++ b/src/cpu/x86/smm/smm_module_handler.c
@@ -20,6 +20,7 @@
#include <arch/io.h>
#include <console/console.h>
#include <cpu/x86/smm.h>
+#include <region.h>
typedef enum { SMI_LOCKED, SMI_UNLOCKED } smi_semaphore;
@@ -113,6 +114,8 @@ void *smm_get_save_state(int cpu)
return base;
}
+static int regions_initialized;
+
void smm_handler_start(void *arg, int cpu, const struct smm_runtime *runtime)
{
/* Make sure to set the global runtime. It's OK to race as the value
@@ -145,6 +148,12 @@ void smm_handler_start(void *arg, int cpu, const struct smm_runtime *runtime)
printk(BIOS_SPEW, "\nSMI# #%d\n", cpu);
+ if (regions_initialized == 0) {
+ regions_initialized =1;
+ boot_region_init();
+ bootrw_media_initialize();
+ }
+
cpu_smi_handler();
northbridge_smi_handler();
southbridge_smi_handler();
diff --git a/src/device/pci_device.c b/src/device/pci_device.c
index aa0d954..bcdbbe4 100644
--- a/src/device/pci_device.c
+++ b/src/device/pci_device.c
@@ -667,7 +667,7 @@ int oprom_is_loaded = 0;
void pci_dev_init(struct device *dev)
{
#if CONFIG_VGA_ROM_RUN
- struct rom_header *rom, *ram;
+ struct rom_header *ram;
/* Only execute VGA ROMs. */
if (((dev->class >> 8) != PCI_CLASS_DISPLAY_VGA))
@@ -694,11 +694,8 @@ void pci_dev_init(struct device *dev)
return;
#endif
- rom = pci_rom_probe(dev);
- if (rom == NULL)
- return;
+ ram = pci_load_vga_rom(dev);
- ram = pci_rom_load(dev, rom);
if (ram == NULL)
return;
diff --git a/src/device/pci_rom.c b/src/device/pci_rom.c
index 1bdccf0..bb17931 100644
--- a/src/device/pci_rom.c
+++ b/src/device/pci_rom.c
@@ -6,6 +6,7 @@
* (Written by Yinghai Lu <yhlu(a)tyan.com> for Tyan)
* Copyright (C) 2005 Ronald G. Minnich <rminnich(a)gmail.com>
* Copyright (C) 2005-2007 Stefan Reinauer <stepan(a)openbios.org>
+ * Copyright (C) 2014 Google Inc.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@@ -28,62 +29,15 @@
#include <device/pci_ops.h>
#include <string.h>
#include <cbfs.h>
+#include <cbfs_core.h>
-struct rom_header *pci_rom_probe(struct device *dev)
+static struct rom_header *
+pci_rom_verify_and_load(struct device *dev, struct rom_header *rom_header,
+ void *load_addr, int check_didvid)
{
- struct rom_header *rom_header;
struct pci_data *rom_data;
-
- /* If it's in FLASH, then don't check device for ROM. */
- rom_header = cbfs_load_optionrom(CBFS_DEFAULT_MEDIA, dev->vendor,
- dev->device, NULL);
-
- u32 vendev = (dev->vendor << 16) | dev->device;
- u32 mapped_vendev = vendev;
-
- if (map_oprom_vendev)
- mapped_vendev = map_oprom_vendev(vendev);
-
- if (!rom_header) {
- if (vendev != mapped_vendev) {
- rom_header = cbfs_load_optionrom(
- CBFS_DEFAULT_MEDIA,
- mapped_vendev >> 16,
- mapped_vendev & 0xffff, NULL);
- }
- }
-
- if (rom_header) {
- printk(BIOS_DEBUG, "In CBFS, ROM address for %s = %p\n",
- dev_path(dev), rom_header);
- } else {
- u32 rom_address;
-
- rom_address = pci_read_config32(dev, PCI_ROM_ADDRESS);
-
- if (rom_address == 0x00000000 || rom_address == 0xffffffff) {
-#if CONFIG_BOARD_EMULATION_QEMU_X86
- if ((dev->class >> 8) == PCI_CLASS_DISPLAY_VGA)
- rom_address = 0xc0000;
- else
-#endif
- return NULL;
- } else {
- /* Enable expansion ROM address decoding. */
- pci_write_config32(dev, PCI_ROM_ADDRESS,
- rom_address|PCI_ROM_ADDRESS_ENABLE);
- }
-
-#if CONFIG_ON_DEVICE_ROM_RUN
- printk(BIOS_DEBUG, "Option ROM address for %s = %lx\n",
- dev_path(dev), (unsigned long)rom_address);
- rom_header = (struct rom_header *)rom_address;
-#else
- printk(BIOS_DEBUG, "Option ROM execution disabled "
- "for %s\n", dev_path(dev));
- return NULL;
-#endif
- }
+ unsigned int rom_size;
+ unsigned int image_size;
printk(BIOS_SPEW, "PCI expansion ROM, signature 0x%04x, "
"INIT size 0x%04x, data ptr 0x%04x\n",
@@ -100,10 +54,11 @@ struct rom_header *pci_rom_probe(struct device *dev)
printk(BIOS_SPEW, "PCI ROM image, vendor ID %04x, device ID %04x,\n",
rom_data->vendor, rom_data->device);
+
/* If the device id is mapped, a mismatch is expected */
- if ((dev->vendor != rom_data->vendor
- || dev->device != rom_data->device)
- && (vendev == mapped_vendev)) {
+ if (check_didvid != 0 &&
+ (dev->vendor != rom_data->vendor ||
+ dev->device != rom_data->device)) {
printk(BIOS_ERR, "ID mismatch: vendor ID %04x, "
"device ID %04x\n", rom_data->vendor, rom_data->device);
return NULL;
@@ -117,29 +72,16 @@ struct rom_header *pci_rom_probe(struct device *dev)
printk(BIOS_DEBUG, "Class Code mismatch ROM %08x, dev %08x\n",
(rom_data->class_hi << 8) | rom_data->class_lo,
dev->class);
- // return NULL;
}
- return rom_header;
-}
-
-static void *pci_ram_image_start = (void *)PCI_RAM_IMAGE_START;
-
-struct rom_header *pci_rom_load(struct device *dev,
- struct rom_header *rom_header)
-{
- struct pci_data * rom_data;
- unsigned int rom_size;
- unsigned int image_size=0;
-
+ image_size = 0;
do {
/* Get next image. */
- rom_header = (struct rom_header *)((void *) rom_header
- + image_size);
-
- rom_data = (struct pci_data *)((void *) rom_header
- + le32_to_cpu(rom_header->data));
+ int data_offset;
+ rom_header = (void *)((char *)rom_header + image_size);
+ data_offset = le32_to_cpu(rom_header->data);
+ rom_data = (void *)((char *)rom_header + data_offset);
image_size = le32_to_cpu(rom_data->ilen) * 512;
} while ((rom_data->type != 0) && (rom_data->indicator != 0)); // make sure we got x86 version
@@ -148,30 +90,128 @@ struct rom_header *pci_rom_load(struct device *dev,
rom_size = rom_header->size * 512;
- /*
- * We check to see if the device thinks it is a VGA device not
- * whether the ROM image is for a VGA device because some
- * devices have a mismatch between the hardware and the ROM.
- */
- if (PCI_CLASS_DISPLAY_VGA == (dev->class >> 8)) {
+ if (load_addr != (void *)rom_header) {
+ printk(BIOS_DEBUG, "Copying ROM from %p to %p, 0x%x bytes.\n",
+ rom_header, load_addr, rom_size);
+ memcpy(load_addr, rom_header, rom_size);
+ }
+
+ return load_addr;
+}
+
+static inline int tohex4(unsigned int c)
+{
+ return (c <= 9) ? (c + '0') : (c - 10 + 'a');
+}
+
+static void tohex16(uint16_t val, char* dest)
+{
+ dest[0] = tohex4(val>>12);
+ dest[1] = tohex4((val>>8) & 0xf);
+ dest[2] = tohex4((val>>4) & 0xf);
+ dest[3] = tohex4(val & 0xf);
+}
+
+static const struct cbfs_file_descriptor *
+cbfs_open_optionrom(uint16_t vendor, uint16_t device)
+{
+ char name[17] = "pciXXXX,XXXX.rom";
+
+ tohex16(vendor, name+3);
+ tohex16(device, name+8);
+
+ return cbfs_open_by_name_type(cbfs_default_descriptor(), name,
+ CBFS_TYPE_OPTIONROM);
+}
+
+static void *cbfs_probe_and_load(struct device *dev, void *dest)
+{
+ const struct cbfs_file_descriptor *file;
+ uint32_t vendev;
+ int remapped;
+ struct rom_header *hdr;
+ void *load_addr;
+ ssize_t filesz;
+
+ load_addr = NULL;
+ remapped = 0;
+ file = cbfs_open_optionrom(dev->vendor, dev->device);
+
+ if (file == NULL && map_oprom_vendev != NULL) {
+ vendev = map_oprom_vendev((dev->vendor << 16) | dev->device);
+ file = cbfs_open_optionrom(vendev >> 16, vendev & 0xffff);
+ remapped = 1;
+ }
+
+ if (file == NULL)
+ return NULL;
+
+ filesz = cbfs_file_content_size(file);
+ hdr = cbfs_file_map_content(file, 0, filesz);
+ if (hdr == NULL)
+ goto out;
+
+ printk(BIOS_DEBUG, "In CBFS, ROM address for %s = %p\n",
+ dev_path(dev), hdr);
+
+ load_addr = pci_rom_verify_and_load(dev, hdr, dest, !remapped);
+ cbfs_file_unmap(file, hdr);
+
+out:
+ cbfs_file_close(file);
+ return load_addr;
+}
+
+#if CONFIG_ON_DEVICE_ROM_RUN
+static void *dev_probe_and_load(struct device *dev, void *dest)
+{
+ uint32_t rom_address;
+ struct rom_header *rom_header;
+
+ rom_address = pci_read_config32(dev, PCI_ROM_ADDRESS);
+
+ if (rom_address == 0x00000000 || rom_address == 0xffffffff) {
+ if (IS_ENABLED(CONFIG_BOARD_EMULATION_QEMU_X86))
+ rom_address = 0xc0000;
+ else
+ return NULL;
+ } else {
+ /* Enable expansion ROM address decoding. */
+ pci_write_config32(dev, PCI_ROM_ADDRESS,
+ rom_address|PCI_ROM_ADDRESS_ENABLE);
+ }
+ printk(BIOS_DEBUG, "Option ROM address for %s = %lx\n",
+ dev_path(dev), (unsigned long)rom_address);
+
+ rom_header = (struct rom_header *)rom_address;
+
+ return pci_rom_verify_and_load(dev, rom_header, dest, 1);
+}
+#endif
+
+struct rom_header *pci_load_vga_rom(struct device *dev)
+{
+ void *vga_load_addr = (void *)PCI_VGA_RAM_IMAGE_START;
+ void *load_addr;
+
+ if (PCI_CLASS_DISPLAY_VGA != (dev->class >> 8))
+ return NULL;
+
#if !CONFIG_MULTIPLE_VGA_ADAPTERS
- extern device_t vga_pri; /* Primary VGA device (device.c). */
- if (dev != vga_pri) return NULL; /* Only one VGA supported. */
+ extern device_t vga_pri; /* Primary VGA device (device.c). */
+ if (dev != vga_pri) return NULL; /* Only one VGA supported. */
#endif
- if ((void *)PCI_VGA_RAM_IMAGE_START != rom_header) {
- printk(BIOS_DEBUG, "Copying VGA ROM Image from %p to "
- "0x%x, 0x%x bytes\n", rom_header,
- PCI_VGA_RAM_IMAGE_START, rom_size);
- memcpy((void *)PCI_VGA_RAM_IMAGE_START, rom_header,
- rom_size);
- }
- return (struct rom_header *) (PCI_VGA_RAM_IMAGE_START);
- }
- printk(BIOS_DEBUG, "Copying non-VGA ROM image from %p to %p, 0x%x "
- "bytes\n", rom_header, pci_ram_image_start, rom_size);
+ load_addr = cbfs_probe_and_load(dev, vga_load_addr);
+
+ if (load_addr == NULL) {
+#if CONFIG_ON_DEVICE_ROM_RUN
+ load_addr = dev_probe_and_load(dev, vga_load_addr);
+#else
+ printk(BIOS_DEBUG, "Option ROM execution disabled for %s\n",
+ dev_path(dev));
+#endif
+ }
- memcpy(pci_ram_image_start, rom_header, rom_size);
- pci_ram_image_start += rom_size;
- return (struct rom_header *) (pci_ram_image_start-rom_size);
+ return load_addr;
}
diff --git a/src/drivers/elog/elog.c b/src/drivers/elog/elog.c
index de34928..597c32e 100644
--- a/src/drivers/elog/elog.c
+++ b/src/drivers/elog/elog.c
@@ -22,10 +22,9 @@
#include <console/console.h>
#include <pc80/mc146818rtc.h>
#include <smbios.h>
-#include <spi-generic.h>
-#include <spi_flash.h>
#include <stdint.h>
#include <string.h>
+#include <region.h>
#include <elog.h>
#include "elog_internal.h"
@@ -54,13 +53,15 @@
#define elog_debug(STR...)
#endif
+
+#define ELOG_REGION_NAME "elog"
+
/*
* Static variables for ELOG state
*/
static struct elog_area *elog_area;
static u16 total_size;
static u16 log_size;
-static u32 flash_base;
static elog_area_state area_state;
static elog_header_state header_state;
@@ -70,51 +71,10 @@ static u16 next_event_offset;
static u16 event_count;
static int elog_initialized;
-static struct spi_flash *elog_spi;
-
-
-static inline u32 get_rom_size(void)
-{
- u32 rom_size;
-
- /* Assume the used space of the ROM image starts from 0. The
- * physical size of the device may not be completely used. */
- rom_size = elog_spi->size;
- if (rom_size > CONFIG_ROM_SIZE)
- rom_size = CONFIG_ROM_SIZE;
-
- return rom_size;
-}
-
-/*
- * Convert a memory mapped flash address into a flash offset
- */
-static inline u32 elog_flash_address_to_offset(u8 *address)
-{
- u32 rom_size;
-
- if (!elog_spi)
- return 0;
- rom_size = get_rom_size();
-
- return (u32)address - ((u32)~0UL - rom_size + 1);
-}
-
-/*
- * Convert a flash offset into a memory mapped flash address
- */
-static inline u8* elog_flash_offset_to_address(u32 offset)
-{
- u32 rom_size;
-
- if (!elog_spi)
- return NULL;
-
- rom_size = get_rom_size();
-
- return (u8*)((u32)~0UL - rom_size + 1 + offset);
-}
+/* Region device for accessing the ELOG area. */
+static struct region_device elog_dev;
+static rhandle_t elog_rh = INVALID_RHANDLE;
/*
* Pointer to an event log header in the event data area
@@ -259,17 +219,16 @@ static void elog_flash_write(void *address, u32 size)
{
u32 offset;
- if (!address || !size || !elog_spi)
+ if (!address || !size)
return;
- offset = flash_base;
- offset += (u8 *)address - (u8 *)elog_area;
+ offset = (u8 *)address - (u8 *)elog_area;
elog_debug("elog_flash_write(address=0x%p offset=0x%08x size=%u)\n",
address, offset, size);
/* Write the data to flash */
- elog_spi->write(elog_spi, offset, size, address);
+ region_writeat(elog_rh, address, offset, size);
}
/*
@@ -280,17 +239,16 @@ static void elog_flash_erase(void *address, u32 size)
{
u32 offset;
- if (!address || !size || !elog_spi)
+ if (!address || !size)
return;
- offset = flash_base;
- offset += (u8 *)address - (u8*)elog_area;
+ offset = (u8 *)address - (u8*)elog_area;
elog_debug("elog_flash_erase(address=0x%p offset=0x%08x size=%u)\n",
address, offset, size);
/* Erase the sectors in this region */
- elog_spi->erase(elog_spi, offset, size);
+ region_eraseat(elog_rh, offset, size);
}
/*
@@ -348,7 +306,7 @@ static void elog_scan_flash(void)
event_buffer_state = ELOG_EVENT_BUFFER_OK;
/* Fill memory buffer by reading from SPI */
- elog_spi->read(elog_spi, flash_base, total_size, elog_area);
+ region_readat(elog_rh, elog_area, 0, total_size);
next_event_offset = 0;
event_count = 0;
@@ -449,13 +407,17 @@ int elog_smbios_write_type15(unsigned long *current, int handle)
{
struct smbios_type15 *t = (struct smbios_type15 *)*current;
int len = sizeof(struct smbios_type15);
+ void *backing_store;
#if CONFIG_ELOG_CBMEM
/* Save event log buffer into CBMEM for the OS to read */
- void *cbmem = cbmem_add(CBMEM_ID_ELOG, total_size);
- if (!cbmem)
+ backing_store = cbmem_add(CBMEM_ID_ELOG, total_size);
+ if (!backing_store)
return 0;
- memcpy(cbmem, elog_area, total_size);
+ memcpy(backing_store, elog_area, total_size);
+#else
+ /* This assumes x86 memory-mapped capabilities of flash. */
+ backing_store = region_mmap(elog_rh, 0, total_size);
#endif
memset(t, 0, len);
@@ -468,11 +430,7 @@ int elog_smbios_write_type15(unsigned long *current, int handle)
t->access_method = SMBIOS_EVENTLOG_ACCESS_METHOD_MMIO32;
t->log_status = SMBIOS_EVENTLOG_STATUS_VALID;
t->change_token = 0;
-#if CONFIG_ELOG_CBMEM
- t->address = (u32)cbmem;
-#else
- t->address = (u32)elog_flash_offset_to_address(flash_base);
-#endif
+ t->address = (u32)backing_store;
t->header_format = ELOG_HEADER_TYPE_OEM;
t->log_type_descriptors = 0;
t->log_type_descriptor_length = 2;
@@ -506,33 +464,46 @@ int elog_clear(void)
return 0;
}
-static void elog_find_flash(void)
+static int elog_find_flash(void)
{
-#if CONFIG_CHROMEOS
- u8 *flash_base_ptr;
-#endif
+ rhandle_t rh;
+
+ if (rhandle_valid(elog_rh))
+ return 0;
elog_debug("elog_find_flash()\n");
#if CONFIG_CHROMEOS
/* Find the ELOG base and size in FMAP */
- total_size = find_fmap_entry("RW_ELOG", (void **)&flash_base_ptr);
- if (total_size < 0) {
+ if (fmap_locate("RW_ELOG", &elog_dev.region.offset,
+ &elog_dev.region.size)) {
printk(BIOS_WARNING, "ELOG: Unable to find RW_ELOG in FMAP, "
"using CONFIG_ELOG_FLASH_BASE instead\n");
- total_size = CONFIG_ELOG_AREA_SIZE;
} else {
- flash_base = elog_flash_address_to_offset(flash_base_ptr);
-
/* Use configured size if smaller than FMAP size */
- if (total_size > CONFIG_ELOG_AREA_SIZE)
- total_size = CONFIG_ELOG_AREA_SIZE;
+ if (elog_dev.region.size > CONFIG_ELOG_AREA_SIZE)
+ elog_dev.region.size = CONFIG_ELOG_AREA_SIZE;
}
#else
- flash_base = CONFIG_ELOG_FLASH_BASE;
- total_size = CONFIG_ELOG_AREA_SIZE;
+ elog_dev.region.offset = CONFIG_ELOG_FLASH_BASE;
+ elog_dev.region.size = CONFIG_ELOG_AREA_SIZE;
#endif
+ total_size = elog_dev.region.size;
log_size = total_size - sizeof(struct elog_header);
+
+ rh = region_locate(BOOTRW_REGION_NAME);
+ if (!rhandle_valid(rh)) {
+ printk(BIOS_WARNING, "Unable to find writable boot region.\n");
+ return -1;
+ }
+ rh = region_register_subregion("elog", &elog_dev, rh);
+ if (!rhandle_valid(rh)) {
+ printk(BIOS_WARNING, "Unable to register ELOG region.\n");
+ return -1;
+ }
+
+ elog_rh = rh;
+ return 0;
}
/*
@@ -545,18 +516,9 @@ int elog_init(void)
elog_debug("elog_init()\n");
- /* Prepare SPI */
- spi_init();
- elog_spi = spi_flash_probe(0, 0, 0, 0);
- if (!elog_spi) {
- printk(BIOS_ERR, "ELOG: Unable to find SPI flash\n");
- return -1;
- }
-
/* Set up the backing store */
- elog_find_flash();
- if (flash_base == 0) {
- printk(BIOS_ERR, "ELOG: Invalid flash base\n");
+ if (elog_find_flash()) {
+ printk(BIOS_ERR, "ELOG: region not set up.\n");
return -1;
}
@@ -589,8 +551,8 @@ int elog_init(void)
elog_initialized = 1;
- printk(BIOS_INFO, "ELOG: FLASH @0x%p [SPI 0x%08x]\n",
- elog_area, flash_base);
+ printk(BIOS_INFO, "ELOG: FLASH @0x%p [SPI 0x%08zx]\n",
+ elog_area, (size_t)elog_dev.region.offset);
printk(BIOS_INFO, "ELOG: area is %d bytes, full threshold %d,"
" shrink size %d\n", total_size,
diff --git a/src/include/cbfs.h b/src/include/cbfs.h
index ebdbf43..bd000c9 100644
--- a/src/include/cbfs.h
+++ b/src/include/cbfs.h
@@ -1,14 +1,8 @@
/*
* This file is part of the coreboot project.
*
- * Copyright (C) 2008 Jordan Crouse <jordan(a)cosmicpenguin.net>
- * Copyright (C) 2013 The Chromium OS Authors. All rights reserved.
+ * Copyright (C) 2014 Google Inc.
*
- * This file is dual-licensed. You can choose between:
- * - The GNU GPL, version 2, as published by the Free Software Foundation
- * - The revised BSD license (without advertising clause)
- *
- * ---------------------------------------------------------------------------
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; version 2 of the License.
@@ -20,62 +14,84 @@
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
- * ---------------------------------------------------------------------------
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * 3. The name of the author may not be used to endorse or promote products
- * derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- * ---------------------------------------------------------------------------
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
-
#ifndef _CBFS_H_
#define _CBFS_H_
-#include <cbfs_core.h>
+#include <stdint.h>
+#include <region.h>
-void *cbfs_load_optionrom(struct cbfs_media *media, uint16_t vendor,
- uint16_t device, void * dest);
-void *cbfs_load_stage(struct cbfs_media *media, const char *name);
-
-/* Simple buffer for streaming media. */
-struct cbfs_simple_buffer {
- char *buffer;
- size_t allocated;
+/* Describe an instance of cbfs. */
+struct cbfs_descriptor {
+ rhandle_t rh;
+ size_t align;
size_t size;
- size_t last_allocate;
};
-void *cbfs_simple_buffer_map(struct cbfs_simple_buffer *buffer,
- struct cbfs_media *media,
- size_t offset, size_t count);
+struct cbfs_file_descriptor;
+
+/* Obtain the default cbfs_descriptor. */
+const struct cbfs_descriptor *cbfs_default_descriptor(void);
+
+/* Open a file by name. Return NULL on error. */
+const struct cbfs_file_descriptor *
+cbfs_open_by_name(const struct cbfs_descriptor *cbfs, const char *name);
+
+/* Open a file by name and type. */
+const struct cbfs_file_descriptor *
+cbfs_open_by_name_type(const struct cbfs_descriptor *cbfs,
+ const char *name, uint32_t type);
+
+/* Close a previously opened file. */
+void cbfs_file_close(const struct cbfs_file_descriptor *fd);
+
+/* Return the size of the file's contents. < 0 on error. */
+ssize_t cbfs_file_content_size(const struct cbfs_file_descriptor *fd);
+
+/* Return the size of the file's metadata contents. < 0 on error. */
+ssize_t cbfs_file_metadata_size(const struct cbfs_file_descriptor *fd);
+
+/*
+ * Read size bytes file contents from offset of into buffer. Returns < 0
+ * on error or bytes read.
+ */
+ssize_t cbfs_file_read_content(const struct cbfs_file_descriptor *fd,
+ void *buf, offset_t offset, size_t size);
+
+/* Attempt to map the file content. Returns NULL on error. */
+void *cbfs_file_map_content(const struct cbfs_file_descriptor *fd,
+ offset_t offset, size_t size);
+
+/*
+ * Read size bytes file metadata from offset of into buffer. Returns < 0
+ * on error or bytes read.
+ */
+ssize_t cbfs_file_read_metadata(const struct cbfs_file_descriptor *fd,
+ void *buf, offset_t offset, size_t size);
+/*
+ * Attempt to map all of the file's metadata. Depending on the file type there
+ * may be no metadata in which case NULL will be returned. File types of
+ * CBFS_TYPE_STAGE and CBFS_TYPE_PAYLOAD are currently the only files that
+ * contain metadata.
+ *
+ * Returns NULL on error.
+ */
+void *cbfs_file_map_metadata(const struct cbfs_file_descriptor *fd);
+
+/* Unmap the mapping associated with addr. No partial unmappings allowed. */
+void cbfs_file_unmap(const struct cbfs_file_descriptor *fd, void *addr);
+
-void *cbfs_simple_buffer_unmap(struct cbfs_simple_buffer *buffer,
- const void *address);
+void *cbfs_load_optionrom(const struct cbfs_descriptor *cbfs,
+ uint16_t vendor, uint16_t device, void * dest);
-// Utility functions
-int run_address(void *f);
+/* Return entry point to stage, or NULL on failure. */
+void *cbfs_load_stage(const struct cbfs_descriptor *cbfs, const char *name);
-/* Defined in individual arch / board implementation. */
-int init_default_cbfs_media(struct cbfs_media *media);
+/* Decompress range of file to destination. Returns bytes decompressed. */
+size_t cbfs_file_inflate(const struct cbfs_file_descriptor *fd,
+ offset_t offset, size_t src_sz, void *dest);
#if defined(__PRE_RAM__)
struct romstage_handoff;
diff --git a/src/include/cbfs_core.h b/src/include/cbfs_core.h
index a1d8127..6a91454 100644
--- a/src/include/cbfs_core.h
+++ b/src/include/cbfs_core.h
@@ -186,50 +186,6 @@ struct cbfs_optionrom {
uint32_t len;
} __attribute__((packed));
-#define CBFS_MEDIA_INVALID_MAP_ADDRESS ((void*)(0xffffffff))
-#define CBFS_DEFAULT_MEDIA ((void*)(0x0))
-
-/* Media for CBFS to load files. */
-struct cbfs_media {
-
- /* implementation dependent context, to hold resource references */
- void *context;
-
- /* opens media and returns 0 on success, -1 on failure */
- int (*open)(struct cbfs_media *media);
-
- /* returns number of bytes read from media into dest, starting from
- * offset for count of bytes */
- size_t (*read)(struct cbfs_media *media, void *dest, size_t offset,
- size_t count);
-
- /* returns a pointer to memory with count of bytes from media source
- * starting from offset, or CBFS_MEDIA_INVALID_MAP_ADDRESS on failure.
- * Note: mapped data can't be free unless unmap is called, even if you
- * do close first. */
- void * (*map)(struct cbfs_media *media, size_t offset, size_t count);
-
- /* returns NULL and releases the memory by address, which was allocated
- * by map */
- void * (*unmap)(struct cbfs_media *media, const void *address);
-
- /* closes media and returns 0 on success, -1 on failure. */
- int (*close)(struct cbfs_media *media);
-};
-
-/* returns pointer to a file entry inside CBFS or NULL */
-struct cbfs_file *cbfs_get_file(struct cbfs_media *media, const char *name);
-
-/* returns pointer to file content inside CBFS after if type is correct */
-void *cbfs_get_file_content(struct cbfs_media *media, const char *name,
- int type, size_t *sz);
-
-/* returns decompressed size on success, 0 on failure */
-int cbfs_decompress(int algo, void *src, void *dst, int len);
-
-/* returns a pointer to CBFS master header, or CBFS_HEADER_INVALID_ADDRESS
- * on failure */
-const struct cbfs_header *cbfs_get_header(struct cbfs_media *media);
#endif /* __ROMCC__ */
diff --git a/src/include/device/pci_rom.h b/src/include/device/pci_rom.h
index fe77276..4bd0bfd 100644
--- a/src/include/device/pci_rom.h
+++ b/src/include/device/pci_rom.h
@@ -6,7 +6,6 @@
#define PCI_ROM_HDR 0xAA55
#define PCI_DATA_HDR (uint32_t) ( ('R' << 24) | ('I' << 16) | ('C' << 8) | 'P' )
-#define PCI_RAM_IMAGE_START 0xD0000
#define PCI_VGA_RAM_IMAGE_START 0xC0000
struct rom_header {
@@ -33,8 +32,7 @@ struct pci_data {
uint16_t reserved_2;
};
-struct rom_header *pci_rom_probe(struct device *dev);
-struct rom_header *pci_rom_load(struct device *dev, struct rom_header *rom_header);
+struct rom_header *pci_load_vga_rom(struct device *dev);
u32 __attribute__((weak)) map_oprom_vendev(u32 vendev);
#endif
diff --git a/src/include/payload_loader.h b/src/include/payload_loader.h
index 7a3f045..7b6fc1c 100644
--- a/src/include/payload_loader.h
+++ b/src/include/payload_loader.h
@@ -22,6 +22,8 @@
#include <stdint.h>
#include <stddef.h>
+struct cbfs_file_descriptor;
+
struct buffer_area {
void *data;
size_t size;
@@ -29,6 +31,7 @@ struct buffer_area {
struct payload {
const char *name;
+ const struct cbfs_file_descriptor *fd;
struct buffer_area backing_store;
/* Used when payload wants memory coreboot ramstage is running at. */
struct buffer_area bounce;
diff --git a/src/include/region.h b/src/include/region.h
new file mode 100644
index 0000000..2f6ae3a
--- /dev/null
+++ b/src/include/region.h
@@ -0,0 +1,146 @@
+/*
+ * This file is part of the coreboot project.
+ *
+ * Copyright (C) 2014 Google Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef REGION_H
+#define REGION_H
+
+#include <stdint.h>
+#include <stddef.h>
+
+/*
+ * Region support.
+ *
+ * Regions are intended to abstract away the access mechanisms for blocks of
+ * data. This could be SPI, eMMC, or a memory region as the backing store.
+ * Subregions can be made by registering a region_device that is associated
+ * with another region. Regions can be addressed by name, but there is no
+ * hierarchy in the namespace. i.e. the operations through subregions are
+ * hierarchical but the namespace is not.
+ *
+ * There are two views to the boot media: read-only and read-write. On certain
+ * architectures the read-write availability is not available until late in
+ * ramstage. Therefore, users of each region need to be cognizant of the fact
+ * that different implementations may be backing a particular region. e.g. on
+ * x86 the read-only boot region doesn't have write and erase capabilities, but
+ * the read-write boot region would allow writes and erases but no mmap.
+ */
+
+/*
+ * Initialize the boot region. Called directly in pre-ramstage or
+ * automatically in ramstage.
+ */
+void boot_region_init(void);
+/* Initialize the boot media. Board/Arch specific code implements this. */
+void boot_media_initialize(void);
+/*
+ * A potential call for chipsets that can't bring their RW area online til
+ * after the device init in ramstage.
+ */
+void bootrw_media_initialize(void);
+/* Initialize the default CBFS region. */
+void cbfs_default_media_initialize(void);
+
+typedef uintptr_t offset_t;
+typedef long rhandle_t;
+#define INVALID_RHANDLE ((rhandle_t)~((uintptr_t)0))
+
+#define BOOTRO_REGION_NAME "bootro"
+#define BOOTRW_REGION_NAME "bootrw"
+#define DEFAULT_CBFS_REGION_NAME "cbfs"
+
+struct region_device;
+
+struct region_device_ops {
+ void *(*mmap)(const struct region_device *, offset_t, size_t);
+ void (*munmap)(const struct region_device *, void *);
+ ssize_t (*readat)(const struct region_device *, void *,
+ offset_t, size_t);
+ ssize_t (*writeat)(const struct region_device *, const void *,
+ offset_t, size_t);
+ ssize_t (*eraseat)(const struct region_device *, offset_t, size_t);
+};
+
+struct region {
+ offset_t offset;
+ size_t size;
+};
+
+struct region_device {
+ const struct region_device_ops *ops;
+ struct region region;
+};
+
+/*
+ * Requests within a region are relative to the region's size. Therefore,
+ * the requests need to be normalized to the parent's region. This routine
+ * does that normalization and checks if the request is within bounds.
+ *
+ * Returns -1 if invalid request or 0 if request is within bounds.
+ */
+int region_request_normalize(const struct region *parent,
+ struct region *request);
+
+static inline int rhandle_valid(rhandle_t rh)
+{
+ return !!(rh >= 0);
+}
+
+/* Register a region_device by name. */
+rhandle_t region_register(const char *name, const struct region_device *rdev);
+
+/* Register a subregion by name under parent. rdev->ops must be NULL. */
+rhandle_t region_register_subregion(const char *name,
+ const struct region_device *rdev,
+ rhandle_t parent);
+
+/* Locate a region of provided name. */
+rhandle_t region_locate(const char *name);
+
+/*
+ * Read subregion within provided region.
+ * Returns bytes read, < 0 on error.
+ */
+ssize_t region_readat(rhandle_t rh, void *buf, offset_t offset, size_t count);
+
+/*
+ * Write to subregion within provided region.
+ * Returns bytes written, < 0 on error.
+ */
+ssize_t region_writeat(rhandle_t rh, const void *buf, offset_t offset,
+ size_t count);
+
+/*
+ * Erase subregion within provide region.
+ * Returns bytes erased, < 0 on error.
+ */
+ssize_t region_eraseat(rhandle_t rh, offset_t offset, size_t count);
+
+/*
+ * Map subregion described by offset and size within the region provided.
+ * Returns pointer to mapped subregion or NULL on error.
+ */
+void *region_mmap(rhandle_t rh, offset_t offset, size_t count);
+
+/* Unmap previously mapped region. */
+void region_munmap(rhandle_t rh, void *addr);
+
+/* Get size of region represented by rh. < 0 on error. */
+ssize_t region_size(rhandle_t rh);
+
+#endif /* REGION_H */
diff --git a/src/include/rmodule.h b/src/include/rmodule.h
index 2147ab0..19f32e4 100644
--- a/src/include/rmodule.h
+++ b/src/include/rmodule.h
@@ -61,6 +61,7 @@ int rmodule_calc_region(unsigned int region_alignment, size_t rmodule_size,
#if CONFIG_DYNAMIC_CBMEM
struct cbfs_stage;
struct cbmem_entry;
+struct cbfs_descriptor;
struct rmod_stage_load {
/* Inputs */
@@ -72,8 +73,10 @@ struct rmod_stage_load {
};
/* Both of the following functions return 0 on success, -1 on error. */
-int rmodule_stage_load(struct rmod_stage_load *rsl, struct cbfs_stage *stage);
-int rmodule_stage_load_from_cbfs(struct rmod_stage_load *rsl);
+int rmodule_stage_load(struct rmod_stage_load *rsl, struct cbfs_stage *stage,
+ void *data);
+int rmodule_stage_load_from_cbfs(const struct cbfs_descriptor *cbfs,
+ struct rmod_stage_load *rsl);
#endif
struct rmodule {
diff --git a/src/lib/Makefile.inc b/src/lib/Makefile.inc
index acd334e..031d72c 100644
--- a/src/lib/Makefile.inc
+++ b/src/lib/Makefile.inc
@@ -18,7 +18,9 @@
#
subdirs-y += loaders
+ifneq ($(CONFIG_ARCH_X86),y)
bootblock-y += cbfs.c
+endif
ifneq ($(CONFIG_HAVE_ARCH_MEMSET),y)
bootblock-y += memset.c
endif
@@ -109,6 +111,13 @@ ramstage-y += cbmem_info.c
ramstage-y += hexdump.c
romstage-y += hexdump.c
+ramstage-y += region.c
+romstage-y += region.c
+ramstage-y += cbfs_boot_region.c
+romstage-y += cbfs_boot_region.c
+smm-y += cbfs_boot_region.c
+ramstage-$(CONFIG_BOOT_REGION_SPI_FLASH) += bootrw_spi_flash_region.c
+smm-$(CONFIG_SPI_FLASH_SMM) += bootrw_spi_flash_region.c
ramstage-$(CONFIG_REG_SCRIPT) += reg_script.c
@@ -125,6 +134,7 @@ smm-y += memmove.c
endif
smm-y += cbfs.c memcmp.c
smm-y += gcc.c
+smm-y += region.c
$(obj)/lib/version.ramstage.o : $(obj)/build.h
diff --git a/src/lib/bootrw_spi_flash_region.c b/src/lib/bootrw_spi_flash_region.c
new file mode 100644
index 0000000..6c85a96
--- /dev/null
+++ b/src/lib/bootrw_spi_flash_region.c
@@ -0,0 +1,138 @@
+/*
+ * This file is part of the coreboot project.
+ *
+ * Copyright (C) 2014 Google Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+
+#include <stddef.h>
+#include <region.h>
+#include <spi-generic.h>
+#include <spi_flash.h>
+
+struct bootrw_flash_device {
+ struct spi_flash *spi;
+ struct region_device dev;
+};
+
+
+static void *
+bootrw_mmap(const struct region_device *rdev, offset_t offset, size_t size)
+{
+ void * addr = NULL;
+#if IS_ENABLED(CONFIG_ARCH_X86)
+ struct bootrw_flash_device *dev;
+
+ dev = container_of(rdev, struct bootrw_flash_device, dev);
+ addr = (void *)(((uintptr_t)-dev->spi->size) + offset);
+#endif
+ return addr;
+}
+
+static void bootrw_munmap(const struct region_device *rdev, void *addr)
+{
+}
+
+static ssize_t
+bootrw_readat(const struct region_device *rdev, void *buf,
+ offset_t offset, size_t size)
+{
+ struct bootrw_flash_device *dev;
+
+ dev = container_of(rdev, struct bootrw_flash_device, dev);
+ if (dev->spi->read(dev->spi, offset, size, buf))
+ return -1;
+ return size;
+}
+
+static ssize_t
+bootrw_writeat(const struct region_device *rdev, const void *buf,
+ offset_t offset, size_t size)
+{
+ struct bootrw_flash_device *dev;
+
+ dev = container_of(rdev, struct bootrw_flash_device, dev);
+ if (dev->spi->write(dev->spi, offset, size, buf))
+ return -1;
+ return size;
+}
+
+static ssize_t
+bootrw_eraseat(const struct region_device *rdev, offset_t offset, size_t size)
+{
+ struct bootrw_flash_device *dev;
+
+ dev = container_of(rdev, struct bootrw_flash_device, dev);
+ if (dev->spi->erase(dev->spi, offset, size))
+ return -1;
+ return size;
+}
+
+static const struct region_device_ops bootrw_ops = {
+ .mmap = bootrw_mmap,
+ .munmap = bootrw_munmap,
+ .readat = bootrw_readat,
+ .writeat = bootrw_writeat,
+ .eraseat = bootrw_eraseat,
+};
+
+static struct bootrw_flash_device flashdev = {
+ .dev = {
+ .ops = &bootrw_ops,
+ .region = {
+ .offset = 0,
+ .size = CONFIG_ROM_SIZE,
+ },
+ }
+};
+
+void bootrw_media_initialize(void)
+{
+ /* Reinitialize spi regs in case. */
+ spi_init();
+
+ if (flashdev.spi != NULL)
+ return;
+
+ flashdev.spi = spi_flash_probe(0, 0, 0, 0);
+ if (flashdev.spi == NULL) {
+ printk(BIOS_WARNING, "SPI probing failed for boot region.\n");
+ return;
+ }
+
+ if (flashdev.spi->size != CONFIG_ROM_SIZE) {
+ printk(BIOS_WARNING,
+ "SPI mismatch with CONFIG_ROM_SIZE: %zx vs %zx\n",
+ (size_t)CONFIG_ROM_SIZE, (size_t)flashdev.spi->size);
+ return;
+ }
+
+ if (!rhandle_valid(region_register(BOOTRW_REGION_NAME, &flashdev.dev)))
+ printk(BIOS_WARNING, "Couldn't register '%s' region.\n",
+ BOOTRW_REGION_NAME);
+}
+
+#if !defined(__PRE_RAM__)
+#include <bootstate.h>
+static void bootrw_bscb(void *unused)
+{
+ bootrw_media_initialize();
+}
+
+BOOT_STATE_INIT_ENTRIES(regions_init) = {
+ BOOT_STATE_INIT_ENTRY(BS_DEV_INIT, BS_ON_ENTRY, bootrw_bscb, NULL),
+};
+#endif
diff --git a/src/lib/cbfs.c b/src/lib/cbfs.c
index dc08937..f5dff88 100644
--- a/src/lib/cbfs.c
+++ b/src/lib/cbfs.c
@@ -1,8 +1,7 @@
/*
* This file is part of the coreboot project.
*
- * Copyright (C) 2008, Jordan Crouse <jordan(a)cosmicpenguin.net>
- * Copyright (C) 2013 The Chromium OS Authors. All rights reserved.
+ * Copyright (C) 2014-2014 Google Inc.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@@ -18,192 +17,402 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
*/
-#ifdef LIBPAYLOAD
-# include <libpayload-config.h>
-# ifdef CONFIG_LZMA
-# include <lzma.h>
-# define CBFS_CORE_WITH_LZMA
-# endif
-# define CBFS_MINI_BUILD
-#elif defined(__SMM__)
-# define CBFS_MINI_BUILD
-#elif defined(__BOOT_BLOCK__)
- /* No LZMA in boot block. */
-#elif defined(__PRE_RAM__) && !CONFIG_COMPRESS_RAMSTAGE
- /* No LZMA in romstage if ramstage is not compressed. */
-#else
-# define CBFS_CORE_WITH_LZMA
-# include <lib.h>
+#if !defined(__BOOT_BLOCK__) && !(defined(__PRE_RAM__) && !IS_ENABLED(CONFIG_COMPRESS_RAMSTAGE))
+#define CBFS_WITH_LZMA
#endif
-#include <cbfs.h>
#include <string.h>
+#include <arch/early_variables.h>
+#include <cbfs.h>
+#include <cbfs_core.h>
#include <cbmem.h>
+#include <console/console.h>
+#include <lib.h>
-#ifdef LIBPAYLOAD
-# include <stdio.h>
-# define DEBUG(x...)
-# define LOG(x...) printf(x)
-# define ERROR(x...) printf(x)
-#else
-# include <console/console.h>
-# define ERROR(x...) printk(BIOS_ERR, "CBFS: " x)
-# define LOG(x...) printk(BIOS_INFO, "CBFS: " x)
-# if CONFIG_DEBUG_CBFS
-# define DEBUG(x...) printk(BIOS_SPEW, "CBFS: " x)
-# else
-# define DEBUG(x...)
-# endif
-#endif
+struct cbfs_file_descriptor {
+ rhandle_t rh;
+ struct region metadata;
+ struct region content;
+};
-#if defined(CONFIG_CBFS_HEADER_ROM_OFFSET) && (CONFIG_CBFS_HEADER_ROM_OFFSET)
-# define CBFS_HEADER_ROM_ADDRESS (CONFIG_CBFS_HEADER_ROM_OFFSET)
-#else
-// Indirect address: only works on 32bit top-aligned systems.
-# define CBFS_HEADER_ROM_ADDRESS (*(uint32_t *)0xfffffffc)
-#endif
+#define MAX_CBFS_OPEN_FILES 4
+struct cbfs_file_cache {
+ struct cbfs_file_descriptor files[MAX_CBFS_OPEN_FILES];
+};
-#include "cbfs_core.c"
+static struct cbfs_file_cache g_cbfs_files CAR_GLOBAL;
-#ifndef __SMM__
-static inline int tohex4(unsigned int c)
+static struct cbfs_file_cache *get_cache(void)
+{
+ return car_get_var_ptr(&g_cbfs_files);
+}
+
+static int cbfs_fd_available(const struct cbfs_file_descriptor *fd)
+{
+ return !!(fd->content.size == 0 && fd->metadata.size == 0);
+}
+
+static void cbfs_fd_mark_free(const struct cbfs_file_descriptor *cfd)
{
- return (c <= 9) ? (c + '0') : (c - 10 + 'a');
+ struct cbfs_file_descriptor *fd = (struct cbfs_file_descriptor *)cfd;
+ memset(fd, 0, sizeof(*fd));
+ fd->rh = INVALID_RHANDLE;
}
-static void tohex16(unsigned int val, char* dest)
+static struct cbfs_file_descriptor *get_available_file(void)
{
- dest[0] = tohex4(val>>12);
- dest[1] = tohex4((val>>8) & 0xf);
- dest[2] = tohex4((val>>4) & 0xf);
- dest[3] = tohex4(val & 0xf);
+ int i;
+ struct cbfs_file_cache *cache = get_cache();
+
+ for (i = 0; i < MAX_CBFS_OPEN_FILES; i++) {
+ if (cbfs_fd_available(&cache->files[i]))
+ return &cache->files[i];
+ }
+
+ return NULL;
}
-void *cbfs_load_optionrom(struct cbfs_media *media, uint16_t vendor,
- uint16_t device, void *dest)
+static void cbfs_fd_add_metadata(struct cbfs_file_descriptor *fd, size_t sz)
{
- char name[17] = "pciXXXX,XXXX.rom";
- struct cbfs_optionrom *orom;
- uint8_t *src;
+ fd->metadata.size += sz;
+ fd->content.offset += sz;
+ fd->content.size -= sz;
+}
- tohex16(vendor, name+3);
- tohex16(device, name+8);
+static const struct cbfs_file_descriptor *
+allocate_file(const struct cbfs_descriptor *cbfs, const struct cbfs_file *file,
+ offset_t offset)
+{
+ struct cbfs_file_descriptor *fd;
+ offset_t file_end;
- orom = (struct cbfs_optionrom *)
- cbfs_get_file_content(media, name, CBFS_TYPE_OPTIONROM, NULL);
+ fd = get_available_file();
- if (orom == NULL)
+ if (fd == NULL) {
+ printk(BIOS_DEBUG, "No available cbfs fds!\n");
return NULL;
+ }
- /* They might have specified a dest address. If so, we can decompress.
- * If not, there's not much hope of decompressing or relocating the rom.
- * in the common case, the expansion rom is uncompressed, we
- * pass 0 in for the dest, and all we have to do is find the rom and
- * return a pointer to it.
- */
+ /* Point offset to beginning of file data. */
+ offset = file->offset + offset;
+ file_end = offset + file->len;
- /* BUG: the cbfstool is (not yet) including a cbfs_optionrom header */
- src = (uint8_t *)orom; // + sizeof(struct cbfs_optionrom);
+ fd->rh = cbfs->rh;
+ fd->metadata.offset = offset;
+ fd->metadata.size = 0;
+ fd->content.offset = offset;
+ fd->content.size = file->len;
- if (! dest)
- return src;
+ if (file->type != CBFS_TYPE_STAGE && file->type != CBFS_TYPE_PAYLOAD)
+ return fd;
+
+ if (file->type == CBFS_TYPE_STAGE) {
+ cbfs_fd_add_metadata(fd, sizeof(struct cbfs_stage));
+ return fd;
+ }
+
+ /* Parse payload segments. */
+ while (offset + sizeof(struct cbfs_payload_segment) <= file_end) {
+ struct cbfs_payload_segment segment;
+ ssize_t read_sz;
+
+ read_sz = region_readat(cbfs->rh, &segment, offset,
+ sizeof(segment));
+ if (read_sz != sizeof(segment)) {
+ printk(BIOS_DEBUG, "Couldn't read segment at 0x%zx\n",
+ (size_t)offset);
+ cbfs_fd_mark_free(fd);
+ return NULL;
+ }
+
+ switch (segment.type) {
+ case PAYLOAD_SEGMENT_CODE:
+ case PAYLOAD_SEGMENT_DATA:
+ case PAYLOAD_SEGMENT_BSS:
+ case PAYLOAD_SEGMENT_PARAMS:
+ cbfs_fd_add_metadata(fd, sizeof(segment));
+ break;
+ case PAYLOAD_SEGMENT_ENTRY:
+ cbfs_fd_add_metadata(fd, sizeof(segment));
+ return fd;
+ default:
+ cbfs_fd_mark_free(fd);
+ return NULL;
+ }
+
+ /* Next segment. */
+ offset += sizeof(segment);
+ }
- if (!cbfs_decompress(ntohl(orom->compression),
- src,
- dest,
- ntohl(orom->len)))
+ cbfs_fd_mark_free(fd);
+ return NULL;
+}
+
+static offset_t
+cbfs_next_offset(offset_t offset, size_t align, size_t increment)
+{
+ offset += increment;
+ if (offset % align)
+ offset += align - (offset % align);
+ return offset;
+}
+
+static const struct cbfs_file_descriptor *
+__cbfs_open(const struct cbfs_descriptor *cbfs, const char *name,
+ uint32_t *type)
+{
+ const struct cbfs_file_descriptor *fd;
+ struct cbfs_file file;
+ ssize_t read_sz;
+ offset_t offset;
+ size_t cbfs_sz;
+ size_t align;
+ rhandle_t rh;
+
+ if (cbfs == NULL || name == NULL)
return NULL;
- return dest;
+ offset = 0;
+ rh = cbfs->rh;
+ align = cbfs->align;
+ cbfs_sz = cbfs->size;
+ fd = NULL;
+
+ while (offset + sizeof(file) < cbfs_sz) {
+ char *file_name;
+ size_t name_sz;
+ size_t entry_sz;
+ int found;
+
+ read_sz = region_readat(rh, &file, offset, sizeof(file));
+ if (read_sz != sizeof(file))
+ return NULL;
+
+ if (memcmp(CBFS_FILE_MAGIC, file.magic, sizeof(file.magic))) {
+ offset = cbfs_next_offset(offset, align, align);
+ continue;
+ }
+
+ file.len = ntohl(file.len);
+ file.type = ntohl(file.type);
+ file.offset = ntohl(file.offset);
+ entry_sz = file.len + file.offset;
+
+ /* File type doesn't match. */
+ if (type != NULL && *type != file.type) {
+ offset = cbfs_next_offset(offset, align, entry_sz);
+ continue;
+ }
+ name_sz = file.offset - sizeof(file);
+ file_name = region_mmap(rh, offset + sizeof(file), name_sz);
+ if (file_name == NULL) {
+ offset = cbfs_next_offset(offset, align, entry_sz);
+ continue;
+ }
+
+ found = !strcmp(file_name, name);
+ region_munmap(rh, file_name);
+
+ if (found) {
+ fd = allocate_file(cbfs, &file, offset);
+ break;
+ }
+ offset = cbfs_next_offset(offset, align, entry_sz);
+ }
+
+ return fd;
}
-void * cbfs_load_stage(struct cbfs_media *media, const char *name)
+const struct cbfs_file_descriptor *
+cbfs_open_by_name(const struct cbfs_descriptor *cbfs, const char *name)
{
- struct cbfs_stage *stage = (struct cbfs_stage *)
- cbfs_get_file_content(media, name, CBFS_TYPE_STAGE, NULL);
- /* this is a mess. There is no ntohll. */
- /* for now, assume compatible byte order until we solve this. */
- uint32_t entry;
- uint32_t final_size;
+ return __cbfs_open(cbfs, name, NULL);
+}
- if (stage == NULL)
- return (void *) -1;
+const struct cbfs_file_descriptor *
+cbfs_open_by_name_type(const struct cbfs_descriptor *cbfs,
+ const char *name, uint32_t type)
+{
+ return __cbfs_open(cbfs, name, &type);
+}
- LOG("loading stage %s @ 0x%x (%d bytes), entry @ 0x%llx\n",
- name,
- (uint32_t) stage->load, stage->memlen,
- stage->entry);
+void cbfs_file_close(const struct cbfs_file_descriptor *file)
+{
+ if (file != NULL)
+ cbfs_fd_mark_free(file);
+}
- final_size = cbfs_decompress(stage->compression,
- ((unsigned char *) stage) +
- sizeof(struct cbfs_stage),
- (void *) (uint32_t) stage->load,
- stage->len);
- if (!final_size)
- return (void *) -1;
+ssize_t cbfs_file_content_size(const struct cbfs_file_descriptor *fd)
+{
+ if (fd == NULL)
+ return -1;
- /* Stages rely the below clearing so that the bss is initialized. */
- memset((void *)((uintptr_t)stage->load + final_size), 0,
- stage->memlen - final_size);
+ return fd->content.size;
+}
- DEBUG("stage loaded.\n");
+ssize_t cbfs_file_metadata_size(const struct cbfs_file_descriptor *fd)
+{
+ if (fd == NULL)
+ return -1;
- entry = stage->entry;
- // entry = ntohll(stage->entry);
+ return fd->metadata.size;
+}
- return (void *) entry;
+ssize_t cbfs_file_read_content(const struct cbfs_file_descriptor *fd,
+ void *buf, offset_t offset, size_t size)
+{
+ struct region region = {
+ .offset = offset,
+ .size = size,
+ };
+
+ if (fd == NULL)
+ return -1;
+
+ if (region_request_normalize(&fd->content, ®ion))
+ return -1;
+
+ return region_readat(fd->rh, buf, region.offset, size);
}
-/* Simple buffer */
+void *cbfs_file_map_content(const struct cbfs_file_descriptor *fd,
+ offset_t offset, size_t size)
+{
+ struct region region = {
+ .offset = offset,
+ .size = size,
+ };
-void *cbfs_simple_buffer_map(struct cbfs_simple_buffer *buffer,
- struct cbfs_media *media,
- size_t offset, size_t count) {
- void *address = buffer->buffer + buffer->allocated;
- DEBUG("simple_buffer_map(offset=%zd, count=%zd): "
- "allocated=%zd, size=%zd, last_allocate=%zd\n",
- offset, count, buffer->allocated, buffer->size,
- buffer->last_allocate);
- if (buffer->allocated + count >= buffer->size)
- return CBFS_MEDIA_INVALID_MAP_ADDRESS;
- if (media->read(media, address, offset, count) != count) {
- ERROR("simple_buffer: fail to read %zd bytes from 0x%zx\n",
- count, offset);
- return CBFS_MEDIA_INVALID_MAP_ADDRESS;
- }
- buffer->allocated += count;
- buffer->last_allocate = count;
- return address;
-}
-
-void *cbfs_simple_buffer_unmap(struct cbfs_simple_buffer *buffer,
- const void *address) {
- // TODO Add simple buffer management so we can free more than last
- // allocated one.
- DEBUG("simple_buffer_unmap(address=0x%p): "
- "allocated=%zd, size=%zd, last_allocate=%zd\n",
- address, buffer->allocated, buffer->size,
- buffer->last_allocate);
- if ((buffer->buffer + buffer->allocated - buffer->last_allocate) ==
- address) {
- buffer->allocated -= buffer->last_allocate;
- buffer->last_allocate = 0;
- }
- return NULL;
+ if (fd == NULL)
+ return NULL;
+
+ if (region_request_normalize(&fd->content, ®ion))
+ return NULL;
+
+ return region_mmap(fd->rh, region.offset, size);
}
-/**
- * run_address is passed the address of a function taking no parameters and
- * jumps to it, returning the result.
- * @param f the address to call as a function.
- * @return value returned by the function.
- */
+ssize_t cbfs_file_read_metadata(const struct cbfs_file_descriptor *fd,
+ void *buf, offset_t offset, size_t size)
+{
+ struct region region = {
+ .offset = offset,
+ .size = size,
+ };
+
+ if (fd == NULL)
+ return -1;
+
+ if (region_request_normalize(&fd->metadata, ®ion))
+ return -1;
+
+ return region_readat(fd->rh, buf, region.offset, size);
+}
+
+void *cbfs_file_map_metadata(const struct cbfs_file_descriptor *fd)
+{
+ if (fd == NULL)
+ return NULL;
+
+ return region_mmap(fd->rh, fd->metadata.offset, fd->metadata.size);
+}
+
+void cbfs_file_unmap(const struct cbfs_file_descriptor *fd, void *addr)
+{
+ if (fd == NULL)
+ return;
+
+ region_munmap(fd->rh, addr);
+}
-int run_address(void *f)
+#ifndef __SMM__
+size_t cbfs_file_inflate(const struct cbfs_file_descriptor *fd,
+ offset_t offset, size_t src_sz, void *dest)
{
- int (*v) (void);
- v = f;
- return v();
+#if defined(CBFS_WITH_LZMA)
+ void *src;
+ size_t dest_sz;
+
+ src = cbfs_file_map_content(fd, offset, src_sz);
+
+ if (src == NULL)
+ return 0;
+
+ dest_sz = ulzma(src, dest);
+
+ cbfs_file_unmap(fd, src);
+
+ return dest_sz;
+#else
+ return 0;
+#endif
}
+void *cbfs_load_stage(const struct cbfs_descriptor *cbfs, const char *name)
+{
+ struct cbfs_stage stage;
+ const struct cbfs_file_descriptor *file;
+ size_t inflated_sz;
+ ssize_t metadata_sz;
+ ssize_t file_sz;
+ uint8_t *dest;
+ void *entry;
+
+ entry = NULL;
+ file = cbfs_open_by_name_type(cbfs, name, CBFS_TYPE_STAGE);
+
+ if (file == NULL)
+ return NULL;
+
+ metadata_sz = cbfs_file_read_metadata(file, &stage, 0, sizeof(stage));
+ if (metadata_sz != sizeof(stage))
+ goto out;
+
+ file_sz = cbfs_file_content_size(file);
+ if (file_sz < 0)
+ goto out;
+
+ printk(BIOS_INFO,
+ "Loading stage '%s' 0x%llx (%d bytes), entry point 0x%llx\n",
+ name, (long long) stage.load, stage.memlen,
+ (long long)stage.entry);
+
+ dest = (void *)(uintptr_t)stage.load;
+ inflated_sz = stage.memlen;
+
+ switch (stage.compression) {
+ case CBFS_COMPRESS_NONE:
+ if (cbfs_file_read_content(file, dest, 0, file_sz) != file_sz)
+ goto out;
+ break;
+#if defined(CBFS_WITH_LZMA)
+ case CBFS_COMPRESS_LZMA:
+ inflated_sz = cbfs_file_inflate(file, 0, file_sz, dest);
+ if (inflated_sz == 0)
+ goto out;
+ break;
+#endif
+ default:
+ printk(BIOS_ERR,"Invalid compression scheme: %d\n",
+ stage.compression);
+ goto out;
+ }
+
+ if (inflated_sz > stage.memlen) {
+ printk(BIOS_ERR,"Inflated size %zu > memory size %zu.\n",
+ inflated_sz, (size_t)stage.memlen);
+ goto out;
+ }
+
+ /* Stages rely the below clearing so that the bss is initialized. */
+ memset(dest + inflated_sz, 0, stage.memlen - inflated_sz);
+
+ printk(BIOS_DEBUG,"stage loaded.\n");
+
+ entry = (void *)(uintptr_t)stage.entry;
+
+out:
+ cbfs_file_close(file);
+ return entry;
+}
#endif
diff --git a/src/lib/cbfs_boot_region.c b/src/lib/cbfs_boot_region.c
new file mode 100644
index 0000000..6ab12f7
--- /dev/null
+++ b/src/lib/cbfs_boot_region.c
@@ -0,0 +1,133 @@
+/*
+ * This file is part of the coreboot project.
+ *
+ * Copyright (C) 2014 Google Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <stdint.h>
+#include <arch/early_variables.h>
+#include <arch/byteorder.h>
+#include <console/console.h>
+#include <cbfs.h>
+#include <cbfs_core.h>
+#include <region.h>
+
+static struct cbfs_descriptor g_cbfs_descriptor CAR_GLOBAL;
+
+const struct cbfs_descriptor *cbfs_default_descriptor(void)
+{
+ return car_get_var_ptr(&g_cbfs_descriptor);
+}
+
+static const struct region_device cbfs_dev = {
+ .region = {
+ .offset = CONFIG_ROM_SIZE - CONFIG_CBFS_SIZE,
+ .size = CONFIG_CBFS_SIZE,
+ },
+};
+
+#if IS_ENABLED(CONFIG_ARCH_X86)
+static offset_t get_header_offset(rhandle_t rh)
+{
+ int32_t header_offset;
+ offset_t off;
+ ssize_t rsize;
+
+ rsize = region_size(rh);
+ off = rsize - sizeof(header_offset);
+ region_readat(rh, &header_offset, off, sizeof(header_offset));
+ return rsize + header_offset;
+}
+#else
+static inline offset_t get_header_offset(rhandle_t rh)
+{
+ return CONFIG_CBFS_HEADER_ROM_OFFSET;
+}
+#endif
+
+void cbfs_default_media_initialize(void)
+{
+ rhandle_t rh;
+ offset_t header_offset;
+ struct cbfs_header *hdr;
+ size_t cbfs_size;
+ struct cbfs_descriptor *cbfs_desc;
+
+ /* Already initialized. */
+ rh = region_locate(DEFAULT_CBFS_REGION_NAME);
+ if (rhandle_valid(rh))
+ return;
+
+ /* Mark region as invalid. */
+ cbfs_desc = (struct cbfs_descriptor *)cbfs_default_descriptor();
+ cbfs_desc->rh = INVALID_RHANDLE;
+
+ /* CBFS provides a readonly view of the rom. */
+ rh = region_locate(BOOTRO_REGION_NAME);
+
+ if (!rhandle_valid(rh)) {
+ printk(BIOS_ERR, "Boot region not found to register cbfs.\n");
+ return;
+ }
+
+ header_offset = get_header_offset(rh);
+ hdr = region_mmap(rh, header_offset, sizeof(*hdr));
+
+ if (hdr == NULL) {
+ printk(BIOS_ERR, "Couldn't mmap() cbfs header.\n");
+ return;
+ }
+
+ if (CBFS_HEADER_MAGIC != ntohl(hdr->magic)) {
+ printk(BIOS_ERR, "Invalid CBFS magic @ 0x%zx: %x vs %x\n",
+ (size_t)header_offset, CBFS_HEADER_MAGIC,
+ ntohl(hdr->magic));
+ goto out;
+ }
+
+ if (cbfs_dev.region.offset != ntohl(hdr->offset)) {
+ printk(BIOS_ERR, "CBFS offset doesn't match: 0x%zx vs 0x%zx\n",
+ (size_t)cbfs_dev.region.offset,
+ (size_t)ntohl(hdr->offset));
+ goto out;
+ }
+
+ cbfs_size = ntohl(hdr->romsize) - ntohl(hdr->offset);
+
+ if (cbfs_dev.region.size != cbfs_size) {
+ printk(BIOS_ERR, "CBFS size doesn't match: 0x%zx vs 0x%zx\n",
+ cbfs_dev.region.size, cbfs_size);
+ goto out;
+ }
+
+#if IS_ENABLED(CONFIG_ARCH_X86)
+ cbfs_size -= htonl(hdr->bootblocksize);
+#endif
+
+ cbfs_desc->align = ntohl(hdr->align);
+ cbfs_desc->size = cbfs_size;
+
+ printk(BIOS_DEBUG, "%s: CBFS align 0x%zx size 0x%zx\n", __func__,
+ cbfs_desc->align, cbfs_desc->size);
+
+ cbfs_desc->rh = region_register_subregion(DEFAULT_CBFS_REGION_NAME,
+ &cbfs_dev, rh);
+ if (!rhandle_valid(cbfs_desc->rh))
+ printk(BIOS_ERR, "Unable to register default CBFS region.\n");
+
+out:
+ region_munmap(rh, hdr);
+}
diff --git a/src/lib/cbfs_core.c b/src/lib/cbfs_core.c
deleted file mode 100644
index 50c037e..0000000
--- a/src/lib/cbfs_core.c
+++ /dev/null
@@ -1,224 +0,0 @@
-/*
- * This file is part of the coreboot project.
- *
- * Copyright (C) 2011 secunet Security Networks AG
- * Copyright (C) 2013 The Chromium OS Authors. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * 3. The name of the author may not be used to endorse or promote products
- * derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-/* The CBFS core requires a couple of #defines or functions to adapt it to the
- * target environment:
- *
- * CBFS_CORE_WITH_LZMA (must be #define)
- * if defined, ulzma() must exist for decompression of data streams
- *
- * CBFS_HEADER_ROM_ADDRESS
- * ROM address (offset) of CBFS header. Underlying CBFS media may interpret
- * it in other way so we call this "address".
- *
- * ERROR(x...)
- * print an error message x (in printf format)
- *
- * LOG(x...)
- * print a message x (in printf format)
- *
- * DEBUG(x...)
- * print a debug message x (in printf format)
- *
- */
-
-#include <cbfs.h>
-#include <string.h>
-
-/* returns a pointer to CBFS master header, or CBFS_HEADER_INVALID_ADDRESS
- * on failure */
-const struct cbfs_header *cbfs_get_header(struct cbfs_media *media)
-{
- const struct cbfs_header *header;
- struct cbfs_media default_media;
-
- if (media == CBFS_DEFAULT_MEDIA) {
- media = &default_media;
- if (init_default_cbfs_media(media) != 0) {
- ERROR("Failed to initialize default media.\n");
- return CBFS_HEADER_INVALID_ADDRESS;
- }
- }
-
- media->open(media);
- DEBUG("CBFS_HEADER_ROM_ADDRESS: 0x%x/0x%x\n", CBFS_HEADER_ROM_ADDRESS,
- CONFIG_ROM_SIZE);
- header = media->map(media, CBFS_HEADER_ROM_ADDRESS, sizeof(*header));
- media->close(media);
-
- if (header == CBFS_MEDIA_INVALID_MAP_ADDRESS) {
- ERROR("Failed to load CBFS header from 0x%x\n",
- CBFS_HEADER_ROM_ADDRESS);
- return CBFS_HEADER_INVALID_ADDRESS;
- }
-
- if (CBFS_HEADER_MAGIC != ntohl(header->magic)) {
- ERROR("Could not find valid CBFS master header at %x: "
- "%x vs %x.\n", CBFS_HEADER_ROM_ADDRESS, CBFS_HEADER_MAGIC,
- ntohl(header->magic));
- if (header->magic == 0xffffffff) {
- ERROR("Maybe ROM is not mapped properly?\n");
- }
- return CBFS_HEADER_INVALID_ADDRESS;
- }
- return header;
-}
-
-/* public API starts here*/
-struct cbfs_file *cbfs_get_file(struct cbfs_media *media, const char *name)
-{
- const char *file_name;
- uint32_t offset, align, romsize, name_len;
- const struct cbfs_header *header;
- struct cbfs_file file, *file_ptr;
- struct cbfs_media default_media;
-
- if (media == CBFS_DEFAULT_MEDIA) {
- media = &default_media;
- if (init_default_cbfs_media(media) != 0) {
- ERROR("Failed to initialize default media.\n");
- return NULL;
- }
- }
-
- if (CBFS_HEADER_INVALID_ADDRESS == (header = cbfs_get_header(media)))
- return NULL;
-
- // Logical offset (for source media) of first file.
- offset = ntohl(header->offset);
- align = ntohl(header->align);
- romsize = ntohl(header->romsize);
-
- // TODO Add a "size" in CBFS header for a platform independent way to
- // determine the end of CBFS data.
-#if defined(CONFIG_ARCH_X86) && CONFIG_ARCH_X86
- romsize -= htonl(header->bootblocksize);
-#endif
- DEBUG("CBFS location: 0x%x~0x%x, align: %d\n", offset, romsize, align);
-
- DEBUG("Looking for '%s' starting from 0x%x.\n", name, offset);
- media->open(media);
- while (offset < romsize &&
- media->read(media, &file, offset, sizeof(file)) == sizeof(file)) {
- if (memcmp(CBFS_FILE_MAGIC, file.magic,
- sizeof(file.magic)) != 0) {
- uint32_t new_align = align;
- if (offset % align)
- new_align += align - (offset % align);
- ERROR("ERROR: No file header found at 0x%x - "
- "try next aligned address: 0x%x.\n", offset,
- offset + new_align);
- offset += new_align;
- continue;
- }
- name_len = ntohl(file.offset) - sizeof(file);
- DEBUG(" - load entry 0x%x file name (%d bytes)...\n", offset,
- name_len);
-
- // load file name (arbitrary length).
- file_name = (const char *)media->map(
- media, offset + sizeof(file), name_len);
- if (file_name == CBFS_MEDIA_INVALID_MAP_ADDRESS) {
- ERROR("ERROR: Failed to get filename: 0x%x.\n", offset);
- } else if (strcmp(file_name, name) == 0) {
- int file_offset = ntohl(file.offset),
- file_len = ntohl(file.len);
- DEBUG("Found file (offset=0x%x, len=%d).\n",
- offset + file_offset, file_len);
- media->unmap(media, file_name);
- file_ptr = media->map(media, offset,
- file_offset + file_len);
- media->close(media);
- return file_ptr;
- } else {
- DEBUG(" (unmatched file @0x%x: %s)\n", offset,
- file_name);
- media->unmap(media, file_name);
- }
-
- // Move to next file.
- offset += ntohl(file.len) + ntohl(file.offset);
- if (offset % align)
- offset += align - (offset % align);
- }
- media->close(media);
- LOG("WARNING: '%s' not found.\n", name);
- return NULL;
-}
-
-void *cbfs_get_file_content(struct cbfs_media *media, const char *name,
- int type, size_t *sz)
-{
- struct cbfs_file *file = cbfs_get_file(media, name);
-
- if (sz)
- *sz = 0;
-
- if (file == NULL) {
- ERROR("Could not find file '%s'.\n", name);
- return NULL;
- }
-
- if (ntohl(file->type) != type) {
- ERROR("File '%s' is of type %x, but we requested %x.\n", name,
- ntohl(file->type), type);
- return NULL;
- }
-
- if (sz)
- *sz = ntohl(file->len);
-
- return (void *)CBFS_SUBHEADER(file);
-}
-
-int cbfs_decompress(int algo, void *src, void *dst, int len)
-{
- switch (algo) {
- case CBFS_COMPRESS_NONE:
- /* Reads need to be aligned at 4 bytes to avoid
- poor flash performance. */
- while (len && ((u32)src & 3)) {
- *(u8*)dst++ = *(u8*)src++;
- len--;
- }
- memmove(dst, src, len);
- return len;
-#ifdef CBFS_CORE_WITH_LZMA
- case CBFS_COMPRESS_LZMA:
- return ulzma(src, dst);
-#endif
- default:
- ERROR("tried to decompress %d bytes with algorithm #%x,"
- "but that algorithm id is unsupported.\n", len,
- algo);
- return 0;
- }
-}
-
diff --git a/src/lib/loaders/cbfs_payload_loader.c b/src/lib/loaders/cbfs_payload_loader.c
index 2c1d179..31ad7e6 100644
--- a/src/lib/loaders/cbfs_payload_loader.c
+++ b/src/lib/loaders/cbfs_payload_loader.c
@@ -18,20 +18,30 @@
*/
#include <cbfs.h>
+#include <cbfs_core.h>
#include <payload_loader.h>
static int cbfs_locate_payload(struct payload *payload)
{
void *buffer;
size_t size;
- const int type = CBFS_TYPE_PAYLOAD;
+ const struct cbfs_file_descriptor *fd;
- buffer = cbfs_get_file_content(CBFS_DEFAULT_MEDIA, payload->name,
- type, &size);
+ fd = cbfs_open_by_name_type(cbfs_default_descriptor(), payload->name,
+ CBFS_TYPE_PAYLOAD);
- if (buffer == NULL)
+ if (fd == NULL)
return -1;
+ size = cbfs_file_content_size(fd);
+ buffer = cbfs_file_map_content(fd, 0, size);
+
+ if (buffer == NULL) {
+ cbfs_file_close(fd);
+ return -1;
+ }
+
+ payload->fd = fd;
payload->backing_store.data = buffer;
payload->backing_store.size = size;
diff --git a/src/lib/loaders/cbfs_ramstage_loader.c b/src/lib/loaders/cbfs_ramstage_loader.c
index 5d5cc0b..5d5edd8 100644
--- a/src/lib/loaders/cbfs_ramstage_loader.c
+++ b/src/lib/loaders/cbfs_ramstage_loader.c
@@ -34,7 +34,8 @@ static void *cbfs_load_ramstage(uint32_t cbmem_id, const char *name,
.name = name,
};
- if (rmodule_stage_load_from_cbfs(&rmod_ram)) {
+ if (rmodule_stage_load_from_cbfs(cbfs_default_descriptor(),
+ &rmod_ram)) {
printk(BIOS_DEBUG, "Could not load ramstage.\n");
return NULL;
}
@@ -49,14 +50,7 @@ static void *cbfs_load_ramstage(uint32_t cbmem_id, const char *name,
static void *cbfs_load_ramstage(uint32_t cbmem_id, const char *name,
const struct cbmem_entry **cbmem_entry)
{
- void *entry;
-
- entry = cbfs_load_stage(CBFS_DEFAULT_MEDIA, name);
-
- if ((void *)entry == (void *) -1)
- entry = NULL;
-
- return entry;
+ return cbfs_load_stage(cbfs_default_descriptor(), name);
}
#endif /* CONFIG_RELOCATABLE_RAMSTAGE */
diff --git a/src/lib/loaders/load_and_run_payload.c b/src/lib/loaders/load_and_run_payload.c
index 2204090..ac4e7bf 100644
--- a/src/lib/loaders/load_and_run_payload.c
+++ b/src/lib/loaders/load_and_run_payload.c
@@ -58,9 +58,8 @@ struct payload *payload_load(void)
ops->name);
continue;
}
- printk(BIOS_DEBUG, "%s: located payload @ %p, %zu bytes.\n",
- ops->name, payload->backing_store.data,
- payload->backing_store.size);
+ printk(BIOS_DEBUG, "%s: located payload, %zu bytes.\n",
+ ops->name, payload->backing_store.size);
break;
}
diff --git a/src/lib/region.c b/src/lib/region.c
new file mode 100644
index 0000000..3d11b7d
--- /dev/null
+++ b/src/lib/region.c
@@ -0,0 +1,306 @@
+/*
+ * This file is part of the coreboot project.
+ *
+ * Copyright (C) 2014 Google Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <string.h>
+#include <console/console.h>
+#include <arch/early_variables.h>
+#include <region.h>
+#include <vendorcode/google/chromeos/fmap.h>
+
+/* MAX_REGIONS could be configurable. */
+#define MAX_REGIONS 6
+
+struct region_registry_entry {
+ rhandle_t parent_slot;
+ const char *name;
+ const struct region_device *rdev;
+};
+
+struct region_registry {
+ struct region_registry_entry entries[MAX_REGIONS];
+};
+
+static struct region_registry g_regions CAR_GLOBAL;
+
+static inline struct region_registry *get_registry(void)
+{
+ return car_get_var_ptr(&g_regions);
+}
+
+static const struct region_registry_entry *
+registry_entry_lookup(const struct region_registry *rr, rhandle_t rh)
+{
+ if (rh < 0 || rh >= MAX_REGIONS)
+ return NULL;
+
+ return &rr->entries[rh];
+}
+
+static int region_enclosed(const struct region *parent,
+ const struct region *child)
+{
+ offset_t parent_end;
+ offset_t child_end;
+
+ child_end = child->offset + child->size;
+ parent_end = parent->offset + parent->size;
+
+ if (child->size > parent->size)
+ return -1;
+
+ if (child->offset >= parent->offset && child_end <= parent_end)
+ return 0;
+
+ return -1;
+}
+
+int region_request_normalize(const struct region *parent,
+ struct region *request)
+{
+ request->offset += parent->offset;
+ return region_enclosed(parent, request);
+}
+
+static rhandle_t __region_register(struct region_registry *rr, const char *name,
+ const struct region_device *rdev,
+ rhandle_t parent)
+{
+ rhandle_t slot;
+
+ for (slot = 0; slot < MAX_REGIONS; slot++) {
+ struct region_registry_entry *entry = &rr->entries[slot];
+
+ /* Find an empty slot. */
+ if (entry->rdev != NULL)
+ continue;
+
+ entry->parent_slot = parent;
+ entry->name = name;
+ entry->rdev = rdev;
+ printk(BIOS_DEBUG,
+ "Region '%s' registered: slot %u, %zu @ 0x%zx.\n",
+ name, (unsigned int)slot, rdev->region.size,
+ (size_t)rdev->region.offset);
+ return slot;
+ }
+
+ return INVALID_RHANDLE;
+}
+
+rhandle_t region_register(const char *name, const struct region_device *rdev)
+{
+ if (name == NULL || rdev == NULL || rdev->ops == NULL)
+ return INVALID_RHANDLE;
+
+ return __region_register(get_registry(), name, rdev, INVALID_RHANDLE);
+}
+
+rhandle_t region_register_subregion(const char *name,
+ const struct region_device *rdev,
+ rhandle_t parent)
+{
+ struct region_registry *rr;
+ const struct region_registry_entry *pentry;
+
+ /* Subregions require NULL ops. */
+ if (name == NULL || rdev == NULL || rdev->ops != NULL)
+ return INVALID_RHANDLE;
+
+ rr = get_registry();
+
+ /* Parent is invalid. */
+ pentry = registry_entry_lookup(rr, parent);
+ if (pentry == NULL)
+ return INVALID_RHANDLE;
+
+ /* Ensure subregion is within bounds. */
+ if (region_enclosed(&pentry->rdev->region, &rdev->region))
+ return INVALID_RHANDLE;
+
+ return __region_register(rr, name, rdev, parent);
+}
+
+/* Locate a region of provided name. */
+rhandle_t region_locate(const char *name)
+{
+ rhandle_t slot;
+ struct region_registry *rr;
+
+ if (name == NULL)
+ return INVALID_RHANDLE;
+
+ rr = get_registry();
+
+ for (slot = 0; slot < MAX_REGIONS; slot++) {
+ const struct region_registry_entry *entry = &rr->entries[slot];
+
+ /* No more valid entries. */
+ if (entry->rdev == NULL)
+ break;
+
+ if (!strcmp(entry->name, name))
+ return slot;
+ }
+ return INVALID_RHANDLE;
+}
+
+/*
+ * Obtain the appropriate region_device while optionally translating the
+ * region into the parent's domain.
+ */
+static const struct region_device *
+find_parent(rhandle_t rh, struct region *region)
+{
+ const struct region_registry_entry *entry;
+ struct region_registry *rr;
+
+ rr = get_registry();
+ entry = registry_entry_lookup(rr, rh);
+
+ if (entry == NULL)
+ return NULL;
+
+ if (region != NULL &&
+ region_request_normalize(&entry->rdev->region, region))
+ return NULL;
+
+ while (entry->rdev->ops == NULL) {
+ entry = &rr->entries[entry->parent_slot];
+ /* Translate the region into the parent's view. */
+ if (region != NULL)
+ region->offset += entry->rdev->region.offset;
+ }
+
+ return entry->rdev;
+}
+
+ssize_t region_readat(rhandle_t rh, void *buf, offset_t offset, size_t count)
+{
+ const struct region_device *rdev;
+ struct region region = {
+ .offset = offset,
+ .size = count,
+ };
+
+ rdev = find_parent(rh, ®ion);
+
+ if (rdev == NULL || rdev->ops->readat == NULL)
+ return -1;
+
+ return rdev->ops->readat(rdev, buf, region.offset, region.size);
+}
+
+ssize_t region_writeat(rhandle_t rh, const void *buf, offset_t offset,
+ size_t count)
+{
+ const struct region_device *rdev;
+ struct region region = {
+ .offset = offset,
+ .size = count,
+ };
+
+ rdev = find_parent(rh, ®ion);
+
+ if (rdev == NULL || rdev->ops->writeat == NULL)
+ return -1;
+
+ return rdev->ops->writeat(rdev, buf, region.offset, region.size);
+}
+
+ssize_t region_eraseat(rhandle_t rh, offset_t offset, size_t count)
+{
+ const struct region_device *rdev;
+ struct region region = {
+ .offset = offset,
+ .size = count,
+ };
+
+ rdev = find_parent(rh, ®ion);
+
+ if (rdev == NULL || rdev->ops->eraseat == NULL)
+ return -1;
+
+ return rdev->ops->eraseat(rdev, region.offset, region.size);
+}
+
+void *region_mmap(rhandle_t rh, offset_t offset, size_t count)
+{
+ const struct region_device *rdev;
+ struct region region = {
+ .offset = offset,
+ .size = count,
+ };
+
+ if (count == 0)
+ return NULL;
+
+ rdev = find_parent(rh, ®ion);
+
+ if (rdev == NULL || rdev->ops->mmap == NULL)
+ return NULL;
+
+ return rdev->ops->mmap(rdev, region.offset, region.size);
+}
+
+void region_munmap(rhandle_t rh, void *addr)
+{
+ const struct region_device *rdev;
+
+ rdev = find_parent(rh, NULL);
+
+ if (rdev == NULL || rdev->ops->munmap == NULL)
+ return;
+
+ return rdev->ops->munmap(rdev, addr);
+}
+
+ssize_t region_size(rhandle_t rh)
+{
+ const struct region_registry_entry *entry;
+
+ entry = registry_entry_lookup(get_registry(), rh);
+
+ if (entry == NULL)
+ return -1;
+
+ return entry->rdev->region.size;
+}
+
+void boot_region_init(void)
+{
+ boot_media_initialize();
+ cbfs_default_media_initialize();
+ fmap_initialize();
+}
+
+/* Provide weak default. */
+void __attribute__((weak)) bootrw_media_initialize(void) {}
+
+#if !defined(__PRE_RAM__)
+#include <bootstate.h>
+static void regions_bscb(void *unused)
+{
+ boot_region_init();
+}
+
+BOOT_STATE_INIT_ENTRIES(regions_init) = {
+ BOOT_STATE_INIT_ENTRY(BS_DEV_INIT_CHIPS, BS_ON_ENTRY,
+ regions_bscb, NULL),
+};
+#endif
diff --git a/src/lib/rmodule.c b/src/lib/rmodule.c
index 2cb70b8..33481b2 100644
--- a/src/lib/rmodule.c
+++ b/src/lib/rmodule.c
@@ -21,6 +21,9 @@
#include <stdlib.h>
#include <string.h>
#include <console/console.h>
+#include <cbfs.h>
+#include <cbfs_core.h>
+#include <lib.h>
#include <rmodule.h>
/* Change this define to get more verbose debugging for module loading. */
@@ -305,11 +308,12 @@ int rmodule_calc_region(unsigned int region_alignment, size_t rmodule_size,
#include <cbmem.h>
#include <cbfs_core.h>
-int rmodule_stage_load(struct rmod_stage_load *rsl, struct cbfs_stage *stage)
+int rmodule_stage_load(struct rmod_stage_load *rsl, struct cbfs_stage *stage,
+ void *data)
{
struct rmodule rmod_stage;
size_t region_size;
- char *stage_region;
+ unsigned char *stage_region;
int rmodule_offset;
int load_offset;
const struct cbmem_entry *cbmem_entry;
@@ -331,8 +335,12 @@ int rmodule_stage_load(struct rmod_stage_load *rsl, struct cbfs_stage *stage)
printk(BIOS_INFO, "Decompressing stage %s @ 0x%p (%d bytes)\n",
rsl->name, &stage_region[rmodule_offset], stage->memlen);
- if (!cbfs_decompress(stage->compression, &stage[1],
- &stage_region[rmodule_offset], stage->len))
+ if (stage->compression == CBFS_COMPRESS_NONE) {
+ memcpy(data, &stage_region[rmodule_offset], stage->len);
+ } else if (stage->compression == CBFS_COMPRESS_LZMA) {
+ if (!ulzma(data, &stage_region[rmodule_offset]))
+ return -1;
+ } else
return -1;
if (rmodule_parse(&stage_region[rmodule_offset], &rmod_stage))
@@ -347,17 +355,35 @@ int rmodule_stage_load(struct rmod_stage_load *rsl, struct cbfs_stage *stage)
return 0;
}
-int rmodule_stage_load_from_cbfs(struct rmod_stage_load *rsl)
+int rmodule_stage_load_from_cbfs(const struct cbfs_descriptor *cbfs,
+ struct rmod_stage_load *rsl)
{
- struct cbfs_stage *stage;
+ const struct cbfs_file_descriptor *fd;
+ struct cbfs_stage stage;
+ size_t rdsz = sizeof(stage);
+ int ret;
+ void *buf;
- stage = cbfs_get_file_content(CBFS_DEFAULT_MEDIA,
- rsl->name, CBFS_TYPE_STAGE, NULL);
+ fd = cbfs_open_by_name_type(cbfs, rsl->name, CBFS_TYPE_STAGE);
- if (stage == NULL)
+ if (fd == NULL)
return -1;
- return rmodule_stage_load(rsl, stage);
+ ret = -1;
+ if (cbfs_file_read_metadata(fd, &stage, 0, rdsz) != rdsz)
+ goto out;
+
+ buf = cbfs_file_map_content(fd, 0, cbfs_file_content_size(fd));
+ if (buf == NULL)
+ goto out;
+
+ ret = rmodule_stage_load(rsl, &stage, buf);
+
+ cbfs_file_unmap(fd, buf);
+
+out:
+ cbfs_file_close(fd);
+ return ret;
}
#endif /* DYNAMIC_CBMEM */
diff --git a/src/lib/selfboot.c b/src/lib/selfboot.c
index feff03e..b6c8797 100644
--- a/src/lib/selfboot.c
+++ b/src/lib/selfboot.c
@@ -25,6 +25,7 @@
#include <stdlib.h>
#include <string.h>
#include <cbfs.h>
+#include <cbfs_core.h>
#include <lib.h>
#include <bootmem.h>
#include <payload_loader.h>
@@ -40,7 +41,7 @@ struct segment {
struct segment *next;
struct segment *prev;
unsigned long s_dstaddr;
- unsigned long s_srcaddr;
+ unsigned long s_srcoffset;
unsigned long s_memsz;
unsigned long s_filesz;
int compression;
@@ -140,7 +141,7 @@ static int relocate_segment(unsigned long buffer, struct segment *seg)
new->s_memsz = len;
seg->s_memsz -= len;
seg->s_dstaddr += len;
- seg->s_srcaddr += len;
+ seg->s_srcoffset += len;
if (seg->s_filesz > len) {
new->s_filesz = len;
seg->s_filesz -= len;
@@ -176,7 +177,7 @@ static int relocate_segment(unsigned long buffer, struct segment *seg)
seg->s_memsz = len;
new->s_memsz -= len;
new->s_dstaddr += len;
- new->s_srcaddr += len;
+ new->s_srcoffset += len;
if (seg->s_filesz > len) {
seg->s_filesz = len;
new->s_filesz -= len;
@@ -213,17 +214,12 @@ static int relocate_segment(unsigned long buffer, struct segment *seg)
static int build_self_segment_list(
- struct segment *head,
+ struct segment *head, struct cbfs_payload_segment *segment,
struct payload *payload, uintptr_t *entry)
{
struct segment *new;
- struct segment *ptr;
- struct cbfs_payload_segment *segment, *first_segment;
- struct cbfs_payload *cbfs_payload;
- cbfs_payload = payload->backing_store.data;
memset(head, 0, sizeof(*head));
head->next = head->prev = head;
- first_segment = segment = &cbfs_payload->segments;
while(1) {
printk(BIOS_DEBUG, "Loading segment from rom address 0x%p\n", segment);
@@ -237,43 +233,39 @@ static int build_self_segment_list(
case PAYLOAD_SEGMENT_DATA:
printk(BIOS_DEBUG, " %s (compression=%x)\n",
segment->type == PAYLOAD_SEGMENT_CODE ? "code" : "data",
- ntohl(segment->compression));
+ segment->compression);
new = malloc(sizeof(*new));
- new->s_dstaddr = ntohll(segment->load_addr);
- new->s_memsz = ntohl(segment->mem_len);
- new->compression = ntohl(segment->compression);
-
- new->s_srcaddr = (uintptr_t)
- ((unsigned char *)first_segment)
- + ntohl(segment->offset);
- new->s_filesz = ntohl(segment->len);
- printk(BIOS_DEBUG, " New segment dstaddr 0x%lx memsize 0x%lx srcaddr 0x%lx filesize 0x%lx\n",
- new->s_dstaddr, new->s_memsz, new->s_srcaddr, new->s_filesz);
+ new->s_dstaddr = segment->load_addr;
+ new->s_memsz = segment->mem_len;
+ new->compression = segment->compression;
+
+ new->s_srcoffset = segment->offset;
+ new->s_filesz = segment->len;
+ printk(BIOS_DEBUG, " New segment dstaddr 0x%lx memsize 0x%lx srcoffset 0x%lx filesize 0x%lx\n",
+ new->s_dstaddr, new->s_memsz, new->s_srcoffset, new->s_filesz);
/* Clean up the values */
if (new->s_filesz > new->s_memsz) {
new->s_filesz = new->s_memsz;
}
printk(BIOS_DEBUG, " (cleaned up) New segment addr 0x%lx size 0x%lx offset 0x%lx filesize 0x%lx\n",
- new->s_dstaddr, new->s_memsz, new->s_srcaddr, new->s_filesz);
+ new->s_dstaddr, new->s_memsz, new->s_srcoffset, new->s_filesz);
break;
case PAYLOAD_SEGMENT_BSS:
- printk(BIOS_DEBUG, " BSS 0x%p (%d byte)\n", (void *)
- (intptr_t)ntohll(segment->load_addr),
- ntohl(segment->mem_len));
+ printk(BIOS_DEBUG, " BSS 0x%p (%d byte)\n",
+ (void *)(intptr_t)segment->load_addr,
+ segment->mem_len);
new = malloc(sizeof(*new));
new->s_filesz = 0;
- new->s_srcaddr = (uintptr_t)
- ((unsigned char *)first_segment)
- + ntohl(segment->offset);
- new->s_dstaddr = ntohll(segment->load_addr);
- new->s_memsz = ntohl(segment->mem_len);
+ new->s_srcoffset = segment->offset;
+ new->s_dstaddr = segment->load_addr;
+ new->s_memsz = segment->mem_len;
break;
case PAYLOAD_SEGMENT_ENTRY:
printk(BIOS_DEBUG, " Entry Point 0x%p\n",
- (void *)(intptr_t)ntohll(segment->load_addr));
- *entry = ntohll(segment->load_addr);
+ (void *)(intptr_t)segment->load_addr);
+ *entry = segment->load_addr;
/* Per definition, a payload always has the entry point
* as last segment. Thus, we use the occurrence of the
* entry point as break condition for the loop.
@@ -292,17 +284,11 @@ static int build_self_segment_list(
/* We have found another CODE, DATA or BSS segment */
segment++;
- /* Find place where to insert our segment */
- for(ptr = head->next; ptr != head; ptr = ptr->next) {
- if (new->s_srcaddr < ntohll(segment->load_addr))
- break;
- }
-
- /* Order by stream offset */
- new->next = ptr;
- new->prev = ptr->prev;
- ptr->prev->next = new;
- ptr->prev = new;
+ /* Add to end of list. */
+ new->next = head;
+ new->prev = head->prev;
+ head->prev->next = new;
+ head->prev = new;
}
return 1;
@@ -315,6 +301,7 @@ static int load_self_segments(
struct segment *ptr;
const unsigned long one_meg = (1UL << 20);
unsigned long bounce_high = lb_end;
+ unsigned char *srcaddr = payload->backing_store.data;
for(ptr = head->next; ptr != head; ptr = ptr->next) {
if (bootmem_region_targets_usable_ram(ptr->s_dstaddr,
@@ -378,7 +365,7 @@ static int load_self_segments(
/* Compute the boundaries of the segment */
dest = (unsigned char *)(ptr->s_dstaddr);
- src = (unsigned char *)(ptr->s_srcaddr);
+ src = srcaddr + ptr->s_srcoffset;
/* Copy data from the initial buffer */
if (ptr->s_filesz) {
@@ -441,13 +428,51 @@ static int load_self_segments(
return 1;
}
+static void
+parse_cbfs_segments(struct cbfs_payload_segment *segments, size_t size)
+{
+ int i;
+ int num;
+
+ num = size / sizeof(struct cbfs_payload_segment);
+
+ for (i = 0; i < num; i++) {
+ /* Note: the type field is in host order. */
+ segments[i].compression = ntohl(segments[i].compression);
+ segments[i].offset = ntohl(segments[i].offset);
+ /* Fix up the offsets to be relative to the data stream. */
+ segments[i].offset -= size;
+ segments[i].load_addr = ntohll(segments[i].load_addr);
+ segments[i].len = ntohl(segments[i].len);
+ segments[i].mem_len = ntohl(segments[i].mem_len);
+ }
+}
+
void *selfload(struct payload *payload)
{
uintptr_t entry = 0;
struct segment head;
+ ssize_t metadata_sz;
+ struct cbfs_payload_segment *segments;
+
+ metadata_sz = cbfs_file_metadata_size(payload->fd);
+
+ if (metadata_sz <= 0)
+ return NULL;
+
+ segments = malloc(sizeof(struct cbfs_payload_segment));
+
+ if (segments == NULL)
+ return NULL;
+
+ if (cbfs_file_read_metadata(payload->fd, segments, 0, metadata_sz) !=
+ metadata_sz)
+ return NULL;
+
+ parse_cbfs_segments(segments, metadata_sz);
/* Preprocess the self segments */
- if (!build_self_segment_list(&head, payload, &entry))
+ if (!build_self_segment_list(&head, segments, payload, &entry))
goto out;
/* Load the segments */
diff --git a/src/soc/intel/baytrail/Kconfig b/src/soc/intel/baytrail/Kconfig
index 2360b36..63b5c89 100644
--- a/src/soc/intel/baytrail/Kconfig
+++ b/src/soc/intel/baytrail/Kconfig
@@ -8,6 +8,7 @@ if SOC_INTEL_BAYTRAIL
config CPU_SPECIFIC_OPTIONS
def_bool y
+ select BOOT_REGION_SPI_FLASH
select CACHE_MRC_SETTINGS
select CAR_MIGRATION
select COLLECT_TIMESTAMPS
diff --git a/src/soc/intel/baytrail/mrc_cache.c b/src/soc/intel/baytrail/mrc_cache.c
index 5613761..784952d 100644
--- a/src/soc/intel/baytrail/mrc_cache.c
+++ b/src/soc/intel/baytrail/mrc_cache.c
@@ -20,6 +20,7 @@
#include <string.h>
#include <console/console.h>
#include <cbmem.h>
+#include <region.h>
#include <ip_checksum.h>
#if CONFIG_CHROMEOS
#include <vendorcode/google/chromeos/fmap.h>
@@ -40,11 +41,20 @@ struct mrc_data_region {
static int mrc_cache_get_region(struct mrc_data_region *region)
{
#if CONFIG_CHROMEOS
- int ret;
- ret = find_fmap_entry("RW_MRC_CACHE", ®ion->base);
- if (ret >= 0) {
- region->size = ret;
- return 0;
+ offset_t offset;
+ size_t size;
+ if (!fmap_locate("RW_MRC_CACHE", &offset, &size)) {
+ void *mapping;
+ rhandle_t rh;
+
+ rh = region_locate(BOOTRO_REGION_NAME);
+ mapping = region_mmap(rh, offset, size);
+
+ if (mapping != NULL) {
+ region->base = mapping;
+ region->size = size;
+ return 0;
+ }
}
#endif
region->base = (void *)CONFIG_MRC_SETTINGS_CACHE_BASE;
diff --git a/src/soc/intel/baytrail/nvm.c b/src/soc/intel/baytrail/nvm.c
index dccc801..14c3f37 100644
--- a/src/soc/intel/baytrail/nvm.c
+++ b/src/soc/intel/baytrail/nvm.c
@@ -24,26 +24,25 @@
#include <spi-generic.h>
#include <spi_flash.h>
#include <baytrail/nvm.h>
+#include <region.h>
/* This module assumes the flash is memory mapped just below 4GiB in the
* address space for reading. Also this module assumes an area it erased
* when all bytes read as all 0xff's. */
-static struct spi_flash *flash;
+static rhandle_t rwrh = INVALID_RHANDLE;
static int nvm_init(void)
{
- if (flash != NULL)
+ if (rhandle_valid(rwrh))
return 0;
- spi_init();
- flash = spi_flash_probe(0, 0, 1000000, SPI_MODE_3);
- if (!flash) {
- printk(BIOS_DEBUG, "Could not find SPI device\n");
- return -1;
- }
+ rwrh = region_locate(BOOTRW_REGION_NAME);
- return 0;
+ if (rhandle_valid(rwrh))
+ return 0;
+
+ return -1;
}
/* Convert memory mapped pointer to flash offset. */
@@ -69,7 +68,10 @@ int nvm_erase(void *start, size_t size)
{
if (nvm_init() < 0)
return -1;
- flash->erase(flash, to_flash_offset(start), size);
+
+ if (region_eraseat(rwrh, to_flash_offset(start), size) != size)
+ return -1;
+
return 0;
}
@@ -78,6 +80,9 @@ int nvm_write(void *start, const void *data, size_t size)
{
if (nvm_init() < 0)
return -1;
- flash->write(flash, to_flash_offset(start), size, data);
+
+ if (region_writeat(rwrh, data, to_flash_offset(start), size) != size)
+ return -1;
+
return 0;
}
diff --git a/src/soc/intel/baytrail/romstage/raminit.c b/src/soc/intel/baytrail/romstage/raminit.c
index 7bcd54f..496e755 100644
--- a/src/soc/intel/baytrail/romstage/raminit.c
+++ b/src/soc/intel/baytrail/romstage/raminit.c
@@ -105,6 +105,7 @@ void raminit(struct mrc_params *mp, int prev_sleep_state)
int ret;
mrc_wrapper_entry_t mrc_entry;
const struct mrc_saved_data *cache;
+ const struct cbfs_file_descriptor *fd;
/* Fill in default entries. */
mp->version = MRC_PARAMS_VER;
@@ -118,10 +119,11 @@ void raminit(struct mrc_params *mp, int prev_sleep_state)
printk(BIOS_DEBUG, "No MRC cache found.\n");
}
- mrc_entry = cbfs_get_file_content(CBFS_DEFAULT_MEDIA, "mrc.bin", 0xab,
- NULL);
+ fd = cbfs_open_by_name_type(cbfs_default_descriptor(), "mrc.bin", 0xab);
+ mrc_entry = cbfs_file_map_content(fd, 0, cbfs_file_content_size(fd));
if (mrc_entry == NULL) {
+ cbfs_file_close(fd);
printk(BIOS_DEBUG, "Couldn't find mrc.bin\n");
return;
}
@@ -130,6 +132,9 @@ void raminit(struct mrc_params *mp, int prev_sleep_state)
ret = mrc_entry(mp);
+ cbfs_file_unmap(fd, mrc_entry);
+ cbfs_file_close(fd);
+
print_dram_info();
cbmem_initialize_empty();
diff --git a/src/soc/intel/baytrail/romstage/romstage.c b/src/soc/intel/baytrail/romstage/romstage.c
index 5af9bf4..37aae10 100644
--- a/src/soc/intel/baytrail/romstage/romstage.c
+++ b/src/soc/intel/baytrail/romstage/romstage.c
@@ -29,6 +29,7 @@
#include <ec/google/chromeec/ec.h>
#endif
#include <elog.h>
+#include <region.h>
#include <ramstage_cache.h>
#include <romstage_handoff.h>
#include <timestamp.h>
@@ -133,6 +134,9 @@ void * asmlinkage romstage_main(unsigned long bist,
google_chromeec_early_init();
#endif
+ /* Initialize the boot media. */
+ boot_region_init();
+
/* Call into mainboard. */
mainboard_romstage_entry(&rp);
diff --git a/src/vendorcode/google/chromeos/Makefile.inc b/src/vendorcode/google/chromeos/Makefile.inc
index 007bd57..24afb2c 100644
--- a/src/vendorcode/google/chromeos/Makefile.inc
+++ b/src/vendorcode/google/chromeos/Makefile.inc
@@ -27,6 +27,7 @@ romstage-y += fmap.c
ramstage-y += fmap.c
ramstage-$(CONFIG_CHROMEOS_RAMOOPS) += ramoops.c
smm-y += fmap.c
+smm-y += ../../../lib/region.c
ifneq ($(wildcard src/mainboard/$(MAINBOARDDIR)/chromeos.c),)
ramstage-srcs += src/mainboard/$(MAINBOARDDIR)/chromeos.c
romstage-srcs += src/mainboard/$(MAINBOARDDIR)/chromeos.c
diff --git a/src/vendorcode/google/chromeos/chromeos.c b/src/vendorcode/google/chromeos/chromeos.c
index e917ba1..6f20109 100644
--- a/src/vendorcode/google/chromeos/chromeos.c
+++ b/src/vendorcode/google/chromeos/chromeos.c
@@ -121,10 +121,14 @@ static int vboot_locate_payload(struct payload *payload)
if (buffer == NULL)
return -1;
+#if 0
payload->backing_store.data = buffer;
payload->backing_store.size = size;
return 0;
+#endif
+ /* TODO: fake a cbfs. Also need this in rmodule loading. */
+ return -1;
}
const struct payload_loader_ops vboot_payload_loader = {
diff --git a/src/vendorcode/google/chromeos/fmap.c b/src/vendorcode/google/chromeos/fmap.c
index 538b8c3..fa17e35 100644
--- a/src/vendorcode/google/chromeos/fmap.c
+++ b/src/vendorcode/google/chromeos/fmap.c
@@ -20,97 +20,134 @@
#include <stdint.h>
#include <stddef.h>
#include <string.h>
+#include <arch/early_variables.h>
#include <console/console.h>
+#include <region.h>
#include "fmap.h"
-/* Find FMAP data structure in ROM.
+/*
* See http://code.google.com/p/flashmap/ for more information on FMAP.
*/
-const struct fmap *fmap_find(void)
-{
- /* FIXME: Get rid of the hard codes. The "easy" way would be to
- * do a binary search, but since ROM accesses are slow, we don't
- * want to spend a lot of time looking for the FMAP. An elegant
- * solution would be to store a pointer to the FMAP in the CBFS
- * master header; that would require some more changes to cbfstool
- * and possibly cros_bundle_firmware.
- */
-
- /* wrapping around 0x100000000 */
- const struct fmap *fmap = (void *)
- (CONFIG_FLASHMAP_OFFSET - CONFIG_ROM_SIZE);
- if (memcmp(fmap, FMAP_SIGNATURE, sizeof(FMAP_SIGNATURE)-1)) {
- printk(BIOS_DEBUG, "No FMAP found at %p.\n", fmap);
- return NULL;
- }
+/*
+ * The reason for the global state is that FMAP needs to be available in
+ * romstage on x86 machines. This necessitates keeping some global variables
+ * around because there is no malloc or global modifiable data without being
+ * placed in BSS. This code relies on CAR globals being migrated in romstage.
+ */
- printk(BIOS_DEBUG, "FMAP: Found \"%s\" version %d.%d at %p.\n",
- fmap->name, fmap->ver_major, fmap->ver_minor, fmap);
- printk(BIOS_DEBUG, "FMAP: base = %llx size = %x #areas = %d\n",
- (unsigned long long)fmap->base, fmap->size, fmap->nareas);
+#define FMAP_REGION_NAME "fmap"
+
+struct fmap_state {
+ int registered;
+ int num_entries;
+};
+
+static struct fmap_state g_fmap_state CAR_GLOBAL;
+static const offset_t fmap_offset = CONFIG_FLASHMAP_OFFSET;
- return fmap;
+static inline struct fmap_state *get_state(void)
+{
+ return car_get_var_ptr(&g_fmap_state);
}
-const struct fmap_area *find_fmap_area(const struct fmap *fmap,
- const char name[])
+static const struct region_device fmap_rdev = {
+ .region = {
+ .offset = 0,
+ .size = CONFIG_ROM_SIZE,
+ },
+};
+
+/* Return < 0 on failure, 0 on success */
+static int fmap_init(void)
{
- const struct fmap_area *area = NULL;
-
- if (fmap) {
- int i;
- for (i = 0; i < fmap->nareas; i++) {
- if (!strcmp((const char *)fmap->areas[i].name, name)) {
- area = &fmap->areas[i];
- break;
- }
- }
- }
+ struct fmap_state *gs;
+ rhandle_t rh;
+ struct fmap *fmap;
- if (area) {
- printk(BIOS_DEBUG, "FMAP: area %s found\n", name);
- printk(BIOS_DEBUG, "FMAP: offset: %x\n", area->offset);
- printk(BIOS_DEBUG, "FMAP: size: %d bytes\n", area->size);
- } else {
- printk(BIOS_DEBUG, "FMAP: area %s not found\n", name);
+ gs = get_state();
+
+ if (gs->registered)
+ return 1;
+
+ /* Execute this function only once. Default to invalid. */
+ gs->registered = 1;
+ rh = region_locate(BOOTRO_REGION_NAME);
+
+ if (!rhandle_valid(rh))
+ return -1;
+
+ fmap = region_mmap(rh, fmap_offset, sizeof(*fmap));
+
+ if (fmap == NULL)
+ return -1;
+
+ if (memcmp(fmap, FMAP_SIGNATURE, sizeof(FMAP_SIGNATURE)-1)) {
+ printk(BIOS_DEBUG, "No FMAP found at %zx.\n", fmap_offset);
+ region_munmap(rh, fmap);
+ return -1;
}
+ printk(BIOS_DEBUG, "FMAP: Found \"%s\" version %d.%d at %zx.\n",
+ fmap->name, fmap->ver_major, fmap->ver_minor, fmap_offset);
+ printk(BIOS_DEBUG, "FMAP: base = %llx size = %x #areas = %d\n",
+ (unsigned long long)fmap->base, fmap->size, fmap->nareas);
+
+ gs->num_entries = fmap->nareas;
+ region_munmap(rh, fmap);
- return area;
+ /* Register fmap device under the boot region. */
+ if (!rhandle_valid(region_register_subregion(FMAP_REGION_NAME,
+ &fmap_rdev, rh)))
+ return -1;
+
+ return 0;
}
-int find_fmap_entry(const char name[], void **pointer)
+int fmap_locate(const char *name, offset_t *offset, size_t *size)
{
-#ifndef __PRE_RAM__
- static
-#endif
- const struct fmap *fmap = NULL;
- const struct fmap_area *area;
- void *base = NULL;
+ rhandle_t rh;
+ struct fmap_area *areas;
+ struct fmap_state * gs;
+ int i;
+ int ret = -1;
- if (!fmap)
- fmap = fmap_find();
+ rh = region_locate(FMAP_REGION_NAME);
+ gs = get_state();
- area = find_fmap_area(fmap, name);
+ if (!rhandle_valid(rh) || gs == NULL)
+ return ret;
- if (!area)
- return -1;
+ areas = region_mmap(rh, sizeof(struct fmap) + fmap_offset,
+ gs->num_entries * sizeof(*areas));
- /* Right now cros_bundle_firmware does not write a valid
- * base address into the FMAP. Hence, if base is 0, assume
- * 4GB-8MB as base address.
- */
- if (fmap->base) {
- base = (void *)(unsigned long)fmap->base;
- printk(BIOS_DEBUG, "FMAP: %s base at %p\n", name, base);
- } else {
- base = (void *)(0 - CONFIG_ROM_SIZE);
- printk(BIOS_WARNING, "FMAP: No valid base address, using"
- " 0x%p\n", base);
+ if (areas == NULL) {
+ printk(BIOS_DEBUG, "FMAP: could not map areas.\n");
+ return ret;
}
- *pointer = (void*) ((u32)base + area->offset);
- printk(BIOS_DEBUG, "FMAP: %s at %p (offset %x)\n",
- name, *pointer, area->offset);
- return area->size;
+ for (i = 0; i < gs->num_entries; i++) {
+ if (strcmp((char *)&areas[i].name[0], name))
+ continue;
+ printk(BIOS_DEBUG, "FMAP: area %s found\n", name);
+ printk(BIOS_DEBUG, "FMAP: offset: %x\n", areas[i].offset);
+ printk(BIOS_DEBUG, "FMAP: size: %d bytes\n", areas[i].size);
+
+ *offset = areas[i].offset;
+ *size = areas[i].size;
+ ret = 0;
+ break;
+ }
+
+ if (ret)
+ printk(BIOS_DEBUG, "FMAP: area '%s' not found.\n", name);
+
+ region_munmap(rh, areas);
+
+ return ret;
+}
+
+void fmap_initialize(void)
+{
+ if (fmap_init() < 0)
+ printk(BIOS_DEBUG, "FMAP region wasn't registered.\n");
}
diff --git a/src/vendorcode/google/chromeos/fmap.h b/src/vendorcode/google/chromeos/fmap.h
index a3d2abd..de935e7 100644
--- a/src/vendorcode/google/chromeos/fmap.h
+++ b/src/vendorcode/google/chromeos/fmap.h
@@ -37,6 +37,7 @@
#define FLASHMAP_LIB_FMAP_H__
#include <stdint.h>
+#include <region.h>
#define FMAP_SIGNATURE "__FMAP__"
#define FMAP_VER_MAJOR 1 /* this header's FMAP minor version */
@@ -70,10 +71,24 @@ struct fmap {
struct fmap_area areas[];
} __attribute__((packed));
+#if IS_ENABLED(CONFIG_CHROMEOS)
+/*
+ * Initialize the fmap state within coreboot.
+ */
+void fmap_initialize(void);
+
+/*
+ * Locate a region by name within the fmap. offset and size are filled in
+ * relative to the boot media the global fmap is located. Returns 0 on
+ * success, < 0 when unable to find the region.
+ */
+int fmap_locate(const char *name, offset_t *offset, size_t *size);
+#else /* IS_ENABLED(CONFIG_CHROMEOS) */
+static inline void fmap_initialize(void) {}
+static inline int fmap_locate(const char *name, offset_t *offset, size_t *size)
+{
+ return -1;
+}
+#endif /* IS_ENABLED(CONFIG_CHROMEOS) */
-/* coreboot specific function prototypes */
-const struct fmap *fmap_find(void);
-const struct fmap_area *find_fmap_area(const struct fmap *fmap,
- const char name[]);
-int find_fmap_entry(const char name[], void **pointer);
#endif /* FLASHMAP_LIB_FMAP_H__*/
diff --git a/src/vendorcode/google/chromeos/vboot_loader.c b/src/vendorcode/google/chromeos/vboot_loader.c
index 0c5220a..98bc1a5 100644
--- a/src/vendorcode/google/chromeos/vboot_loader.c
+++ b/src/vendorcode/google/chromeos/vboot_loader.c
@@ -21,6 +21,7 @@
#include <stdint.h>
#include <stddef.h>
#include <cbfs.h>
+#include <cbfs_core.h>
#include <cbmem.h>
#include <console/console.h>
#include <console/vtxprintf.h>
@@ -45,7 +46,8 @@ static void vboot_run_stub(struct vboot_context *context)
};
void (*entry)(struct vboot_context *context);
- if (rmodule_stage_load_from_cbfs(&rmod_stage)) {
+ if (rmodule_stage_load_from_cbfs(cbfs_default_descriptor(),
+ &rmod_stage)) {
printk(BIOS_DEBUG, "Could not load vboot stub.\n");
goto out;
}
@@ -74,6 +76,30 @@ static void fatal_error(void)
hard_reset();
}
+static void locate_region(const char *name, void **parea, uint32_t *psize)
+{
+ offset_t offset;
+ size_t size;
+ rhandle_t rh;
+
+ *psize = 0;
+ *parea = NULL;
+
+ if (fmap_locate(name, &offset, &size))
+ return;
+
+ rh = region_locate(BOOTRO_REGION_NAME);
+ if (!rhandle_valid(rh))
+ return;
+
+ /*
+ * This leaks the mappings on anything but x86 systems which have
+ * CBFS memory-mapped.
+ */
+ *psize = size;
+ *parea = region_mmap(rh, offset, size);
+}
+
static void vboot_invoke_wrapper(struct vboot_handoff *vboot_handoff)
{
VbCommonParams cparams;
@@ -105,20 +131,17 @@ static void vboot_invoke_wrapper(struct vboot_handoff *vboot_handoff)
context.cparams = &cparams;
context.fparams = &fparams;
- cparams.gbb_size = find_fmap_entry("GBB", &cparams.gbb_data);
+ locate_region("GBB", &cparams.gbb_data, &cparams.gbb_size);
cparams.shared_data_blob = &vboot_handoff->shared_data[0];
cparams.shared_data_size = VB_SHARED_DATA_MIN_SIZE;
cparams.caller_context = &context;
- fparams.verification_size_A =
- find_fmap_entry("VBLOCK_A", &fparams.verification_block_A);
- fparams.verification_size_B =
- find_fmap_entry("VBLOCK_B", &fparams.verification_block_B);
-
- context.fw_a_size =
- find_fmap_entry("FW_MAIN_A", (void **)&context.fw_a);
- context.fw_b_size =
- find_fmap_entry("FW_MAIN_B", (void **)&context.fw_b);
+ locate_region("VBLOCK_A", &fparams.verification_block_A,
+ &fparams.verification_size_A);
+ locate_region("VBLOCK_B", &fparams.verification_block_B,
+ &fparams.verification_size_B);
+ locate_region("FW_MAIN_A", (void **)&context.fw_a, &context.fw_a_size);
+ locate_region("FW_MAIN_B", (void **)&context.fw_b, &context.fw_b_size);
/* Check all fmap entries. */
if (context.fw_a == NULL || context.fw_b == NULL ||
@@ -195,7 +218,7 @@ static void *vboot_load_ramstage(uint32_t cbmem_id, const char *name,
stage = (void *)fwc->address;
- if (rmodule_stage_load(&rmod_load, stage)) {
+ if (rmodule_stage_load(&rmod_load, stage, &stage[1])) {
vboot_handoff->selected_firmware = VB_SELECT_FIRMWARE_READONLY;
printk(BIOS_DEBUG, "Could not load ramstage region.\n");
return NULL;
1
0
Aaron Durbin (adurbin(a)google.com) just uploaded a new patch set to gerrit, which you can find at http://review.coreboot.org/5394
-gerrit
commit e3ee6d330996209e1121361d4d590659e1e45064
Author: Aaron Durbin <adurbin(a)chromium.org>
Date: Thu Mar 13 08:50:00 2014 -0500
regions support
Needs some cleanup work. Compile tested as of now.
Change-Id: I2a78278090ae928468e197ac73d1fb18596bf8cb
Signed-off-by: Aaron Durbin <adurbin(a)chromium.org>
---
src/Kconfig | 7 +
src/arch/x86/boot/smbios.c | 8 +-
src/arch/x86/lib/rom_media.c | 114 +++---
src/cpu/intel/microcode/microcode.c | 38 +-
src/cpu/x86/mirror_payload.c | 38 +-
src/cpu/x86/smm/smm_module_handler.c | 9 +
src/device/pci_device.c | 7 +-
src/device/pci_rom.c | 232 +++++++-----
src/drivers/elog/elog.c | 142 +++-----
src/include/cbfs.h | 120 +++---
src/include/cbfs_core.h | 44 ---
src/include/device/pci_rom.h | 4 +-
src/include/payload_loader.h | 3 +
src/include/region.h | 145 ++++++++
src/include/rmodule.h | 7 +-
src/lib/Makefile.inc | 10 +
src/lib/bootrw_spi_flash_region.c | 119 ++++++
src/lib/cbfs.c | 501 ++++++++++++++++++--------
src/lib/cbfs_boot_region.c | 133 +++++++
src/lib/cbfs_core.c | 224 ------------
src/lib/loaders/cbfs_payload_loader.c | 18 +-
src/lib/loaders/cbfs_ramstage_loader.c | 12 +-
src/lib/loaders/load_and_run_payload.c | 5 +-
src/lib/region.c | 305 ++++++++++++++++
src/lib/rmodule.c | 46 ++-
src/lib/selfboot.c | 113 +++---
src/soc/intel/baytrail/Kconfig | 1 +
src/soc/intel/baytrail/mrc_cache.c | 20 +-
src/soc/intel/baytrail/nvm.c | 27 +-
src/soc/intel/baytrail/romstage/raminit.c | 9 +-
src/soc/intel/baytrail/romstage/romstage.c | 4 +
src/vendorcode/google/chromeos/Makefile.inc | 1 +
src/vendorcode/google/chromeos/chromeos.c | 4 +
src/vendorcode/google/chromeos/fmap.c | 177 +++++----
src/vendorcode/google/chromeos/fmap.h | 25 +-
src/vendorcode/google/chromeos/vboot_loader.c | 47 ++-
36 files changed, 1780 insertions(+), 939 deletions(-)
diff --git a/src/Kconfig b/src/Kconfig
index 531a8c8..b0b8d26 100644
--- a/src/Kconfig
+++ b/src/Kconfig
@@ -1094,3 +1094,10 @@ config REG_SCRIPT
default n
help
Internal option that controls whether we compile in register scripts.
+
+config BOOT_REGION_SPI_FLASH
+ def_bool n
+ depends on ARCH_X86
+ help
+ Use generic SPI flash boot region support. This will provide a
+ function to initialize the read-write boot region.
diff --git a/src/arch/x86/boot/smbios.c b/src/arch/x86/boot/smbios.c
index 0e84acc..0434715 100644
--- a/src/arch/x86/boot/smbios.c
+++ b/src/arch/x86/boot/smbios.c
@@ -27,7 +27,6 @@
#include <device/device.h>
#include <arch/cpu.h>
#include <cpu/x86/name.h>
-#include <cbfs_core.h>
#include <arch/byteorder.h>
#include <elog.h>
#if CONFIG_CHROMEOS
@@ -147,12 +146,7 @@ static int smbios_write_type0(unsigned long *current, int handle)
#endif
{
- const struct cbfs_header *header;
- u32 romsize = CONFIG_ROM_SIZE;
- header = cbfs_get_header(CBFS_DEFAULT_MEDIA);
- if (header != CBFS_HEADER_INVALID_ADDRESS)
- romsize = ntohl(header->romsize);
- t->bios_rom_size = (romsize / 65535) - 1;
+ t->bios_rom_size = (CONFIG_ROM_SIZE / 65535) - 1;
}
t->system_bios_major_release = 4;
diff --git a/src/arch/x86/lib/rom_media.c b/src/arch/x86/lib/rom_media.c
index ed2122c..aa17d64 100644
--- a/src/arch/x86/lib/rom_media.c
+++ b/src/arch/x86/lib/rom_media.c
@@ -18,84 +18,64 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
* MA 02110-1301 USA
*/
-#include <cbfs.h>
+#include <stdint.h>
#include <string.h>
+#include <console/console.h>
+#include <region.h>
-#ifdef LIBPAYLOAD
-# define printk(x...)
-# define init_default_cbfs_media libpayload_init_default_cbfs_media
- extern int libpayload_init_default_cbfs_media(struct cbfs_media *media);
-#else
-# include <console/console.h>
-#endif
-
-// Implementation of memory-mapped ROM media source on X86.
-
-static int x86_rom_open(struct cbfs_media *media) {
- return 0;
+static inline void *get_pointer(offset_t off)
+{
+ const uintptr_t base_address = (uintptr_t)-CONFIG_ROM_SIZE;
+ return (void *)(base_address + off);
}
-static void *x86_rom_map(struct cbfs_media *media, size_t offset, size_t count) {
- void *ptr;
- // Some address (ex, pointer to master header) may be given in memory
- // mapped location. To workaround that, we handle >0xf0000000 as real
- // memory pointer.
-
- if ((uint32_t)offset > (uint32_t)0xf0000000)
- ptr = (void*)offset;
- else
- ptr = (void*)(0 - (uint32_t)media->context + offset);
- return ptr;
+static void *
+boot_mmap(const struct region_device *rdev, offset_t off, size_t size)
+{
+ return get_pointer(off);
}
-static void *x86_rom_unmap(struct cbfs_media *media, const void *address) {
- return NULL;
+static void boot_munmap(const struct region_device *rdev, void *addr)
+{
}
-static size_t x86_rom_read(struct cbfs_media *media, void *dest, size_t offset,
- size_t count) {
- void *ptr = x86_rom_map(media, offset, count);
- memcpy(dest, ptr, count);
- x86_rom_unmap(media, ptr);
- return count;
+static ssize_t
+boot_readat(const struct region_device *rdev, void *buf,
+ offset_t off, size_t size)
+{
+ memcpy(buf, get_pointer(off), size);
+ return size;
}
-static int x86_rom_close(struct cbfs_media *media) {
- return 0;
-}
+static const struct region_device_ops boot_dev_ops = {
+ .mmap = boot_mmap,
+ .munmap = boot_munmap,
+ .readat = boot_readat,
+};
+
+static const struct region_device boot_dev = {
+ .ops = &boot_dev_ops,
+ .region = {
+ .offset = 0,
+ .size = CONFIG_ROM_SIZE,
+ },
+};
-int init_x86rom_cbfs_media(struct cbfs_media *media);
-int init_x86rom_cbfs_media(struct cbfs_media *media) {
- // On X86, we always keep a reference of pointer to CBFS header in
- // 0xfffffffc, and the pointer is still a memory-mapped address.
- // Since the CBFS core always use ROM offset, we need to figure out
- // header->romsize even before media is initialized.
- struct cbfs_header *header = (struct cbfs_header*)
- *(uint32_t*)(0xfffffffc);
- if (CBFS_HEADER_MAGIC != ntohl(header->magic)) {
-#if defined(CONFIG_ROM_SIZE)
- printk(BIOS_ERR, "Invalid CBFS master header at %p\n", header);
- media->context = (void*)CONFIG_ROM_SIZE;
-#else
- return -1;
-#endif
- } else {
- uint32_t romsize = ntohl(header->romsize);
- media->context = (void*)romsize;
-#if defined(CONFIG_ROM_SIZE)
- if (CONFIG_ROM_SIZE != romsize)
- printk(BIOS_INFO, "Warning: rom size unmatch (%d/%d)\n",
- CONFIG_ROM_SIZE, romsize);
-#endif
+void boot_media_initialize(void)
+{
+ rhandle_t rh;
+ const char *bootro_name = BOOTRO_REGION_NAME;
+
+ rh = region_locate(bootro_name);
+
+ /* Already registered. */
+ if (rhandle_valid(rh)) {
+ printk(BIOS_DEBUG, "Already Registered: '%s'\n", bootro_name);
+ return;
}
- media->open = x86_rom_open;
- media->close = x86_rom_close;
- media->map = x86_rom_map;
- media->unmap = x86_rom_unmap;
- media->read = x86_rom_read;
- return 0;
-}
-int init_default_cbfs_media(struct cbfs_media *media) {
- return init_x86rom_cbfs_media(media);
+ rh = region_register(bootro_name, &boot_dev);
+
+ if (!rhandle_valid(rh))
+ printk(BIOS_ERR, "Failed to register '%s'.\n", bootro_name);
}
diff --git a/src/cpu/intel/microcode/microcode.c b/src/cpu/intel/microcode/microcode.c
index 947dfd7..d6753c1 100644
--- a/src/cpu/intel/microcode/microcode.c
+++ b/src/cpu/intel/microcode/microcode.c
@@ -107,28 +107,48 @@ void intel_microcode_load_unlocked(const void *microcode_patch)
#endif
}
+#if !defined(__ROMCC__)
+static void *microcode_locate(u32 *len)
+{
+ const struct cbfs_file_descriptor *fd;
+ void *buf;
+
+ fd = cbfs_open_by_name(cbfs_default_descriptor(), MICROCODE_CBFS_FILE);
+ if (fd == NULL)
+ return NULL;
+
+ /*
+ * The following sequence relies on x86 having a persistent
+ * memory-mapped view of the SPI rom.
+ */
+ *len = cbfs_file_content_size(fd);
+ buf = cbfs_file_map_content(fd, 0, *len);
+ cbfs_file_close(fd);
+
+ return buf;
+}
+#endif
+
const void *intel_microcode_find(void)
{
- struct cbfs_file *microcode_file;
const struct microcode *ucode_updates;
u32 eax, microcode_len;
u32 pf, rev, sig, update_size;
unsigned int x86_model, x86_family;
msr_t msr;
+#if defined(__ROMCC__)
+ struct cbfs_file *file;
-#ifdef __PRE_RAM__
- microcode_file = walkcbfs_head((char *) MICROCODE_CBFS_FILE);
+ file = walkcbfs_head((char *) MICROCODE_CBFS_FILE);
+ microcode_len = ntohl(file->len);
+ ucode_updates = CBFS_SUBHEADER(file);
#else
- microcode_file = cbfs_get_file(CBFS_DEFAULT_MEDIA,
- MICROCODE_CBFS_FILE);
+ ucode_updates = microcode_locate(µcode_len);
#endif
- if (!microcode_file)
+ if (!ucode_updates)
return NULL;
- ucode_updates = CBFS_SUBHEADER(microcode_file);
- microcode_len = ntohl(microcode_file->len);
-
/* CPUID sets MSR 0x8B iff a microcode update has been loaded. */
msr.lo = 0;
msr.hi = 0;
diff --git a/src/cpu/x86/mirror_payload.c b/src/cpu/x86/mirror_payload.c
index edd2641..a6975e1 100644
--- a/src/cpu/x86/mirror_payload.c
+++ b/src/cpu/x86/mirror_payload.c
@@ -30,26 +30,12 @@ void mirror_payload(struct payload *payload)
size_t size;
char *src;
uintptr_t alignment_diff;
- const unsigned long cacheline_size = 64;
- const uintptr_t intra_cacheline_mask = cacheline_size - 1;
- const uintptr_t cacheline_mask = ~intra_cacheline_mask;
+ const unsigned long dword_size = sizeof(uint32_t);
+ const uintptr_t dword_mask = dword_size - 1;
src = payload->backing_store.data;
size = payload->backing_store.size;
- /*
- * Adjust size so that the start and end points are aligned to a
- * cacheline. The SPI hardware controllers on Intel machines should
- * cache full length cachelines as well as prefetch data. Once the
- * data is mirrored in memory all accesses should hit the CPU's cache.
- */
- alignment_diff = (intra_cacheline_mask & (uintptr_t)src);
- size += alignment_diff;
-
- size = ALIGN(size, cacheline_size);
-
- printk(BIOS_DEBUG, "Payload aligned size: 0x%zx\n", size);
-
buffer = bootmem_allocate_buffer(size);
if (buffer == NULL) {
@@ -57,7 +43,18 @@ void mirror_payload(struct payload *payload)
return;
}
- src = (void *)(cacheline_mask & (uintptr_t)src);
+ /*
+ * Do copies in 32-bit aligned reads from backing source.
+ * 1. Do a copy to align the source address.
+ * 2. Do remaining copy.
+ */
+ alignment_diff = dword_mask & (uintptr_t)src;
+ if (alignment_diff != 0) {
+ mempcy(buffer, src, alignment_diff);
+ src += alignment_diff;
+ buffer += alignment_diff;
+ size -= alignment_diff;
+ }
/*
* Note that if mempcy is not using 32-bit moves the performance will
@@ -66,6 +63,9 @@ void mirror_payload(struct payload *payload)
*/
memcpy(buffer, src, size);
- /* Update the payload's backing store. */
- payload->backing_store.data = &buffer[alignment_diff];
+ /*
+ * Update the payload's backing store. May leak resources depending
+ * cbfs stroage source.
+ */
+ payload->backing_store.data = buffer;
}
diff --git a/src/cpu/x86/smm/smm_module_handler.c b/src/cpu/x86/smm/smm_module_handler.c
index 444e335..ffe56c0 100644
--- a/src/cpu/x86/smm/smm_module_handler.c
+++ b/src/cpu/x86/smm/smm_module_handler.c
@@ -20,6 +20,7 @@
#include <arch/io.h>
#include <console/console.h>
#include <cpu/x86/smm.h>
+#include <region.h>
typedef enum { SMI_LOCKED, SMI_UNLOCKED } smi_semaphore;
@@ -113,6 +114,8 @@ void *smm_get_save_state(int cpu)
return base;
}
+static int regions_initialized;
+
void smm_handler_start(void *arg, int cpu, const struct smm_runtime *runtime)
{
/* Make sure to set the global runtime. It's OK to race as the value
@@ -145,6 +148,12 @@ void smm_handler_start(void *arg, int cpu, const struct smm_runtime *runtime)
printk(BIOS_SPEW, "\nSMI# #%d\n", cpu);
+ if (regions_initialized == 0) {
+ regions_initialized =1;
+ boot_region_init();
+ bootrw_media_initialize();
+ }
+
cpu_smi_handler();
northbridge_smi_handler();
southbridge_smi_handler();
diff --git a/src/device/pci_device.c b/src/device/pci_device.c
index aa0d954..bcdbbe4 100644
--- a/src/device/pci_device.c
+++ b/src/device/pci_device.c
@@ -667,7 +667,7 @@ int oprom_is_loaded = 0;
void pci_dev_init(struct device *dev)
{
#if CONFIG_VGA_ROM_RUN
- struct rom_header *rom, *ram;
+ struct rom_header *ram;
/* Only execute VGA ROMs. */
if (((dev->class >> 8) != PCI_CLASS_DISPLAY_VGA))
@@ -694,11 +694,8 @@ void pci_dev_init(struct device *dev)
return;
#endif
- rom = pci_rom_probe(dev);
- if (rom == NULL)
- return;
+ ram = pci_load_vga_rom(dev);
- ram = pci_rom_load(dev, rom);
if (ram == NULL)
return;
diff --git a/src/device/pci_rom.c b/src/device/pci_rom.c
index 1bdccf0..bb17931 100644
--- a/src/device/pci_rom.c
+++ b/src/device/pci_rom.c
@@ -6,6 +6,7 @@
* (Written by Yinghai Lu <yhlu(a)tyan.com> for Tyan)
* Copyright (C) 2005 Ronald G. Minnich <rminnich(a)gmail.com>
* Copyright (C) 2005-2007 Stefan Reinauer <stepan(a)openbios.org>
+ * Copyright (C) 2014 Google Inc.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@@ -28,62 +29,15 @@
#include <device/pci_ops.h>
#include <string.h>
#include <cbfs.h>
+#include <cbfs_core.h>
-struct rom_header *pci_rom_probe(struct device *dev)
+static struct rom_header *
+pci_rom_verify_and_load(struct device *dev, struct rom_header *rom_header,
+ void *load_addr, int check_didvid)
{
- struct rom_header *rom_header;
struct pci_data *rom_data;
-
- /* If it's in FLASH, then don't check device for ROM. */
- rom_header = cbfs_load_optionrom(CBFS_DEFAULT_MEDIA, dev->vendor,
- dev->device, NULL);
-
- u32 vendev = (dev->vendor << 16) | dev->device;
- u32 mapped_vendev = vendev;
-
- if (map_oprom_vendev)
- mapped_vendev = map_oprom_vendev(vendev);
-
- if (!rom_header) {
- if (vendev != mapped_vendev) {
- rom_header = cbfs_load_optionrom(
- CBFS_DEFAULT_MEDIA,
- mapped_vendev >> 16,
- mapped_vendev & 0xffff, NULL);
- }
- }
-
- if (rom_header) {
- printk(BIOS_DEBUG, "In CBFS, ROM address for %s = %p\n",
- dev_path(dev), rom_header);
- } else {
- u32 rom_address;
-
- rom_address = pci_read_config32(dev, PCI_ROM_ADDRESS);
-
- if (rom_address == 0x00000000 || rom_address == 0xffffffff) {
-#if CONFIG_BOARD_EMULATION_QEMU_X86
- if ((dev->class >> 8) == PCI_CLASS_DISPLAY_VGA)
- rom_address = 0xc0000;
- else
-#endif
- return NULL;
- } else {
- /* Enable expansion ROM address decoding. */
- pci_write_config32(dev, PCI_ROM_ADDRESS,
- rom_address|PCI_ROM_ADDRESS_ENABLE);
- }
-
-#if CONFIG_ON_DEVICE_ROM_RUN
- printk(BIOS_DEBUG, "Option ROM address for %s = %lx\n",
- dev_path(dev), (unsigned long)rom_address);
- rom_header = (struct rom_header *)rom_address;
-#else
- printk(BIOS_DEBUG, "Option ROM execution disabled "
- "for %s\n", dev_path(dev));
- return NULL;
-#endif
- }
+ unsigned int rom_size;
+ unsigned int image_size;
printk(BIOS_SPEW, "PCI expansion ROM, signature 0x%04x, "
"INIT size 0x%04x, data ptr 0x%04x\n",
@@ -100,10 +54,11 @@ struct rom_header *pci_rom_probe(struct device *dev)
printk(BIOS_SPEW, "PCI ROM image, vendor ID %04x, device ID %04x,\n",
rom_data->vendor, rom_data->device);
+
/* If the device id is mapped, a mismatch is expected */
- if ((dev->vendor != rom_data->vendor
- || dev->device != rom_data->device)
- && (vendev == mapped_vendev)) {
+ if (check_didvid != 0 &&
+ (dev->vendor != rom_data->vendor ||
+ dev->device != rom_data->device)) {
printk(BIOS_ERR, "ID mismatch: vendor ID %04x, "
"device ID %04x\n", rom_data->vendor, rom_data->device);
return NULL;
@@ -117,29 +72,16 @@ struct rom_header *pci_rom_probe(struct device *dev)
printk(BIOS_DEBUG, "Class Code mismatch ROM %08x, dev %08x\n",
(rom_data->class_hi << 8) | rom_data->class_lo,
dev->class);
- // return NULL;
}
- return rom_header;
-}
-
-static void *pci_ram_image_start = (void *)PCI_RAM_IMAGE_START;
-
-struct rom_header *pci_rom_load(struct device *dev,
- struct rom_header *rom_header)
-{
- struct pci_data * rom_data;
- unsigned int rom_size;
- unsigned int image_size=0;
-
+ image_size = 0;
do {
/* Get next image. */
- rom_header = (struct rom_header *)((void *) rom_header
- + image_size);
-
- rom_data = (struct pci_data *)((void *) rom_header
- + le32_to_cpu(rom_header->data));
+ int data_offset;
+ rom_header = (void *)((char *)rom_header + image_size);
+ data_offset = le32_to_cpu(rom_header->data);
+ rom_data = (void *)((char *)rom_header + data_offset);
image_size = le32_to_cpu(rom_data->ilen) * 512;
} while ((rom_data->type != 0) && (rom_data->indicator != 0)); // make sure we got x86 version
@@ -148,30 +90,128 @@ struct rom_header *pci_rom_load(struct device *dev,
rom_size = rom_header->size * 512;
- /*
- * We check to see if the device thinks it is a VGA device not
- * whether the ROM image is for a VGA device because some
- * devices have a mismatch between the hardware and the ROM.
- */
- if (PCI_CLASS_DISPLAY_VGA == (dev->class >> 8)) {
+ if (load_addr != (void *)rom_header) {
+ printk(BIOS_DEBUG, "Copying ROM from %p to %p, 0x%x bytes.\n",
+ rom_header, load_addr, rom_size);
+ memcpy(load_addr, rom_header, rom_size);
+ }
+
+ return load_addr;
+}
+
+static inline int tohex4(unsigned int c)
+{
+ return (c <= 9) ? (c + '0') : (c - 10 + 'a');
+}
+
+static void tohex16(uint16_t val, char* dest)
+{
+ dest[0] = tohex4(val>>12);
+ dest[1] = tohex4((val>>8) & 0xf);
+ dest[2] = tohex4((val>>4) & 0xf);
+ dest[3] = tohex4(val & 0xf);
+}
+
+static const struct cbfs_file_descriptor *
+cbfs_open_optionrom(uint16_t vendor, uint16_t device)
+{
+ char name[17] = "pciXXXX,XXXX.rom";
+
+ tohex16(vendor, name+3);
+ tohex16(device, name+8);
+
+ return cbfs_open_by_name_type(cbfs_default_descriptor(), name,
+ CBFS_TYPE_OPTIONROM);
+}
+
+static void *cbfs_probe_and_load(struct device *dev, void *dest)
+{
+ const struct cbfs_file_descriptor *file;
+ uint32_t vendev;
+ int remapped;
+ struct rom_header *hdr;
+ void *load_addr;
+ ssize_t filesz;
+
+ load_addr = NULL;
+ remapped = 0;
+ file = cbfs_open_optionrom(dev->vendor, dev->device);
+
+ if (file == NULL && map_oprom_vendev != NULL) {
+ vendev = map_oprom_vendev((dev->vendor << 16) | dev->device);
+ file = cbfs_open_optionrom(vendev >> 16, vendev & 0xffff);
+ remapped = 1;
+ }
+
+ if (file == NULL)
+ return NULL;
+
+ filesz = cbfs_file_content_size(file);
+ hdr = cbfs_file_map_content(file, 0, filesz);
+ if (hdr == NULL)
+ goto out;
+
+ printk(BIOS_DEBUG, "In CBFS, ROM address for %s = %p\n",
+ dev_path(dev), hdr);
+
+ load_addr = pci_rom_verify_and_load(dev, hdr, dest, !remapped);
+ cbfs_file_unmap(file, hdr);
+
+out:
+ cbfs_file_close(file);
+ return load_addr;
+}
+
+#if CONFIG_ON_DEVICE_ROM_RUN
+static void *dev_probe_and_load(struct device *dev, void *dest)
+{
+ uint32_t rom_address;
+ struct rom_header *rom_header;
+
+ rom_address = pci_read_config32(dev, PCI_ROM_ADDRESS);
+
+ if (rom_address == 0x00000000 || rom_address == 0xffffffff) {
+ if (IS_ENABLED(CONFIG_BOARD_EMULATION_QEMU_X86))
+ rom_address = 0xc0000;
+ else
+ return NULL;
+ } else {
+ /* Enable expansion ROM address decoding. */
+ pci_write_config32(dev, PCI_ROM_ADDRESS,
+ rom_address|PCI_ROM_ADDRESS_ENABLE);
+ }
+ printk(BIOS_DEBUG, "Option ROM address for %s = %lx\n",
+ dev_path(dev), (unsigned long)rom_address);
+
+ rom_header = (struct rom_header *)rom_address;
+
+ return pci_rom_verify_and_load(dev, rom_header, dest, 1);
+}
+#endif
+
+struct rom_header *pci_load_vga_rom(struct device *dev)
+{
+ void *vga_load_addr = (void *)PCI_VGA_RAM_IMAGE_START;
+ void *load_addr;
+
+ if (PCI_CLASS_DISPLAY_VGA != (dev->class >> 8))
+ return NULL;
+
#if !CONFIG_MULTIPLE_VGA_ADAPTERS
- extern device_t vga_pri; /* Primary VGA device (device.c). */
- if (dev != vga_pri) return NULL; /* Only one VGA supported. */
+ extern device_t vga_pri; /* Primary VGA device (device.c). */
+ if (dev != vga_pri) return NULL; /* Only one VGA supported. */
#endif
- if ((void *)PCI_VGA_RAM_IMAGE_START != rom_header) {
- printk(BIOS_DEBUG, "Copying VGA ROM Image from %p to "
- "0x%x, 0x%x bytes\n", rom_header,
- PCI_VGA_RAM_IMAGE_START, rom_size);
- memcpy((void *)PCI_VGA_RAM_IMAGE_START, rom_header,
- rom_size);
- }
- return (struct rom_header *) (PCI_VGA_RAM_IMAGE_START);
- }
- printk(BIOS_DEBUG, "Copying non-VGA ROM image from %p to %p, 0x%x "
- "bytes\n", rom_header, pci_ram_image_start, rom_size);
+ load_addr = cbfs_probe_and_load(dev, vga_load_addr);
+
+ if (load_addr == NULL) {
+#if CONFIG_ON_DEVICE_ROM_RUN
+ load_addr = dev_probe_and_load(dev, vga_load_addr);
+#else
+ printk(BIOS_DEBUG, "Option ROM execution disabled for %s\n",
+ dev_path(dev));
+#endif
+ }
- memcpy(pci_ram_image_start, rom_header, rom_size);
- pci_ram_image_start += rom_size;
- return (struct rom_header *) (pci_ram_image_start-rom_size);
+ return load_addr;
}
diff --git a/src/drivers/elog/elog.c b/src/drivers/elog/elog.c
index de34928..597c32e 100644
--- a/src/drivers/elog/elog.c
+++ b/src/drivers/elog/elog.c
@@ -22,10 +22,9 @@
#include <console/console.h>
#include <pc80/mc146818rtc.h>
#include <smbios.h>
-#include <spi-generic.h>
-#include <spi_flash.h>
#include <stdint.h>
#include <string.h>
+#include <region.h>
#include <elog.h>
#include "elog_internal.h"
@@ -54,13 +53,15 @@
#define elog_debug(STR...)
#endif
+
+#define ELOG_REGION_NAME "elog"
+
/*
* Static variables for ELOG state
*/
static struct elog_area *elog_area;
static u16 total_size;
static u16 log_size;
-static u32 flash_base;
static elog_area_state area_state;
static elog_header_state header_state;
@@ -70,51 +71,10 @@ static u16 next_event_offset;
static u16 event_count;
static int elog_initialized;
-static struct spi_flash *elog_spi;
-
-
-static inline u32 get_rom_size(void)
-{
- u32 rom_size;
-
- /* Assume the used space of the ROM image starts from 0. The
- * physical size of the device may not be completely used. */
- rom_size = elog_spi->size;
- if (rom_size > CONFIG_ROM_SIZE)
- rom_size = CONFIG_ROM_SIZE;
-
- return rom_size;
-}
-
-/*
- * Convert a memory mapped flash address into a flash offset
- */
-static inline u32 elog_flash_address_to_offset(u8 *address)
-{
- u32 rom_size;
-
- if (!elog_spi)
- return 0;
- rom_size = get_rom_size();
-
- return (u32)address - ((u32)~0UL - rom_size + 1);
-}
-
-/*
- * Convert a flash offset into a memory mapped flash address
- */
-static inline u8* elog_flash_offset_to_address(u32 offset)
-{
- u32 rom_size;
-
- if (!elog_spi)
- return NULL;
-
- rom_size = get_rom_size();
-
- return (u8*)((u32)~0UL - rom_size + 1 + offset);
-}
+/* Region device for accessing the ELOG area. */
+static struct region_device elog_dev;
+static rhandle_t elog_rh = INVALID_RHANDLE;
/*
* Pointer to an event log header in the event data area
@@ -259,17 +219,16 @@ static void elog_flash_write(void *address, u32 size)
{
u32 offset;
- if (!address || !size || !elog_spi)
+ if (!address || !size)
return;
- offset = flash_base;
- offset += (u8 *)address - (u8 *)elog_area;
+ offset = (u8 *)address - (u8 *)elog_area;
elog_debug("elog_flash_write(address=0x%p offset=0x%08x size=%u)\n",
address, offset, size);
/* Write the data to flash */
- elog_spi->write(elog_spi, offset, size, address);
+ region_writeat(elog_rh, address, offset, size);
}
/*
@@ -280,17 +239,16 @@ static void elog_flash_erase(void *address, u32 size)
{
u32 offset;
- if (!address || !size || !elog_spi)
+ if (!address || !size)
return;
- offset = flash_base;
- offset += (u8 *)address - (u8*)elog_area;
+ offset = (u8 *)address - (u8*)elog_area;
elog_debug("elog_flash_erase(address=0x%p offset=0x%08x size=%u)\n",
address, offset, size);
/* Erase the sectors in this region */
- elog_spi->erase(elog_spi, offset, size);
+ region_eraseat(elog_rh, offset, size);
}
/*
@@ -348,7 +306,7 @@ static void elog_scan_flash(void)
event_buffer_state = ELOG_EVENT_BUFFER_OK;
/* Fill memory buffer by reading from SPI */
- elog_spi->read(elog_spi, flash_base, total_size, elog_area);
+ region_readat(elog_rh, elog_area, 0, total_size);
next_event_offset = 0;
event_count = 0;
@@ -449,13 +407,17 @@ int elog_smbios_write_type15(unsigned long *current, int handle)
{
struct smbios_type15 *t = (struct smbios_type15 *)*current;
int len = sizeof(struct smbios_type15);
+ void *backing_store;
#if CONFIG_ELOG_CBMEM
/* Save event log buffer into CBMEM for the OS to read */
- void *cbmem = cbmem_add(CBMEM_ID_ELOG, total_size);
- if (!cbmem)
+ backing_store = cbmem_add(CBMEM_ID_ELOG, total_size);
+ if (!backing_store)
return 0;
- memcpy(cbmem, elog_area, total_size);
+ memcpy(backing_store, elog_area, total_size);
+#else
+ /* This assumes x86 memory-mapped capabilities of flash. */
+ backing_store = region_mmap(elog_rh, 0, total_size);
#endif
memset(t, 0, len);
@@ -468,11 +430,7 @@ int elog_smbios_write_type15(unsigned long *current, int handle)
t->access_method = SMBIOS_EVENTLOG_ACCESS_METHOD_MMIO32;
t->log_status = SMBIOS_EVENTLOG_STATUS_VALID;
t->change_token = 0;
-#if CONFIG_ELOG_CBMEM
- t->address = (u32)cbmem;
-#else
- t->address = (u32)elog_flash_offset_to_address(flash_base);
-#endif
+ t->address = (u32)backing_store;
t->header_format = ELOG_HEADER_TYPE_OEM;
t->log_type_descriptors = 0;
t->log_type_descriptor_length = 2;
@@ -506,33 +464,46 @@ int elog_clear(void)
return 0;
}
-static void elog_find_flash(void)
+static int elog_find_flash(void)
{
-#if CONFIG_CHROMEOS
- u8 *flash_base_ptr;
-#endif
+ rhandle_t rh;
+
+ if (rhandle_valid(elog_rh))
+ return 0;
elog_debug("elog_find_flash()\n");
#if CONFIG_CHROMEOS
/* Find the ELOG base and size in FMAP */
- total_size = find_fmap_entry("RW_ELOG", (void **)&flash_base_ptr);
- if (total_size < 0) {
+ if (fmap_locate("RW_ELOG", &elog_dev.region.offset,
+ &elog_dev.region.size)) {
printk(BIOS_WARNING, "ELOG: Unable to find RW_ELOG in FMAP, "
"using CONFIG_ELOG_FLASH_BASE instead\n");
- total_size = CONFIG_ELOG_AREA_SIZE;
} else {
- flash_base = elog_flash_address_to_offset(flash_base_ptr);
-
/* Use configured size if smaller than FMAP size */
- if (total_size > CONFIG_ELOG_AREA_SIZE)
- total_size = CONFIG_ELOG_AREA_SIZE;
+ if (elog_dev.region.size > CONFIG_ELOG_AREA_SIZE)
+ elog_dev.region.size = CONFIG_ELOG_AREA_SIZE;
}
#else
- flash_base = CONFIG_ELOG_FLASH_BASE;
- total_size = CONFIG_ELOG_AREA_SIZE;
+ elog_dev.region.offset = CONFIG_ELOG_FLASH_BASE;
+ elog_dev.region.size = CONFIG_ELOG_AREA_SIZE;
#endif
+ total_size = elog_dev.region.size;
log_size = total_size - sizeof(struct elog_header);
+
+ rh = region_locate(BOOTRW_REGION_NAME);
+ if (!rhandle_valid(rh)) {
+ printk(BIOS_WARNING, "Unable to find writable boot region.\n");
+ return -1;
+ }
+ rh = region_register_subregion("elog", &elog_dev, rh);
+ if (!rhandle_valid(rh)) {
+ printk(BIOS_WARNING, "Unable to register ELOG region.\n");
+ return -1;
+ }
+
+ elog_rh = rh;
+ return 0;
}
/*
@@ -545,18 +516,9 @@ int elog_init(void)
elog_debug("elog_init()\n");
- /* Prepare SPI */
- spi_init();
- elog_spi = spi_flash_probe(0, 0, 0, 0);
- if (!elog_spi) {
- printk(BIOS_ERR, "ELOG: Unable to find SPI flash\n");
- return -1;
- }
-
/* Set up the backing store */
- elog_find_flash();
- if (flash_base == 0) {
- printk(BIOS_ERR, "ELOG: Invalid flash base\n");
+ if (elog_find_flash()) {
+ printk(BIOS_ERR, "ELOG: region not set up.\n");
return -1;
}
@@ -589,8 +551,8 @@ int elog_init(void)
elog_initialized = 1;
- printk(BIOS_INFO, "ELOG: FLASH @0x%p [SPI 0x%08x]\n",
- elog_area, flash_base);
+ printk(BIOS_INFO, "ELOG: FLASH @0x%p [SPI 0x%08zx]\n",
+ elog_area, (size_t)elog_dev.region.offset);
printk(BIOS_INFO, "ELOG: area is %d bytes, full threshold %d,"
" shrink size %d\n", total_size,
diff --git a/src/include/cbfs.h b/src/include/cbfs.h
index ebdbf43..bd000c9 100644
--- a/src/include/cbfs.h
+++ b/src/include/cbfs.h
@@ -1,14 +1,8 @@
/*
* This file is part of the coreboot project.
*
- * Copyright (C) 2008 Jordan Crouse <jordan(a)cosmicpenguin.net>
- * Copyright (C) 2013 The Chromium OS Authors. All rights reserved.
+ * Copyright (C) 2014 Google Inc.
*
- * This file is dual-licensed. You can choose between:
- * - The GNU GPL, version 2, as published by the Free Software Foundation
- * - The revised BSD license (without advertising clause)
- *
- * ---------------------------------------------------------------------------
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; version 2 of the License.
@@ -20,62 +14,84 @@
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
- * ---------------------------------------------------------------------------
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * 3. The name of the author may not be used to endorse or promote products
- * derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- * ---------------------------------------------------------------------------
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
-
#ifndef _CBFS_H_
#define _CBFS_H_
-#include <cbfs_core.h>
+#include <stdint.h>
+#include <region.h>
-void *cbfs_load_optionrom(struct cbfs_media *media, uint16_t vendor,
- uint16_t device, void * dest);
-void *cbfs_load_stage(struct cbfs_media *media, const char *name);
-
-/* Simple buffer for streaming media. */
-struct cbfs_simple_buffer {
- char *buffer;
- size_t allocated;
+/* Describe an instance of cbfs. */
+struct cbfs_descriptor {
+ rhandle_t rh;
+ size_t align;
size_t size;
- size_t last_allocate;
};
-void *cbfs_simple_buffer_map(struct cbfs_simple_buffer *buffer,
- struct cbfs_media *media,
- size_t offset, size_t count);
+struct cbfs_file_descriptor;
+
+/* Obtain the default cbfs_descriptor. */
+const struct cbfs_descriptor *cbfs_default_descriptor(void);
+
+/* Open a file by name. Return NULL on error. */
+const struct cbfs_file_descriptor *
+cbfs_open_by_name(const struct cbfs_descriptor *cbfs, const char *name);
+
+/* Open a file by name and type. */
+const struct cbfs_file_descriptor *
+cbfs_open_by_name_type(const struct cbfs_descriptor *cbfs,
+ const char *name, uint32_t type);
+
+/* Close a previously opened file. */
+void cbfs_file_close(const struct cbfs_file_descriptor *fd);
+
+/* Return the size of the file's contents. < 0 on error. */
+ssize_t cbfs_file_content_size(const struct cbfs_file_descriptor *fd);
+
+/* Return the size of the file's metadata contents. < 0 on error. */
+ssize_t cbfs_file_metadata_size(const struct cbfs_file_descriptor *fd);
+
+/*
+ * Read size bytes file contents from offset of into buffer. Returns < 0
+ * on error or bytes read.
+ */
+ssize_t cbfs_file_read_content(const struct cbfs_file_descriptor *fd,
+ void *buf, offset_t offset, size_t size);
+
+/* Attempt to map the file content. Returns NULL on error. */
+void *cbfs_file_map_content(const struct cbfs_file_descriptor *fd,
+ offset_t offset, size_t size);
+
+/*
+ * Read size bytes file metadata from offset of into buffer. Returns < 0
+ * on error or bytes read.
+ */
+ssize_t cbfs_file_read_metadata(const struct cbfs_file_descriptor *fd,
+ void *buf, offset_t offset, size_t size);
+/*
+ * Attempt to map all of the file's metadata. Depending on the file type there
+ * may be no metadata in which case NULL will be returned. File types of
+ * CBFS_TYPE_STAGE and CBFS_TYPE_PAYLOAD are currently the only files that
+ * contain metadata.
+ *
+ * Returns NULL on error.
+ */
+void *cbfs_file_map_metadata(const struct cbfs_file_descriptor *fd);
+
+/* Unmap the mapping associated with addr. No partial unmappings allowed. */
+void cbfs_file_unmap(const struct cbfs_file_descriptor *fd, void *addr);
+
-void *cbfs_simple_buffer_unmap(struct cbfs_simple_buffer *buffer,
- const void *address);
+void *cbfs_load_optionrom(const struct cbfs_descriptor *cbfs,
+ uint16_t vendor, uint16_t device, void * dest);
-// Utility functions
-int run_address(void *f);
+/* Return entry point to stage, or NULL on failure. */
+void *cbfs_load_stage(const struct cbfs_descriptor *cbfs, const char *name);
-/* Defined in individual arch / board implementation. */
-int init_default_cbfs_media(struct cbfs_media *media);
+/* Decompress range of file to destination. Returns bytes decompressed. */
+size_t cbfs_file_inflate(const struct cbfs_file_descriptor *fd,
+ offset_t offset, size_t src_sz, void *dest);
#if defined(__PRE_RAM__)
struct romstage_handoff;
diff --git a/src/include/cbfs_core.h b/src/include/cbfs_core.h
index a1d8127..6a91454 100644
--- a/src/include/cbfs_core.h
+++ b/src/include/cbfs_core.h
@@ -186,50 +186,6 @@ struct cbfs_optionrom {
uint32_t len;
} __attribute__((packed));
-#define CBFS_MEDIA_INVALID_MAP_ADDRESS ((void*)(0xffffffff))
-#define CBFS_DEFAULT_MEDIA ((void*)(0x0))
-
-/* Media for CBFS to load files. */
-struct cbfs_media {
-
- /* implementation dependent context, to hold resource references */
- void *context;
-
- /* opens media and returns 0 on success, -1 on failure */
- int (*open)(struct cbfs_media *media);
-
- /* returns number of bytes read from media into dest, starting from
- * offset for count of bytes */
- size_t (*read)(struct cbfs_media *media, void *dest, size_t offset,
- size_t count);
-
- /* returns a pointer to memory with count of bytes from media source
- * starting from offset, or CBFS_MEDIA_INVALID_MAP_ADDRESS on failure.
- * Note: mapped data can't be free unless unmap is called, even if you
- * do close first. */
- void * (*map)(struct cbfs_media *media, size_t offset, size_t count);
-
- /* returns NULL and releases the memory by address, which was allocated
- * by map */
- void * (*unmap)(struct cbfs_media *media, const void *address);
-
- /* closes media and returns 0 on success, -1 on failure. */
- int (*close)(struct cbfs_media *media);
-};
-
-/* returns pointer to a file entry inside CBFS or NULL */
-struct cbfs_file *cbfs_get_file(struct cbfs_media *media, const char *name);
-
-/* returns pointer to file content inside CBFS after if type is correct */
-void *cbfs_get_file_content(struct cbfs_media *media, const char *name,
- int type, size_t *sz);
-
-/* returns decompressed size on success, 0 on failure */
-int cbfs_decompress(int algo, void *src, void *dst, int len);
-
-/* returns a pointer to CBFS master header, or CBFS_HEADER_INVALID_ADDRESS
- * on failure */
-const struct cbfs_header *cbfs_get_header(struct cbfs_media *media);
#endif /* __ROMCC__ */
diff --git a/src/include/device/pci_rom.h b/src/include/device/pci_rom.h
index fe77276..4bd0bfd 100644
--- a/src/include/device/pci_rom.h
+++ b/src/include/device/pci_rom.h
@@ -6,7 +6,6 @@
#define PCI_ROM_HDR 0xAA55
#define PCI_DATA_HDR (uint32_t) ( ('R' << 24) | ('I' << 16) | ('C' << 8) | 'P' )
-#define PCI_RAM_IMAGE_START 0xD0000
#define PCI_VGA_RAM_IMAGE_START 0xC0000
struct rom_header {
@@ -33,8 +32,7 @@ struct pci_data {
uint16_t reserved_2;
};
-struct rom_header *pci_rom_probe(struct device *dev);
-struct rom_header *pci_rom_load(struct device *dev, struct rom_header *rom_header);
+struct rom_header *pci_load_vga_rom(struct device *dev);
u32 __attribute__((weak)) map_oprom_vendev(u32 vendev);
#endif
diff --git a/src/include/payload_loader.h b/src/include/payload_loader.h
index 7a3f045..7b6fc1c 100644
--- a/src/include/payload_loader.h
+++ b/src/include/payload_loader.h
@@ -22,6 +22,8 @@
#include <stdint.h>
#include <stddef.h>
+struct cbfs_file_descriptor;
+
struct buffer_area {
void *data;
size_t size;
@@ -29,6 +31,7 @@ struct buffer_area {
struct payload {
const char *name;
+ const struct cbfs_file_descriptor *fd;
struct buffer_area backing_store;
/* Used when payload wants memory coreboot ramstage is running at. */
struct buffer_area bounce;
diff --git a/src/include/region.h b/src/include/region.h
new file mode 100644
index 0000000..cd66bde
--- /dev/null
+++ b/src/include/region.h
@@ -0,0 +1,145 @@
+/*
+ * This file is part of the coreboot project.
+ *
+ * Copyright (C) 2014 Google Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef REGION_H
+#define REGION_H
+
+#include <stdint.h>
+#include <stddef.h>
+
+/*
+ * Region support.
+ *
+ * Regions are intended to abstract away the access mechanisms for blocks of
+ * data. This could be SPI, eMMC, or a memory region as the backing store.
+ * Subregions can be made by registering a region_device that is associated
+ * with another region. Regions can be addressed by name, but there is no
+ * hierarchy in the namespace. i.e. the operations through subregions are
+ * hierarchical but the namespace is not.
+ *
+ * There are two views to the boot media: read-only and read-write. On certain
+ * architectures the read-write availability is not available until late in
+ * ramstage. Therefore, users of each region need to be cognizant of the fact
+ * that different implementations may be backing a particular region. e.g. on
+ * x86 the read-only boot region doesn't have write and erase capabilities, but
+ * the read-write boot region would allow writes and erases but no mmap.
+ */
+
+/*
+ * Initialize the boot region. Called directly in pre-ramstage or
+ * automatically in ramstage.
+ */
+void boot_region_init(void);
+/* Initialize the boot media. Board/Arch specific code implements this. */
+void boot_media_initialize(void);
+/*
+ * A potential call for chipsets that can't bring their RW area online til
+ * after the device init in ramstage.
+ */
+void bootrw_media_initialize(void);
+/* Initialize the default CBFS region. */
+void cbfs_default_media_initialize(void);
+
+typedef uintptr_t offset_t;
+typedef long rhandle_t;
+#define INVALID_RHANDLE ((rhandle_t)~((uintptr_t)0))
+
+#define BOOTRO_REGION_NAME "bootro"
+#define BOOTRW_REGION_NAME "bootrw"
+#define DEFAULT_CBFS_REGION_NAME "cbfs"
+
+struct region_device;
+
+struct region_device_ops {
+ void *(*mmap)(const struct region_device *, offset_t, size_t);
+ void (*munmap)(const struct region_device *, void *);
+ ssize_t (*readat)(const struct region_device *, void *,
+ offset_t, size_t);
+ ssize_t (*writeat)(const struct region_device *, const void *,
+ offset_t, size_t);
+ ssize_t (*eraseat)(const struct region_device *, offset_t, size_t);
+};
+
+struct region {
+ offset_t offset;
+ size_t size;
+};
+
+struct region_device {
+ const struct region_device_ops *ops;
+ struct region region;
+};
+
+/*
+ * Requests within a region are relative to the region's size. Therefore,
+ * the requests need to be normalized to the parent's region. This routine
+ * does that normalization and checks if the request is within bounds.
+ *
+ * Returns -1 if invalid request or 0 if request is within bounds.
+ */
+int region_request_normalize(const struct region *parent,
+ struct region *request);
+
+static inline int rhandle_valid(rhandle_t rh)
+{
+ return !!(rh >= 0);
+}
+
+/* Register a region_device by name. */
+rhandle_t region_register(const char *name, const struct region_device *rdev);
+
+/* Register a subregion by name under parent. rdev->ops must be NULL. */
+rhandle_t region_register_subregion(const char *name,
+ const struct region_device *rdev,
+ rhandle_t parent);
+
+/* Locate a region of provided name. */
+rhandle_t region_locate(const char *name);
+
+/*
+ * Read subregion within provided region.
+ * Returns bytes read, < 0 on error.
+ */
+ssize_t region_readat(rhandle_t rh, void *buf, offset_t offset, size_t count);
+
+/*
+ * Write to subregion within provided region.
+ * Returns bytes written, < 0 on error.
+ */
+ssize_t region_writeat(rhandle_t rh, void *buf, offset_t offset, size_t count);
+
+/*
+ * Erase subregion within provide region.
+ * Returns bytes erased, < 0 on error.
+ */
+ssize_t region_eraseat(rhandle_t rh, offset_t offset, size_t count);
+
+/*
+ * Map subregion described by offset and size within the region provided.
+ * Returns pointer to mapped subregion or NULL on error.
+ */
+void *region_mmap(rhandle_t rh, offset_t offset, size_t count);
+
+/* Unmap previously mapped region. */
+void region_munmap(rhandle_t rh, void *addr);
+
+/* Get size of region represented by rh. < 0 on error. */
+ssize_t region_size(rhandle_t rh);
+
+#endif /* REGION_H */
diff --git a/src/include/rmodule.h b/src/include/rmodule.h
index 2147ab0..19f32e4 100644
--- a/src/include/rmodule.h
+++ b/src/include/rmodule.h
@@ -61,6 +61,7 @@ int rmodule_calc_region(unsigned int region_alignment, size_t rmodule_size,
#if CONFIG_DYNAMIC_CBMEM
struct cbfs_stage;
struct cbmem_entry;
+struct cbfs_descriptor;
struct rmod_stage_load {
/* Inputs */
@@ -72,8 +73,10 @@ struct rmod_stage_load {
};
/* Both of the following functions return 0 on success, -1 on error. */
-int rmodule_stage_load(struct rmod_stage_load *rsl, struct cbfs_stage *stage);
-int rmodule_stage_load_from_cbfs(struct rmod_stage_load *rsl);
+int rmodule_stage_load(struct rmod_stage_load *rsl, struct cbfs_stage *stage,
+ void *data);
+int rmodule_stage_load_from_cbfs(const struct cbfs_descriptor *cbfs,
+ struct rmod_stage_load *rsl);
#endif
struct rmodule {
diff --git a/src/lib/Makefile.inc b/src/lib/Makefile.inc
index acd334e..031d72c 100644
--- a/src/lib/Makefile.inc
+++ b/src/lib/Makefile.inc
@@ -18,7 +18,9 @@
#
subdirs-y += loaders
+ifneq ($(CONFIG_ARCH_X86),y)
bootblock-y += cbfs.c
+endif
ifneq ($(CONFIG_HAVE_ARCH_MEMSET),y)
bootblock-y += memset.c
endif
@@ -109,6 +111,13 @@ ramstage-y += cbmem_info.c
ramstage-y += hexdump.c
romstage-y += hexdump.c
+ramstage-y += region.c
+romstage-y += region.c
+ramstage-y += cbfs_boot_region.c
+romstage-y += cbfs_boot_region.c
+smm-y += cbfs_boot_region.c
+ramstage-$(CONFIG_BOOT_REGION_SPI_FLASH) += bootrw_spi_flash_region.c
+smm-$(CONFIG_SPI_FLASH_SMM) += bootrw_spi_flash_region.c
ramstage-$(CONFIG_REG_SCRIPT) += reg_script.c
@@ -125,6 +134,7 @@ smm-y += memmove.c
endif
smm-y += cbfs.c memcmp.c
smm-y += gcc.c
+smm-y += region.c
$(obj)/lib/version.ramstage.o : $(obj)/build.h
diff --git a/src/lib/bootrw_spi_flash_region.c b/src/lib/bootrw_spi_flash_region.c
new file mode 100644
index 0000000..2ef8e75
--- /dev/null
+++ b/src/lib/bootrw_spi_flash_region.c
@@ -0,0 +1,119 @@
+/*
+ * This file is part of the coreboot project.
+ *
+ * Copyright (C) 2014 Google Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+
+#include <stddef.h>
+#include <region.h>
+#include <spi-generic.h>
+#include <spi_flash.h>
+
+struct bootrw_flash_device {
+ struct spi_flash *spi;
+ struct region_device dev;
+};
+
+
+static ssize_t
+bootrw_readat(const struct region_device *rdev, void *buf,
+ offset_t offset, size_t size)
+{
+ struct bootrw_flash_device *dev;
+
+ dev = container_of(rdev, struct bootrw_flash_device, dev);
+ if (dev->spi->read(dev->spi, offset, size, buf))
+ return -1;
+ return size;
+}
+
+static ssize_t
+bootrw_writeat(const struct region_device *rdev, const void *buf,
+ offset_t offset, size_t size)
+{
+ struct bootrw_flash_device *dev;
+
+ dev = container_of(rdev, struct bootrw_flash_device, dev);
+ if (dev->spi->write(dev->spi, offset, size, buf))
+ return -1;
+ return size;
+}
+
+static ssize_t
+bootrw_eraseat(const struct region_device *rdev, offset_t offset, size_t size)
+{
+ struct bootrw_flash_device *dev;
+
+ dev = container_of(rdev, struct bootrw_flash_device, dev);
+ if (dev->spi->erase(dev->spi, offset, size))
+ return -1;
+ return size;
+}
+
+static const struct region_device_ops bootrw_ops = {
+ .readat = bootrw_readat,
+ .writeat = bootrw_writeat,
+ .eraseat = bootrw_eraseat,
+};
+
+static struct bootrw_flash_device flashdev = {
+ .dev = {
+ .ops = &bootrw_ops,
+ .region = {
+ .offset = 0,
+ .size = CONFIG_ROM_SIZE,
+ },
+ }
+};
+
+void bootrw_media_initialize(void)
+{
+ /* Reinitialize spi regs in case. */
+ spi_init();
+
+ if (flashdev.spi != NULL)
+ return;
+
+ flashdev.spi = spi_flash_probe(0, 0, 0, 0);
+ if (flashdev.spi == NULL) {
+ printk(BIOS_WARNING, "SPI probing failed for boot region.\n");
+ return;
+ }
+
+ if (flashdev.spi->size != CONFIG_ROM_SIZE) {
+ printk(BIOS_WARNING,
+ "SPI mismatch with CONFIG_ROM_SIZE: %zx vs %zx\n",
+ (size_t)CONFIG_ROM_SIZE, (size_t)flashdev.spi->size);
+ return;
+ }
+
+ if (!rhandle_valid(region_register(BOOTRW_REGION_NAME, &flashdev.dev)))
+ printk(BIOS_WARNING, "Couldn't register '%s' region.\n",
+ BOOTRW_REGION_NAME);
+}
+
+#if !defined(__PRE_RAM__)
+#include <bootstate.h>
+static void bootrw_bscb(void *unused)
+{
+ bootrw_media_initialize();
+}
+
+BOOT_STATE_INIT_ENTRIES(regions_init) = {
+ BOOT_STATE_INIT_ENTRY(BS_DEV_INIT, BS_ON_ENTRY, bootrw_bscb, NULL),
+};
+#endif
diff --git a/src/lib/cbfs.c b/src/lib/cbfs.c
index dc08937..f5dff88 100644
--- a/src/lib/cbfs.c
+++ b/src/lib/cbfs.c
@@ -1,8 +1,7 @@
/*
* This file is part of the coreboot project.
*
- * Copyright (C) 2008, Jordan Crouse <jordan(a)cosmicpenguin.net>
- * Copyright (C) 2013 The Chromium OS Authors. All rights reserved.
+ * Copyright (C) 2014-2014 Google Inc.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@@ -18,192 +17,402 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
*/
-#ifdef LIBPAYLOAD
-# include <libpayload-config.h>
-# ifdef CONFIG_LZMA
-# include <lzma.h>
-# define CBFS_CORE_WITH_LZMA
-# endif
-# define CBFS_MINI_BUILD
-#elif defined(__SMM__)
-# define CBFS_MINI_BUILD
-#elif defined(__BOOT_BLOCK__)
- /* No LZMA in boot block. */
-#elif defined(__PRE_RAM__) && !CONFIG_COMPRESS_RAMSTAGE
- /* No LZMA in romstage if ramstage is not compressed. */
-#else
-# define CBFS_CORE_WITH_LZMA
-# include <lib.h>
+#if !defined(__BOOT_BLOCK__) && !(defined(__PRE_RAM__) && !IS_ENABLED(CONFIG_COMPRESS_RAMSTAGE))
+#define CBFS_WITH_LZMA
#endif
-#include <cbfs.h>
#include <string.h>
+#include <arch/early_variables.h>
+#include <cbfs.h>
+#include <cbfs_core.h>
#include <cbmem.h>
+#include <console/console.h>
+#include <lib.h>
-#ifdef LIBPAYLOAD
-# include <stdio.h>
-# define DEBUG(x...)
-# define LOG(x...) printf(x)
-# define ERROR(x...) printf(x)
-#else
-# include <console/console.h>
-# define ERROR(x...) printk(BIOS_ERR, "CBFS: " x)
-# define LOG(x...) printk(BIOS_INFO, "CBFS: " x)
-# if CONFIG_DEBUG_CBFS
-# define DEBUG(x...) printk(BIOS_SPEW, "CBFS: " x)
-# else
-# define DEBUG(x...)
-# endif
-#endif
+struct cbfs_file_descriptor {
+ rhandle_t rh;
+ struct region metadata;
+ struct region content;
+};
-#if defined(CONFIG_CBFS_HEADER_ROM_OFFSET) && (CONFIG_CBFS_HEADER_ROM_OFFSET)
-# define CBFS_HEADER_ROM_ADDRESS (CONFIG_CBFS_HEADER_ROM_OFFSET)
-#else
-// Indirect address: only works on 32bit top-aligned systems.
-# define CBFS_HEADER_ROM_ADDRESS (*(uint32_t *)0xfffffffc)
-#endif
+#define MAX_CBFS_OPEN_FILES 4
+struct cbfs_file_cache {
+ struct cbfs_file_descriptor files[MAX_CBFS_OPEN_FILES];
+};
-#include "cbfs_core.c"
+static struct cbfs_file_cache g_cbfs_files CAR_GLOBAL;
-#ifndef __SMM__
-static inline int tohex4(unsigned int c)
+static struct cbfs_file_cache *get_cache(void)
+{
+ return car_get_var_ptr(&g_cbfs_files);
+}
+
+static int cbfs_fd_available(const struct cbfs_file_descriptor *fd)
+{
+ return !!(fd->content.size == 0 && fd->metadata.size == 0);
+}
+
+static void cbfs_fd_mark_free(const struct cbfs_file_descriptor *cfd)
{
- return (c <= 9) ? (c + '0') : (c - 10 + 'a');
+ struct cbfs_file_descriptor *fd = (struct cbfs_file_descriptor *)cfd;
+ memset(fd, 0, sizeof(*fd));
+ fd->rh = INVALID_RHANDLE;
}
-static void tohex16(unsigned int val, char* dest)
+static struct cbfs_file_descriptor *get_available_file(void)
{
- dest[0] = tohex4(val>>12);
- dest[1] = tohex4((val>>8) & 0xf);
- dest[2] = tohex4((val>>4) & 0xf);
- dest[3] = tohex4(val & 0xf);
+ int i;
+ struct cbfs_file_cache *cache = get_cache();
+
+ for (i = 0; i < MAX_CBFS_OPEN_FILES; i++) {
+ if (cbfs_fd_available(&cache->files[i]))
+ return &cache->files[i];
+ }
+
+ return NULL;
}
-void *cbfs_load_optionrom(struct cbfs_media *media, uint16_t vendor,
- uint16_t device, void *dest)
+static void cbfs_fd_add_metadata(struct cbfs_file_descriptor *fd, size_t sz)
{
- char name[17] = "pciXXXX,XXXX.rom";
- struct cbfs_optionrom *orom;
- uint8_t *src;
+ fd->metadata.size += sz;
+ fd->content.offset += sz;
+ fd->content.size -= sz;
+}
- tohex16(vendor, name+3);
- tohex16(device, name+8);
+static const struct cbfs_file_descriptor *
+allocate_file(const struct cbfs_descriptor *cbfs, const struct cbfs_file *file,
+ offset_t offset)
+{
+ struct cbfs_file_descriptor *fd;
+ offset_t file_end;
- orom = (struct cbfs_optionrom *)
- cbfs_get_file_content(media, name, CBFS_TYPE_OPTIONROM, NULL);
+ fd = get_available_file();
- if (orom == NULL)
+ if (fd == NULL) {
+ printk(BIOS_DEBUG, "No available cbfs fds!\n");
return NULL;
+ }
- /* They might have specified a dest address. If so, we can decompress.
- * If not, there's not much hope of decompressing or relocating the rom.
- * in the common case, the expansion rom is uncompressed, we
- * pass 0 in for the dest, and all we have to do is find the rom and
- * return a pointer to it.
- */
+ /* Point offset to beginning of file data. */
+ offset = file->offset + offset;
+ file_end = offset + file->len;
- /* BUG: the cbfstool is (not yet) including a cbfs_optionrom header */
- src = (uint8_t *)orom; // + sizeof(struct cbfs_optionrom);
+ fd->rh = cbfs->rh;
+ fd->metadata.offset = offset;
+ fd->metadata.size = 0;
+ fd->content.offset = offset;
+ fd->content.size = file->len;
- if (! dest)
- return src;
+ if (file->type != CBFS_TYPE_STAGE && file->type != CBFS_TYPE_PAYLOAD)
+ return fd;
+
+ if (file->type == CBFS_TYPE_STAGE) {
+ cbfs_fd_add_metadata(fd, sizeof(struct cbfs_stage));
+ return fd;
+ }
+
+ /* Parse payload segments. */
+ while (offset + sizeof(struct cbfs_payload_segment) <= file_end) {
+ struct cbfs_payload_segment segment;
+ ssize_t read_sz;
+
+ read_sz = region_readat(cbfs->rh, &segment, offset,
+ sizeof(segment));
+ if (read_sz != sizeof(segment)) {
+ printk(BIOS_DEBUG, "Couldn't read segment at 0x%zx\n",
+ (size_t)offset);
+ cbfs_fd_mark_free(fd);
+ return NULL;
+ }
+
+ switch (segment.type) {
+ case PAYLOAD_SEGMENT_CODE:
+ case PAYLOAD_SEGMENT_DATA:
+ case PAYLOAD_SEGMENT_BSS:
+ case PAYLOAD_SEGMENT_PARAMS:
+ cbfs_fd_add_metadata(fd, sizeof(segment));
+ break;
+ case PAYLOAD_SEGMENT_ENTRY:
+ cbfs_fd_add_metadata(fd, sizeof(segment));
+ return fd;
+ default:
+ cbfs_fd_mark_free(fd);
+ return NULL;
+ }
+
+ /* Next segment. */
+ offset += sizeof(segment);
+ }
- if (!cbfs_decompress(ntohl(orom->compression),
- src,
- dest,
- ntohl(orom->len)))
+ cbfs_fd_mark_free(fd);
+ return NULL;
+}
+
+static offset_t
+cbfs_next_offset(offset_t offset, size_t align, size_t increment)
+{
+ offset += increment;
+ if (offset % align)
+ offset += align - (offset % align);
+ return offset;
+}
+
+static const struct cbfs_file_descriptor *
+__cbfs_open(const struct cbfs_descriptor *cbfs, const char *name,
+ uint32_t *type)
+{
+ const struct cbfs_file_descriptor *fd;
+ struct cbfs_file file;
+ ssize_t read_sz;
+ offset_t offset;
+ size_t cbfs_sz;
+ size_t align;
+ rhandle_t rh;
+
+ if (cbfs == NULL || name == NULL)
return NULL;
- return dest;
+ offset = 0;
+ rh = cbfs->rh;
+ align = cbfs->align;
+ cbfs_sz = cbfs->size;
+ fd = NULL;
+
+ while (offset + sizeof(file) < cbfs_sz) {
+ char *file_name;
+ size_t name_sz;
+ size_t entry_sz;
+ int found;
+
+ read_sz = region_readat(rh, &file, offset, sizeof(file));
+ if (read_sz != sizeof(file))
+ return NULL;
+
+ if (memcmp(CBFS_FILE_MAGIC, file.magic, sizeof(file.magic))) {
+ offset = cbfs_next_offset(offset, align, align);
+ continue;
+ }
+
+ file.len = ntohl(file.len);
+ file.type = ntohl(file.type);
+ file.offset = ntohl(file.offset);
+ entry_sz = file.len + file.offset;
+
+ /* File type doesn't match. */
+ if (type != NULL && *type != file.type) {
+ offset = cbfs_next_offset(offset, align, entry_sz);
+ continue;
+ }
+ name_sz = file.offset - sizeof(file);
+ file_name = region_mmap(rh, offset + sizeof(file), name_sz);
+ if (file_name == NULL) {
+ offset = cbfs_next_offset(offset, align, entry_sz);
+ continue;
+ }
+
+ found = !strcmp(file_name, name);
+ region_munmap(rh, file_name);
+
+ if (found) {
+ fd = allocate_file(cbfs, &file, offset);
+ break;
+ }
+ offset = cbfs_next_offset(offset, align, entry_sz);
+ }
+
+ return fd;
}
-void * cbfs_load_stage(struct cbfs_media *media, const char *name)
+const struct cbfs_file_descriptor *
+cbfs_open_by_name(const struct cbfs_descriptor *cbfs, const char *name)
{
- struct cbfs_stage *stage = (struct cbfs_stage *)
- cbfs_get_file_content(media, name, CBFS_TYPE_STAGE, NULL);
- /* this is a mess. There is no ntohll. */
- /* for now, assume compatible byte order until we solve this. */
- uint32_t entry;
- uint32_t final_size;
+ return __cbfs_open(cbfs, name, NULL);
+}
- if (stage == NULL)
- return (void *) -1;
+const struct cbfs_file_descriptor *
+cbfs_open_by_name_type(const struct cbfs_descriptor *cbfs,
+ const char *name, uint32_t type)
+{
+ return __cbfs_open(cbfs, name, &type);
+}
- LOG("loading stage %s @ 0x%x (%d bytes), entry @ 0x%llx\n",
- name,
- (uint32_t) stage->load, stage->memlen,
- stage->entry);
+void cbfs_file_close(const struct cbfs_file_descriptor *file)
+{
+ if (file != NULL)
+ cbfs_fd_mark_free(file);
+}
- final_size = cbfs_decompress(stage->compression,
- ((unsigned char *) stage) +
- sizeof(struct cbfs_stage),
- (void *) (uint32_t) stage->load,
- stage->len);
- if (!final_size)
- return (void *) -1;
+ssize_t cbfs_file_content_size(const struct cbfs_file_descriptor *fd)
+{
+ if (fd == NULL)
+ return -1;
- /* Stages rely the below clearing so that the bss is initialized. */
- memset((void *)((uintptr_t)stage->load + final_size), 0,
- stage->memlen - final_size);
+ return fd->content.size;
+}
- DEBUG("stage loaded.\n");
+ssize_t cbfs_file_metadata_size(const struct cbfs_file_descriptor *fd)
+{
+ if (fd == NULL)
+ return -1;
- entry = stage->entry;
- // entry = ntohll(stage->entry);
+ return fd->metadata.size;
+}
- return (void *) entry;
+ssize_t cbfs_file_read_content(const struct cbfs_file_descriptor *fd,
+ void *buf, offset_t offset, size_t size)
+{
+ struct region region = {
+ .offset = offset,
+ .size = size,
+ };
+
+ if (fd == NULL)
+ return -1;
+
+ if (region_request_normalize(&fd->content, ®ion))
+ return -1;
+
+ return region_readat(fd->rh, buf, region.offset, size);
}
-/* Simple buffer */
+void *cbfs_file_map_content(const struct cbfs_file_descriptor *fd,
+ offset_t offset, size_t size)
+{
+ struct region region = {
+ .offset = offset,
+ .size = size,
+ };
-void *cbfs_simple_buffer_map(struct cbfs_simple_buffer *buffer,
- struct cbfs_media *media,
- size_t offset, size_t count) {
- void *address = buffer->buffer + buffer->allocated;
- DEBUG("simple_buffer_map(offset=%zd, count=%zd): "
- "allocated=%zd, size=%zd, last_allocate=%zd\n",
- offset, count, buffer->allocated, buffer->size,
- buffer->last_allocate);
- if (buffer->allocated + count >= buffer->size)
- return CBFS_MEDIA_INVALID_MAP_ADDRESS;
- if (media->read(media, address, offset, count) != count) {
- ERROR("simple_buffer: fail to read %zd bytes from 0x%zx\n",
- count, offset);
- return CBFS_MEDIA_INVALID_MAP_ADDRESS;
- }
- buffer->allocated += count;
- buffer->last_allocate = count;
- return address;
-}
-
-void *cbfs_simple_buffer_unmap(struct cbfs_simple_buffer *buffer,
- const void *address) {
- // TODO Add simple buffer management so we can free more than last
- // allocated one.
- DEBUG("simple_buffer_unmap(address=0x%p): "
- "allocated=%zd, size=%zd, last_allocate=%zd\n",
- address, buffer->allocated, buffer->size,
- buffer->last_allocate);
- if ((buffer->buffer + buffer->allocated - buffer->last_allocate) ==
- address) {
- buffer->allocated -= buffer->last_allocate;
- buffer->last_allocate = 0;
- }
- return NULL;
+ if (fd == NULL)
+ return NULL;
+
+ if (region_request_normalize(&fd->content, ®ion))
+ return NULL;
+
+ return region_mmap(fd->rh, region.offset, size);
}
-/**
- * run_address is passed the address of a function taking no parameters and
- * jumps to it, returning the result.
- * @param f the address to call as a function.
- * @return value returned by the function.
- */
+ssize_t cbfs_file_read_metadata(const struct cbfs_file_descriptor *fd,
+ void *buf, offset_t offset, size_t size)
+{
+ struct region region = {
+ .offset = offset,
+ .size = size,
+ };
+
+ if (fd == NULL)
+ return -1;
+
+ if (region_request_normalize(&fd->metadata, ®ion))
+ return -1;
+
+ return region_readat(fd->rh, buf, region.offset, size);
+}
+
+void *cbfs_file_map_metadata(const struct cbfs_file_descriptor *fd)
+{
+ if (fd == NULL)
+ return NULL;
+
+ return region_mmap(fd->rh, fd->metadata.offset, fd->metadata.size);
+}
+
+void cbfs_file_unmap(const struct cbfs_file_descriptor *fd, void *addr)
+{
+ if (fd == NULL)
+ return;
+
+ region_munmap(fd->rh, addr);
+}
-int run_address(void *f)
+#ifndef __SMM__
+size_t cbfs_file_inflate(const struct cbfs_file_descriptor *fd,
+ offset_t offset, size_t src_sz, void *dest)
{
- int (*v) (void);
- v = f;
- return v();
+#if defined(CBFS_WITH_LZMA)
+ void *src;
+ size_t dest_sz;
+
+ src = cbfs_file_map_content(fd, offset, src_sz);
+
+ if (src == NULL)
+ return 0;
+
+ dest_sz = ulzma(src, dest);
+
+ cbfs_file_unmap(fd, src);
+
+ return dest_sz;
+#else
+ return 0;
+#endif
}
+void *cbfs_load_stage(const struct cbfs_descriptor *cbfs, const char *name)
+{
+ struct cbfs_stage stage;
+ const struct cbfs_file_descriptor *file;
+ size_t inflated_sz;
+ ssize_t metadata_sz;
+ ssize_t file_sz;
+ uint8_t *dest;
+ void *entry;
+
+ entry = NULL;
+ file = cbfs_open_by_name_type(cbfs, name, CBFS_TYPE_STAGE);
+
+ if (file == NULL)
+ return NULL;
+
+ metadata_sz = cbfs_file_read_metadata(file, &stage, 0, sizeof(stage));
+ if (metadata_sz != sizeof(stage))
+ goto out;
+
+ file_sz = cbfs_file_content_size(file);
+ if (file_sz < 0)
+ goto out;
+
+ printk(BIOS_INFO,
+ "Loading stage '%s' 0x%llx (%d bytes), entry point 0x%llx\n",
+ name, (long long) stage.load, stage.memlen,
+ (long long)stage.entry);
+
+ dest = (void *)(uintptr_t)stage.load;
+ inflated_sz = stage.memlen;
+
+ switch (stage.compression) {
+ case CBFS_COMPRESS_NONE:
+ if (cbfs_file_read_content(file, dest, 0, file_sz) != file_sz)
+ goto out;
+ break;
+#if defined(CBFS_WITH_LZMA)
+ case CBFS_COMPRESS_LZMA:
+ inflated_sz = cbfs_file_inflate(file, 0, file_sz, dest);
+ if (inflated_sz == 0)
+ goto out;
+ break;
+#endif
+ default:
+ printk(BIOS_ERR,"Invalid compression scheme: %d\n",
+ stage.compression);
+ goto out;
+ }
+
+ if (inflated_sz > stage.memlen) {
+ printk(BIOS_ERR,"Inflated size %zu > memory size %zu.\n",
+ inflated_sz, (size_t)stage.memlen);
+ goto out;
+ }
+
+ /* Stages rely the below clearing so that the bss is initialized. */
+ memset(dest + inflated_sz, 0, stage.memlen - inflated_sz);
+
+ printk(BIOS_DEBUG,"stage loaded.\n");
+
+ entry = (void *)(uintptr_t)stage.entry;
+
+out:
+ cbfs_file_close(file);
+ return entry;
+}
#endif
diff --git a/src/lib/cbfs_boot_region.c b/src/lib/cbfs_boot_region.c
new file mode 100644
index 0000000..6ab12f7
--- /dev/null
+++ b/src/lib/cbfs_boot_region.c
@@ -0,0 +1,133 @@
+/*
+ * This file is part of the coreboot project.
+ *
+ * Copyright (C) 2014 Google Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <stdint.h>
+#include <arch/early_variables.h>
+#include <arch/byteorder.h>
+#include <console/console.h>
+#include <cbfs.h>
+#include <cbfs_core.h>
+#include <region.h>
+
+static struct cbfs_descriptor g_cbfs_descriptor CAR_GLOBAL;
+
+const struct cbfs_descriptor *cbfs_default_descriptor(void)
+{
+ return car_get_var_ptr(&g_cbfs_descriptor);
+}
+
+static const struct region_device cbfs_dev = {
+ .region = {
+ .offset = CONFIG_ROM_SIZE - CONFIG_CBFS_SIZE,
+ .size = CONFIG_CBFS_SIZE,
+ },
+};
+
+#if IS_ENABLED(CONFIG_ARCH_X86)
+static offset_t get_header_offset(rhandle_t rh)
+{
+ int32_t header_offset;
+ offset_t off;
+ ssize_t rsize;
+
+ rsize = region_size(rh);
+ off = rsize - sizeof(header_offset);
+ region_readat(rh, &header_offset, off, sizeof(header_offset));
+ return rsize + header_offset;
+}
+#else
+static inline offset_t get_header_offset(rhandle_t rh)
+{
+ return CONFIG_CBFS_HEADER_ROM_OFFSET;
+}
+#endif
+
+void cbfs_default_media_initialize(void)
+{
+ rhandle_t rh;
+ offset_t header_offset;
+ struct cbfs_header *hdr;
+ size_t cbfs_size;
+ struct cbfs_descriptor *cbfs_desc;
+
+ /* Already initialized. */
+ rh = region_locate(DEFAULT_CBFS_REGION_NAME);
+ if (rhandle_valid(rh))
+ return;
+
+ /* Mark region as invalid. */
+ cbfs_desc = (struct cbfs_descriptor *)cbfs_default_descriptor();
+ cbfs_desc->rh = INVALID_RHANDLE;
+
+ /* CBFS provides a readonly view of the rom. */
+ rh = region_locate(BOOTRO_REGION_NAME);
+
+ if (!rhandle_valid(rh)) {
+ printk(BIOS_ERR, "Boot region not found to register cbfs.\n");
+ return;
+ }
+
+ header_offset = get_header_offset(rh);
+ hdr = region_mmap(rh, header_offset, sizeof(*hdr));
+
+ if (hdr == NULL) {
+ printk(BIOS_ERR, "Couldn't mmap() cbfs header.\n");
+ return;
+ }
+
+ if (CBFS_HEADER_MAGIC != ntohl(hdr->magic)) {
+ printk(BIOS_ERR, "Invalid CBFS magic @ 0x%zx: %x vs %x\n",
+ (size_t)header_offset, CBFS_HEADER_MAGIC,
+ ntohl(hdr->magic));
+ goto out;
+ }
+
+ if (cbfs_dev.region.offset != ntohl(hdr->offset)) {
+ printk(BIOS_ERR, "CBFS offset doesn't match: 0x%zx vs 0x%zx\n",
+ (size_t)cbfs_dev.region.offset,
+ (size_t)ntohl(hdr->offset));
+ goto out;
+ }
+
+ cbfs_size = ntohl(hdr->romsize) - ntohl(hdr->offset);
+
+ if (cbfs_dev.region.size != cbfs_size) {
+ printk(BIOS_ERR, "CBFS size doesn't match: 0x%zx vs 0x%zx\n",
+ cbfs_dev.region.size, cbfs_size);
+ goto out;
+ }
+
+#if IS_ENABLED(CONFIG_ARCH_X86)
+ cbfs_size -= htonl(hdr->bootblocksize);
+#endif
+
+ cbfs_desc->align = ntohl(hdr->align);
+ cbfs_desc->size = cbfs_size;
+
+ printk(BIOS_DEBUG, "%s: CBFS align 0x%zx size 0x%zx\n", __func__,
+ cbfs_desc->align, cbfs_desc->size);
+
+ cbfs_desc->rh = region_register_subregion(DEFAULT_CBFS_REGION_NAME,
+ &cbfs_dev, rh);
+ if (!rhandle_valid(cbfs_desc->rh))
+ printk(BIOS_ERR, "Unable to register default CBFS region.\n");
+
+out:
+ region_munmap(rh, hdr);
+}
diff --git a/src/lib/cbfs_core.c b/src/lib/cbfs_core.c
deleted file mode 100644
index 50c037e..0000000
--- a/src/lib/cbfs_core.c
+++ /dev/null
@@ -1,224 +0,0 @@
-/*
- * This file is part of the coreboot project.
- *
- * Copyright (C) 2011 secunet Security Networks AG
- * Copyright (C) 2013 The Chromium OS Authors. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * 3. The name of the author may not be used to endorse or promote products
- * derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-/* The CBFS core requires a couple of #defines or functions to adapt it to the
- * target environment:
- *
- * CBFS_CORE_WITH_LZMA (must be #define)
- * if defined, ulzma() must exist for decompression of data streams
- *
- * CBFS_HEADER_ROM_ADDRESS
- * ROM address (offset) of CBFS header. Underlying CBFS media may interpret
- * it in other way so we call this "address".
- *
- * ERROR(x...)
- * print an error message x (in printf format)
- *
- * LOG(x...)
- * print a message x (in printf format)
- *
- * DEBUG(x...)
- * print a debug message x (in printf format)
- *
- */
-
-#include <cbfs.h>
-#include <string.h>
-
-/* returns a pointer to CBFS master header, or CBFS_HEADER_INVALID_ADDRESS
- * on failure */
-const struct cbfs_header *cbfs_get_header(struct cbfs_media *media)
-{
- const struct cbfs_header *header;
- struct cbfs_media default_media;
-
- if (media == CBFS_DEFAULT_MEDIA) {
- media = &default_media;
- if (init_default_cbfs_media(media) != 0) {
- ERROR("Failed to initialize default media.\n");
- return CBFS_HEADER_INVALID_ADDRESS;
- }
- }
-
- media->open(media);
- DEBUG("CBFS_HEADER_ROM_ADDRESS: 0x%x/0x%x\n", CBFS_HEADER_ROM_ADDRESS,
- CONFIG_ROM_SIZE);
- header = media->map(media, CBFS_HEADER_ROM_ADDRESS, sizeof(*header));
- media->close(media);
-
- if (header == CBFS_MEDIA_INVALID_MAP_ADDRESS) {
- ERROR("Failed to load CBFS header from 0x%x\n",
- CBFS_HEADER_ROM_ADDRESS);
- return CBFS_HEADER_INVALID_ADDRESS;
- }
-
- if (CBFS_HEADER_MAGIC != ntohl(header->magic)) {
- ERROR("Could not find valid CBFS master header at %x: "
- "%x vs %x.\n", CBFS_HEADER_ROM_ADDRESS, CBFS_HEADER_MAGIC,
- ntohl(header->magic));
- if (header->magic == 0xffffffff) {
- ERROR("Maybe ROM is not mapped properly?\n");
- }
- return CBFS_HEADER_INVALID_ADDRESS;
- }
- return header;
-}
-
-/* public API starts here*/
-struct cbfs_file *cbfs_get_file(struct cbfs_media *media, const char *name)
-{
- const char *file_name;
- uint32_t offset, align, romsize, name_len;
- const struct cbfs_header *header;
- struct cbfs_file file, *file_ptr;
- struct cbfs_media default_media;
-
- if (media == CBFS_DEFAULT_MEDIA) {
- media = &default_media;
- if (init_default_cbfs_media(media) != 0) {
- ERROR("Failed to initialize default media.\n");
- return NULL;
- }
- }
-
- if (CBFS_HEADER_INVALID_ADDRESS == (header = cbfs_get_header(media)))
- return NULL;
-
- // Logical offset (for source media) of first file.
- offset = ntohl(header->offset);
- align = ntohl(header->align);
- romsize = ntohl(header->romsize);
-
- // TODO Add a "size" in CBFS header for a platform independent way to
- // determine the end of CBFS data.
-#if defined(CONFIG_ARCH_X86) && CONFIG_ARCH_X86
- romsize -= htonl(header->bootblocksize);
-#endif
- DEBUG("CBFS location: 0x%x~0x%x, align: %d\n", offset, romsize, align);
-
- DEBUG("Looking for '%s' starting from 0x%x.\n", name, offset);
- media->open(media);
- while (offset < romsize &&
- media->read(media, &file, offset, sizeof(file)) == sizeof(file)) {
- if (memcmp(CBFS_FILE_MAGIC, file.magic,
- sizeof(file.magic)) != 0) {
- uint32_t new_align = align;
- if (offset % align)
- new_align += align - (offset % align);
- ERROR("ERROR: No file header found at 0x%x - "
- "try next aligned address: 0x%x.\n", offset,
- offset + new_align);
- offset += new_align;
- continue;
- }
- name_len = ntohl(file.offset) - sizeof(file);
- DEBUG(" - load entry 0x%x file name (%d bytes)...\n", offset,
- name_len);
-
- // load file name (arbitrary length).
- file_name = (const char *)media->map(
- media, offset + sizeof(file), name_len);
- if (file_name == CBFS_MEDIA_INVALID_MAP_ADDRESS) {
- ERROR("ERROR: Failed to get filename: 0x%x.\n", offset);
- } else if (strcmp(file_name, name) == 0) {
- int file_offset = ntohl(file.offset),
- file_len = ntohl(file.len);
- DEBUG("Found file (offset=0x%x, len=%d).\n",
- offset + file_offset, file_len);
- media->unmap(media, file_name);
- file_ptr = media->map(media, offset,
- file_offset + file_len);
- media->close(media);
- return file_ptr;
- } else {
- DEBUG(" (unmatched file @0x%x: %s)\n", offset,
- file_name);
- media->unmap(media, file_name);
- }
-
- // Move to next file.
- offset += ntohl(file.len) + ntohl(file.offset);
- if (offset % align)
- offset += align - (offset % align);
- }
- media->close(media);
- LOG("WARNING: '%s' not found.\n", name);
- return NULL;
-}
-
-void *cbfs_get_file_content(struct cbfs_media *media, const char *name,
- int type, size_t *sz)
-{
- struct cbfs_file *file = cbfs_get_file(media, name);
-
- if (sz)
- *sz = 0;
-
- if (file == NULL) {
- ERROR("Could not find file '%s'.\n", name);
- return NULL;
- }
-
- if (ntohl(file->type) != type) {
- ERROR("File '%s' is of type %x, but we requested %x.\n", name,
- ntohl(file->type), type);
- return NULL;
- }
-
- if (sz)
- *sz = ntohl(file->len);
-
- return (void *)CBFS_SUBHEADER(file);
-}
-
-int cbfs_decompress(int algo, void *src, void *dst, int len)
-{
- switch (algo) {
- case CBFS_COMPRESS_NONE:
- /* Reads need to be aligned at 4 bytes to avoid
- poor flash performance. */
- while (len && ((u32)src & 3)) {
- *(u8*)dst++ = *(u8*)src++;
- len--;
- }
- memmove(dst, src, len);
- return len;
-#ifdef CBFS_CORE_WITH_LZMA
- case CBFS_COMPRESS_LZMA:
- return ulzma(src, dst);
-#endif
- default:
- ERROR("tried to decompress %d bytes with algorithm #%x,"
- "but that algorithm id is unsupported.\n", len,
- algo);
- return 0;
- }
-}
-
diff --git a/src/lib/loaders/cbfs_payload_loader.c b/src/lib/loaders/cbfs_payload_loader.c
index 2c1d179..31ad7e6 100644
--- a/src/lib/loaders/cbfs_payload_loader.c
+++ b/src/lib/loaders/cbfs_payload_loader.c
@@ -18,20 +18,30 @@
*/
#include <cbfs.h>
+#include <cbfs_core.h>
#include <payload_loader.h>
static int cbfs_locate_payload(struct payload *payload)
{
void *buffer;
size_t size;
- const int type = CBFS_TYPE_PAYLOAD;
+ const struct cbfs_file_descriptor *fd;
- buffer = cbfs_get_file_content(CBFS_DEFAULT_MEDIA, payload->name,
- type, &size);
+ fd = cbfs_open_by_name_type(cbfs_default_descriptor(), payload->name,
+ CBFS_TYPE_PAYLOAD);
- if (buffer == NULL)
+ if (fd == NULL)
return -1;
+ size = cbfs_file_content_size(fd);
+ buffer = cbfs_file_map_content(fd, 0, size);
+
+ if (buffer == NULL) {
+ cbfs_file_close(fd);
+ return -1;
+ }
+
+ payload->fd = fd;
payload->backing_store.data = buffer;
payload->backing_store.size = size;
diff --git a/src/lib/loaders/cbfs_ramstage_loader.c b/src/lib/loaders/cbfs_ramstage_loader.c
index 5d5cc0b..5d5edd8 100644
--- a/src/lib/loaders/cbfs_ramstage_loader.c
+++ b/src/lib/loaders/cbfs_ramstage_loader.c
@@ -34,7 +34,8 @@ static void *cbfs_load_ramstage(uint32_t cbmem_id, const char *name,
.name = name,
};
- if (rmodule_stage_load_from_cbfs(&rmod_ram)) {
+ if (rmodule_stage_load_from_cbfs(cbfs_default_descriptor(),
+ &rmod_ram)) {
printk(BIOS_DEBUG, "Could not load ramstage.\n");
return NULL;
}
@@ -49,14 +50,7 @@ static void *cbfs_load_ramstage(uint32_t cbmem_id, const char *name,
static void *cbfs_load_ramstage(uint32_t cbmem_id, const char *name,
const struct cbmem_entry **cbmem_entry)
{
- void *entry;
-
- entry = cbfs_load_stage(CBFS_DEFAULT_MEDIA, name);
-
- if ((void *)entry == (void *) -1)
- entry = NULL;
-
- return entry;
+ return cbfs_load_stage(cbfs_default_descriptor(), name);
}
#endif /* CONFIG_RELOCATABLE_RAMSTAGE */
diff --git a/src/lib/loaders/load_and_run_payload.c b/src/lib/loaders/load_and_run_payload.c
index 2204090..ac4e7bf 100644
--- a/src/lib/loaders/load_and_run_payload.c
+++ b/src/lib/loaders/load_and_run_payload.c
@@ -58,9 +58,8 @@ struct payload *payload_load(void)
ops->name);
continue;
}
- printk(BIOS_DEBUG, "%s: located payload @ %p, %zu bytes.\n",
- ops->name, payload->backing_store.data,
- payload->backing_store.size);
+ printk(BIOS_DEBUG, "%s: located payload, %zu bytes.\n",
+ ops->name, payload->backing_store.size);
break;
}
diff --git a/src/lib/region.c b/src/lib/region.c
new file mode 100644
index 0000000..6300b89
--- /dev/null
+++ b/src/lib/region.c
@@ -0,0 +1,305 @@
+/*
+ * This file is part of the coreboot project.
+ *
+ * Copyright (C) 2014 Google Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <string.h>
+#include <console/console.h>
+#include <arch/early_variables.h>
+#include <region.h>
+#include <vendorcode/google/chromeos/fmap.h>
+
+/* MAX_REGIONS could be configurable. */
+#define MAX_REGIONS 6
+
+struct region_registry_entry {
+ rhandle_t parent_slot;
+ const char *name;
+ const struct region_device *rdev;
+};
+
+struct region_registry {
+ struct region_registry_entry entries[MAX_REGIONS];
+};
+
+static struct region_registry g_regions CAR_GLOBAL;
+
+static inline struct region_registry *get_registry(void)
+{
+ return car_get_var_ptr(&g_regions);
+}
+
+static const struct region_registry_entry *
+registry_entry_lookup(const struct region_registry *rr, rhandle_t rh)
+{
+ if (rh < 0 || rh >= MAX_REGIONS)
+ return NULL;
+
+ return &rr->entries[rh];
+}
+
+static int region_enclosed(const struct region *parent,
+ const struct region *child)
+{
+ offset_t parent_end;
+ offset_t child_end;
+
+ child_end = child->offset + child->size;
+ parent_end = parent->offset + parent->size;
+
+ if (child->size > parent->size)
+ return -1;
+
+ if (child->offset >= parent->offset && child_end <= parent_end)
+ return 0;
+
+ return -1;
+}
+
+int region_request_normalize(const struct region *parent,
+ struct region *request)
+{
+ request->offset += parent->offset;
+ return region_enclosed(parent, request);
+}
+
+static rhandle_t __region_register(struct region_registry *rr, const char *name,
+ const struct region_device *rdev,
+ rhandle_t parent)
+{
+ rhandle_t slot;
+
+ for (slot = 0; slot < MAX_REGIONS; slot++) {
+ struct region_registry_entry *entry = &rr->entries[slot];
+
+ /* Find an empty slot. */
+ if (entry->rdev != NULL)
+ continue;
+
+ entry->parent_slot = parent;
+ entry->name = name;
+ entry->rdev = rdev;
+ printk(BIOS_DEBUG,
+ "Region '%s' registered: slot %u, %zu @ 0x%zx.\n",
+ name, (unsigned int)slot, rdev->region.size,
+ (size_t)rdev->region.offset);
+ return slot;
+ }
+
+ return INVALID_RHANDLE;
+}
+
+rhandle_t region_register(const char *name, const struct region_device *rdev)
+{
+ if (name == NULL || rdev == NULL || rdev->ops == NULL)
+ return INVALID_RHANDLE;
+
+ return __region_register(get_registry(), name, rdev, INVALID_RHANDLE);
+}
+
+rhandle_t region_register_subregion(const char *name,
+ const struct region_device *rdev,
+ rhandle_t parent)
+{
+ struct region_registry *rr;
+ const struct region_registry_entry *pentry;
+
+ /* Subregions require NULL ops. */
+ if (name == NULL || rdev == NULL || rdev->ops != NULL)
+ return INVALID_RHANDLE;
+
+ rr = get_registry();
+
+ /* Parent is invalid. */
+ pentry = registry_entry_lookup(rr, parent);
+ if (pentry == NULL)
+ return INVALID_RHANDLE;
+
+ /* Ensure subregion is within bounds. */
+ if (region_enclosed(&pentry->rdev->region, &rdev->region))
+ return INVALID_RHANDLE;
+
+ return __region_register(rr, name, rdev, parent);
+}
+
+/* Locate a region of provided name. */
+rhandle_t region_locate(const char *name)
+{
+ rhandle_t slot;
+ struct region_registry *rr;
+
+ if (name == NULL)
+ return INVALID_RHANDLE;
+
+ rr = get_registry();
+
+ for (slot = 0; slot < MAX_REGIONS; slot++) {
+ const struct region_registry_entry *entry = &rr->entries[slot];
+
+ /* No more valid entries. */
+ if (entry->rdev == NULL)
+ break;
+
+ if (!strcmp(entry->name, name))
+ return slot;
+ }
+ return INVALID_RHANDLE;
+}
+
+/*
+ * Obtain the appropriate region_device while optionally translating the
+ * region into the parent's domain.
+ */
+static const struct region_device *
+find_parent(rhandle_t rh, struct region *region)
+{
+ const struct region_registry_entry *entry;
+ struct region_registry *rr;
+
+ rr = get_registry();
+ entry = registry_entry_lookup(rr, rh);
+
+ if (entry == NULL)
+ return NULL;
+
+ if (region != NULL &&
+ region_request_normalize(&entry->rdev->region, region))
+ return NULL;
+
+ while (entry->rdev->ops == NULL) {
+ entry = &rr->entries[entry->parent_slot];
+ /* Translate the region into the parent's view. */
+ if (region != NULL)
+ region->offset += entry->rdev->region.offset;
+ }
+
+ return entry->rdev;
+}
+
+ssize_t region_readat(rhandle_t rh, void *buf, offset_t offset, size_t count)
+{
+ const struct region_device *rdev;
+ struct region region = {
+ .offset = offset,
+ .size = count,
+ };
+
+ rdev = find_parent(rh, ®ion);
+
+ if (rdev == NULL || rdev->ops->readat == NULL)
+ return -1;
+
+ return rdev->ops->readat(rdev, buf, region.offset, region.size);
+}
+
+ssize_t region_writeat(rhandle_t rh, void *buf, offset_t offset, size_t count)
+{
+ const struct region_device *rdev;
+ struct region region = {
+ .offset = offset,
+ .size = count,
+ };
+
+ rdev = find_parent(rh, ®ion);
+
+ if (rdev == NULL || rdev->ops->writeat == NULL)
+ return -1;
+
+ return rdev->ops->writeat(rdev, buf, region.offset, region.size);
+}
+
+ssize_t region_eraseat(rhandle_t rh, offset_t offset, size_t count)
+{
+ const struct region_device *rdev;
+ struct region region = {
+ .offset = offset,
+ .size = count,
+ };
+
+ rdev = find_parent(rh, ®ion);
+
+ if (rdev == NULL || rdev->ops->eraseat == NULL)
+ return -1;
+
+ return rdev->ops->eraseat(rdev, region.offset, region.size);
+}
+
+void *region_mmap(rhandle_t rh, offset_t offset, size_t count)
+{
+ const struct region_device *rdev;
+ struct region region = {
+ .offset = offset,
+ .size = count,
+ };
+
+ if (count == 0)
+ return NULL;
+
+ rdev = find_parent(rh, ®ion);
+
+ if (rdev == NULL || rdev->ops->mmap == NULL)
+ return NULL;
+
+ return rdev->ops->mmap(rdev, region.offset, region.size);
+}
+
+void region_munmap(rhandle_t rh, void *addr)
+{
+ const struct region_device *rdev;
+
+ rdev = find_parent(rh, NULL);
+
+ if (rdev == NULL || rdev->ops->munmap == NULL)
+ return;
+
+ return rdev->ops->munmap(rdev, addr);
+}
+
+ssize_t region_size(rhandle_t rh)
+{
+ const struct region_registry_entry *entry;
+
+ entry = registry_entry_lookup(get_registry(), rh);
+
+ if (entry == NULL)
+ return -1;
+
+ return entry->rdev->region.size;
+}
+
+void boot_region_init(void)
+{
+ boot_media_initialize();
+ cbfs_default_media_initialize();
+ fmap_initialize();
+}
+
+/* Provide weak default. */
+void __attribute__((weak)) bootrw_media_initialize(void) {}
+
+#if !defined(__PRE_RAM__)
+#include <bootstate.h>
+static void regions_bscb(void *unused)
+{
+ boot_region_init();
+}
+
+BOOT_STATE_INIT_ENTRIES(regions_init) = {
+ BOOT_STATE_INIT_ENTRY(BS_DEV_INIT_CHIPS, BS_ON_ENTRY,
+ regions_bscb, NULL),
+};
+#endif
diff --git a/src/lib/rmodule.c b/src/lib/rmodule.c
index 2cb70b8..33481b2 100644
--- a/src/lib/rmodule.c
+++ b/src/lib/rmodule.c
@@ -21,6 +21,9 @@
#include <stdlib.h>
#include <string.h>
#include <console/console.h>
+#include <cbfs.h>
+#include <cbfs_core.h>
+#include <lib.h>
#include <rmodule.h>
/* Change this define to get more verbose debugging for module loading. */
@@ -305,11 +308,12 @@ int rmodule_calc_region(unsigned int region_alignment, size_t rmodule_size,
#include <cbmem.h>
#include <cbfs_core.h>
-int rmodule_stage_load(struct rmod_stage_load *rsl, struct cbfs_stage *stage)
+int rmodule_stage_load(struct rmod_stage_load *rsl, struct cbfs_stage *stage,
+ void *data)
{
struct rmodule rmod_stage;
size_t region_size;
- char *stage_region;
+ unsigned char *stage_region;
int rmodule_offset;
int load_offset;
const struct cbmem_entry *cbmem_entry;
@@ -331,8 +335,12 @@ int rmodule_stage_load(struct rmod_stage_load *rsl, struct cbfs_stage *stage)
printk(BIOS_INFO, "Decompressing stage %s @ 0x%p (%d bytes)\n",
rsl->name, &stage_region[rmodule_offset], stage->memlen);
- if (!cbfs_decompress(stage->compression, &stage[1],
- &stage_region[rmodule_offset], stage->len))
+ if (stage->compression == CBFS_COMPRESS_NONE) {
+ memcpy(data, &stage_region[rmodule_offset], stage->len);
+ } else if (stage->compression == CBFS_COMPRESS_LZMA) {
+ if (!ulzma(data, &stage_region[rmodule_offset]))
+ return -1;
+ } else
return -1;
if (rmodule_parse(&stage_region[rmodule_offset], &rmod_stage))
@@ -347,17 +355,35 @@ int rmodule_stage_load(struct rmod_stage_load *rsl, struct cbfs_stage *stage)
return 0;
}
-int rmodule_stage_load_from_cbfs(struct rmod_stage_load *rsl)
+int rmodule_stage_load_from_cbfs(const struct cbfs_descriptor *cbfs,
+ struct rmod_stage_load *rsl)
{
- struct cbfs_stage *stage;
+ const struct cbfs_file_descriptor *fd;
+ struct cbfs_stage stage;
+ size_t rdsz = sizeof(stage);
+ int ret;
+ void *buf;
- stage = cbfs_get_file_content(CBFS_DEFAULT_MEDIA,
- rsl->name, CBFS_TYPE_STAGE, NULL);
+ fd = cbfs_open_by_name_type(cbfs, rsl->name, CBFS_TYPE_STAGE);
- if (stage == NULL)
+ if (fd == NULL)
return -1;
- return rmodule_stage_load(rsl, stage);
+ ret = -1;
+ if (cbfs_file_read_metadata(fd, &stage, 0, rdsz) != rdsz)
+ goto out;
+
+ buf = cbfs_file_map_content(fd, 0, cbfs_file_content_size(fd));
+ if (buf == NULL)
+ goto out;
+
+ ret = rmodule_stage_load(rsl, &stage, buf);
+
+ cbfs_file_unmap(fd, buf);
+
+out:
+ cbfs_file_close(fd);
+ return ret;
}
#endif /* DYNAMIC_CBMEM */
diff --git a/src/lib/selfboot.c b/src/lib/selfboot.c
index feff03e..b6c8797 100644
--- a/src/lib/selfboot.c
+++ b/src/lib/selfboot.c
@@ -25,6 +25,7 @@
#include <stdlib.h>
#include <string.h>
#include <cbfs.h>
+#include <cbfs_core.h>
#include <lib.h>
#include <bootmem.h>
#include <payload_loader.h>
@@ -40,7 +41,7 @@ struct segment {
struct segment *next;
struct segment *prev;
unsigned long s_dstaddr;
- unsigned long s_srcaddr;
+ unsigned long s_srcoffset;
unsigned long s_memsz;
unsigned long s_filesz;
int compression;
@@ -140,7 +141,7 @@ static int relocate_segment(unsigned long buffer, struct segment *seg)
new->s_memsz = len;
seg->s_memsz -= len;
seg->s_dstaddr += len;
- seg->s_srcaddr += len;
+ seg->s_srcoffset += len;
if (seg->s_filesz > len) {
new->s_filesz = len;
seg->s_filesz -= len;
@@ -176,7 +177,7 @@ static int relocate_segment(unsigned long buffer, struct segment *seg)
seg->s_memsz = len;
new->s_memsz -= len;
new->s_dstaddr += len;
- new->s_srcaddr += len;
+ new->s_srcoffset += len;
if (seg->s_filesz > len) {
seg->s_filesz = len;
new->s_filesz -= len;
@@ -213,17 +214,12 @@ static int relocate_segment(unsigned long buffer, struct segment *seg)
static int build_self_segment_list(
- struct segment *head,
+ struct segment *head, struct cbfs_payload_segment *segment,
struct payload *payload, uintptr_t *entry)
{
struct segment *new;
- struct segment *ptr;
- struct cbfs_payload_segment *segment, *first_segment;
- struct cbfs_payload *cbfs_payload;
- cbfs_payload = payload->backing_store.data;
memset(head, 0, sizeof(*head));
head->next = head->prev = head;
- first_segment = segment = &cbfs_payload->segments;
while(1) {
printk(BIOS_DEBUG, "Loading segment from rom address 0x%p\n", segment);
@@ -237,43 +233,39 @@ static int build_self_segment_list(
case PAYLOAD_SEGMENT_DATA:
printk(BIOS_DEBUG, " %s (compression=%x)\n",
segment->type == PAYLOAD_SEGMENT_CODE ? "code" : "data",
- ntohl(segment->compression));
+ segment->compression);
new = malloc(sizeof(*new));
- new->s_dstaddr = ntohll(segment->load_addr);
- new->s_memsz = ntohl(segment->mem_len);
- new->compression = ntohl(segment->compression);
-
- new->s_srcaddr = (uintptr_t)
- ((unsigned char *)first_segment)
- + ntohl(segment->offset);
- new->s_filesz = ntohl(segment->len);
- printk(BIOS_DEBUG, " New segment dstaddr 0x%lx memsize 0x%lx srcaddr 0x%lx filesize 0x%lx\n",
- new->s_dstaddr, new->s_memsz, new->s_srcaddr, new->s_filesz);
+ new->s_dstaddr = segment->load_addr;
+ new->s_memsz = segment->mem_len;
+ new->compression = segment->compression;
+
+ new->s_srcoffset = segment->offset;
+ new->s_filesz = segment->len;
+ printk(BIOS_DEBUG, " New segment dstaddr 0x%lx memsize 0x%lx srcoffset 0x%lx filesize 0x%lx\n",
+ new->s_dstaddr, new->s_memsz, new->s_srcoffset, new->s_filesz);
/* Clean up the values */
if (new->s_filesz > new->s_memsz) {
new->s_filesz = new->s_memsz;
}
printk(BIOS_DEBUG, " (cleaned up) New segment addr 0x%lx size 0x%lx offset 0x%lx filesize 0x%lx\n",
- new->s_dstaddr, new->s_memsz, new->s_srcaddr, new->s_filesz);
+ new->s_dstaddr, new->s_memsz, new->s_srcoffset, new->s_filesz);
break;
case PAYLOAD_SEGMENT_BSS:
- printk(BIOS_DEBUG, " BSS 0x%p (%d byte)\n", (void *)
- (intptr_t)ntohll(segment->load_addr),
- ntohl(segment->mem_len));
+ printk(BIOS_DEBUG, " BSS 0x%p (%d byte)\n",
+ (void *)(intptr_t)segment->load_addr,
+ segment->mem_len);
new = malloc(sizeof(*new));
new->s_filesz = 0;
- new->s_srcaddr = (uintptr_t)
- ((unsigned char *)first_segment)
- + ntohl(segment->offset);
- new->s_dstaddr = ntohll(segment->load_addr);
- new->s_memsz = ntohl(segment->mem_len);
+ new->s_srcoffset = segment->offset;
+ new->s_dstaddr = segment->load_addr;
+ new->s_memsz = segment->mem_len;
break;
case PAYLOAD_SEGMENT_ENTRY:
printk(BIOS_DEBUG, " Entry Point 0x%p\n",
- (void *)(intptr_t)ntohll(segment->load_addr));
- *entry = ntohll(segment->load_addr);
+ (void *)(intptr_t)segment->load_addr);
+ *entry = segment->load_addr;
/* Per definition, a payload always has the entry point
* as last segment. Thus, we use the occurrence of the
* entry point as break condition for the loop.
@@ -292,17 +284,11 @@ static int build_self_segment_list(
/* We have found another CODE, DATA or BSS segment */
segment++;
- /* Find place where to insert our segment */
- for(ptr = head->next; ptr != head; ptr = ptr->next) {
- if (new->s_srcaddr < ntohll(segment->load_addr))
- break;
- }
-
- /* Order by stream offset */
- new->next = ptr;
- new->prev = ptr->prev;
- ptr->prev->next = new;
- ptr->prev = new;
+ /* Add to end of list. */
+ new->next = head;
+ new->prev = head->prev;
+ head->prev->next = new;
+ head->prev = new;
}
return 1;
@@ -315,6 +301,7 @@ static int load_self_segments(
struct segment *ptr;
const unsigned long one_meg = (1UL << 20);
unsigned long bounce_high = lb_end;
+ unsigned char *srcaddr = payload->backing_store.data;
for(ptr = head->next; ptr != head; ptr = ptr->next) {
if (bootmem_region_targets_usable_ram(ptr->s_dstaddr,
@@ -378,7 +365,7 @@ static int load_self_segments(
/* Compute the boundaries of the segment */
dest = (unsigned char *)(ptr->s_dstaddr);
- src = (unsigned char *)(ptr->s_srcaddr);
+ src = srcaddr + ptr->s_srcoffset;
/* Copy data from the initial buffer */
if (ptr->s_filesz) {
@@ -441,13 +428,51 @@ static int load_self_segments(
return 1;
}
+static void
+parse_cbfs_segments(struct cbfs_payload_segment *segments, size_t size)
+{
+ int i;
+ int num;
+
+ num = size / sizeof(struct cbfs_payload_segment);
+
+ for (i = 0; i < num; i++) {
+ /* Note: the type field is in host order. */
+ segments[i].compression = ntohl(segments[i].compression);
+ segments[i].offset = ntohl(segments[i].offset);
+ /* Fix up the offsets to be relative to the data stream. */
+ segments[i].offset -= size;
+ segments[i].load_addr = ntohll(segments[i].load_addr);
+ segments[i].len = ntohl(segments[i].len);
+ segments[i].mem_len = ntohl(segments[i].mem_len);
+ }
+}
+
void *selfload(struct payload *payload)
{
uintptr_t entry = 0;
struct segment head;
+ ssize_t metadata_sz;
+ struct cbfs_payload_segment *segments;
+
+ metadata_sz = cbfs_file_metadata_size(payload->fd);
+
+ if (metadata_sz <= 0)
+ return NULL;
+
+ segments = malloc(sizeof(struct cbfs_payload_segment));
+
+ if (segments == NULL)
+ return NULL;
+
+ if (cbfs_file_read_metadata(payload->fd, segments, 0, metadata_sz) !=
+ metadata_sz)
+ return NULL;
+
+ parse_cbfs_segments(segments, metadata_sz);
/* Preprocess the self segments */
- if (!build_self_segment_list(&head, payload, &entry))
+ if (!build_self_segment_list(&head, segments, payload, &entry))
goto out;
/* Load the segments */
diff --git a/src/soc/intel/baytrail/Kconfig b/src/soc/intel/baytrail/Kconfig
index 2360b36..63b5c89 100644
--- a/src/soc/intel/baytrail/Kconfig
+++ b/src/soc/intel/baytrail/Kconfig
@@ -8,6 +8,7 @@ if SOC_INTEL_BAYTRAIL
config CPU_SPECIFIC_OPTIONS
def_bool y
+ select BOOT_REGION_SPI_FLASH
select CACHE_MRC_SETTINGS
select CAR_MIGRATION
select COLLECT_TIMESTAMPS
diff --git a/src/soc/intel/baytrail/mrc_cache.c b/src/soc/intel/baytrail/mrc_cache.c
index 5613761..784952d 100644
--- a/src/soc/intel/baytrail/mrc_cache.c
+++ b/src/soc/intel/baytrail/mrc_cache.c
@@ -20,6 +20,7 @@
#include <string.h>
#include <console/console.h>
#include <cbmem.h>
+#include <region.h>
#include <ip_checksum.h>
#if CONFIG_CHROMEOS
#include <vendorcode/google/chromeos/fmap.h>
@@ -40,11 +41,20 @@ struct mrc_data_region {
static int mrc_cache_get_region(struct mrc_data_region *region)
{
#if CONFIG_CHROMEOS
- int ret;
- ret = find_fmap_entry("RW_MRC_CACHE", ®ion->base);
- if (ret >= 0) {
- region->size = ret;
- return 0;
+ offset_t offset;
+ size_t size;
+ if (!fmap_locate("RW_MRC_CACHE", &offset, &size)) {
+ void *mapping;
+ rhandle_t rh;
+
+ rh = region_locate(BOOTRO_REGION_NAME);
+ mapping = region_mmap(rh, offset, size);
+
+ if (mapping != NULL) {
+ region->base = mapping;
+ region->size = size;
+ return 0;
+ }
}
#endif
region->base = (void *)CONFIG_MRC_SETTINGS_CACHE_BASE;
diff --git a/src/soc/intel/baytrail/nvm.c b/src/soc/intel/baytrail/nvm.c
index dccc801..44d67ae 100644
--- a/src/soc/intel/baytrail/nvm.c
+++ b/src/soc/intel/baytrail/nvm.c
@@ -24,26 +24,25 @@
#include <spi-generic.h>
#include <spi_flash.h>
#include <baytrail/nvm.h>
+#include <region.h>
/* This module assumes the flash is memory mapped just below 4GiB in the
* address space for reading. Also this module assumes an area it erased
* when all bytes read as all 0xff's. */
-static struct spi_flash *flash;
+static rhandle_t rwrh = INVALID_RHANDLE;
static int nvm_init(void)
{
- if (flash != NULL)
+ if (rhandle_valid(rwrh))
return 0;
- spi_init();
- flash = spi_flash_probe(0, 0, 1000000, SPI_MODE_3);
- if (!flash) {
- printk(BIOS_DEBUG, "Could not find SPI device\n");
- return -1;
- }
+ rwrh = region_locate(BOOTRW_REGION_NAME);
- return 0;
+ if (rhandle_valid(rwrh))
+ return 0;
+
+ return -1;
}
/* Convert memory mapped pointer to flash offset. */
@@ -69,7 +68,10 @@ int nvm_erase(void *start, size_t size)
{
if (nvm_init() < 0)
return -1;
- flash->erase(flash, to_flash_offset(start), size);
+
+ if (region_eraseat(rwrh, to_flash_offset(start), size) != size)
+ return -1;
+
return 0;
}
@@ -78,6 +80,9 @@ int nvm_write(void *start, const void *data, size_t size)
{
if (nvm_init() < 0)
return -1;
- flash->write(flash, to_flash_offset(start), size, data);
+
+ if (region_eraseat(rwrh, to_flash_offset(start), size) != size)
+ return -1;
+
return 0;
}
diff --git a/src/soc/intel/baytrail/romstage/raminit.c b/src/soc/intel/baytrail/romstage/raminit.c
index 7bcd54f..496e755 100644
--- a/src/soc/intel/baytrail/romstage/raminit.c
+++ b/src/soc/intel/baytrail/romstage/raminit.c
@@ -105,6 +105,7 @@ void raminit(struct mrc_params *mp, int prev_sleep_state)
int ret;
mrc_wrapper_entry_t mrc_entry;
const struct mrc_saved_data *cache;
+ const struct cbfs_file_descriptor *fd;
/* Fill in default entries. */
mp->version = MRC_PARAMS_VER;
@@ -118,10 +119,11 @@ void raminit(struct mrc_params *mp, int prev_sleep_state)
printk(BIOS_DEBUG, "No MRC cache found.\n");
}
- mrc_entry = cbfs_get_file_content(CBFS_DEFAULT_MEDIA, "mrc.bin", 0xab,
- NULL);
+ fd = cbfs_open_by_name_type(cbfs_default_descriptor(), "mrc.bin", 0xab);
+ mrc_entry = cbfs_file_map_content(fd, 0, cbfs_file_content_size(fd));
if (mrc_entry == NULL) {
+ cbfs_file_close(fd);
printk(BIOS_DEBUG, "Couldn't find mrc.bin\n");
return;
}
@@ -130,6 +132,9 @@ void raminit(struct mrc_params *mp, int prev_sleep_state)
ret = mrc_entry(mp);
+ cbfs_file_unmap(fd, mrc_entry);
+ cbfs_file_close(fd);
+
print_dram_info();
cbmem_initialize_empty();
diff --git a/src/soc/intel/baytrail/romstage/romstage.c b/src/soc/intel/baytrail/romstage/romstage.c
index 5af9bf4..37aae10 100644
--- a/src/soc/intel/baytrail/romstage/romstage.c
+++ b/src/soc/intel/baytrail/romstage/romstage.c
@@ -29,6 +29,7 @@
#include <ec/google/chromeec/ec.h>
#endif
#include <elog.h>
+#include <region.h>
#include <ramstage_cache.h>
#include <romstage_handoff.h>
#include <timestamp.h>
@@ -133,6 +134,9 @@ void * asmlinkage romstage_main(unsigned long bist,
google_chromeec_early_init();
#endif
+ /* Initialize the boot media. */
+ boot_region_init();
+
/* Call into mainboard. */
mainboard_romstage_entry(&rp);
diff --git a/src/vendorcode/google/chromeos/Makefile.inc b/src/vendorcode/google/chromeos/Makefile.inc
index 007bd57..24afb2c 100644
--- a/src/vendorcode/google/chromeos/Makefile.inc
+++ b/src/vendorcode/google/chromeos/Makefile.inc
@@ -27,6 +27,7 @@ romstage-y += fmap.c
ramstage-y += fmap.c
ramstage-$(CONFIG_CHROMEOS_RAMOOPS) += ramoops.c
smm-y += fmap.c
+smm-y += ../../../lib/region.c
ifneq ($(wildcard src/mainboard/$(MAINBOARDDIR)/chromeos.c),)
ramstage-srcs += src/mainboard/$(MAINBOARDDIR)/chromeos.c
romstage-srcs += src/mainboard/$(MAINBOARDDIR)/chromeos.c
diff --git a/src/vendorcode/google/chromeos/chromeos.c b/src/vendorcode/google/chromeos/chromeos.c
index e917ba1..6f20109 100644
--- a/src/vendorcode/google/chromeos/chromeos.c
+++ b/src/vendorcode/google/chromeos/chromeos.c
@@ -121,10 +121,14 @@ static int vboot_locate_payload(struct payload *payload)
if (buffer == NULL)
return -1;
+#if 0
payload->backing_store.data = buffer;
payload->backing_store.size = size;
return 0;
+#endif
+ /* TODO: fake a cbfs. Also need this in rmodule loading. */
+ return -1;
}
const struct payload_loader_ops vboot_payload_loader = {
diff --git a/src/vendorcode/google/chromeos/fmap.c b/src/vendorcode/google/chromeos/fmap.c
index 538b8c3..fa17e35 100644
--- a/src/vendorcode/google/chromeos/fmap.c
+++ b/src/vendorcode/google/chromeos/fmap.c
@@ -20,97 +20,134 @@
#include <stdint.h>
#include <stddef.h>
#include <string.h>
+#include <arch/early_variables.h>
#include <console/console.h>
+#include <region.h>
#include "fmap.h"
-/* Find FMAP data structure in ROM.
+/*
* See http://code.google.com/p/flashmap/ for more information on FMAP.
*/
-const struct fmap *fmap_find(void)
-{
- /* FIXME: Get rid of the hard codes. The "easy" way would be to
- * do a binary search, but since ROM accesses are slow, we don't
- * want to spend a lot of time looking for the FMAP. An elegant
- * solution would be to store a pointer to the FMAP in the CBFS
- * master header; that would require some more changes to cbfstool
- * and possibly cros_bundle_firmware.
- */
-
- /* wrapping around 0x100000000 */
- const struct fmap *fmap = (void *)
- (CONFIG_FLASHMAP_OFFSET - CONFIG_ROM_SIZE);
- if (memcmp(fmap, FMAP_SIGNATURE, sizeof(FMAP_SIGNATURE)-1)) {
- printk(BIOS_DEBUG, "No FMAP found at %p.\n", fmap);
- return NULL;
- }
+/*
+ * The reason for the global state is that FMAP needs to be available in
+ * romstage on x86 machines. This necessitates keeping some global variables
+ * around because there is no malloc or global modifiable data without being
+ * placed in BSS. This code relies on CAR globals being migrated in romstage.
+ */
- printk(BIOS_DEBUG, "FMAP: Found \"%s\" version %d.%d at %p.\n",
- fmap->name, fmap->ver_major, fmap->ver_minor, fmap);
- printk(BIOS_DEBUG, "FMAP: base = %llx size = %x #areas = %d\n",
- (unsigned long long)fmap->base, fmap->size, fmap->nareas);
+#define FMAP_REGION_NAME "fmap"
+
+struct fmap_state {
+ int registered;
+ int num_entries;
+};
+
+static struct fmap_state g_fmap_state CAR_GLOBAL;
+static const offset_t fmap_offset = CONFIG_FLASHMAP_OFFSET;
- return fmap;
+static inline struct fmap_state *get_state(void)
+{
+ return car_get_var_ptr(&g_fmap_state);
}
-const struct fmap_area *find_fmap_area(const struct fmap *fmap,
- const char name[])
+static const struct region_device fmap_rdev = {
+ .region = {
+ .offset = 0,
+ .size = CONFIG_ROM_SIZE,
+ },
+};
+
+/* Return < 0 on failure, 0 on success */
+static int fmap_init(void)
{
- const struct fmap_area *area = NULL;
-
- if (fmap) {
- int i;
- for (i = 0; i < fmap->nareas; i++) {
- if (!strcmp((const char *)fmap->areas[i].name, name)) {
- area = &fmap->areas[i];
- break;
- }
- }
- }
+ struct fmap_state *gs;
+ rhandle_t rh;
+ struct fmap *fmap;
- if (area) {
- printk(BIOS_DEBUG, "FMAP: area %s found\n", name);
- printk(BIOS_DEBUG, "FMAP: offset: %x\n", area->offset);
- printk(BIOS_DEBUG, "FMAP: size: %d bytes\n", area->size);
- } else {
- printk(BIOS_DEBUG, "FMAP: area %s not found\n", name);
+ gs = get_state();
+
+ if (gs->registered)
+ return 1;
+
+ /* Execute this function only once. Default to invalid. */
+ gs->registered = 1;
+ rh = region_locate(BOOTRO_REGION_NAME);
+
+ if (!rhandle_valid(rh))
+ return -1;
+
+ fmap = region_mmap(rh, fmap_offset, sizeof(*fmap));
+
+ if (fmap == NULL)
+ return -1;
+
+ if (memcmp(fmap, FMAP_SIGNATURE, sizeof(FMAP_SIGNATURE)-1)) {
+ printk(BIOS_DEBUG, "No FMAP found at %zx.\n", fmap_offset);
+ region_munmap(rh, fmap);
+ return -1;
}
+ printk(BIOS_DEBUG, "FMAP: Found \"%s\" version %d.%d at %zx.\n",
+ fmap->name, fmap->ver_major, fmap->ver_minor, fmap_offset);
+ printk(BIOS_DEBUG, "FMAP: base = %llx size = %x #areas = %d\n",
+ (unsigned long long)fmap->base, fmap->size, fmap->nareas);
+
+ gs->num_entries = fmap->nareas;
+ region_munmap(rh, fmap);
- return area;
+ /* Register fmap device under the boot region. */
+ if (!rhandle_valid(region_register_subregion(FMAP_REGION_NAME,
+ &fmap_rdev, rh)))
+ return -1;
+
+ return 0;
}
-int find_fmap_entry(const char name[], void **pointer)
+int fmap_locate(const char *name, offset_t *offset, size_t *size)
{
-#ifndef __PRE_RAM__
- static
-#endif
- const struct fmap *fmap = NULL;
- const struct fmap_area *area;
- void *base = NULL;
+ rhandle_t rh;
+ struct fmap_area *areas;
+ struct fmap_state * gs;
+ int i;
+ int ret = -1;
- if (!fmap)
- fmap = fmap_find();
+ rh = region_locate(FMAP_REGION_NAME);
+ gs = get_state();
- area = find_fmap_area(fmap, name);
+ if (!rhandle_valid(rh) || gs == NULL)
+ return ret;
- if (!area)
- return -1;
+ areas = region_mmap(rh, sizeof(struct fmap) + fmap_offset,
+ gs->num_entries * sizeof(*areas));
- /* Right now cros_bundle_firmware does not write a valid
- * base address into the FMAP. Hence, if base is 0, assume
- * 4GB-8MB as base address.
- */
- if (fmap->base) {
- base = (void *)(unsigned long)fmap->base;
- printk(BIOS_DEBUG, "FMAP: %s base at %p\n", name, base);
- } else {
- base = (void *)(0 - CONFIG_ROM_SIZE);
- printk(BIOS_WARNING, "FMAP: No valid base address, using"
- " 0x%p\n", base);
+ if (areas == NULL) {
+ printk(BIOS_DEBUG, "FMAP: could not map areas.\n");
+ return ret;
}
- *pointer = (void*) ((u32)base + area->offset);
- printk(BIOS_DEBUG, "FMAP: %s at %p (offset %x)\n",
- name, *pointer, area->offset);
- return area->size;
+ for (i = 0; i < gs->num_entries; i++) {
+ if (strcmp((char *)&areas[i].name[0], name))
+ continue;
+ printk(BIOS_DEBUG, "FMAP: area %s found\n", name);
+ printk(BIOS_DEBUG, "FMAP: offset: %x\n", areas[i].offset);
+ printk(BIOS_DEBUG, "FMAP: size: %d bytes\n", areas[i].size);
+
+ *offset = areas[i].offset;
+ *size = areas[i].size;
+ ret = 0;
+ break;
+ }
+
+ if (ret)
+ printk(BIOS_DEBUG, "FMAP: area '%s' not found.\n", name);
+
+ region_munmap(rh, areas);
+
+ return ret;
+}
+
+void fmap_initialize(void)
+{
+ if (fmap_init() < 0)
+ printk(BIOS_DEBUG, "FMAP region wasn't registered.\n");
}
diff --git a/src/vendorcode/google/chromeos/fmap.h b/src/vendorcode/google/chromeos/fmap.h
index a3d2abd..de935e7 100644
--- a/src/vendorcode/google/chromeos/fmap.h
+++ b/src/vendorcode/google/chromeos/fmap.h
@@ -37,6 +37,7 @@
#define FLASHMAP_LIB_FMAP_H__
#include <stdint.h>
+#include <region.h>
#define FMAP_SIGNATURE "__FMAP__"
#define FMAP_VER_MAJOR 1 /* this header's FMAP minor version */
@@ -70,10 +71,24 @@ struct fmap {
struct fmap_area areas[];
} __attribute__((packed));
+#if IS_ENABLED(CONFIG_CHROMEOS)
+/*
+ * Initialize the fmap state within coreboot.
+ */
+void fmap_initialize(void);
+
+/*
+ * Locate a region by name within the fmap. offset and size are filled in
+ * relative to the boot media the global fmap is located. Returns 0 on
+ * success, < 0 when unable to find the region.
+ */
+int fmap_locate(const char *name, offset_t *offset, size_t *size);
+#else /* IS_ENABLED(CONFIG_CHROMEOS) */
+static inline void fmap_initialize(void) {}
+static inline int fmap_locate(const char *name, offset_t *offset, size_t *size)
+{
+ return -1;
+}
+#endif /* IS_ENABLED(CONFIG_CHROMEOS) */
-/* coreboot specific function prototypes */
-const struct fmap *fmap_find(void);
-const struct fmap_area *find_fmap_area(const struct fmap *fmap,
- const char name[]);
-int find_fmap_entry(const char name[], void **pointer);
#endif /* FLASHMAP_LIB_FMAP_H__*/
diff --git a/src/vendorcode/google/chromeos/vboot_loader.c b/src/vendorcode/google/chromeos/vboot_loader.c
index 0c5220a..98bc1a5 100644
--- a/src/vendorcode/google/chromeos/vboot_loader.c
+++ b/src/vendorcode/google/chromeos/vboot_loader.c
@@ -21,6 +21,7 @@
#include <stdint.h>
#include <stddef.h>
#include <cbfs.h>
+#include <cbfs_core.h>
#include <cbmem.h>
#include <console/console.h>
#include <console/vtxprintf.h>
@@ -45,7 +46,8 @@ static void vboot_run_stub(struct vboot_context *context)
};
void (*entry)(struct vboot_context *context);
- if (rmodule_stage_load_from_cbfs(&rmod_stage)) {
+ if (rmodule_stage_load_from_cbfs(cbfs_default_descriptor(),
+ &rmod_stage)) {
printk(BIOS_DEBUG, "Could not load vboot stub.\n");
goto out;
}
@@ -74,6 +76,30 @@ static void fatal_error(void)
hard_reset();
}
+static void locate_region(const char *name, void **parea, uint32_t *psize)
+{
+ offset_t offset;
+ size_t size;
+ rhandle_t rh;
+
+ *psize = 0;
+ *parea = NULL;
+
+ if (fmap_locate(name, &offset, &size))
+ return;
+
+ rh = region_locate(BOOTRO_REGION_NAME);
+ if (!rhandle_valid(rh))
+ return;
+
+ /*
+ * This leaks the mappings on anything but x86 systems which have
+ * CBFS memory-mapped.
+ */
+ *psize = size;
+ *parea = region_mmap(rh, offset, size);
+}
+
static void vboot_invoke_wrapper(struct vboot_handoff *vboot_handoff)
{
VbCommonParams cparams;
@@ -105,20 +131,17 @@ static void vboot_invoke_wrapper(struct vboot_handoff *vboot_handoff)
context.cparams = &cparams;
context.fparams = &fparams;
- cparams.gbb_size = find_fmap_entry("GBB", &cparams.gbb_data);
+ locate_region("GBB", &cparams.gbb_data, &cparams.gbb_size);
cparams.shared_data_blob = &vboot_handoff->shared_data[0];
cparams.shared_data_size = VB_SHARED_DATA_MIN_SIZE;
cparams.caller_context = &context;
- fparams.verification_size_A =
- find_fmap_entry("VBLOCK_A", &fparams.verification_block_A);
- fparams.verification_size_B =
- find_fmap_entry("VBLOCK_B", &fparams.verification_block_B);
-
- context.fw_a_size =
- find_fmap_entry("FW_MAIN_A", (void **)&context.fw_a);
- context.fw_b_size =
- find_fmap_entry("FW_MAIN_B", (void **)&context.fw_b);
+ locate_region("VBLOCK_A", &fparams.verification_block_A,
+ &fparams.verification_size_A);
+ locate_region("VBLOCK_B", &fparams.verification_block_B,
+ &fparams.verification_size_B);
+ locate_region("FW_MAIN_A", (void **)&context.fw_a, &context.fw_a_size);
+ locate_region("FW_MAIN_B", (void **)&context.fw_b, &context.fw_b_size);
/* Check all fmap entries. */
if (context.fw_a == NULL || context.fw_b == NULL ||
@@ -195,7 +218,7 @@ static void *vboot_load_ramstage(uint32_t cbmem_id, const char *name,
stage = (void *)fwc->address;
- if (rmodule_stage_load(&rmod_load, stage)) {
+ if (rmodule_stage_load(&rmod_load, stage, &stage[1])) {
vboot_handoff->selected_firmware = VB_SELECT_FIRMWARE_READONLY;
printk(BIOS_DEBUG, "Could not load ramstage region.\n");
return NULL;
1
0
Aaron Durbin (adurbin(a)google.com) just uploaded a new patch set to gerrit, which you can find at http://review.coreboot.org/5394
-gerrit
commit 3acad49d6e4ba786e6adf3b7917daea59671638a
Author: Aaron Durbin <adurbin(a)chromium.org>
Date: Thu Mar 13 08:50:00 2014 -0500
regions support
Needs some cleanup work. Compile tested as of now.
Change-Id: I2a78278090ae928468e197ac73d1fb18596bf8cb
Signed-off-by: Aaron Durbin <adurbin(a)chromium.org>
---
src/Kconfig | 7 +
src/arch/x86/boot/smbios.c | 8 +-
src/arch/x86/lib/rom_media.c | 114 +++---
src/cpu/intel/microcode/microcode.c | 38 +-
src/cpu/x86/mirror_payload.c | 38 +-
src/device/pci_device.c | 7 +-
src/device/pci_rom.c | 232 +++++++-----
src/drivers/elog/elog.c | 142 +++-----
src/include/cbfs.h | 120 +++---
src/include/cbfs_core.h | 44 ---
src/include/device/pci_rom.h | 4 +-
src/include/payload_loader.h | 3 +
src/include/region.h | 145 ++++++++
src/include/rmodule.h | 7 +-
src/lib/Makefile.inc | 10 +
src/lib/bootrw_spi_flash_region.c | 119 ++++++
src/lib/cbfs.c | 501 ++++++++++++++++++--------
src/lib/cbfs_boot_region.c | 133 +++++++
src/lib/cbfs_core.c | 224 ------------
src/lib/loaders/cbfs_payload_loader.c | 18 +-
src/lib/loaders/cbfs_ramstage_loader.c | 12 +-
src/lib/loaders/load_and_run_payload.c | 5 +-
src/lib/region.c | 305 ++++++++++++++++
src/lib/rmodule.c | 46 ++-
src/lib/selfboot.c | 113 +++---
src/soc/intel/baytrail/Kconfig | 1 +
src/soc/intel/baytrail/mrc_cache.c | 20 +-
src/soc/intel/baytrail/nvm.c | 27 +-
src/soc/intel/baytrail/romstage/raminit.c | 9 +-
src/soc/intel/baytrail/romstage/romstage.c | 4 +
src/vendorcode/google/chromeos/Makefile.inc | 1 +
src/vendorcode/google/chromeos/chromeos.c | 4 +
src/vendorcode/google/chromeos/fmap.c | 177 +++++----
src/vendorcode/google/chromeos/fmap.h | 25 +-
src/vendorcode/google/chromeos/vboot_loader.c | 47 ++-
35 files changed, 1771 insertions(+), 939 deletions(-)
diff --git a/src/Kconfig b/src/Kconfig
index 531a8c8..b0b8d26 100644
--- a/src/Kconfig
+++ b/src/Kconfig
@@ -1094,3 +1094,10 @@ config REG_SCRIPT
default n
help
Internal option that controls whether we compile in register scripts.
+
+config BOOT_REGION_SPI_FLASH
+ def_bool n
+ depends on ARCH_X86
+ help
+ Use generic SPI flash boot region support. This will provide a
+ function to initialize the read-write boot region.
diff --git a/src/arch/x86/boot/smbios.c b/src/arch/x86/boot/smbios.c
index 0e84acc..0434715 100644
--- a/src/arch/x86/boot/smbios.c
+++ b/src/arch/x86/boot/smbios.c
@@ -27,7 +27,6 @@
#include <device/device.h>
#include <arch/cpu.h>
#include <cpu/x86/name.h>
-#include <cbfs_core.h>
#include <arch/byteorder.h>
#include <elog.h>
#if CONFIG_CHROMEOS
@@ -147,12 +146,7 @@ static int smbios_write_type0(unsigned long *current, int handle)
#endif
{
- const struct cbfs_header *header;
- u32 romsize = CONFIG_ROM_SIZE;
- header = cbfs_get_header(CBFS_DEFAULT_MEDIA);
- if (header != CBFS_HEADER_INVALID_ADDRESS)
- romsize = ntohl(header->romsize);
- t->bios_rom_size = (romsize / 65535) - 1;
+ t->bios_rom_size = (CONFIG_ROM_SIZE / 65535) - 1;
}
t->system_bios_major_release = 4;
diff --git a/src/arch/x86/lib/rom_media.c b/src/arch/x86/lib/rom_media.c
index ed2122c..aa17d64 100644
--- a/src/arch/x86/lib/rom_media.c
+++ b/src/arch/x86/lib/rom_media.c
@@ -18,84 +18,64 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
* MA 02110-1301 USA
*/
-#include <cbfs.h>
+#include <stdint.h>
#include <string.h>
+#include <console/console.h>
+#include <region.h>
-#ifdef LIBPAYLOAD
-# define printk(x...)
-# define init_default_cbfs_media libpayload_init_default_cbfs_media
- extern int libpayload_init_default_cbfs_media(struct cbfs_media *media);
-#else
-# include <console/console.h>
-#endif
-
-// Implementation of memory-mapped ROM media source on X86.
-
-static int x86_rom_open(struct cbfs_media *media) {
- return 0;
+static inline void *get_pointer(offset_t off)
+{
+ const uintptr_t base_address = (uintptr_t)-CONFIG_ROM_SIZE;
+ return (void *)(base_address + off);
}
-static void *x86_rom_map(struct cbfs_media *media, size_t offset, size_t count) {
- void *ptr;
- // Some address (ex, pointer to master header) may be given in memory
- // mapped location. To workaround that, we handle >0xf0000000 as real
- // memory pointer.
-
- if ((uint32_t)offset > (uint32_t)0xf0000000)
- ptr = (void*)offset;
- else
- ptr = (void*)(0 - (uint32_t)media->context + offset);
- return ptr;
+static void *
+boot_mmap(const struct region_device *rdev, offset_t off, size_t size)
+{
+ return get_pointer(off);
}
-static void *x86_rom_unmap(struct cbfs_media *media, const void *address) {
- return NULL;
+static void boot_munmap(const struct region_device *rdev, void *addr)
+{
}
-static size_t x86_rom_read(struct cbfs_media *media, void *dest, size_t offset,
- size_t count) {
- void *ptr = x86_rom_map(media, offset, count);
- memcpy(dest, ptr, count);
- x86_rom_unmap(media, ptr);
- return count;
+static ssize_t
+boot_readat(const struct region_device *rdev, void *buf,
+ offset_t off, size_t size)
+{
+ memcpy(buf, get_pointer(off), size);
+ return size;
}
-static int x86_rom_close(struct cbfs_media *media) {
- return 0;
-}
+static const struct region_device_ops boot_dev_ops = {
+ .mmap = boot_mmap,
+ .munmap = boot_munmap,
+ .readat = boot_readat,
+};
+
+static const struct region_device boot_dev = {
+ .ops = &boot_dev_ops,
+ .region = {
+ .offset = 0,
+ .size = CONFIG_ROM_SIZE,
+ },
+};
-int init_x86rom_cbfs_media(struct cbfs_media *media);
-int init_x86rom_cbfs_media(struct cbfs_media *media) {
- // On X86, we always keep a reference of pointer to CBFS header in
- // 0xfffffffc, and the pointer is still a memory-mapped address.
- // Since the CBFS core always use ROM offset, we need to figure out
- // header->romsize even before media is initialized.
- struct cbfs_header *header = (struct cbfs_header*)
- *(uint32_t*)(0xfffffffc);
- if (CBFS_HEADER_MAGIC != ntohl(header->magic)) {
-#if defined(CONFIG_ROM_SIZE)
- printk(BIOS_ERR, "Invalid CBFS master header at %p\n", header);
- media->context = (void*)CONFIG_ROM_SIZE;
-#else
- return -1;
-#endif
- } else {
- uint32_t romsize = ntohl(header->romsize);
- media->context = (void*)romsize;
-#if defined(CONFIG_ROM_SIZE)
- if (CONFIG_ROM_SIZE != romsize)
- printk(BIOS_INFO, "Warning: rom size unmatch (%d/%d)\n",
- CONFIG_ROM_SIZE, romsize);
-#endif
+void boot_media_initialize(void)
+{
+ rhandle_t rh;
+ const char *bootro_name = BOOTRO_REGION_NAME;
+
+ rh = region_locate(bootro_name);
+
+ /* Already registered. */
+ if (rhandle_valid(rh)) {
+ printk(BIOS_DEBUG, "Already Registered: '%s'\n", bootro_name);
+ return;
}
- media->open = x86_rom_open;
- media->close = x86_rom_close;
- media->map = x86_rom_map;
- media->unmap = x86_rom_unmap;
- media->read = x86_rom_read;
- return 0;
-}
-int init_default_cbfs_media(struct cbfs_media *media) {
- return init_x86rom_cbfs_media(media);
+ rh = region_register(bootro_name, &boot_dev);
+
+ if (!rhandle_valid(rh))
+ printk(BIOS_ERR, "Failed to register '%s'.\n", bootro_name);
}
diff --git a/src/cpu/intel/microcode/microcode.c b/src/cpu/intel/microcode/microcode.c
index 947dfd7..d6753c1 100644
--- a/src/cpu/intel/microcode/microcode.c
+++ b/src/cpu/intel/microcode/microcode.c
@@ -107,28 +107,48 @@ void intel_microcode_load_unlocked(const void *microcode_patch)
#endif
}
+#if !defined(__ROMCC__)
+static void *microcode_locate(u32 *len)
+{
+ const struct cbfs_file_descriptor *fd;
+ void *buf;
+
+ fd = cbfs_open_by_name(cbfs_default_descriptor(), MICROCODE_CBFS_FILE);
+ if (fd == NULL)
+ return NULL;
+
+ /*
+ * The following sequence relies on x86 having a persistent
+ * memory-mapped view of the SPI rom.
+ */
+ *len = cbfs_file_content_size(fd);
+ buf = cbfs_file_map_content(fd, 0, *len);
+ cbfs_file_close(fd);
+
+ return buf;
+}
+#endif
+
const void *intel_microcode_find(void)
{
- struct cbfs_file *microcode_file;
const struct microcode *ucode_updates;
u32 eax, microcode_len;
u32 pf, rev, sig, update_size;
unsigned int x86_model, x86_family;
msr_t msr;
+#if defined(__ROMCC__)
+ struct cbfs_file *file;
-#ifdef __PRE_RAM__
- microcode_file = walkcbfs_head((char *) MICROCODE_CBFS_FILE);
+ file = walkcbfs_head((char *) MICROCODE_CBFS_FILE);
+ microcode_len = ntohl(file->len);
+ ucode_updates = CBFS_SUBHEADER(file);
#else
- microcode_file = cbfs_get_file(CBFS_DEFAULT_MEDIA,
- MICROCODE_CBFS_FILE);
+ ucode_updates = microcode_locate(µcode_len);
#endif
- if (!microcode_file)
+ if (!ucode_updates)
return NULL;
- ucode_updates = CBFS_SUBHEADER(microcode_file);
- microcode_len = ntohl(microcode_file->len);
-
/* CPUID sets MSR 0x8B iff a microcode update has been loaded. */
msr.lo = 0;
msr.hi = 0;
diff --git a/src/cpu/x86/mirror_payload.c b/src/cpu/x86/mirror_payload.c
index edd2641..a6975e1 100644
--- a/src/cpu/x86/mirror_payload.c
+++ b/src/cpu/x86/mirror_payload.c
@@ -30,26 +30,12 @@ void mirror_payload(struct payload *payload)
size_t size;
char *src;
uintptr_t alignment_diff;
- const unsigned long cacheline_size = 64;
- const uintptr_t intra_cacheline_mask = cacheline_size - 1;
- const uintptr_t cacheline_mask = ~intra_cacheline_mask;
+ const unsigned long dword_size = sizeof(uint32_t);
+ const uintptr_t dword_mask = dword_size - 1;
src = payload->backing_store.data;
size = payload->backing_store.size;
- /*
- * Adjust size so that the start and end points are aligned to a
- * cacheline. The SPI hardware controllers on Intel machines should
- * cache full length cachelines as well as prefetch data. Once the
- * data is mirrored in memory all accesses should hit the CPU's cache.
- */
- alignment_diff = (intra_cacheline_mask & (uintptr_t)src);
- size += alignment_diff;
-
- size = ALIGN(size, cacheline_size);
-
- printk(BIOS_DEBUG, "Payload aligned size: 0x%zx\n", size);
-
buffer = bootmem_allocate_buffer(size);
if (buffer == NULL) {
@@ -57,7 +43,18 @@ void mirror_payload(struct payload *payload)
return;
}
- src = (void *)(cacheline_mask & (uintptr_t)src);
+ /*
+ * Do copies in 32-bit aligned reads from backing source.
+ * 1. Do a copy to align the source address.
+ * 2. Do remaining copy.
+ */
+ alignment_diff = dword_mask & (uintptr_t)src;
+ if (alignment_diff != 0) {
+ mempcy(buffer, src, alignment_diff);
+ src += alignment_diff;
+ buffer += alignment_diff;
+ size -= alignment_diff;
+ }
/*
* Note that if mempcy is not using 32-bit moves the performance will
@@ -66,6 +63,9 @@ void mirror_payload(struct payload *payload)
*/
memcpy(buffer, src, size);
- /* Update the payload's backing store. */
- payload->backing_store.data = &buffer[alignment_diff];
+ /*
+ * Update the payload's backing store. May leak resources depending
+ * cbfs stroage source.
+ */
+ payload->backing_store.data = buffer;
}
diff --git a/src/device/pci_device.c b/src/device/pci_device.c
index aa0d954..bcdbbe4 100644
--- a/src/device/pci_device.c
+++ b/src/device/pci_device.c
@@ -667,7 +667,7 @@ int oprom_is_loaded = 0;
void pci_dev_init(struct device *dev)
{
#if CONFIG_VGA_ROM_RUN
- struct rom_header *rom, *ram;
+ struct rom_header *ram;
/* Only execute VGA ROMs. */
if (((dev->class >> 8) != PCI_CLASS_DISPLAY_VGA))
@@ -694,11 +694,8 @@ void pci_dev_init(struct device *dev)
return;
#endif
- rom = pci_rom_probe(dev);
- if (rom == NULL)
- return;
+ ram = pci_load_vga_rom(dev);
- ram = pci_rom_load(dev, rom);
if (ram == NULL)
return;
diff --git a/src/device/pci_rom.c b/src/device/pci_rom.c
index 1bdccf0..bb17931 100644
--- a/src/device/pci_rom.c
+++ b/src/device/pci_rom.c
@@ -6,6 +6,7 @@
* (Written by Yinghai Lu <yhlu(a)tyan.com> for Tyan)
* Copyright (C) 2005 Ronald G. Minnich <rminnich(a)gmail.com>
* Copyright (C) 2005-2007 Stefan Reinauer <stepan(a)openbios.org>
+ * Copyright (C) 2014 Google Inc.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@@ -28,62 +29,15 @@
#include <device/pci_ops.h>
#include <string.h>
#include <cbfs.h>
+#include <cbfs_core.h>
-struct rom_header *pci_rom_probe(struct device *dev)
+static struct rom_header *
+pci_rom_verify_and_load(struct device *dev, struct rom_header *rom_header,
+ void *load_addr, int check_didvid)
{
- struct rom_header *rom_header;
struct pci_data *rom_data;
-
- /* If it's in FLASH, then don't check device for ROM. */
- rom_header = cbfs_load_optionrom(CBFS_DEFAULT_MEDIA, dev->vendor,
- dev->device, NULL);
-
- u32 vendev = (dev->vendor << 16) | dev->device;
- u32 mapped_vendev = vendev;
-
- if (map_oprom_vendev)
- mapped_vendev = map_oprom_vendev(vendev);
-
- if (!rom_header) {
- if (vendev != mapped_vendev) {
- rom_header = cbfs_load_optionrom(
- CBFS_DEFAULT_MEDIA,
- mapped_vendev >> 16,
- mapped_vendev & 0xffff, NULL);
- }
- }
-
- if (rom_header) {
- printk(BIOS_DEBUG, "In CBFS, ROM address for %s = %p\n",
- dev_path(dev), rom_header);
- } else {
- u32 rom_address;
-
- rom_address = pci_read_config32(dev, PCI_ROM_ADDRESS);
-
- if (rom_address == 0x00000000 || rom_address == 0xffffffff) {
-#if CONFIG_BOARD_EMULATION_QEMU_X86
- if ((dev->class >> 8) == PCI_CLASS_DISPLAY_VGA)
- rom_address = 0xc0000;
- else
-#endif
- return NULL;
- } else {
- /* Enable expansion ROM address decoding. */
- pci_write_config32(dev, PCI_ROM_ADDRESS,
- rom_address|PCI_ROM_ADDRESS_ENABLE);
- }
-
-#if CONFIG_ON_DEVICE_ROM_RUN
- printk(BIOS_DEBUG, "Option ROM address for %s = %lx\n",
- dev_path(dev), (unsigned long)rom_address);
- rom_header = (struct rom_header *)rom_address;
-#else
- printk(BIOS_DEBUG, "Option ROM execution disabled "
- "for %s\n", dev_path(dev));
- return NULL;
-#endif
- }
+ unsigned int rom_size;
+ unsigned int image_size;
printk(BIOS_SPEW, "PCI expansion ROM, signature 0x%04x, "
"INIT size 0x%04x, data ptr 0x%04x\n",
@@ -100,10 +54,11 @@ struct rom_header *pci_rom_probe(struct device *dev)
printk(BIOS_SPEW, "PCI ROM image, vendor ID %04x, device ID %04x,\n",
rom_data->vendor, rom_data->device);
+
/* If the device id is mapped, a mismatch is expected */
- if ((dev->vendor != rom_data->vendor
- || dev->device != rom_data->device)
- && (vendev == mapped_vendev)) {
+ if (check_didvid != 0 &&
+ (dev->vendor != rom_data->vendor ||
+ dev->device != rom_data->device)) {
printk(BIOS_ERR, "ID mismatch: vendor ID %04x, "
"device ID %04x\n", rom_data->vendor, rom_data->device);
return NULL;
@@ -117,29 +72,16 @@ struct rom_header *pci_rom_probe(struct device *dev)
printk(BIOS_DEBUG, "Class Code mismatch ROM %08x, dev %08x\n",
(rom_data->class_hi << 8) | rom_data->class_lo,
dev->class);
- // return NULL;
}
- return rom_header;
-}
-
-static void *pci_ram_image_start = (void *)PCI_RAM_IMAGE_START;
-
-struct rom_header *pci_rom_load(struct device *dev,
- struct rom_header *rom_header)
-{
- struct pci_data * rom_data;
- unsigned int rom_size;
- unsigned int image_size=0;
-
+ image_size = 0;
do {
/* Get next image. */
- rom_header = (struct rom_header *)((void *) rom_header
- + image_size);
-
- rom_data = (struct pci_data *)((void *) rom_header
- + le32_to_cpu(rom_header->data));
+ int data_offset;
+ rom_header = (void *)((char *)rom_header + image_size);
+ data_offset = le32_to_cpu(rom_header->data);
+ rom_data = (void *)((char *)rom_header + data_offset);
image_size = le32_to_cpu(rom_data->ilen) * 512;
} while ((rom_data->type != 0) && (rom_data->indicator != 0)); // make sure we got x86 version
@@ -148,30 +90,128 @@ struct rom_header *pci_rom_load(struct device *dev,
rom_size = rom_header->size * 512;
- /*
- * We check to see if the device thinks it is a VGA device not
- * whether the ROM image is for a VGA device because some
- * devices have a mismatch between the hardware and the ROM.
- */
- if (PCI_CLASS_DISPLAY_VGA == (dev->class >> 8)) {
+ if (load_addr != (void *)rom_header) {
+ printk(BIOS_DEBUG, "Copying ROM from %p to %p, 0x%x bytes.\n",
+ rom_header, load_addr, rom_size);
+ memcpy(load_addr, rom_header, rom_size);
+ }
+
+ return load_addr;
+}
+
+static inline int tohex4(unsigned int c)
+{
+ return (c <= 9) ? (c + '0') : (c - 10 + 'a');
+}
+
+static void tohex16(uint16_t val, char* dest)
+{
+ dest[0] = tohex4(val>>12);
+ dest[1] = tohex4((val>>8) & 0xf);
+ dest[2] = tohex4((val>>4) & 0xf);
+ dest[3] = tohex4(val & 0xf);
+}
+
+static const struct cbfs_file_descriptor *
+cbfs_open_optionrom(uint16_t vendor, uint16_t device)
+{
+ char name[17] = "pciXXXX,XXXX.rom";
+
+ tohex16(vendor, name+3);
+ tohex16(device, name+8);
+
+ return cbfs_open_by_name_type(cbfs_default_descriptor(), name,
+ CBFS_TYPE_OPTIONROM);
+}
+
+static void *cbfs_probe_and_load(struct device *dev, void *dest)
+{
+ const struct cbfs_file_descriptor *file;
+ uint32_t vendev;
+ int remapped;
+ struct rom_header *hdr;
+ void *load_addr;
+ ssize_t filesz;
+
+ load_addr = NULL;
+ remapped = 0;
+ file = cbfs_open_optionrom(dev->vendor, dev->device);
+
+ if (file == NULL && map_oprom_vendev != NULL) {
+ vendev = map_oprom_vendev((dev->vendor << 16) | dev->device);
+ file = cbfs_open_optionrom(vendev >> 16, vendev & 0xffff);
+ remapped = 1;
+ }
+
+ if (file == NULL)
+ return NULL;
+
+ filesz = cbfs_file_content_size(file);
+ hdr = cbfs_file_map_content(file, 0, filesz);
+ if (hdr == NULL)
+ goto out;
+
+ printk(BIOS_DEBUG, "In CBFS, ROM address for %s = %p\n",
+ dev_path(dev), hdr);
+
+ load_addr = pci_rom_verify_and_load(dev, hdr, dest, !remapped);
+ cbfs_file_unmap(file, hdr);
+
+out:
+ cbfs_file_close(file);
+ return load_addr;
+}
+
+#if CONFIG_ON_DEVICE_ROM_RUN
+static void *dev_probe_and_load(struct device *dev, void *dest)
+{
+ uint32_t rom_address;
+ struct rom_header *rom_header;
+
+ rom_address = pci_read_config32(dev, PCI_ROM_ADDRESS);
+
+ if (rom_address == 0x00000000 || rom_address == 0xffffffff) {
+ if (IS_ENABLED(CONFIG_BOARD_EMULATION_QEMU_X86))
+ rom_address = 0xc0000;
+ else
+ return NULL;
+ } else {
+ /* Enable expansion ROM address decoding. */
+ pci_write_config32(dev, PCI_ROM_ADDRESS,
+ rom_address|PCI_ROM_ADDRESS_ENABLE);
+ }
+ printk(BIOS_DEBUG, "Option ROM address for %s = %lx\n",
+ dev_path(dev), (unsigned long)rom_address);
+
+ rom_header = (struct rom_header *)rom_address;
+
+ return pci_rom_verify_and_load(dev, rom_header, dest, 1);
+}
+#endif
+
+struct rom_header *pci_load_vga_rom(struct device *dev)
+{
+ void *vga_load_addr = (void *)PCI_VGA_RAM_IMAGE_START;
+ void *load_addr;
+
+ if (PCI_CLASS_DISPLAY_VGA != (dev->class >> 8))
+ return NULL;
+
#if !CONFIG_MULTIPLE_VGA_ADAPTERS
- extern device_t vga_pri; /* Primary VGA device (device.c). */
- if (dev != vga_pri) return NULL; /* Only one VGA supported. */
+ extern device_t vga_pri; /* Primary VGA device (device.c). */
+ if (dev != vga_pri) return NULL; /* Only one VGA supported. */
#endif
- if ((void *)PCI_VGA_RAM_IMAGE_START != rom_header) {
- printk(BIOS_DEBUG, "Copying VGA ROM Image from %p to "
- "0x%x, 0x%x bytes\n", rom_header,
- PCI_VGA_RAM_IMAGE_START, rom_size);
- memcpy((void *)PCI_VGA_RAM_IMAGE_START, rom_header,
- rom_size);
- }
- return (struct rom_header *) (PCI_VGA_RAM_IMAGE_START);
- }
- printk(BIOS_DEBUG, "Copying non-VGA ROM image from %p to %p, 0x%x "
- "bytes\n", rom_header, pci_ram_image_start, rom_size);
+ load_addr = cbfs_probe_and_load(dev, vga_load_addr);
+
+ if (load_addr == NULL) {
+#if CONFIG_ON_DEVICE_ROM_RUN
+ load_addr = dev_probe_and_load(dev, vga_load_addr);
+#else
+ printk(BIOS_DEBUG, "Option ROM execution disabled for %s\n",
+ dev_path(dev));
+#endif
+ }
- memcpy(pci_ram_image_start, rom_header, rom_size);
- pci_ram_image_start += rom_size;
- return (struct rom_header *) (pci_ram_image_start-rom_size);
+ return load_addr;
}
diff --git a/src/drivers/elog/elog.c b/src/drivers/elog/elog.c
index de34928..597c32e 100644
--- a/src/drivers/elog/elog.c
+++ b/src/drivers/elog/elog.c
@@ -22,10 +22,9 @@
#include <console/console.h>
#include <pc80/mc146818rtc.h>
#include <smbios.h>
-#include <spi-generic.h>
-#include <spi_flash.h>
#include <stdint.h>
#include <string.h>
+#include <region.h>
#include <elog.h>
#include "elog_internal.h"
@@ -54,13 +53,15 @@
#define elog_debug(STR...)
#endif
+
+#define ELOG_REGION_NAME "elog"
+
/*
* Static variables for ELOG state
*/
static struct elog_area *elog_area;
static u16 total_size;
static u16 log_size;
-static u32 flash_base;
static elog_area_state area_state;
static elog_header_state header_state;
@@ -70,51 +71,10 @@ static u16 next_event_offset;
static u16 event_count;
static int elog_initialized;
-static struct spi_flash *elog_spi;
-
-
-static inline u32 get_rom_size(void)
-{
- u32 rom_size;
-
- /* Assume the used space of the ROM image starts from 0. The
- * physical size of the device may not be completely used. */
- rom_size = elog_spi->size;
- if (rom_size > CONFIG_ROM_SIZE)
- rom_size = CONFIG_ROM_SIZE;
-
- return rom_size;
-}
-
-/*
- * Convert a memory mapped flash address into a flash offset
- */
-static inline u32 elog_flash_address_to_offset(u8 *address)
-{
- u32 rom_size;
-
- if (!elog_spi)
- return 0;
- rom_size = get_rom_size();
-
- return (u32)address - ((u32)~0UL - rom_size + 1);
-}
-
-/*
- * Convert a flash offset into a memory mapped flash address
- */
-static inline u8* elog_flash_offset_to_address(u32 offset)
-{
- u32 rom_size;
-
- if (!elog_spi)
- return NULL;
-
- rom_size = get_rom_size();
-
- return (u8*)((u32)~0UL - rom_size + 1 + offset);
-}
+/* Region device for accessing the ELOG area. */
+static struct region_device elog_dev;
+static rhandle_t elog_rh = INVALID_RHANDLE;
/*
* Pointer to an event log header in the event data area
@@ -259,17 +219,16 @@ static void elog_flash_write(void *address, u32 size)
{
u32 offset;
- if (!address || !size || !elog_spi)
+ if (!address || !size)
return;
- offset = flash_base;
- offset += (u8 *)address - (u8 *)elog_area;
+ offset = (u8 *)address - (u8 *)elog_area;
elog_debug("elog_flash_write(address=0x%p offset=0x%08x size=%u)\n",
address, offset, size);
/* Write the data to flash */
- elog_spi->write(elog_spi, offset, size, address);
+ region_writeat(elog_rh, address, offset, size);
}
/*
@@ -280,17 +239,16 @@ static void elog_flash_erase(void *address, u32 size)
{
u32 offset;
- if (!address || !size || !elog_spi)
+ if (!address || !size)
return;
- offset = flash_base;
- offset += (u8 *)address - (u8*)elog_area;
+ offset = (u8 *)address - (u8*)elog_area;
elog_debug("elog_flash_erase(address=0x%p offset=0x%08x size=%u)\n",
address, offset, size);
/* Erase the sectors in this region */
- elog_spi->erase(elog_spi, offset, size);
+ region_eraseat(elog_rh, offset, size);
}
/*
@@ -348,7 +306,7 @@ static void elog_scan_flash(void)
event_buffer_state = ELOG_EVENT_BUFFER_OK;
/* Fill memory buffer by reading from SPI */
- elog_spi->read(elog_spi, flash_base, total_size, elog_area);
+ region_readat(elog_rh, elog_area, 0, total_size);
next_event_offset = 0;
event_count = 0;
@@ -449,13 +407,17 @@ int elog_smbios_write_type15(unsigned long *current, int handle)
{
struct smbios_type15 *t = (struct smbios_type15 *)*current;
int len = sizeof(struct smbios_type15);
+ void *backing_store;
#if CONFIG_ELOG_CBMEM
/* Save event log buffer into CBMEM for the OS to read */
- void *cbmem = cbmem_add(CBMEM_ID_ELOG, total_size);
- if (!cbmem)
+ backing_store = cbmem_add(CBMEM_ID_ELOG, total_size);
+ if (!backing_store)
return 0;
- memcpy(cbmem, elog_area, total_size);
+ memcpy(backing_store, elog_area, total_size);
+#else
+ /* This assumes x86 memory-mapped capabilities of flash. */
+ backing_store = region_mmap(elog_rh, 0, total_size);
#endif
memset(t, 0, len);
@@ -468,11 +430,7 @@ int elog_smbios_write_type15(unsigned long *current, int handle)
t->access_method = SMBIOS_EVENTLOG_ACCESS_METHOD_MMIO32;
t->log_status = SMBIOS_EVENTLOG_STATUS_VALID;
t->change_token = 0;
-#if CONFIG_ELOG_CBMEM
- t->address = (u32)cbmem;
-#else
- t->address = (u32)elog_flash_offset_to_address(flash_base);
-#endif
+ t->address = (u32)backing_store;
t->header_format = ELOG_HEADER_TYPE_OEM;
t->log_type_descriptors = 0;
t->log_type_descriptor_length = 2;
@@ -506,33 +464,46 @@ int elog_clear(void)
return 0;
}
-static void elog_find_flash(void)
+static int elog_find_flash(void)
{
-#if CONFIG_CHROMEOS
- u8 *flash_base_ptr;
-#endif
+ rhandle_t rh;
+
+ if (rhandle_valid(elog_rh))
+ return 0;
elog_debug("elog_find_flash()\n");
#if CONFIG_CHROMEOS
/* Find the ELOG base and size in FMAP */
- total_size = find_fmap_entry("RW_ELOG", (void **)&flash_base_ptr);
- if (total_size < 0) {
+ if (fmap_locate("RW_ELOG", &elog_dev.region.offset,
+ &elog_dev.region.size)) {
printk(BIOS_WARNING, "ELOG: Unable to find RW_ELOG in FMAP, "
"using CONFIG_ELOG_FLASH_BASE instead\n");
- total_size = CONFIG_ELOG_AREA_SIZE;
} else {
- flash_base = elog_flash_address_to_offset(flash_base_ptr);
-
/* Use configured size if smaller than FMAP size */
- if (total_size > CONFIG_ELOG_AREA_SIZE)
- total_size = CONFIG_ELOG_AREA_SIZE;
+ if (elog_dev.region.size > CONFIG_ELOG_AREA_SIZE)
+ elog_dev.region.size = CONFIG_ELOG_AREA_SIZE;
}
#else
- flash_base = CONFIG_ELOG_FLASH_BASE;
- total_size = CONFIG_ELOG_AREA_SIZE;
+ elog_dev.region.offset = CONFIG_ELOG_FLASH_BASE;
+ elog_dev.region.size = CONFIG_ELOG_AREA_SIZE;
#endif
+ total_size = elog_dev.region.size;
log_size = total_size - sizeof(struct elog_header);
+
+ rh = region_locate(BOOTRW_REGION_NAME);
+ if (!rhandle_valid(rh)) {
+ printk(BIOS_WARNING, "Unable to find writable boot region.\n");
+ return -1;
+ }
+ rh = region_register_subregion("elog", &elog_dev, rh);
+ if (!rhandle_valid(rh)) {
+ printk(BIOS_WARNING, "Unable to register ELOG region.\n");
+ return -1;
+ }
+
+ elog_rh = rh;
+ return 0;
}
/*
@@ -545,18 +516,9 @@ int elog_init(void)
elog_debug("elog_init()\n");
- /* Prepare SPI */
- spi_init();
- elog_spi = spi_flash_probe(0, 0, 0, 0);
- if (!elog_spi) {
- printk(BIOS_ERR, "ELOG: Unable to find SPI flash\n");
- return -1;
- }
-
/* Set up the backing store */
- elog_find_flash();
- if (flash_base == 0) {
- printk(BIOS_ERR, "ELOG: Invalid flash base\n");
+ if (elog_find_flash()) {
+ printk(BIOS_ERR, "ELOG: region not set up.\n");
return -1;
}
@@ -589,8 +551,8 @@ int elog_init(void)
elog_initialized = 1;
- printk(BIOS_INFO, "ELOG: FLASH @0x%p [SPI 0x%08x]\n",
- elog_area, flash_base);
+ printk(BIOS_INFO, "ELOG: FLASH @0x%p [SPI 0x%08zx]\n",
+ elog_area, (size_t)elog_dev.region.offset);
printk(BIOS_INFO, "ELOG: area is %d bytes, full threshold %d,"
" shrink size %d\n", total_size,
diff --git a/src/include/cbfs.h b/src/include/cbfs.h
index ebdbf43..bd000c9 100644
--- a/src/include/cbfs.h
+++ b/src/include/cbfs.h
@@ -1,14 +1,8 @@
/*
* This file is part of the coreboot project.
*
- * Copyright (C) 2008 Jordan Crouse <jordan(a)cosmicpenguin.net>
- * Copyright (C) 2013 The Chromium OS Authors. All rights reserved.
+ * Copyright (C) 2014 Google Inc.
*
- * This file is dual-licensed. You can choose between:
- * - The GNU GPL, version 2, as published by the Free Software Foundation
- * - The revised BSD license (without advertising clause)
- *
- * ---------------------------------------------------------------------------
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; version 2 of the License.
@@ -20,62 +14,84 @@
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
- * ---------------------------------------------------------------------------
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * 3. The name of the author may not be used to endorse or promote products
- * derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- * ---------------------------------------------------------------------------
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
-
#ifndef _CBFS_H_
#define _CBFS_H_
-#include <cbfs_core.h>
+#include <stdint.h>
+#include <region.h>
-void *cbfs_load_optionrom(struct cbfs_media *media, uint16_t vendor,
- uint16_t device, void * dest);
-void *cbfs_load_stage(struct cbfs_media *media, const char *name);
-
-/* Simple buffer for streaming media. */
-struct cbfs_simple_buffer {
- char *buffer;
- size_t allocated;
+/* Describe an instance of cbfs. */
+struct cbfs_descriptor {
+ rhandle_t rh;
+ size_t align;
size_t size;
- size_t last_allocate;
};
-void *cbfs_simple_buffer_map(struct cbfs_simple_buffer *buffer,
- struct cbfs_media *media,
- size_t offset, size_t count);
+struct cbfs_file_descriptor;
+
+/* Obtain the default cbfs_descriptor. */
+const struct cbfs_descriptor *cbfs_default_descriptor(void);
+
+/* Open a file by name. Return NULL on error. */
+const struct cbfs_file_descriptor *
+cbfs_open_by_name(const struct cbfs_descriptor *cbfs, const char *name);
+
+/* Open a file by name and type. */
+const struct cbfs_file_descriptor *
+cbfs_open_by_name_type(const struct cbfs_descriptor *cbfs,
+ const char *name, uint32_t type);
+
+/* Close a previously opened file. */
+void cbfs_file_close(const struct cbfs_file_descriptor *fd);
+
+/* Return the size of the file's contents. < 0 on error. */
+ssize_t cbfs_file_content_size(const struct cbfs_file_descriptor *fd);
+
+/* Return the size of the file's metadata contents. < 0 on error. */
+ssize_t cbfs_file_metadata_size(const struct cbfs_file_descriptor *fd);
+
+/*
+ * Read size bytes file contents from offset of into buffer. Returns < 0
+ * on error or bytes read.
+ */
+ssize_t cbfs_file_read_content(const struct cbfs_file_descriptor *fd,
+ void *buf, offset_t offset, size_t size);
+
+/* Attempt to map the file content. Returns NULL on error. */
+void *cbfs_file_map_content(const struct cbfs_file_descriptor *fd,
+ offset_t offset, size_t size);
+
+/*
+ * Read size bytes file metadata from offset of into buffer. Returns < 0
+ * on error or bytes read.
+ */
+ssize_t cbfs_file_read_metadata(const struct cbfs_file_descriptor *fd,
+ void *buf, offset_t offset, size_t size);
+/*
+ * Attempt to map all of the file's metadata. Depending on the file type there
+ * may be no metadata in which case NULL will be returned. File types of
+ * CBFS_TYPE_STAGE and CBFS_TYPE_PAYLOAD are currently the only files that
+ * contain metadata.
+ *
+ * Returns NULL on error.
+ */
+void *cbfs_file_map_metadata(const struct cbfs_file_descriptor *fd);
+
+/* Unmap the mapping associated with addr. No partial unmappings allowed. */
+void cbfs_file_unmap(const struct cbfs_file_descriptor *fd, void *addr);
+
-void *cbfs_simple_buffer_unmap(struct cbfs_simple_buffer *buffer,
- const void *address);
+void *cbfs_load_optionrom(const struct cbfs_descriptor *cbfs,
+ uint16_t vendor, uint16_t device, void * dest);
-// Utility functions
-int run_address(void *f);
+/* Return entry point to stage, or NULL on failure. */
+void *cbfs_load_stage(const struct cbfs_descriptor *cbfs, const char *name);
-/* Defined in individual arch / board implementation. */
-int init_default_cbfs_media(struct cbfs_media *media);
+/* Decompress range of file to destination. Returns bytes decompressed. */
+size_t cbfs_file_inflate(const struct cbfs_file_descriptor *fd,
+ offset_t offset, size_t src_sz, void *dest);
#if defined(__PRE_RAM__)
struct romstage_handoff;
diff --git a/src/include/cbfs_core.h b/src/include/cbfs_core.h
index a1d8127..6a91454 100644
--- a/src/include/cbfs_core.h
+++ b/src/include/cbfs_core.h
@@ -186,50 +186,6 @@ struct cbfs_optionrom {
uint32_t len;
} __attribute__((packed));
-#define CBFS_MEDIA_INVALID_MAP_ADDRESS ((void*)(0xffffffff))
-#define CBFS_DEFAULT_MEDIA ((void*)(0x0))
-
-/* Media for CBFS to load files. */
-struct cbfs_media {
-
- /* implementation dependent context, to hold resource references */
- void *context;
-
- /* opens media and returns 0 on success, -1 on failure */
- int (*open)(struct cbfs_media *media);
-
- /* returns number of bytes read from media into dest, starting from
- * offset for count of bytes */
- size_t (*read)(struct cbfs_media *media, void *dest, size_t offset,
- size_t count);
-
- /* returns a pointer to memory with count of bytes from media source
- * starting from offset, or CBFS_MEDIA_INVALID_MAP_ADDRESS on failure.
- * Note: mapped data can't be free unless unmap is called, even if you
- * do close first. */
- void * (*map)(struct cbfs_media *media, size_t offset, size_t count);
-
- /* returns NULL and releases the memory by address, which was allocated
- * by map */
- void * (*unmap)(struct cbfs_media *media, const void *address);
-
- /* closes media and returns 0 on success, -1 on failure. */
- int (*close)(struct cbfs_media *media);
-};
-
-/* returns pointer to a file entry inside CBFS or NULL */
-struct cbfs_file *cbfs_get_file(struct cbfs_media *media, const char *name);
-
-/* returns pointer to file content inside CBFS after if type is correct */
-void *cbfs_get_file_content(struct cbfs_media *media, const char *name,
- int type, size_t *sz);
-
-/* returns decompressed size on success, 0 on failure */
-int cbfs_decompress(int algo, void *src, void *dst, int len);
-
-/* returns a pointer to CBFS master header, or CBFS_HEADER_INVALID_ADDRESS
- * on failure */
-const struct cbfs_header *cbfs_get_header(struct cbfs_media *media);
#endif /* __ROMCC__ */
diff --git a/src/include/device/pci_rom.h b/src/include/device/pci_rom.h
index fe77276..4bd0bfd 100644
--- a/src/include/device/pci_rom.h
+++ b/src/include/device/pci_rom.h
@@ -6,7 +6,6 @@
#define PCI_ROM_HDR 0xAA55
#define PCI_DATA_HDR (uint32_t) ( ('R' << 24) | ('I' << 16) | ('C' << 8) | 'P' )
-#define PCI_RAM_IMAGE_START 0xD0000
#define PCI_VGA_RAM_IMAGE_START 0xC0000
struct rom_header {
@@ -33,8 +32,7 @@ struct pci_data {
uint16_t reserved_2;
};
-struct rom_header *pci_rom_probe(struct device *dev);
-struct rom_header *pci_rom_load(struct device *dev, struct rom_header *rom_header);
+struct rom_header *pci_load_vga_rom(struct device *dev);
u32 __attribute__((weak)) map_oprom_vendev(u32 vendev);
#endif
diff --git a/src/include/payload_loader.h b/src/include/payload_loader.h
index 7a3f045..7b6fc1c 100644
--- a/src/include/payload_loader.h
+++ b/src/include/payload_loader.h
@@ -22,6 +22,8 @@
#include <stdint.h>
#include <stddef.h>
+struct cbfs_file_descriptor;
+
struct buffer_area {
void *data;
size_t size;
@@ -29,6 +31,7 @@ struct buffer_area {
struct payload {
const char *name;
+ const struct cbfs_file_descriptor *fd;
struct buffer_area backing_store;
/* Used when payload wants memory coreboot ramstage is running at. */
struct buffer_area bounce;
diff --git a/src/include/region.h b/src/include/region.h
new file mode 100644
index 0000000..cd66bde
--- /dev/null
+++ b/src/include/region.h
@@ -0,0 +1,145 @@
+/*
+ * This file is part of the coreboot project.
+ *
+ * Copyright (C) 2014 Google Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef REGION_H
+#define REGION_H
+
+#include <stdint.h>
+#include <stddef.h>
+
+/*
+ * Region support.
+ *
+ * Regions are intended to abstract away the access mechanisms for blocks of
+ * data. This could be SPI, eMMC, or a memory region as the backing store.
+ * Subregions can be made by registering a region_device that is associated
+ * with another region. Regions can be addressed by name, but there is no
+ * hierarchy in the namespace. i.e. the operations through subregions are
+ * hierarchical but the namespace is not.
+ *
+ * There are two views to the boot media: read-only and read-write. On certain
+ * architectures the read-write availability is not available until late in
+ * ramstage. Therefore, users of each region need to be cognizant of the fact
+ * that different implementations may be backing a particular region. e.g. on
+ * x86 the read-only boot region doesn't have write and erase capabilities, but
+ * the read-write boot region would allow writes and erases but no mmap.
+ */
+
+/*
+ * Initialize the boot region. Called directly in pre-ramstage or
+ * automatically in ramstage.
+ */
+void boot_region_init(void);
+/* Initialize the boot media. Board/Arch specific code implements this. */
+void boot_media_initialize(void);
+/*
+ * A potential call for chipsets that can't bring their RW area online til
+ * after the device init in ramstage.
+ */
+void bootrw_media_initialize(void);
+/* Initialize the default CBFS region. */
+void cbfs_default_media_initialize(void);
+
+typedef uintptr_t offset_t;
+typedef long rhandle_t;
+#define INVALID_RHANDLE ((rhandle_t)~((uintptr_t)0))
+
+#define BOOTRO_REGION_NAME "bootro"
+#define BOOTRW_REGION_NAME "bootrw"
+#define DEFAULT_CBFS_REGION_NAME "cbfs"
+
+struct region_device;
+
+struct region_device_ops {
+ void *(*mmap)(const struct region_device *, offset_t, size_t);
+ void (*munmap)(const struct region_device *, void *);
+ ssize_t (*readat)(const struct region_device *, void *,
+ offset_t, size_t);
+ ssize_t (*writeat)(const struct region_device *, const void *,
+ offset_t, size_t);
+ ssize_t (*eraseat)(const struct region_device *, offset_t, size_t);
+};
+
+struct region {
+ offset_t offset;
+ size_t size;
+};
+
+struct region_device {
+ const struct region_device_ops *ops;
+ struct region region;
+};
+
+/*
+ * Requests within a region are relative to the region's size. Therefore,
+ * the requests need to be normalized to the parent's region. This routine
+ * does that normalization and checks if the request is within bounds.
+ *
+ * Returns -1 if invalid request or 0 if request is within bounds.
+ */
+int region_request_normalize(const struct region *parent,
+ struct region *request);
+
+static inline int rhandle_valid(rhandle_t rh)
+{
+ return !!(rh >= 0);
+}
+
+/* Register a region_device by name. */
+rhandle_t region_register(const char *name, const struct region_device *rdev);
+
+/* Register a subregion by name under parent. rdev->ops must be NULL. */
+rhandle_t region_register_subregion(const char *name,
+ const struct region_device *rdev,
+ rhandle_t parent);
+
+/* Locate a region of provided name. */
+rhandle_t region_locate(const char *name);
+
+/*
+ * Read subregion within provided region.
+ * Returns bytes read, < 0 on error.
+ */
+ssize_t region_readat(rhandle_t rh, void *buf, offset_t offset, size_t count);
+
+/*
+ * Write to subregion within provided region.
+ * Returns bytes written, < 0 on error.
+ */
+ssize_t region_writeat(rhandle_t rh, void *buf, offset_t offset, size_t count);
+
+/*
+ * Erase subregion within provide region.
+ * Returns bytes erased, < 0 on error.
+ */
+ssize_t region_eraseat(rhandle_t rh, offset_t offset, size_t count);
+
+/*
+ * Map subregion described by offset and size within the region provided.
+ * Returns pointer to mapped subregion or NULL on error.
+ */
+void *region_mmap(rhandle_t rh, offset_t offset, size_t count);
+
+/* Unmap previously mapped region. */
+void region_munmap(rhandle_t rh, void *addr);
+
+/* Get size of region represented by rh. < 0 on error. */
+ssize_t region_size(rhandle_t rh);
+
+#endif /* REGION_H */
diff --git a/src/include/rmodule.h b/src/include/rmodule.h
index 2147ab0..19f32e4 100644
--- a/src/include/rmodule.h
+++ b/src/include/rmodule.h
@@ -61,6 +61,7 @@ int rmodule_calc_region(unsigned int region_alignment, size_t rmodule_size,
#if CONFIG_DYNAMIC_CBMEM
struct cbfs_stage;
struct cbmem_entry;
+struct cbfs_descriptor;
struct rmod_stage_load {
/* Inputs */
@@ -72,8 +73,10 @@ struct rmod_stage_load {
};
/* Both of the following functions return 0 on success, -1 on error. */
-int rmodule_stage_load(struct rmod_stage_load *rsl, struct cbfs_stage *stage);
-int rmodule_stage_load_from_cbfs(struct rmod_stage_load *rsl);
+int rmodule_stage_load(struct rmod_stage_load *rsl, struct cbfs_stage *stage,
+ void *data);
+int rmodule_stage_load_from_cbfs(const struct cbfs_descriptor *cbfs,
+ struct rmod_stage_load *rsl);
#endif
struct rmodule {
diff --git a/src/lib/Makefile.inc b/src/lib/Makefile.inc
index acd334e..052dc9f 100644
--- a/src/lib/Makefile.inc
+++ b/src/lib/Makefile.inc
@@ -18,7 +18,9 @@
#
subdirs-y += loaders
+ifneq ($(CONFIG_ARCH_X86),y)
bootblock-y += cbfs.c
+endif
ifneq ($(CONFIG_HAVE_ARCH_MEMSET),y)
bootblock-y += memset.c
endif
@@ -109,6 +111,13 @@ ramstage-y += cbmem_info.c
ramstage-y += hexdump.c
romstage-y += hexdump.c
+ramstage-y += region.c
+romstage-y += region.c
+ramstage-y += cbfs_boot_region.c
+romstage-y += cbfs_boot_region.c
+smm-y += cbfs_boot_region.c
+ramstage-$(CONFIG_BOOT_REGION_SPI_FLASH) += bootrw_spi_flash_region.c
+smm-$(CONFIG_BOOT_REGION_SPI_FLASH) += bootrw_spi_flash_region.c
ramstage-$(CONFIG_REG_SCRIPT) += reg_script.c
@@ -125,6 +134,7 @@ smm-y += memmove.c
endif
smm-y += cbfs.c memcmp.c
smm-y += gcc.c
+smm-y += region.c
$(obj)/lib/version.ramstage.o : $(obj)/build.h
diff --git a/src/lib/bootrw_spi_flash_region.c b/src/lib/bootrw_spi_flash_region.c
new file mode 100644
index 0000000..2ef8e75
--- /dev/null
+++ b/src/lib/bootrw_spi_flash_region.c
@@ -0,0 +1,119 @@
+/*
+ * This file is part of the coreboot project.
+ *
+ * Copyright (C) 2014 Google Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+
+#include <stddef.h>
+#include <region.h>
+#include <spi-generic.h>
+#include <spi_flash.h>
+
+struct bootrw_flash_device {
+ struct spi_flash *spi;
+ struct region_device dev;
+};
+
+
+static ssize_t
+bootrw_readat(const struct region_device *rdev, void *buf,
+ offset_t offset, size_t size)
+{
+ struct bootrw_flash_device *dev;
+
+ dev = container_of(rdev, struct bootrw_flash_device, dev);
+ if (dev->spi->read(dev->spi, offset, size, buf))
+ return -1;
+ return size;
+}
+
+static ssize_t
+bootrw_writeat(const struct region_device *rdev, const void *buf,
+ offset_t offset, size_t size)
+{
+ struct bootrw_flash_device *dev;
+
+ dev = container_of(rdev, struct bootrw_flash_device, dev);
+ if (dev->spi->write(dev->spi, offset, size, buf))
+ return -1;
+ return size;
+}
+
+static ssize_t
+bootrw_eraseat(const struct region_device *rdev, offset_t offset, size_t size)
+{
+ struct bootrw_flash_device *dev;
+
+ dev = container_of(rdev, struct bootrw_flash_device, dev);
+ if (dev->spi->erase(dev->spi, offset, size))
+ return -1;
+ return size;
+}
+
+static const struct region_device_ops bootrw_ops = {
+ .readat = bootrw_readat,
+ .writeat = bootrw_writeat,
+ .eraseat = bootrw_eraseat,
+};
+
+static struct bootrw_flash_device flashdev = {
+ .dev = {
+ .ops = &bootrw_ops,
+ .region = {
+ .offset = 0,
+ .size = CONFIG_ROM_SIZE,
+ },
+ }
+};
+
+void bootrw_media_initialize(void)
+{
+ /* Reinitialize spi regs in case. */
+ spi_init();
+
+ if (flashdev.spi != NULL)
+ return;
+
+ flashdev.spi = spi_flash_probe(0, 0, 0, 0);
+ if (flashdev.spi == NULL) {
+ printk(BIOS_WARNING, "SPI probing failed for boot region.\n");
+ return;
+ }
+
+ if (flashdev.spi->size != CONFIG_ROM_SIZE) {
+ printk(BIOS_WARNING,
+ "SPI mismatch with CONFIG_ROM_SIZE: %zx vs %zx\n",
+ (size_t)CONFIG_ROM_SIZE, (size_t)flashdev.spi->size);
+ return;
+ }
+
+ if (!rhandle_valid(region_register(BOOTRW_REGION_NAME, &flashdev.dev)))
+ printk(BIOS_WARNING, "Couldn't register '%s' region.\n",
+ BOOTRW_REGION_NAME);
+}
+
+#if !defined(__PRE_RAM__)
+#include <bootstate.h>
+static void bootrw_bscb(void *unused)
+{
+ bootrw_media_initialize();
+}
+
+BOOT_STATE_INIT_ENTRIES(regions_init) = {
+ BOOT_STATE_INIT_ENTRY(BS_DEV_INIT, BS_ON_ENTRY, bootrw_bscb, NULL),
+};
+#endif
diff --git a/src/lib/cbfs.c b/src/lib/cbfs.c
index dc08937..f5dff88 100644
--- a/src/lib/cbfs.c
+++ b/src/lib/cbfs.c
@@ -1,8 +1,7 @@
/*
* This file is part of the coreboot project.
*
- * Copyright (C) 2008, Jordan Crouse <jordan(a)cosmicpenguin.net>
- * Copyright (C) 2013 The Chromium OS Authors. All rights reserved.
+ * Copyright (C) 2014-2014 Google Inc.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@@ -18,192 +17,402 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
*/
-#ifdef LIBPAYLOAD
-# include <libpayload-config.h>
-# ifdef CONFIG_LZMA
-# include <lzma.h>
-# define CBFS_CORE_WITH_LZMA
-# endif
-# define CBFS_MINI_BUILD
-#elif defined(__SMM__)
-# define CBFS_MINI_BUILD
-#elif defined(__BOOT_BLOCK__)
- /* No LZMA in boot block. */
-#elif defined(__PRE_RAM__) && !CONFIG_COMPRESS_RAMSTAGE
- /* No LZMA in romstage if ramstage is not compressed. */
-#else
-# define CBFS_CORE_WITH_LZMA
-# include <lib.h>
+#if !defined(__BOOT_BLOCK__) && !(defined(__PRE_RAM__) && !IS_ENABLED(CONFIG_COMPRESS_RAMSTAGE))
+#define CBFS_WITH_LZMA
#endif
-#include <cbfs.h>
#include <string.h>
+#include <arch/early_variables.h>
+#include <cbfs.h>
+#include <cbfs_core.h>
#include <cbmem.h>
+#include <console/console.h>
+#include <lib.h>
-#ifdef LIBPAYLOAD
-# include <stdio.h>
-# define DEBUG(x...)
-# define LOG(x...) printf(x)
-# define ERROR(x...) printf(x)
-#else
-# include <console/console.h>
-# define ERROR(x...) printk(BIOS_ERR, "CBFS: " x)
-# define LOG(x...) printk(BIOS_INFO, "CBFS: " x)
-# if CONFIG_DEBUG_CBFS
-# define DEBUG(x...) printk(BIOS_SPEW, "CBFS: " x)
-# else
-# define DEBUG(x...)
-# endif
-#endif
+struct cbfs_file_descriptor {
+ rhandle_t rh;
+ struct region metadata;
+ struct region content;
+};
-#if defined(CONFIG_CBFS_HEADER_ROM_OFFSET) && (CONFIG_CBFS_HEADER_ROM_OFFSET)
-# define CBFS_HEADER_ROM_ADDRESS (CONFIG_CBFS_HEADER_ROM_OFFSET)
-#else
-// Indirect address: only works on 32bit top-aligned systems.
-# define CBFS_HEADER_ROM_ADDRESS (*(uint32_t *)0xfffffffc)
-#endif
+#define MAX_CBFS_OPEN_FILES 4
+struct cbfs_file_cache {
+ struct cbfs_file_descriptor files[MAX_CBFS_OPEN_FILES];
+};
-#include "cbfs_core.c"
+static struct cbfs_file_cache g_cbfs_files CAR_GLOBAL;
-#ifndef __SMM__
-static inline int tohex4(unsigned int c)
+static struct cbfs_file_cache *get_cache(void)
+{
+ return car_get_var_ptr(&g_cbfs_files);
+}
+
+static int cbfs_fd_available(const struct cbfs_file_descriptor *fd)
+{
+ return !!(fd->content.size == 0 && fd->metadata.size == 0);
+}
+
+static void cbfs_fd_mark_free(const struct cbfs_file_descriptor *cfd)
{
- return (c <= 9) ? (c + '0') : (c - 10 + 'a');
+ struct cbfs_file_descriptor *fd = (struct cbfs_file_descriptor *)cfd;
+ memset(fd, 0, sizeof(*fd));
+ fd->rh = INVALID_RHANDLE;
}
-static void tohex16(unsigned int val, char* dest)
+static struct cbfs_file_descriptor *get_available_file(void)
{
- dest[0] = tohex4(val>>12);
- dest[1] = tohex4((val>>8) & 0xf);
- dest[2] = tohex4((val>>4) & 0xf);
- dest[3] = tohex4(val & 0xf);
+ int i;
+ struct cbfs_file_cache *cache = get_cache();
+
+ for (i = 0; i < MAX_CBFS_OPEN_FILES; i++) {
+ if (cbfs_fd_available(&cache->files[i]))
+ return &cache->files[i];
+ }
+
+ return NULL;
}
-void *cbfs_load_optionrom(struct cbfs_media *media, uint16_t vendor,
- uint16_t device, void *dest)
+static void cbfs_fd_add_metadata(struct cbfs_file_descriptor *fd, size_t sz)
{
- char name[17] = "pciXXXX,XXXX.rom";
- struct cbfs_optionrom *orom;
- uint8_t *src;
+ fd->metadata.size += sz;
+ fd->content.offset += sz;
+ fd->content.size -= sz;
+}
- tohex16(vendor, name+3);
- tohex16(device, name+8);
+static const struct cbfs_file_descriptor *
+allocate_file(const struct cbfs_descriptor *cbfs, const struct cbfs_file *file,
+ offset_t offset)
+{
+ struct cbfs_file_descriptor *fd;
+ offset_t file_end;
- orom = (struct cbfs_optionrom *)
- cbfs_get_file_content(media, name, CBFS_TYPE_OPTIONROM, NULL);
+ fd = get_available_file();
- if (orom == NULL)
+ if (fd == NULL) {
+ printk(BIOS_DEBUG, "No available cbfs fds!\n");
return NULL;
+ }
- /* They might have specified a dest address. If so, we can decompress.
- * If not, there's not much hope of decompressing or relocating the rom.
- * in the common case, the expansion rom is uncompressed, we
- * pass 0 in for the dest, and all we have to do is find the rom and
- * return a pointer to it.
- */
+ /* Point offset to beginning of file data. */
+ offset = file->offset + offset;
+ file_end = offset + file->len;
- /* BUG: the cbfstool is (not yet) including a cbfs_optionrom header */
- src = (uint8_t *)orom; // + sizeof(struct cbfs_optionrom);
+ fd->rh = cbfs->rh;
+ fd->metadata.offset = offset;
+ fd->metadata.size = 0;
+ fd->content.offset = offset;
+ fd->content.size = file->len;
- if (! dest)
- return src;
+ if (file->type != CBFS_TYPE_STAGE && file->type != CBFS_TYPE_PAYLOAD)
+ return fd;
+
+ if (file->type == CBFS_TYPE_STAGE) {
+ cbfs_fd_add_metadata(fd, sizeof(struct cbfs_stage));
+ return fd;
+ }
+
+ /* Parse payload segments. */
+ while (offset + sizeof(struct cbfs_payload_segment) <= file_end) {
+ struct cbfs_payload_segment segment;
+ ssize_t read_sz;
+
+ read_sz = region_readat(cbfs->rh, &segment, offset,
+ sizeof(segment));
+ if (read_sz != sizeof(segment)) {
+ printk(BIOS_DEBUG, "Couldn't read segment at 0x%zx\n",
+ (size_t)offset);
+ cbfs_fd_mark_free(fd);
+ return NULL;
+ }
+
+ switch (segment.type) {
+ case PAYLOAD_SEGMENT_CODE:
+ case PAYLOAD_SEGMENT_DATA:
+ case PAYLOAD_SEGMENT_BSS:
+ case PAYLOAD_SEGMENT_PARAMS:
+ cbfs_fd_add_metadata(fd, sizeof(segment));
+ break;
+ case PAYLOAD_SEGMENT_ENTRY:
+ cbfs_fd_add_metadata(fd, sizeof(segment));
+ return fd;
+ default:
+ cbfs_fd_mark_free(fd);
+ return NULL;
+ }
+
+ /* Next segment. */
+ offset += sizeof(segment);
+ }
- if (!cbfs_decompress(ntohl(orom->compression),
- src,
- dest,
- ntohl(orom->len)))
+ cbfs_fd_mark_free(fd);
+ return NULL;
+}
+
+static offset_t
+cbfs_next_offset(offset_t offset, size_t align, size_t increment)
+{
+ offset += increment;
+ if (offset % align)
+ offset += align - (offset % align);
+ return offset;
+}
+
+static const struct cbfs_file_descriptor *
+__cbfs_open(const struct cbfs_descriptor *cbfs, const char *name,
+ uint32_t *type)
+{
+ const struct cbfs_file_descriptor *fd;
+ struct cbfs_file file;
+ ssize_t read_sz;
+ offset_t offset;
+ size_t cbfs_sz;
+ size_t align;
+ rhandle_t rh;
+
+ if (cbfs == NULL || name == NULL)
return NULL;
- return dest;
+ offset = 0;
+ rh = cbfs->rh;
+ align = cbfs->align;
+ cbfs_sz = cbfs->size;
+ fd = NULL;
+
+ while (offset + sizeof(file) < cbfs_sz) {
+ char *file_name;
+ size_t name_sz;
+ size_t entry_sz;
+ int found;
+
+ read_sz = region_readat(rh, &file, offset, sizeof(file));
+ if (read_sz != sizeof(file))
+ return NULL;
+
+ if (memcmp(CBFS_FILE_MAGIC, file.magic, sizeof(file.magic))) {
+ offset = cbfs_next_offset(offset, align, align);
+ continue;
+ }
+
+ file.len = ntohl(file.len);
+ file.type = ntohl(file.type);
+ file.offset = ntohl(file.offset);
+ entry_sz = file.len + file.offset;
+
+ /* File type doesn't match. */
+ if (type != NULL && *type != file.type) {
+ offset = cbfs_next_offset(offset, align, entry_sz);
+ continue;
+ }
+ name_sz = file.offset - sizeof(file);
+ file_name = region_mmap(rh, offset + sizeof(file), name_sz);
+ if (file_name == NULL) {
+ offset = cbfs_next_offset(offset, align, entry_sz);
+ continue;
+ }
+
+ found = !strcmp(file_name, name);
+ region_munmap(rh, file_name);
+
+ if (found) {
+ fd = allocate_file(cbfs, &file, offset);
+ break;
+ }
+ offset = cbfs_next_offset(offset, align, entry_sz);
+ }
+
+ return fd;
}
-void * cbfs_load_stage(struct cbfs_media *media, const char *name)
+const struct cbfs_file_descriptor *
+cbfs_open_by_name(const struct cbfs_descriptor *cbfs, const char *name)
{
- struct cbfs_stage *stage = (struct cbfs_stage *)
- cbfs_get_file_content(media, name, CBFS_TYPE_STAGE, NULL);
- /* this is a mess. There is no ntohll. */
- /* for now, assume compatible byte order until we solve this. */
- uint32_t entry;
- uint32_t final_size;
+ return __cbfs_open(cbfs, name, NULL);
+}
- if (stage == NULL)
- return (void *) -1;
+const struct cbfs_file_descriptor *
+cbfs_open_by_name_type(const struct cbfs_descriptor *cbfs,
+ const char *name, uint32_t type)
+{
+ return __cbfs_open(cbfs, name, &type);
+}
- LOG("loading stage %s @ 0x%x (%d bytes), entry @ 0x%llx\n",
- name,
- (uint32_t) stage->load, stage->memlen,
- stage->entry);
+void cbfs_file_close(const struct cbfs_file_descriptor *file)
+{
+ if (file != NULL)
+ cbfs_fd_mark_free(file);
+}
- final_size = cbfs_decompress(stage->compression,
- ((unsigned char *) stage) +
- sizeof(struct cbfs_stage),
- (void *) (uint32_t) stage->load,
- stage->len);
- if (!final_size)
- return (void *) -1;
+ssize_t cbfs_file_content_size(const struct cbfs_file_descriptor *fd)
+{
+ if (fd == NULL)
+ return -1;
- /* Stages rely the below clearing so that the bss is initialized. */
- memset((void *)((uintptr_t)stage->load + final_size), 0,
- stage->memlen - final_size);
+ return fd->content.size;
+}
- DEBUG("stage loaded.\n");
+ssize_t cbfs_file_metadata_size(const struct cbfs_file_descriptor *fd)
+{
+ if (fd == NULL)
+ return -1;
- entry = stage->entry;
- // entry = ntohll(stage->entry);
+ return fd->metadata.size;
+}
- return (void *) entry;
+ssize_t cbfs_file_read_content(const struct cbfs_file_descriptor *fd,
+ void *buf, offset_t offset, size_t size)
+{
+ struct region region = {
+ .offset = offset,
+ .size = size,
+ };
+
+ if (fd == NULL)
+ return -1;
+
+ if (region_request_normalize(&fd->content, ®ion))
+ return -1;
+
+ return region_readat(fd->rh, buf, region.offset, size);
}
-/* Simple buffer */
+void *cbfs_file_map_content(const struct cbfs_file_descriptor *fd,
+ offset_t offset, size_t size)
+{
+ struct region region = {
+ .offset = offset,
+ .size = size,
+ };
-void *cbfs_simple_buffer_map(struct cbfs_simple_buffer *buffer,
- struct cbfs_media *media,
- size_t offset, size_t count) {
- void *address = buffer->buffer + buffer->allocated;
- DEBUG("simple_buffer_map(offset=%zd, count=%zd): "
- "allocated=%zd, size=%zd, last_allocate=%zd\n",
- offset, count, buffer->allocated, buffer->size,
- buffer->last_allocate);
- if (buffer->allocated + count >= buffer->size)
- return CBFS_MEDIA_INVALID_MAP_ADDRESS;
- if (media->read(media, address, offset, count) != count) {
- ERROR("simple_buffer: fail to read %zd bytes from 0x%zx\n",
- count, offset);
- return CBFS_MEDIA_INVALID_MAP_ADDRESS;
- }
- buffer->allocated += count;
- buffer->last_allocate = count;
- return address;
-}
-
-void *cbfs_simple_buffer_unmap(struct cbfs_simple_buffer *buffer,
- const void *address) {
- // TODO Add simple buffer management so we can free more than last
- // allocated one.
- DEBUG("simple_buffer_unmap(address=0x%p): "
- "allocated=%zd, size=%zd, last_allocate=%zd\n",
- address, buffer->allocated, buffer->size,
- buffer->last_allocate);
- if ((buffer->buffer + buffer->allocated - buffer->last_allocate) ==
- address) {
- buffer->allocated -= buffer->last_allocate;
- buffer->last_allocate = 0;
- }
- return NULL;
+ if (fd == NULL)
+ return NULL;
+
+ if (region_request_normalize(&fd->content, ®ion))
+ return NULL;
+
+ return region_mmap(fd->rh, region.offset, size);
}
-/**
- * run_address is passed the address of a function taking no parameters and
- * jumps to it, returning the result.
- * @param f the address to call as a function.
- * @return value returned by the function.
- */
+ssize_t cbfs_file_read_metadata(const struct cbfs_file_descriptor *fd,
+ void *buf, offset_t offset, size_t size)
+{
+ struct region region = {
+ .offset = offset,
+ .size = size,
+ };
+
+ if (fd == NULL)
+ return -1;
+
+ if (region_request_normalize(&fd->metadata, ®ion))
+ return -1;
+
+ return region_readat(fd->rh, buf, region.offset, size);
+}
+
+void *cbfs_file_map_metadata(const struct cbfs_file_descriptor *fd)
+{
+ if (fd == NULL)
+ return NULL;
+
+ return region_mmap(fd->rh, fd->metadata.offset, fd->metadata.size);
+}
+
+void cbfs_file_unmap(const struct cbfs_file_descriptor *fd, void *addr)
+{
+ if (fd == NULL)
+ return;
+
+ region_munmap(fd->rh, addr);
+}
-int run_address(void *f)
+#ifndef __SMM__
+size_t cbfs_file_inflate(const struct cbfs_file_descriptor *fd,
+ offset_t offset, size_t src_sz, void *dest)
{
- int (*v) (void);
- v = f;
- return v();
+#if defined(CBFS_WITH_LZMA)
+ void *src;
+ size_t dest_sz;
+
+ src = cbfs_file_map_content(fd, offset, src_sz);
+
+ if (src == NULL)
+ return 0;
+
+ dest_sz = ulzma(src, dest);
+
+ cbfs_file_unmap(fd, src);
+
+ return dest_sz;
+#else
+ return 0;
+#endif
}
+void *cbfs_load_stage(const struct cbfs_descriptor *cbfs, const char *name)
+{
+ struct cbfs_stage stage;
+ const struct cbfs_file_descriptor *file;
+ size_t inflated_sz;
+ ssize_t metadata_sz;
+ ssize_t file_sz;
+ uint8_t *dest;
+ void *entry;
+
+ entry = NULL;
+ file = cbfs_open_by_name_type(cbfs, name, CBFS_TYPE_STAGE);
+
+ if (file == NULL)
+ return NULL;
+
+ metadata_sz = cbfs_file_read_metadata(file, &stage, 0, sizeof(stage));
+ if (metadata_sz != sizeof(stage))
+ goto out;
+
+ file_sz = cbfs_file_content_size(file);
+ if (file_sz < 0)
+ goto out;
+
+ printk(BIOS_INFO,
+ "Loading stage '%s' 0x%llx (%d bytes), entry point 0x%llx\n",
+ name, (long long) stage.load, stage.memlen,
+ (long long)stage.entry);
+
+ dest = (void *)(uintptr_t)stage.load;
+ inflated_sz = stage.memlen;
+
+ switch (stage.compression) {
+ case CBFS_COMPRESS_NONE:
+ if (cbfs_file_read_content(file, dest, 0, file_sz) != file_sz)
+ goto out;
+ break;
+#if defined(CBFS_WITH_LZMA)
+ case CBFS_COMPRESS_LZMA:
+ inflated_sz = cbfs_file_inflate(file, 0, file_sz, dest);
+ if (inflated_sz == 0)
+ goto out;
+ break;
+#endif
+ default:
+ printk(BIOS_ERR,"Invalid compression scheme: %d\n",
+ stage.compression);
+ goto out;
+ }
+
+ if (inflated_sz > stage.memlen) {
+ printk(BIOS_ERR,"Inflated size %zu > memory size %zu.\n",
+ inflated_sz, (size_t)stage.memlen);
+ goto out;
+ }
+
+ /* Stages rely the below clearing so that the bss is initialized. */
+ memset(dest + inflated_sz, 0, stage.memlen - inflated_sz);
+
+ printk(BIOS_DEBUG,"stage loaded.\n");
+
+ entry = (void *)(uintptr_t)stage.entry;
+
+out:
+ cbfs_file_close(file);
+ return entry;
+}
#endif
diff --git a/src/lib/cbfs_boot_region.c b/src/lib/cbfs_boot_region.c
new file mode 100644
index 0000000..6ab12f7
--- /dev/null
+++ b/src/lib/cbfs_boot_region.c
@@ -0,0 +1,133 @@
+/*
+ * This file is part of the coreboot project.
+ *
+ * Copyright (C) 2014 Google Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <stdint.h>
+#include <arch/early_variables.h>
+#include <arch/byteorder.h>
+#include <console/console.h>
+#include <cbfs.h>
+#include <cbfs_core.h>
+#include <region.h>
+
+static struct cbfs_descriptor g_cbfs_descriptor CAR_GLOBAL;
+
+const struct cbfs_descriptor *cbfs_default_descriptor(void)
+{
+ return car_get_var_ptr(&g_cbfs_descriptor);
+}
+
+static const struct region_device cbfs_dev = {
+ .region = {
+ .offset = CONFIG_ROM_SIZE - CONFIG_CBFS_SIZE,
+ .size = CONFIG_CBFS_SIZE,
+ },
+};
+
+#if IS_ENABLED(CONFIG_ARCH_X86)
+static offset_t get_header_offset(rhandle_t rh)
+{
+ int32_t header_offset;
+ offset_t off;
+ ssize_t rsize;
+
+ rsize = region_size(rh);
+ off = rsize - sizeof(header_offset);
+ region_readat(rh, &header_offset, off, sizeof(header_offset));
+ return rsize + header_offset;
+}
+#else
+static inline offset_t get_header_offset(rhandle_t rh)
+{
+ return CONFIG_CBFS_HEADER_ROM_OFFSET;
+}
+#endif
+
+void cbfs_default_media_initialize(void)
+{
+ rhandle_t rh;
+ offset_t header_offset;
+ struct cbfs_header *hdr;
+ size_t cbfs_size;
+ struct cbfs_descriptor *cbfs_desc;
+
+ /* Already initialized. */
+ rh = region_locate(DEFAULT_CBFS_REGION_NAME);
+ if (rhandle_valid(rh))
+ return;
+
+ /* Mark region as invalid. */
+ cbfs_desc = (struct cbfs_descriptor *)cbfs_default_descriptor();
+ cbfs_desc->rh = INVALID_RHANDLE;
+
+ /* CBFS provides a readonly view of the rom. */
+ rh = region_locate(BOOTRO_REGION_NAME);
+
+ if (!rhandle_valid(rh)) {
+ printk(BIOS_ERR, "Boot region not found to register cbfs.\n");
+ return;
+ }
+
+ header_offset = get_header_offset(rh);
+ hdr = region_mmap(rh, header_offset, sizeof(*hdr));
+
+ if (hdr == NULL) {
+ printk(BIOS_ERR, "Couldn't mmap() cbfs header.\n");
+ return;
+ }
+
+ if (CBFS_HEADER_MAGIC != ntohl(hdr->magic)) {
+ printk(BIOS_ERR, "Invalid CBFS magic @ 0x%zx: %x vs %x\n",
+ (size_t)header_offset, CBFS_HEADER_MAGIC,
+ ntohl(hdr->magic));
+ goto out;
+ }
+
+ if (cbfs_dev.region.offset != ntohl(hdr->offset)) {
+ printk(BIOS_ERR, "CBFS offset doesn't match: 0x%zx vs 0x%zx\n",
+ (size_t)cbfs_dev.region.offset,
+ (size_t)ntohl(hdr->offset));
+ goto out;
+ }
+
+ cbfs_size = ntohl(hdr->romsize) - ntohl(hdr->offset);
+
+ if (cbfs_dev.region.size != cbfs_size) {
+ printk(BIOS_ERR, "CBFS size doesn't match: 0x%zx vs 0x%zx\n",
+ cbfs_dev.region.size, cbfs_size);
+ goto out;
+ }
+
+#if IS_ENABLED(CONFIG_ARCH_X86)
+ cbfs_size -= htonl(hdr->bootblocksize);
+#endif
+
+ cbfs_desc->align = ntohl(hdr->align);
+ cbfs_desc->size = cbfs_size;
+
+ printk(BIOS_DEBUG, "%s: CBFS align 0x%zx size 0x%zx\n", __func__,
+ cbfs_desc->align, cbfs_desc->size);
+
+ cbfs_desc->rh = region_register_subregion(DEFAULT_CBFS_REGION_NAME,
+ &cbfs_dev, rh);
+ if (!rhandle_valid(cbfs_desc->rh))
+ printk(BIOS_ERR, "Unable to register default CBFS region.\n");
+
+out:
+ region_munmap(rh, hdr);
+}
diff --git a/src/lib/cbfs_core.c b/src/lib/cbfs_core.c
deleted file mode 100644
index 50c037e..0000000
--- a/src/lib/cbfs_core.c
+++ /dev/null
@@ -1,224 +0,0 @@
-/*
- * This file is part of the coreboot project.
- *
- * Copyright (C) 2011 secunet Security Networks AG
- * Copyright (C) 2013 The Chromium OS Authors. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * 3. The name of the author may not be used to endorse or promote products
- * derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-/* The CBFS core requires a couple of #defines or functions to adapt it to the
- * target environment:
- *
- * CBFS_CORE_WITH_LZMA (must be #define)
- * if defined, ulzma() must exist for decompression of data streams
- *
- * CBFS_HEADER_ROM_ADDRESS
- * ROM address (offset) of CBFS header. Underlying CBFS media may interpret
- * it in other way so we call this "address".
- *
- * ERROR(x...)
- * print an error message x (in printf format)
- *
- * LOG(x...)
- * print a message x (in printf format)
- *
- * DEBUG(x...)
- * print a debug message x (in printf format)
- *
- */
-
-#include <cbfs.h>
-#include <string.h>
-
-/* returns a pointer to CBFS master header, or CBFS_HEADER_INVALID_ADDRESS
- * on failure */
-const struct cbfs_header *cbfs_get_header(struct cbfs_media *media)
-{
- const struct cbfs_header *header;
- struct cbfs_media default_media;
-
- if (media == CBFS_DEFAULT_MEDIA) {
- media = &default_media;
- if (init_default_cbfs_media(media) != 0) {
- ERROR("Failed to initialize default media.\n");
- return CBFS_HEADER_INVALID_ADDRESS;
- }
- }
-
- media->open(media);
- DEBUG("CBFS_HEADER_ROM_ADDRESS: 0x%x/0x%x\n", CBFS_HEADER_ROM_ADDRESS,
- CONFIG_ROM_SIZE);
- header = media->map(media, CBFS_HEADER_ROM_ADDRESS, sizeof(*header));
- media->close(media);
-
- if (header == CBFS_MEDIA_INVALID_MAP_ADDRESS) {
- ERROR("Failed to load CBFS header from 0x%x\n",
- CBFS_HEADER_ROM_ADDRESS);
- return CBFS_HEADER_INVALID_ADDRESS;
- }
-
- if (CBFS_HEADER_MAGIC != ntohl(header->magic)) {
- ERROR("Could not find valid CBFS master header at %x: "
- "%x vs %x.\n", CBFS_HEADER_ROM_ADDRESS, CBFS_HEADER_MAGIC,
- ntohl(header->magic));
- if (header->magic == 0xffffffff) {
- ERROR("Maybe ROM is not mapped properly?\n");
- }
- return CBFS_HEADER_INVALID_ADDRESS;
- }
- return header;
-}
-
-/* public API starts here*/
-struct cbfs_file *cbfs_get_file(struct cbfs_media *media, const char *name)
-{
- const char *file_name;
- uint32_t offset, align, romsize, name_len;
- const struct cbfs_header *header;
- struct cbfs_file file, *file_ptr;
- struct cbfs_media default_media;
-
- if (media == CBFS_DEFAULT_MEDIA) {
- media = &default_media;
- if (init_default_cbfs_media(media) != 0) {
- ERROR("Failed to initialize default media.\n");
- return NULL;
- }
- }
-
- if (CBFS_HEADER_INVALID_ADDRESS == (header = cbfs_get_header(media)))
- return NULL;
-
- // Logical offset (for source media) of first file.
- offset = ntohl(header->offset);
- align = ntohl(header->align);
- romsize = ntohl(header->romsize);
-
- // TODO Add a "size" in CBFS header for a platform independent way to
- // determine the end of CBFS data.
-#if defined(CONFIG_ARCH_X86) && CONFIG_ARCH_X86
- romsize -= htonl(header->bootblocksize);
-#endif
- DEBUG("CBFS location: 0x%x~0x%x, align: %d\n", offset, romsize, align);
-
- DEBUG("Looking for '%s' starting from 0x%x.\n", name, offset);
- media->open(media);
- while (offset < romsize &&
- media->read(media, &file, offset, sizeof(file)) == sizeof(file)) {
- if (memcmp(CBFS_FILE_MAGIC, file.magic,
- sizeof(file.magic)) != 0) {
- uint32_t new_align = align;
- if (offset % align)
- new_align += align - (offset % align);
- ERROR("ERROR: No file header found at 0x%x - "
- "try next aligned address: 0x%x.\n", offset,
- offset + new_align);
- offset += new_align;
- continue;
- }
- name_len = ntohl(file.offset) - sizeof(file);
- DEBUG(" - load entry 0x%x file name (%d bytes)...\n", offset,
- name_len);
-
- // load file name (arbitrary length).
- file_name = (const char *)media->map(
- media, offset + sizeof(file), name_len);
- if (file_name == CBFS_MEDIA_INVALID_MAP_ADDRESS) {
- ERROR("ERROR: Failed to get filename: 0x%x.\n", offset);
- } else if (strcmp(file_name, name) == 0) {
- int file_offset = ntohl(file.offset),
- file_len = ntohl(file.len);
- DEBUG("Found file (offset=0x%x, len=%d).\n",
- offset + file_offset, file_len);
- media->unmap(media, file_name);
- file_ptr = media->map(media, offset,
- file_offset + file_len);
- media->close(media);
- return file_ptr;
- } else {
- DEBUG(" (unmatched file @0x%x: %s)\n", offset,
- file_name);
- media->unmap(media, file_name);
- }
-
- // Move to next file.
- offset += ntohl(file.len) + ntohl(file.offset);
- if (offset % align)
- offset += align - (offset % align);
- }
- media->close(media);
- LOG("WARNING: '%s' not found.\n", name);
- return NULL;
-}
-
-void *cbfs_get_file_content(struct cbfs_media *media, const char *name,
- int type, size_t *sz)
-{
- struct cbfs_file *file = cbfs_get_file(media, name);
-
- if (sz)
- *sz = 0;
-
- if (file == NULL) {
- ERROR("Could not find file '%s'.\n", name);
- return NULL;
- }
-
- if (ntohl(file->type) != type) {
- ERROR("File '%s' is of type %x, but we requested %x.\n", name,
- ntohl(file->type), type);
- return NULL;
- }
-
- if (sz)
- *sz = ntohl(file->len);
-
- return (void *)CBFS_SUBHEADER(file);
-}
-
-int cbfs_decompress(int algo, void *src, void *dst, int len)
-{
- switch (algo) {
- case CBFS_COMPRESS_NONE:
- /* Reads need to be aligned at 4 bytes to avoid
- poor flash performance. */
- while (len && ((u32)src & 3)) {
- *(u8*)dst++ = *(u8*)src++;
- len--;
- }
- memmove(dst, src, len);
- return len;
-#ifdef CBFS_CORE_WITH_LZMA
- case CBFS_COMPRESS_LZMA:
- return ulzma(src, dst);
-#endif
- default:
- ERROR("tried to decompress %d bytes with algorithm #%x,"
- "but that algorithm id is unsupported.\n", len,
- algo);
- return 0;
- }
-}
-
diff --git a/src/lib/loaders/cbfs_payload_loader.c b/src/lib/loaders/cbfs_payload_loader.c
index 2c1d179..31ad7e6 100644
--- a/src/lib/loaders/cbfs_payload_loader.c
+++ b/src/lib/loaders/cbfs_payload_loader.c
@@ -18,20 +18,30 @@
*/
#include <cbfs.h>
+#include <cbfs_core.h>
#include <payload_loader.h>
static int cbfs_locate_payload(struct payload *payload)
{
void *buffer;
size_t size;
- const int type = CBFS_TYPE_PAYLOAD;
+ const struct cbfs_file_descriptor *fd;
- buffer = cbfs_get_file_content(CBFS_DEFAULT_MEDIA, payload->name,
- type, &size);
+ fd = cbfs_open_by_name_type(cbfs_default_descriptor(), payload->name,
+ CBFS_TYPE_PAYLOAD);
- if (buffer == NULL)
+ if (fd == NULL)
return -1;
+ size = cbfs_file_content_size(fd);
+ buffer = cbfs_file_map_content(fd, 0, size);
+
+ if (buffer == NULL) {
+ cbfs_file_close(fd);
+ return -1;
+ }
+
+ payload->fd = fd;
payload->backing_store.data = buffer;
payload->backing_store.size = size;
diff --git a/src/lib/loaders/cbfs_ramstage_loader.c b/src/lib/loaders/cbfs_ramstage_loader.c
index 5d5cc0b..5d5edd8 100644
--- a/src/lib/loaders/cbfs_ramstage_loader.c
+++ b/src/lib/loaders/cbfs_ramstage_loader.c
@@ -34,7 +34,8 @@ static void *cbfs_load_ramstage(uint32_t cbmem_id, const char *name,
.name = name,
};
- if (rmodule_stage_load_from_cbfs(&rmod_ram)) {
+ if (rmodule_stage_load_from_cbfs(cbfs_default_descriptor(),
+ &rmod_ram)) {
printk(BIOS_DEBUG, "Could not load ramstage.\n");
return NULL;
}
@@ -49,14 +50,7 @@ static void *cbfs_load_ramstage(uint32_t cbmem_id, const char *name,
static void *cbfs_load_ramstage(uint32_t cbmem_id, const char *name,
const struct cbmem_entry **cbmem_entry)
{
- void *entry;
-
- entry = cbfs_load_stage(CBFS_DEFAULT_MEDIA, name);
-
- if ((void *)entry == (void *) -1)
- entry = NULL;
-
- return entry;
+ return cbfs_load_stage(cbfs_default_descriptor(), name);
}
#endif /* CONFIG_RELOCATABLE_RAMSTAGE */
diff --git a/src/lib/loaders/load_and_run_payload.c b/src/lib/loaders/load_and_run_payload.c
index 2204090..ac4e7bf 100644
--- a/src/lib/loaders/load_and_run_payload.c
+++ b/src/lib/loaders/load_and_run_payload.c
@@ -58,9 +58,8 @@ struct payload *payload_load(void)
ops->name);
continue;
}
- printk(BIOS_DEBUG, "%s: located payload @ %p, %zu bytes.\n",
- ops->name, payload->backing_store.data,
- payload->backing_store.size);
+ printk(BIOS_DEBUG, "%s: located payload, %zu bytes.\n",
+ ops->name, payload->backing_store.size);
break;
}
diff --git a/src/lib/region.c b/src/lib/region.c
new file mode 100644
index 0000000..6300b89
--- /dev/null
+++ b/src/lib/region.c
@@ -0,0 +1,305 @@
+/*
+ * This file is part of the coreboot project.
+ *
+ * Copyright (C) 2014 Google Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <string.h>
+#include <console/console.h>
+#include <arch/early_variables.h>
+#include <region.h>
+#include <vendorcode/google/chromeos/fmap.h>
+
+/* MAX_REGIONS could be configurable. */
+#define MAX_REGIONS 6
+
+struct region_registry_entry {
+ rhandle_t parent_slot;
+ const char *name;
+ const struct region_device *rdev;
+};
+
+struct region_registry {
+ struct region_registry_entry entries[MAX_REGIONS];
+};
+
+static struct region_registry g_regions CAR_GLOBAL;
+
+static inline struct region_registry *get_registry(void)
+{
+ return car_get_var_ptr(&g_regions);
+}
+
+static const struct region_registry_entry *
+registry_entry_lookup(const struct region_registry *rr, rhandle_t rh)
+{
+ if (rh < 0 || rh >= MAX_REGIONS)
+ return NULL;
+
+ return &rr->entries[rh];
+}
+
+static int region_enclosed(const struct region *parent,
+ const struct region *child)
+{
+ offset_t parent_end;
+ offset_t child_end;
+
+ child_end = child->offset + child->size;
+ parent_end = parent->offset + parent->size;
+
+ if (child->size > parent->size)
+ return -1;
+
+ if (child->offset >= parent->offset && child_end <= parent_end)
+ return 0;
+
+ return -1;
+}
+
+int region_request_normalize(const struct region *parent,
+ struct region *request)
+{
+ request->offset += parent->offset;
+ return region_enclosed(parent, request);
+}
+
+static rhandle_t __region_register(struct region_registry *rr, const char *name,
+ const struct region_device *rdev,
+ rhandle_t parent)
+{
+ rhandle_t slot;
+
+ for (slot = 0; slot < MAX_REGIONS; slot++) {
+ struct region_registry_entry *entry = &rr->entries[slot];
+
+ /* Find an empty slot. */
+ if (entry->rdev != NULL)
+ continue;
+
+ entry->parent_slot = parent;
+ entry->name = name;
+ entry->rdev = rdev;
+ printk(BIOS_DEBUG,
+ "Region '%s' registered: slot %u, %zu @ 0x%zx.\n",
+ name, (unsigned int)slot, rdev->region.size,
+ (size_t)rdev->region.offset);
+ return slot;
+ }
+
+ return INVALID_RHANDLE;
+}
+
+rhandle_t region_register(const char *name, const struct region_device *rdev)
+{
+ if (name == NULL || rdev == NULL || rdev->ops == NULL)
+ return INVALID_RHANDLE;
+
+ return __region_register(get_registry(), name, rdev, INVALID_RHANDLE);
+}
+
+rhandle_t region_register_subregion(const char *name,
+ const struct region_device *rdev,
+ rhandle_t parent)
+{
+ struct region_registry *rr;
+ const struct region_registry_entry *pentry;
+
+ /* Subregions require NULL ops. */
+ if (name == NULL || rdev == NULL || rdev->ops != NULL)
+ return INVALID_RHANDLE;
+
+ rr = get_registry();
+
+ /* Parent is invalid. */
+ pentry = registry_entry_lookup(rr, parent);
+ if (pentry == NULL)
+ return INVALID_RHANDLE;
+
+ /* Ensure subregion is within bounds. */
+ if (region_enclosed(&pentry->rdev->region, &rdev->region))
+ return INVALID_RHANDLE;
+
+ return __region_register(rr, name, rdev, parent);
+}
+
+/* Locate a region of provided name. */
+rhandle_t region_locate(const char *name)
+{
+ rhandle_t slot;
+ struct region_registry *rr;
+
+ if (name == NULL)
+ return INVALID_RHANDLE;
+
+ rr = get_registry();
+
+ for (slot = 0; slot < MAX_REGIONS; slot++) {
+ const struct region_registry_entry *entry = &rr->entries[slot];
+
+ /* No more valid entries. */
+ if (entry->rdev == NULL)
+ break;
+
+ if (!strcmp(entry->name, name))
+ return slot;
+ }
+ return INVALID_RHANDLE;
+}
+
+/*
+ * Obtain the appropriate region_device while optionally translating the
+ * region into the parent's domain.
+ */
+static const struct region_device *
+find_parent(rhandle_t rh, struct region *region)
+{
+ const struct region_registry_entry *entry;
+ struct region_registry *rr;
+
+ rr = get_registry();
+ entry = registry_entry_lookup(rr, rh);
+
+ if (entry == NULL)
+ return NULL;
+
+ if (region != NULL &&
+ region_request_normalize(&entry->rdev->region, region))
+ return NULL;
+
+ while (entry->rdev->ops == NULL) {
+ entry = &rr->entries[entry->parent_slot];
+ /* Translate the region into the parent's view. */
+ if (region != NULL)
+ region->offset += entry->rdev->region.offset;
+ }
+
+ return entry->rdev;
+}
+
+ssize_t region_readat(rhandle_t rh, void *buf, offset_t offset, size_t count)
+{
+ const struct region_device *rdev;
+ struct region region = {
+ .offset = offset,
+ .size = count,
+ };
+
+ rdev = find_parent(rh, ®ion);
+
+ if (rdev == NULL || rdev->ops->readat == NULL)
+ return -1;
+
+ return rdev->ops->readat(rdev, buf, region.offset, region.size);
+}
+
+ssize_t region_writeat(rhandle_t rh, void *buf, offset_t offset, size_t count)
+{
+ const struct region_device *rdev;
+ struct region region = {
+ .offset = offset,
+ .size = count,
+ };
+
+ rdev = find_parent(rh, ®ion);
+
+ if (rdev == NULL || rdev->ops->writeat == NULL)
+ return -1;
+
+ return rdev->ops->writeat(rdev, buf, region.offset, region.size);
+}
+
+ssize_t region_eraseat(rhandle_t rh, offset_t offset, size_t count)
+{
+ const struct region_device *rdev;
+ struct region region = {
+ .offset = offset,
+ .size = count,
+ };
+
+ rdev = find_parent(rh, ®ion);
+
+ if (rdev == NULL || rdev->ops->eraseat == NULL)
+ return -1;
+
+ return rdev->ops->eraseat(rdev, region.offset, region.size);
+}
+
+void *region_mmap(rhandle_t rh, offset_t offset, size_t count)
+{
+ const struct region_device *rdev;
+ struct region region = {
+ .offset = offset,
+ .size = count,
+ };
+
+ if (count == 0)
+ return NULL;
+
+ rdev = find_parent(rh, ®ion);
+
+ if (rdev == NULL || rdev->ops->mmap == NULL)
+ return NULL;
+
+ return rdev->ops->mmap(rdev, region.offset, region.size);
+}
+
+void region_munmap(rhandle_t rh, void *addr)
+{
+ const struct region_device *rdev;
+
+ rdev = find_parent(rh, NULL);
+
+ if (rdev == NULL || rdev->ops->munmap == NULL)
+ return;
+
+ return rdev->ops->munmap(rdev, addr);
+}
+
+ssize_t region_size(rhandle_t rh)
+{
+ const struct region_registry_entry *entry;
+
+ entry = registry_entry_lookup(get_registry(), rh);
+
+ if (entry == NULL)
+ return -1;
+
+ return entry->rdev->region.size;
+}
+
+void boot_region_init(void)
+{
+ boot_media_initialize();
+ cbfs_default_media_initialize();
+ fmap_initialize();
+}
+
+/* Provide weak default. */
+void __attribute__((weak)) bootrw_media_initialize(void) {}
+
+#if !defined(__PRE_RAM__)
+#include <bootstate.h>
+static void regions_bscb(void *unused)
+{
+ boot_region_init();
+}
+
+BOOT_STATE_INIT_ENTRIES(regions_init) = {
+ BOOT_STATE_INIT_ENTRY(BS_DEV_INIT_CHIPS, BS_ON_ENTRY,
+ regions_bscb, NULL),
+};
+#endif
diff --git a/src/lib/rmodule.c b/src/lib/rmodule.c
index 2cb70b8..33481b2 100644
--- a/src/lib/rmodule.c
+++ b/src/lib/rmodule.c
@@ -21,6 +21,9 @@
#include <stdlib.h>
#include <string.h>
#include <console/console.h>
+#include <cbfs.h>
+#include <cbfs_core.h>
+#include <lib.h>
#include <rmodule.h>
/* Change this define to get more verbose debugging for module loading. */
@@ -305,11 +308,12 @@ int rmodule_calc_region(unsigned int region_alignment, size_t rmodule_size,
#include <cbmem.h>
#include <cbfs_core.h>
-int rmodule_stage_load(struct rmod_stage_load *rsl, struct cbfs_stage *stage)
+int rmodule_stage_load(struct rmod_stage_load *rsl, struct cbfs_stage *stage,
+ void *data)
{
struct rmodule rmod_stage;
size_t region_size;
- char *stage_region;
+ unsigned char *stage_region;
int rmodule_offset;
int load_offset;
const struct cbmem_entry *cbmem_entry;
@@ -331,8 +335,12 @@ int rmodule_stage_load(struct rmod_stage_load *rsl, struct cbfs_stage *stage)
printk(BIOS_INFO, "Decompressing stage %s @ 0x%p (%d bytes)\n",
rsl->name, &stage_region[rmodule_offset], stage->memlen);
- if (!cbfs_decompress(stage->compression, &stage[1],
- &stage_region[rmodule_offset], stage->len))
+ if (stage->compression == CBFS_COMPRESS_NONE) {
+ memcpy(data, &stage_region[rmodule_offset], stage->len);
+ } else if (stage->compression == CBFS_COMPRESS_LZMA) {
+ if (!ulzma(data, &stage_region[rmodule_offset]))
+ return -1;
+ } else
return -1;
if (rmodule_parse(&stage_region[rmodule_offset], &rmod_stage))
@@ -347,17 +355,35 @@ int rmodule_stage_load(struct rmod_stage_load *rsl, struct cbfs_stage *stage)
return 0;
}
-int rmodule_stage_load_from_cbfs(struct rmod_stage_load *rsl)
+int rmodule_stage_load_from_cbfs(const struct cbfs_descriptor *cbfs,
+ struct rmod_stage_load *rsl)
{
- struct cbfs_stage *stage;
+ const struct cbfs_file_descriptor *fd;
+ struct cbfs_stage stage;
+ size_t rdsz = sizeof(stage);
+ int ret;
+ void *buf;
- stage = cbfs_get_file_content(CBFS_DEFAULT_MEDIA,
- rsl->name, CBFS_TYPE_STAGE, NULL);
+ fd = cbfs_open_by_name_type(cbfs, rsl->name, CBFS_TYPE_STAGE);
- if (stage == NULL)
+ if (fd == NULL)
return -1;
- return rmodule_stage_load(rsl, stage);
+ ret = -1;
+ if (cbfs_file_read_metadata(fd, &stage, 0, rdsz) != rdsz)
+ goto out;
+
+ buf = cbfs_file_map_content(fd, 0, cbfs_file_content_size(fd));
+ if (buf == NULL)
+ goto out;
+
+ ret = rmodule_stage_load(rsl, &stage, buf);
+
+ cbfs_file_unmap(fd, buf);
+
+out:
+ cbfs_file_close(fd);
+ return ret;
}
#endif /* DYNAMIC_CBMEM */
diff --git a/src/lib/selfboot.c b/src/lib/selfboot.c
index feff03e..b6c8797 100644
--- a/src/lib/selfboot.c
+++ b/src/lib/selfboot.c
@@ -25,6 +25,7 @@
#include <stdlib.h>
#include <string.h>
#include <cbfs.h>
+#include <cbfs_core.h>
#include <lib.h>
#include <bootmem.h>
#include <payload_loader.h>
@@ -40,7 +41,7 @@ struct segment {
struct segment *next;
struct segment *prev;
unsigned long s_dstaddr;
- unsigned long s_srcaddr;
+ unsigned long s_srcoffset;
unsigned long s_memsz;
unsigned long s_filesz;
int compression;
@@ -140,7 +141,7 @@ static int relocate_segment(unsigned long buffer, struct segment *seg)
new->s_memsz = len;
seg->s_memsz -= len;
seg->s_dstaddr += len;
- seg->s_srcaddr += len;
+ seg->s_srcoffset += len;
if (seg->s_filesz > len) {
new->s_filesz = len;
seg->s_filesz -= len;
@@ -176,7 +177,7 @@ static int relocate_segment(unsigned long buffer, struct segment *seg)
seg->s_memsz = len;
new->s_memsz -= len;
new->s_dstaddr += len;
- new->s_srcaddr += len;
+ new->s_srcoffset += len;
if (seg->s_filesz > len) {
seg->s_filesz = len;
new->s_filesz -= len;
@@ -213,17 +214,12 @@ static int relocate_segment(unsigned long buffer, struct segment *seg)
static int build_self_segment_list(
- struct segment *head,
+ struct segment *head, struct cbfs_payload_segment *segment,
struct payload *payload, uintptr_t *entry)
{
struct segment *new;
- struct segment *ptr;
- struct cbfs_payload_segment *segment, *first_segment;
- struct cbfs_payload *cbfs_payload;
- cbfs_payload = payload->backing_store.data;
memset(head, 0, sizeof(*head));
head->next = head->prev = head;
- first_segment = segment = &cbfs_payload->segments;
while(1) {
printk(BIOS_DEBUG, "Loading segment from rom address 0x%p\n", segment);
@@ -237,43 +233,39 @@ static int build_self_segment_list(
case PAYLOAD_SEGMENT_DATA:
printk(BIOS_DEBUG, " %s (compression=%x)\n",
segment->type == PAYLOAD_SEGMENT_CODE ? "code" : "data",
- ntohl(segment->compression));
+ segment->compression);
new = malloc(sizeof(*new));
- new->s_dstaddr = ntohll(segment->load_addr);
- new->s_memsz = ntohl(segment->mem_len);
- new->compression = ntohl(segment->compression);
-
- new->s_srcaddr = (uintptr_t)
- ((unsigned char *)first_segment)
- + ntohl(segment->offset);
- new->s_filesz = ntohl(segment->len);
- printk(BIOS_DEBUG, " New segment dstaddr 0x%lx memsize 0x%lx srcaddr 0x%lx filesize 0x%lx\n",
- new->s_dstaddr, new->s_memsz, new->s_srcaddr, new->s_filesz);
+ new->s_dstaddr = segment->load_addr;
+ new->s_memsz = segment->mem_len;
+ new->compression = segment->compression;
+
+ new->s_srcoffset = segment->offset;
+ new->s_filesz = segment->len;
+ printk(BIOS_DEBUG, " New segment dstaddr 0x%lx memsize 0x%lx srcoffset 0x%lx filesize 0x%lx\n",
+ new->s_dstaddr, new->s_memsz, new->s_srcoffset, new->s_filesz);
/* Clean up the values */
if (new->s_filesz > new->s_memsz) {
new->s_filesz = new->s_memsz;
}
printk(BIOS_DEBUG, " (cleaned up) New segment addr 0x%lx size 0x%lx offset 0x%lx filesize 0x%lx\n",
- new->s_dstaddr, new->s_memsz, new->s_srcaddr, new->s_filesz);
+ new->s_dstaddr, new->s_memsz, new->s_srcoffset, new->s_filesz);
break;
case PAYLOAD_SEGMENT_BSS:
- printk(BIOS_DEBUG, " BSS 0x%p (%d byte)\n", (void *)
- (intptr_t)ntohll(segment->load_addr),
- ntohl(segment->mem_len));
+ printk(BIOS_DEBUG, " BSS 0x%p (%d byte)\n",
+ (void *)(intptr_t)segment->load_addr,
+ segment->mem_len);
new = malloc(sizeof(*new));
new->s_filesz = 0;
- new->s_srcaddr = (uintptr_t)
- ((unsigned char *)first_segment)
- + ntohl(segment->offset);
- new->s_dstaddr = ntohll(segment->load_addr);
- new->s_memsz = ntohl(segment->mem_len);
+ new->s_srcoffset = segment->offset;
+ new->s_dstaddr = segment->load_addr;
+ new->s_memsz = segment->mem_len;
break;
case PAYLOAD_SEGMENT_ENTRY:
printk(BIOS_DEBUG, " Entry Point 0x%p\n",
- (void *)(intptr_t)ntohll(segment->load_addr));
- *entry = ntohll(segment->load_addr);
+ (void *)(intptr_t)segment->load_addr);
+ *entry = segment->load_addr;
/* Per definition, a payload always has the entry point
* as last segment. Thus, we use the occurrence of the
* entry point as break condition for the loop.
@@ -292,17 +284,11 @@ static int build_self_segment_list(
/* We have found another CODE, DATA or BSS segment */
segment++;
- /* Find place where to insert our segment */
- for(ptr = head->next; ptr != head; ptr = ptr->next) {
- if (new->s_srcaddr < ntohll(segment->load_addr))
- break;
- }
-
- /* Order by stream offset */
- new->next = ptr;
- new->prev = ptr->prev;
- ptr->prev->next = new;
- ptr->prev = new;
+ /* Add to end of list. */
+ new->next = head;
+ new->prev = head->prev;
+ head->prev->next = new;
+ head->prev = new;
}
return 1;
@@ -315,6 +301,7 @@ static int load_self_segments(
struct segment *ptr;
const unsigned long one_meg = (1UL << 20);
unsigned long bounce_high = lb_end;
+ unsigned char *srcaddr = payload->backing_store.data;
for(ptr = head->next; ptr != head; ptr = ptr->next) {
if (bootmem_region_targets_usable_ram(ptr->s_dstaddr,
@@ -378,7 +365,7 @@ static int load_self_segments(
/* Compute the boundaries of the segment */
dest = (unsigned char *)(ptr->s_dstaddr);
- src = (unsigned char *)(ptr->s_srcaddr);
+ src = srcaddr + ptr->s_srcoffset;
/* Copy data from the initial buffer */
if (ptr->s_filesz) {
@@ -441,13 +428,51 @@ static int load_self_segments(
return 1;
}
+static void
+parse_cbfs_segments(struct cbfs_payload_segment *segments, size_t size)
+{
+ int i;
+ int num;
+
+ num = size / sizeof(struct cbfs_payload_segment);
+
+ for (i = 0; i < num; i++) {
+ /* Note: the type field is in host order. */
+ segments[i].compression = ntohl(segments[i].compression);
+ segments[i].offset = ntohl(segments[i].offset);
+ /* Fix up the offsets to be relative to the data stream. */
+ segments[i].offset -= size;
+ segments[i].load_addr = ntohll(segments[i].load_addr);
+ segments[i].len = ntohl(segments[i].len);
+ segments[i].mem_len = ntohl(segments[i].mem_len);
+ }
+}
+
void *selfload(struct payload *payload)
{
uintptr_t entry = 0;
struct segment head;
+ ssize_t metadata_sz;
+ struct cbfs_payload_segment *segments;
+
+ metadata_sz = cbfs_file_metadata_size(payload->fd);
+
+ if (metadata_sz <= 0)
+ return NULL;
+
+ segments = malloc(sizeof(struct cbfs_payload_segment));
+
+ if (segments == NULL)
+ return NULL;
+
+ if (cbfs_file_read_metadata(payload->fd, segments, 0, metadata_sz) !=
+ metadata_sz)
+ return NULL;
+
+ parse_cbfs_segments(segments, metadata_sz);
/* Preprocess the self segments */
- if (!build_self_segment_list(&head, payload, &entry))
+ if (!build_self_segment_list(&head, segments, payload, &entry))
goto out;
/* Load the segments */
diff --git a/src/soc/intel/baytrail/Kconfig b/src/soc/intel/baytrail/Kconfig
index 2360b36..63b5c89 100644
--- a/src/soc/intel/baytrail/Kconfig
+++ b/src/soc/intel/baytrail/Kconfig
@@ -8,6 +8,7 @@ if SOC_INTEL_BAYTRAIL
config CPU_SPECIFIC_OPTIONS
def_bool y
+ select BOOT_REGION_SPI_FLASH
select CACHE_MRC_SETTINGS
select CAR_MIGRATION
select COLLECT_TIMESTAMPS
diff --git a/src/soc/intel/baytrail/mrc_cache.c b/src/soc/intel/baytrail/mrc_cache.c
index 5613761..784952d 100644
--- a/src/soc/intel/baytrail/mrc_cache.c
+++ b/src/soc/intel/baytrail/mrc_cache.c
@@ -20,6 +20,7 @@
#include <string.h>
#include <console/console.h>
#include <cbmem.h>
+#include <region.h>
#include <ip_checksum.h>
#if CONFIG_CHROMEOS
#include <vendorcode/google/chromeos/fmap.h>
@@ -40,11 +41,20 @@ struct mrc_data_region {
static int mrc_cache_get_region(struct mrc_data_region *region)
{
#if CONFIG_CHROMEOS
- int ret;
- ret = find_fmap_entry("RW_MRC_CACHE", ®ion->base);
- if (ret >= 0) {
- region->size = ret;
- return 0;
+ offset_t offset;
+ size_t size;
+ if (!fmap_locate("RW_MRC_CACHE", &offset, &size)) {
+ void *mapping;
+ rhandle_t rh;
+
+ rh = region_locate(BOOTRO_REGION_NAME);
+ mapping = region_mmap(rh, offset, size);
+
+ if (mapping != NULL) {
+ region->base = mapping;
+ region->size = size;
+ return 0;
+ }
}
#endif
region->base = (void *)CONFIG_MRC_SETTINGS_CACHE_BASE;
diff --git a/src/soc/intel/baytrail/nvm.c b/src/soc/intel/baytrail/nvm.c
index dccc801..44d67ae 100644
--- a/src/soc/intel/baytrail/nvm.c
+++ b/src/soc/intel/baytrail/nvm.c
@@ -24,26 +24,25 @@
#include <spi-generic.h>
#include <spi_flash.h>
#include <baytrail/nvm.h>
+#include <region.h>
/* This module assumes the flash is memory mapped just below 4GiB in the
* address space for reading. Also this module assumes an area it erased
* when all bytes read as all 0xff's. */
-static struct spi_flash *flash;
+static rhandle_t rwrh = INVALID_RHANDLE;
static int nvm_init(void)
{
- if (flash != NULL)
+ if (rhandle_valid(rwrh))
return 0;
- spi_init();
- flash = spi_flash_probe(0, 0, 1000000, SPI_MODE_3);
- if (!flash) {
- printk(BIOS_DEBUG, "Could not find SPI device\n");
- return -1;
- }
+ rwrh = region_locate(BOOTRW_REGION_NAME);
- return 0;
+ if (rhandle_valid(rwrh))
+ return 0;
+
+ return -1;
}
/* Convert memory mapped pointer to flash offset. */
@@ -69,7 +68,10 @@ int nvm_erase(void *start, size_t size)
{
if (nvm_init() < 0)
return -1;
- flash->erase(flash, to_flash_offset(start), size);
+
+ if (region_eraseat(rwrh, to_flash_offset(start), size) != size)
+ return -1;
+
return 0;
}
@@ -78,6 +80,9 @@ int nvm_write(void *start, const void *data, size_t size)
{
if (nvm_init() < 0)
return -1;
- flash->write(flash, to_flash_offset(start), size, data);
+
+ if (region_eraseat(rwrh, to_flash_offset(start), size) != size)
+ return -1;
+
return 0;
}
diff --git a/src/soc/intel/baytrail/romstage/raminit.c b/src/soc/intel/baytrail/romstage/raminit.c
index 7bcd54f..496e755 100644
--- a/src/soc/intel/baytrail/romstage/raminit.c
+++ b/src/soc/intel/baytrail/romstage/raminit.c
@@ -105,6 +105,7 @@ void raminit(struct mrc_params *mp, int prev_sleep_state)
int ret;
mrc_wrapper_entry_t mrc_entry;
const struct mrc_saved_data *cache;
+ const struct cbfs_file_descriptor *fd;
/* Fill in default entries. */
mp->version = MRC_PARAMS_VER;
@@ -118,10 +119,11 @@ void raminit(struct mrc_params *mp, int prev_sleep_state)
printk(BIOS_DEBUG, "No MRC cache found.\n");
}
- mrc_entry = cbfs_get_file_content(CBFS_DEFAULT_MEDIA, "mrc.bin", 0xab,
- NULL);
+ fd = cbfs_open_by_name_type(cbfs_default_descriptor(), "mrc.bin", 0xab);
+ mrc_entry = cbfs_file_map_content(fd, 0, cbfs_file_content_size(fd));
if (mrc_entry == NULL) {
+ cbfs_file_close(fd);
printk(BIOS_DEBUG, "Couldn't find mrc.bin\n");
return;
}
@@ -130,6 +132,9 @@ void raminit(struct mrc_params *mp, int prev_sleep_state)
ret = mrc_entry(mp);
+ cbfs_file_unmap(fd, mrc_entry);
+ cbfs_file_close(fd);
+
print_dram_info();
cbmem_initialize_empty();
diff --git a/src/soc/intel/baytrail/romstage/romstage.c b/src/soc/intel/baytrail/romstage/romstage.c
index 5af9bf4..37aae10 100644
--- a/src/soc/intel/baytrail/romstage/romstage.c
+++ b/src/soc/intel/baytrail/romstage/romstage.c
@@ -29,6 +29,7 @@
#include <ec/google/chromeec/ec.h>
#endif
#include <elog.h>
+#include <region.h>
#include <ramstage_cache.h>
#include <romstage_handoff.h>
#include <timestamp.h>
@@ -133,6 +134,9 @@ void * asmlinkage romstage_main(unsigned long bist,
google_chromeec_early_init();
#endif
+ /* Initialize the boot media. */
+ boot_region_init();
+
/* Call into mainboard. */
mainboard_romstage_entry(&rp);
diff --git a/src/vendorcode/google/chromeos/Makefile.inc b/src/vendorcode/google/chromeos/Makefile.inc
index 007bd57..24afb2c 100644
--- a/src/vendorcode/google/chromeos/Makefile.inc
+++ b/src/vendorcode/google/chromeos/Makefile.inc
@@ -27,6 +27,7 @@ romstage-y += fmap.c
ramstage-y += fmap.c
ramstage-$(CONFIG_CHROMEOS_RAMOOPS) += ramoops.c
smm-y += fmap.c
+smm-y += ../../../lib/region.c
ifneq ($(wildcard src/mainboard/$(MAINBOARDDIR)/chromeos.c),)
ramstage-srcs += src/mainboard/$(MAINBOARDDIR)/chromeos.c
romstage-srcs += src/mainboard/$(MAINBOARDDIR)/chromeos.c
diff --git a/src/vendorcode/google/chromeos/chromeos.c b/src/vendorcode/google/chromeos/chromeos.c
index e917ba1..6f20109 100644
--- a/src/vendorcode/google/chromeos/chromeos.c
+++ b/src/vendorcode/google/chromeos/chromeos.c
@@ -121,10 +121,14 @@ static int vboot_locate_payload(struct payload *payload)
if (buffer == NULL)
return -1;
+#if 0
payload->backing_store.data = buffer;
payload->backing_store.size = size;
return 0;
+#endif
+ /* TODO: fake a cbfs. Also need this in rmodule loading. */
+ return -1;
}
const struct payload_loader_ops vboot_payload_loader = {
diff --git a/src/vendorcode/google/chromeos/fmap.c b/src/vendorcode/google/chromeos/fmap.c
index 538b8c3..fa17e35 100644
--- a/src/vendorcode/google/chromeos/fmap.c
+++ b/src/vendorcode/google/chromeos/fmap.c
@@ -20,97 +20,134 @@
#include <stdint.h>
#include <stddef.h>
#include <string.h>
+#include <arch/early_variables.h>
#include <console/console.h>
+#include <region.h>
#include "fmap.h"
-/* Find FMAP data structure in ROM.
+/*
* See http://code.google.com/p/flashmap/ for more information on FMAP.
*/
-const struct fmap *fmap_find(void)
-{
- /* FIXME: Get rid of the hard codes. The "easy" way would be to
- * do a binary search, but since ROM accesses are slow, we don't
- * want to spend a lot of time looking for the FMAP. An elegant
- * solution would be to store a pointer to the FMAP in the CBFS
- * master header; that would require some more changes to cbfstool
- * and possibly cros_bundle_firmware.
- */
-
- /* wrapping around 0x100000000 */
- const struct fmap *fmap = (void *)
- (CONFIG_FLASHMAP_OFFSET - CONFIG_ROM_SIZE);
- if (memcmp(fmap, FMAP_SIGNATURE, sizeof(FMAP_SIGNATURE)-1)) {
- printk(BIOS_DEBUG, "No FMAP found at %p.\n", fmap);
- return NULL;
- }
+/*
+ * The reason for the global state is that FMAP needs to be available in
+ * romstage on x86 machines. This necessitates keeping some global variables
+ * around because there is no malloc or global modifiable data without being
+ * placed in BSS. This code relies on CAR globals being migrated in romstage.
+ */
- printk(BIOS_DEBUG, "FMAP: Found \"%s\" version %d.%d at %p.\n",
- fmap->name, fmap->ver_major, fmap->ver_minor, fmap);
- printk(BIOS_DEBUG, "FMAP: base = %llx size = %x #areas = %d\n",
- (unsigned long long)fmap->base, fmap->size, fmap->nareas);
+#define FMAP_REGION_NAME "fmap"
+
+struct fmap_state {
+ int registered;
+ int num_entries;
+};
+
+static struct fmap_state g_fmap_state CAR_GLOBAL;
+static const offset_t fmap_offset = CONFIG_FLASHMAP_OFFSET;
- return fmap;
+static inline struct fmap_state *get_state(void)
+{
+ return car_get_var_ptr(&g_fmap_state);
}
-const struct fmap_area *find_fmap_area(const struct fmap *fmap,
- const char name[])
+static const struct region_device fmap_rdev = {
+ .region = {
+ .offset = 0,
+ .size = CONFIG_ROM_SIZE,
+ },
+};
+
+/* Return < 0 on failure, 0 on success */
+static int fmap_init(void)
{
- const struct fmap_area *area = NULL;
-
- if (fmap) {
- int i;
- for (i = 0; i < fmap->nareas; i++) {
- if (!strcmp((const char *)fmap->areas[i].name, name)) {
- area = &fmap->areas[i];
- break;
- }
- }
- }
+ struct fmap_state *gs;
+ rhandle_t rh;
+ struct fmap *fmap;
- if (area) {
- printk(BIOS_DEBUG, "FMAP: area %s found\n", name);
- printk(BIOS_DEBUG, "FMAP: offset: %x\n", area->offset);
- printk(BIOS_DEBUG, "FMAP: size: %d bytes\n", area->size);
- } else {
- printk(BIOS_DEBUG, "FMAP: area %s not found\n", name);
+ gs = get_state();
+
+ if (gs->registered)
+ return 1;
+
+ /* Execute this function only once. Default to invalid. */
+ gs->registered = 1;
+ rh = region_locate(BOOTRO_REGION_NAME);
+
+ if (!rhandle_valid(rh))
+ return -1;
+
+ fmap = region_mmap(rh, fmap_offset, sizeof(*fmap));
+
+ if (fmap == NULL)
+ return -1;
+
+ if (memcmp(fmap, FMAP_SIGNATURE, sizeof(FMAP_SIGNATURE)-1)) {
+ printk(BIOS_DEBUG, "No FMAP found at %zx.\n", fmap_offset);
+ region_munmap(rh, fmap);
+ return -1;
}
+ printk(BIOS_DEBUG, "FMAP: Found \"%s\" version %d.%d at %zx.\n",
+ fmap->name, fmap->ver_major, fmap->ver_minor, fmap_offset);
+ printk(BIOS_DEBUG, "FMAP: base = %llx size = %x #areas = %d\n",
+ (unsigned long long)fmap->base, fmap->size, fmap->nareas);
+
+ gs->num_entries = fmap->nareas;
+ region_munmap(rh, fmap);
- return area;
+ /* Register fmap device under the boot region. */
+ if (!rhandle_valid(region_register_subregion(FMAP_REGION_NAME,
+ &fmap_rdev, rh)))
+ return -1;
+
+ return 0;
}
-int find_fmap_entry(const char name[], void **pointer)
+int fmap_locate(const char *name, offset_t *offset, size_t *size)
{
-#ifndef __PRE_RAM__
- static
-#endif
- const struct fmap *fmap = NULL;
- const struct fmap_area *area;
- void *base = NULL;
+ rhandle_t rh;
+ struct fmap_area *areas;
+ struct fmap_state * gs;
+ int i;
+ int ret = -1;
- if (!fmap)
- fmap = fmap_find();
+ rh = region_locate(FMAP_REGION_NAME);
+ gs = get_state();
- area = find_fmap_area(fmap, name);
+ if (!rhandle_valid(rh) || gs == NULL)
+ return ret;
- if (!area)
- return -1;
+ areas = region_mmap(rh, sizeof(struct fmap) + fmap_offset,
+ gs->num_entries * sizeof(*areas));
- /* Right now cros_bundle_firmware does not write a valid
- * base address into the FMAP. Hence, if base is 0, assume
- * 4GB-8MB as base address.
- */
- if (fmap->base) {
- base = (void *)(unsigned long)fmap->base;
- printk(BIOS_DEBUG, "FMAP: %s base at %p\n", name, base);
- } else {
- base = (void *)(0 - CONFIG_ROM_SIZE);
- printk(BIOS_WARNING, "FMAP: No valid base address, using"
- " 0x%p\n", base);
+ if (areas == NULL) {
+ printk(BIOS_DEBUG, "FMAP: could not map areas.\n");
+ return ret;
}
- *pointer = (void*) ((u32)base + area->offset);
- printk(BIOS_DEBUG, "FMAP: %s at %p (offset %x)\n",
- name, *pointer, area->offset);
- return area->size;
+ for (i = 0; i < gs->num_entries; i++) {
+ if (strcmp((char *)&areas[i].name[0], name))
+ continue;
+ printk(BIOS_DEBUG, "FMAP: area %s found\n", name);
+ printk(BIOS_DEBUG, "FMAP: offset: %x\n", areas[i].offset);
+ printk(BIOS_DEBUG, "FMAP: size: %d bytes\n", areas[i].size);
+
+ *offset = areas[i].offset;
+ *size = areas[i].size;
+ ret = 0;
+ break;
+ }
+
+ if (ret)
+ printk(BIOS_DEBUG, "FMAP: area '%s' not found.\n", name);
+
+ region_munmap(rh, areas);
+
+ return ret;
+}
+
+void fmap_initialize(void)
+{
+ if (fmap_init() < 0)
+ printk(BIOS_DEBUG, "FMAP region wasn't registered.\n");
}
diff --git a/src/vendorcode/google/chromeos/fmap.h b/src/vendorcode/google/chromeos/fmap.h
index a3d2abd..de935e7 100644
--- a/src/vendorcode/google/chromeos/fmap.h
+++ b/src/vendorcode/google/chromeos/fmap.h
@@ -37,6 +37,7 @@
#define FLASHMAP_LIB_FMAP_H__
#include <stdint.h>
+#include <region.h>
#define FMAP_SIGNATURE "__FMAP__"
#define FMAP_VER_MAJOR 1 /* this header's FMAP minor version */
@@ -70,10 +71,24 @@ struct fmap {
struct fmap_area areas[];
} __attribute__((packed));
+#if IS_ENABLED(CONFIG_CHROMEOS)
+/*
+ * Initialize the fmap state within coreboot.
+ */
+void fmap_initialize(void);
+
+/*
+ * Locate a region by name within the fmap. offset and size are filled in
+ * relative to the boot media the global fmap is located. Returns 0 on
+ * success, < 0 when unable to find the region.
+ */
+int fmap_locate(const char *name, offset_t *offset, size_t *size);
+#else /* IS_ENABLED(CONFIG_CHROMEOS) */
+static inline void fmap_initialize(void) {}
+static inline int fmap_locate(const char *name, offset_t *offset, size_t *size)
+{
+ return -1;
+}
+#endif /* IS_ENABLED(CONFIG_CHROMEOS) */
-/* coreboot specific function prototypes */
-const struct fmap *fmap_find(void);
-const struct fmap_area *find_fmap_area(const struct fmap *fmap,
- const char name[]);
-int find_fmap_entry(const char name[], void **pointer);
#endif /* FLASHMAP_LIB_FMAP_H__*/
diff --git a/src/vendorcode/google/chromeos/vboot_loader.c b/src/vendorcode/google/chromeos/vboot_loader.c
index 0c5220a..98bc1a5 100644
--- a/src/vendorcode/google/chromeos/vboot_loader.c
+++ b/src/vendorcode/google/chromeos/vboot_loader.c
@@ -21,6 +21,7 @@
#include <stdint.h>
#include <stddef.h>
#include <cbfs.h>
+#include <cbfs_core.h>
#include <cbmem.h>
#include <console/console.h>
#include <console/vtxprintf.h>
@@ -45,7 +46,8 @@ static void vboot_run_stub(struct vboot_context *context)
};
void (*entry)(struct vboot_context *context);
- if (rmodule_stage_load_from_cbfs(&rmod_stage)) {
+ if (rmodule_stage_load_from_cbfs(cbfs_default_descriptor(),
+ &rmod_stage)) {
printk(BIOS_DEBUG, "Could not load vboot stub.\n");
goto out;
}
@@ -74,6 +76,30 @@ static void fatal_error(void)
hard_reset();
}
+static void locate_region(const char *name, void **parea, uint32_t *psize)
+{
+ offset_t offset;
+ size_t size;
+ rhandle_t rh;
+
+ *psize = 0;
+ *parea = NULL;
+
+ if (fmap_locate(name, &offset, &size))
+ return;
+
+ rh = region_locate(BOOTRO_REGION_NAME);
+ if (!rhandle_valid(rh))
+ return;
+
+ /*
+ * This leaks the mappings on anything but x86 systems which have
+ * CBFS memory-mapped.
+ */
+ *psize = size;
+ *parea = region_mmap(rh, offset, size);
+}
+
static void vboot_invoke_wrapper(struct vboot_handoff *vboot_handoff)
{
VbCommonParams cparams;
@@ -105,20 +131,17 @@ static void vboot_invoke_wrapper(struct vboot_handoff *vboot_handoff)
context.cparams = &cparams;
context.fparams = &fparams;
- cparams.gbb_size = find_fmap_entry("GBB", &cparams.gbb_data);
+ locate_region("GBB", &cparams.gbb_data, &cparams.gbb_size);
cparams.shared_data_blob = &vboot_handoff->shared_data[0];
cparams.shared_data_size = VB_SHARED_DATA_MIN_SIZE;
cparams.caller_context = &context;
- fparams.verification_size_A =
- find_fmap_entry("VBLOCK_A", &fparams.verification_block_A);
- fparams.verification_size_B =
- find_fmap_entry("VBLOCK_B", &fparams.verification_block_B);
-
- context.fw_a_size =
- find_fmap_entry("FW_MAIN_A", (void **)&context.fw_a);
- context.fw_b_size =
- find_fmap_entry("FW_MAIN_B", (void **)&context.fw_b);
+ locate_region("VBLOCK_A", &fparams.verification_block_A,
+ &fparams.verification_size_A);
+ locate_region("VBLOCK_B", &fparams.verification_block_B,
+ &fparams.verification_size_B);
+ locate_region("FW_MAIN_A", (void **)&context.fw_a, &context.fw_a_size);
+ locate_region("FW_MAIN_B", (void **)&context.fw_b, &context.fw_b_size);
/* Check all fmap entries. */
if (context.fw_a == NULL || context.fw_b == NULL ||
@@ -195,7 +218,7 @@ static void *vboot_load_ramstage(uint32_t cbmem_id, const char *name,
stage = (void *)fwc->address;
- if (rmodule_stage_load(&rmod_load, stage)) {
+ if (rmodule_stage_load(&rmod_load, stage, &stage[1])) {
vboot_handoff->selected_firmware = VB_SELECT_FIRMWARE_READONLY;
printk(BIOS_DEBUG, "Could not load ramstage region.\n");
return NULL;
1
0
Patch set updated for coreboot: 72cd44d util: add rmodtool for parsing ELF files to rmodules
by Stefan Reinauer 18 Mar '14
by Stefan Reinauer 18 Mar '14
18 Mar '14
Stefan Reinauer (stefan.reinauer(a)coreboot.org) just uploaded a new patch set to gerrit, which you can find at http://review.coreboot.org/5378
-gerrit
commit 72cd44dea771ac9788b0c3d2aa693ffaf3faa7d1
Author: Aaron Durbin <adurbin(a)chromium.org>
Date: Fri Mar 7 15:11:53 2014 -0600
util: add rmodtool for parsing ELF files to rmodules
The current implementation of creating rmodules relies
on the invoking the linker in a certain manner with
the relocations overlaid on the BSS section. It's not
really surprising that the linker doesn't always behave
the way one wants depending on the linker used and
the architecture. Instead, introduce rmodtool which takes
an elf file as an input, parses it, and creates a new elf
file in the format the rmodule loader expects.
Change-Id: I31ac2d327d450ef841c3a7d9740b787278382bef
Signed-off-by: Aaron Durbin <adurbin(a)chromium.org>
---
.gitignore | 1 +
util/cbfstool/Makefile | 30 ++-
util/cbfstool/Makefile.inc | 22 +-
util/cbfstool/rmodtool.c | 106 ++++++++
util/cbfstool/rmodule.c | 629 +++++++++++++++++++++++++++++++++++++++++++++
util/cbfstool/rmodule.h | 30 +++
6 files changed, 802 insertions(+), 16 deletions(-)
diff --git a/.gitignore b/.gitignore
index 96af4a6..b37c195 100644
--- a/.gitignore
+++ b/.gitignore
@@ -59,6 +59,7 @@ util/*/.dependencies
util/*/.test
util/board_status/board-status
util/cbfstool/cbfstool
+util/cbfstool/rmodtool
util/cbmem/.dependencies
util/cbmem/cbmem
util/dumpmmcr/dumpmmcr
diff --git a/util/cbfstool/Makefile b/util/cbfstool/Makefile
index bc49c64..e647c88 100644
--- a/util/cbfstool/Makefile
+++ b/util/cbfstool/Makefile
@@ -8,30 +8,40 @@ CFLAGS += -Wstrict-aliasing -Werror
CFLAGS += -Wshadow
LDFLAGS += -g
-BINARY:=$(obj)/cbfstool
+CBFSTOOL_BINARY:=$(obj)/cbfstool
-COMMON:=cbfstool.o common.o cbfs_image.o compress.o fit.o
-COMMON+=elfheaders.o cbfs-mkstage.o cbfs-mkpayload.o xdr.o
+CBFSTOOL_COMMON:=cbfstool.o common.o cbfs_image.o compress.o fit.o
+CBFSTOOL_COMMON+=elfheaders.o cbfs-mkstage.o cbfs-mkpayload.o xdr.o
# LZMA
-COMMON+=lzma/lzma.o
-COMMON+=lzma/C/LzFind.o lzma/C/LzmaDec.o lzma/C/LzmaEnc.o
+CBFSTOOL_COMMON+=lzma/lzma.o
+CBFSTOOL_COMMON+=lzma/C/LzFind.o lzma/C/LzmaDec.o lzma/C/LzmaEnc.o
-COMMON+=linux_trampoline.o cbfs-payload-linux.o
+CBFSTOOL_COMMON+=linux_trampoline.o cbfs-payload-linux.o
-COMMON:=$(addprefix $(obj)/,$(COMMON))
+CBFSTOOL_COMMON:=$(addprefix $(obj)/,$(CBFSTOOL_COMMON))
-all: dep $(BINARY)
+
+RMODTOOL_BINARY:=$(obj)/rmodtool
+RMODTOOL_COMMON:=rmodtool.o rmodule.o common.o elfheaders.o xdr.o
+
+RMODTOOL_COMMON:=$(addprefix $(obj)/,$(RMODTOOL_COMMON))
+
+all: dep $(CBFSTOOL_BINARY) $(RMODTOOL_BINARY)
$(obj)/%.o: %.c
$(HOSTCC) $(CFLAGS) -c -o $@ $<
clean:
- rm -f $(COMMON) $(BINARY)
+ rm -f $(CBFSTOOL_COMMON) $(CBFSTOOL_BINARY)
+ rm -f $(RMODTOOL_COMMON) $(RMODTOOL_BINARY)
tags:
ctags *.[ch]
-$(obj)/cbfstool:$(COMMON)
+$(obj)/cbfstool:$(CBFSTOOL_COMMON)
+ $(HOSTCC) $(CFLAGS) -o $@ $^
+
+$(obj)/rmodtool:$(RMODTOOL_COMMON)
$(HOSTCC) $(CFLAGS) -o $@ $^
dep:
diff --git a/util/cbfstool/Makefile.inc b/util/cbfstool/Makefile.inc
index c19b7d9..2923938 100644
--- a/util/cbfstool/Makefile.inc
+++ b/util/cbfstool/Makefile.inc
@@ -17,10 +17,16 @@ cbfsobj += LzmaEnc.o
cbfsobj += linux_trampoline.o
cbfsobj += cbfs-payload-linux.o
-CBFSTOOLFLAGS= -g
+rmodobj += rmodtool.o
+rmodobj += rmodule.o
+rmodobj += common.o
+rmodobj += elfheaders.o
+rmodobj += xdr.o
+
+TOOLFLAGS= -g
ifeq ($(shell uname -s | cut -c-7 2>/dev/null), MINGW32)
-CBFSTOOLFLAGS+=-mno-ms-bitfields
+TOOLFLAGS+=-mno-ms-bitfields
endif
$(objutil)/cbfstool:
@@ -28,17 +34,21 @@ $(objutil)/cbfstool:
$(objutil)/cbfstool/%.o: $(top)/util/cbfstool/%.c
printf " HOSTCC $(subst $(objutil)/,,$(@))\n"
- $(HOSTCC) $(CBFSTOOLFLAGS) $(HOSTCFLAGS) -c -o $@ $<
+ $(HOSTCC) $(TOOLFLAGS) $(HOSTCFLAGS) -c -o $@ $<
$(objutil)/cbfstool/%.o: $(top)/util/cbfstool/lzma/%.c
printf " HOSTCC $(subst $(objutil)/,,$(@))\n"
- $(HOSTCC) $(CBFSTOOLFLAGS) $(HOSTCFLAGS) -c -o $@ $<
+ $(HOSTCC) $(TOOLFLAGS) $(HOSTCFLAGS) -c -o $@ $<
$(objutil)/cbfstool/%.o: $(top)/util/cbfstool/lzma/C/%.c
printf " HOSTCC $(subst $(objutil)/,,$(@))\n"
- $(HOSTCC) $(CBFSTOOLFLAGS) $(HOSTCFLAGS) -c -o $@ $<
+ $(HOSTCC) $(TOOLFLAGS) $(HOSTCFLAGS) -c -o $@ $<
$(objutil)/cbfstool/cbfstool: $(objutil)/cbfstool $(addprefix $(objutil)/cbfstool/,$(cbfsobj))
printf " HOSTCC $(subst $(objutil)/,,$(@)) (link)\n"
- $(HOSTCC) $(CBFSTOOLFLAGS) -o $@ $(addprefix $(objutil)/cbfstool/,$(cbfsobj))
+ $(HOSTCC) $(TOOLFLAGS) -o $@ $(addprefix $(objutil)/cbfstool/,$(cbfsobj))
+
+$(objutil)/cbfstool/rmodtool: $(objutil)/cbfstool $(addprefix $(objutil)/cbfstool/,$(rmodobj))
+ printf " HOSTCC $(subst $(objutil)/,,$(@)) (link)\n"
+ $(HOSTCC) $(TOOLFLAGS) -o $@ $(addprefix $(objutil)/cbfstool/,$(rmodobj))
diff --git a/util/cbfstool/rmodtool.c b/util/cbfstool/rmodtool.c
new file mode 100644
index 0000000..1455cd9
--- /dev/null
+++ b/util/cbfstool/rmodtool.c
@@ -0,0 +1,106 @@
+/*
+ * cbfstool, CLI utility for creating rmodules
+ *
+ * Copyright (C) 2014 Google, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <getopt.h>
+#include "common.h"
+#include "rmodule.h"
+
+static const char *optstring = "i:o:vh?";
+static struct option long_options[] = {
+ {"inelf", required_argument, 0, 'i' },
+ {"outelf", required_argument, 0, 'o' },
+ {"verbose", no_argument, 0, 'v' },
+ {"help", no_argument, 0, 'h' },
+ {NULL, 0, 0, 0 }
+};
+
+static void usage(char *name)
+{
+ printf(
+ "rmodtool: utility for creating rmodules\n\n"
+ "USAGE: %s [-h] [-v] <-i|--inelf name> <-o|--outelf name>\n",
+ name
+ );
+}
+
+int main(int argc, char *argv[])
+{
+ int c;
+ struct buffer elfin;
+ struct buffer elfout;
+ const char *input_file = NULL;
+ const char *output_file = NULL;
+
+ if (argc < 3) {
+ usage(argv[0]);
+ return 1;
+ }
+
+ while (1) {
+ int optindex = 0;
+
+ c = getopt_long(argc, argv, optstring, long_options, &optindex);
+
+ if (c == -1)
+ break;
+
+ switch (c) {
+ case 'i':
+ input_file = optarg;
+ break;
+ case 'h':
+ usage(argv[0]);
+ return 1;
+ case 'o':
+ output_file = optarg;
+ break;
+ case 'v':
+ verbose++;
+ break;
+ default:
+ break;
+ }
+ }
+
+ if (input_file == NULL || output_file == NULL) {
+ usage(argv[0]);
+ return 1;
+ }
+
+ if (buffer_from_file(&elfin, input_file)) {
+ ERROR("Couldn't read in file '%s'.\n", input_file);
+ return 1;
+ }
+
+ if (rmodule_create(&elfin, &elfout)) {
+ ERROR("Unable to create rmodule from '%s'.\n", input_file);
+ return 1;
+ }
+
+ if (buffer_write_file(&elfout, output_file)) {
+ ERROR("Unable to write rmodule elf '%s'.\n", output_file);
+ return 1;
+ }
+
+ return 0;
+}
diff --git a/util/cbfstool/rmodule.c b/util/cbfstool/rmodule.c
new file mode 100644
index 0000000..a901d7a
--- /dev/null
+++ b/util/cbfstool/rmodule.c
@@ -0,0 +1,629 @@
+/*
+ ;* Copyright (C) 2014 Google, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "elfparsing.h"
+#include "rmodule.h"
+#include "../../src/include/rmodule-defs.h"
+
+struct rmod_context;
+
+struct arch_ops {
+ int arch;
+ /* Determine if relocation is a valid type for the architecture. */
+ int (*valid_type)(struct rmod_context *ctx, Elf64_Rela *rel);
+ /* Determine if relocation should be emitted. */
+ int (*should_emit)(struct rmod_context *ctx, Elf64_Rela *rel);
+};
+
+struct rmod_context {
+ /* Ops to process relocations. */
+ struct arch_ops *ops;
+
+ /* endian conversion ops */
+ struct xdr *xdr;
+
+ /* Parsed ELF sturcture. */
+ struct parsed_elf pelf;
+ /* Program segment. */
+ Elf64_Phdr *phdr;
+
+ /* Collection of relocation addresses fixup in the module. */
+ Elf64_Xword nrelocs;
+ Elf64_Addr *emitted_relocs;
+
+ /* The following fields are addresses within the linked program. */
+ Elf64_Addr link_addr;
+ Elf64_Addr entry;
+ Elf64_Addr parameters_begin;
+ Elf64_Addr parameters_end;
+ Elf64_Addr bss_begin;
+ Elf64_Addr bss_end;
+ Elf64_Xword size;
+};
+
+/*
+ * Architecture specific support operations.
+ */
+static int valid_reloc_386(struct rmod_context *ctx, Elf64_Rela *rel)
+{
+ int type;
+
+ type = ELF64_R_TYPE(rel->r_info);
+
+ /* Only these 2 relocations are expected to be found. */
+ return (type == R_386_32 || type == R_386_PC32);
+}
+
+static int should_emit_386(struct rmod_context *ctx, Elf64_Rela *rel)
+{
+ int type;
+
+ type = ELF64_R_TYPE(rel->r_info);
+
+ /* R_386_32 relocations are absolute. Must emit these. */
+ return (type == R_386_32);
+}
+
+static struct arch_ops reloc_ops[] = {
+ {
+ .arch = EM_386,
+ .valid_type = valid_reloc_386,
+ .should_emit = should_emit_386,
+ },
+};
+
+/*
+ * Relocation processing loops.
+ */
+
+static int for_each_reloc(struct rmod_context *ctx, int do_emit)
+{
+ Elf64_Half i;
+ struct parsed_elf *pelf = &ctx->pelf;
+
+ for (i = 0; i < pelf->ehdr.e_shnum; i++) {
+ Elf64_Shdr *shdr;
+ Elf64_Rela *relocs;
+ Elf64_Xword nrelocs;
+ Elf64_Xword j;
+
+ relocs = pelf->relocs[i];
+
+ /* No relocations in this section. */
+ if (relocs == NULL)
+ continue;
+
+ shdr = &pelf->shdr[i];
+ nrelocs = shdr->sh_size / shdr->sh_entsize;
+
+ for (j = 0; j < nrelocs; j++) {
+ Elf64_Rela *r = &relocs[j];
+
+ if (!ctx->ops->valid_type(ctx, r)) {
+ ERROR("Invalid reloc type: %u\n",
+ (unsigned int)ELF64_R_TYPE(r->r_info));
+ return -1;
+ }
+
+ if (ctx->ops->should_emit(ctx, r)) {
+ int n = ctx->nrelocs;
+ if (do_emit)
+ ctx->emitted_relocs[n] = r->r_offset;
+ ctx->nrelocs++;
+ }
+ }
+ }
+
+ return 0;
+}
+
+static int find_program_segment(struct rmod_context *ctx)
+{
+ int i;
+ int nsegments;
+ struct parsed_elf *pelf;
+ Elf64_Phdr *phdr;
+
+ pelf = &ctx->pelf;
+
+ /* There should only be a single loadable segment. */
+ nsegments = 0;
+ for (i = 0; i < pelf->ehdr.e_phnum; i++) {
+ if (pelf->phdr[i].p_type != PT_LOAD)
+ continue;
+ phdr = &pelf->phdr[i];
+ nsegments++;
+ }
+
+ if (nsegments != 1) {
+ ERROR("Unexepcted number of loadable segments: %d.\n",
+ nsegments);
+ return -1;
+ }
+
+ INFO("Segment at 0x%0llx, file size 0x%0llx, mem size 0x%0llx.\n",
+ (long long)phdr->p_vaddr, (long long)phdr->p_filesz,
+ (long long)phdr->p_memsz);
+
+ ctx->phdr = phdr;
+
+ return 0;
+}
+
+static int
+filter_relocation_sections(struct rmod_context *ctx)
+{
+ int i;
+ const char *shstrtab;
+ struct parsed_elf *pelf;
+ const Elf64_Phdr *phdr;
+
+ pelf = &ctx->pelf;
+ phdr = ctx->phdr;
+ shstrtab = buffer_get(pelf->strtabs[pelf->ehdr.e_shstrndx]);
+
+ /*
+ * Find all relocation sections that contain relocation entries
+ * for sections that fall within the bounds of the segment. For
+ * easier processing the pointer to the relocation array for the
+ * sections that don't fall within the loadable program are NULL'd
+ * out.
+ */
+ for (i = 0; i < pelf->ehdr.e_shnum; i++) {
+ Elf64_Shdr *shdr;
+ Elf64_Word sh_info;
+ const char *section_name;
+
+ shdr = &pelf->shdr[i];
+
+ /* Ignore non-relocation sections. */
+ if (shdr->sh_type != SHT_RELA && shdr->sh_type != SHT_REL)
+ continue;
+
+ /* Obtain section which relocations apply. */
+ sh_info = shdr->sh_info;
+ shdr = &pelf->shdr[sh_info];
+
+ section_name = &shstrtab[shdr->sh_name];
+ DEBUG("Relocation section found for '%s' section.\n",
+ section_name);
+
+ /* Do not process relocations for debug sections. */
+ if (strstr(section_name, ".debug") != NULL) {
+ pelf->relocs[i] = NULL;
+ continue;
+ }
+
+ /*
+ * If relocations apply to a non program section ignore the
+ * relocations for future processing.
+ */
+ if (shdr->sh_type != SHT_PROGBITS) {
+ pelf->relocs[i] = NULL;
+ continue;
+ }
+
+ if (shdr->sh_addr < phdr->p_vaddr ||
+ ((shdr->sh_addr + shdr->sh_size) >
+ (phdr->p_vaddr + phdr->p_memsz))) {
+ ERROR("Relocations being applied to section %d not "
+ "within segment region.\n", sh_info);
+ return -1;
+ }
+ }
+
+ return 0;
+}
+
+static int vaddr_cmp(const void *a, const void *b)
+{
+ const Elf64_Addr *pa = a;
+ const Elf64_Addr *pb = b;
+
+ if (*pa < *pb)
+ return -1;
+ if (*pa > *pb)
+ return 1;
+ return 0;
+}
+
+static int collect_relocations(struct rmod_context *ctx)
+{
+ int nrelocs;
+
+ /*
+ * The relocs array in the pelf should only contain relocations that
+ * apply to the program. Count the number relocations. Then collect
+ * them into the allocated buffer.
+ */
+ if (for_each_reloc(ctx, 0))
+ return -1;
+
+ nrelocs = ctx->nrelocs;
+ INFO("%d relocations to be emitted.\n", nrelocs);
+ if (!nrelocs) {
+ ERROR("No valid relocations in file.\n");
+ return -1;
+ }
+
+ /* Reset the counter for indexing into the array. */
+ ctx->nrelocs = 0;
+ ctx->emitted_relocs = calloc(nrelocs, sizeof(Elf64_Addr));
+ /* Write out the relocations into the emitted_relocs array. */
+ if (for_each_reloc(ctx, 1))
+ return -1;
+
+ if (ctx->nrelocs != nrelocs) {
+ ERROR("Mismatch counted and emitted relocations: %zu vs %zu.\n",
+ (size_t)nrelocs, (size_t)ctx->nrelocs);
+ return -1;
+ }
+
+ /* Sort the relocations by their address. */
+ qsort(ctx->emitted_relocs, nrelocs, sizeof(Elf64_Addr), vaddr_cmp);
+
+ return 0;
+}
+
+static int
+populate_sym(struct rmod_context *ctx, const char *sym_name, Elf64_Addr *addr,
+ int nsyms, const char *strtab)
+{
+ int i;
+ Elf64_Sym *syms;
+
+ syms = ctx->pelf.syms;
+
+ for (i = 0; i < nsyms; i++) {
+ if (syms[i].st_name == 0)
+ continue;
+ if (strcmp(sym_name, &strtab[syms[i].st_name]))
+ continue;
+ DEBUG("%s -> 0x%llx\n", sym_name, (long long)syms[i].st_value);
+ *addr = syms[i].st_value;
+ return 0;
+ }
+ ERROR("symbol '%s' not found.\n", sym_name);
+ return -1;
+}
+
+static int populate_program_info(struct rmod_context *ctx)
+{
+ int i;
+ const char *strtab;
+ struct parsed_elf *pelf;
+ Elf64_Ehdr *ehdr;
+ int nsyms;
+
+ pelf = &ctx->pelf;
+ ehdr = &pelf->ehdr;
+
+ /* Obtain the string table. */
+ strtab = NULL;
+ for (i = 0; i < ehdr->e_shnum; i++) {
+ if (ctx->pelf.strtabs[i] == NULL)
+ continue;
+ /* Don't use the section headers' string table. */
+ if (i == ehdr->e_shstrndx)
+ continue;
+ strtab = buffer_get(ctx->pelf.strtabs[i]);
+ break;
+ }
+
+ if (strtab == NULL) {
+ ERROR("No string table found.\n");
+ return -1;
+ }
+
+ /* Determine number of symbols. */
+ nsyms = 0;
+ for (i = 0; i < ehdr->e_shnum; i++) {
+ if (pelf->shdr[i].sh_type != SHT_SYMTAB)
+ continue;
+
+ nsyms = pelf->shdr[i].sh_size / pelf->shdr[i].sh_entsize;
+ break;
+ }
+
+ if (populate_sym(ctx, "_module_params_begin", &ctx->parameters_begin,
+ nsyms, strtab))
+ return -1;
+
+ if (populate_sym(ctx, "_module_params_end", &ctx->parameters_end,
+ nsyms, strtab))
+ return -1;
+
+ if (populate_sym(ctx, "_bss", &ctx->bss_begin, nsyms, strtab))
+ return -1;
+
+ if (populate_sym(ctx, "_ebss", &ctx->bss_end, nsyms, strtab))
+ return -1;
+
+ if (populate_sym(ctx, "__rmodule_entry", &ctx->entry, nsyms, strtab))
+ return -1;
+
+ /* Link address is the virtual address of the program segment. */
+ ctx->link_addr = ctx->phdr->p_vaddr;
+
+ /* The program size is the memsz of the program segment. */
+ ctx->size = ctx->phdr->p_memsz;
+
+ return 0;
+}
+
+static int
+add_section(struct elf_writer *ew, struct buffer *data, const char *name,
+ Elf64_Addr addr, Elf64_Word size)
+{
+ Elf64_Shdr shdr;
+ int ret;
+
+ memset(&shdr, 0, sizeof(shdr));
+ if (data != NULL) {
+ shdr.sh_type = SHT_PROGBITS;
+ shdr.sh_flags = SHF_ALLOC | SHF_WRITE | SHF_EXECINSTR;
+ } else {
+ shdr.sh_type = SHT_NOBITS;
+ shdr.sh_flags = SHF_ALLOC;
+ }
+ shdr.sh_addr = addr;
+ shdr.sh_offset = addr;
+ shdr.sh_size = size;
+
+ ret = elf_writer_add_section(ew, &shdr, data, name);
+
+ if (ret)
+ ERROR("Could not add '%s' section.\n", name);
+
+ return ret;
+}
+
+static int
+write_elf(const struct rmod_context *ctx, const struct buffer *in,
+ struct buffer *out)
+{
+ int i;
+ int ret;
+ int bit64;
+ size_t loc;
+ size_t rmod_data_size;
+ struct elf_writer *ew;
+ struct buffer rmod_data;
+ struct buffer rmod_header;
+ struct buffer program;
+ struct buffer relocs;
+ Elf64_Xword total_size;
+ Elf64_Addr addr;
+ Elf64_Ehdr ehdr;
+
+ bit64 = ctx->pelf.ehdr.e_ident[EI_CLASS] == ELFCLASS64;
+
+ /*
+ * 3 sections will be added to the ELF file.
+ * +------------------+
+ * | rmodule header |
+ * +------------------+
+ * | program |
+ * +------------------+
+ * | relocations |
+ * +------------------+
+ */
+
+ /* Create buffer for header and relocations. */
+ rmod_data_size = sizeof(struct rmodule_header);
+ if (bit64)
+ rmod_data_size += ctx->nrelocs * sizeof(Elf64_Addr);
+ else
+ rmod_data_size += ctx->nrelocs * sizeof(Elf32_Addr);
+
+ if (buffer_create(&rmod_data, rmod_data_size, "rmod"))
+ return -1;
+
+ buffer_splice(&rmod_header, &rmod_data,
+ 0, sizeof(struct rmodule_header));
+ buffer_clone(&relocs, &rmod_data);
+ buffer_seek(&relocs, sizeof(struct rmodule_header));
+
+ /* Reset current location. */
+ buffer_set_size(&rmod_header, 0);
+ buffer_set_size(&relocs, 0);
+
+ /* Program contents. */
+ buffer_splice(&program, in, ctx->phdr->p_offset, ctx->phdr->p_filesz);
+
+ /* Create ELF writer with modified entry point. */
+ memcpy(&ehdr, &ctx->pelf.ehdr, sizeof(ehdr));
+ ehdr.e_entry = ctx->entry;
+ ew = elf_writer_init(&ehdr);
+
+ if (ew == NULL) {
+ ERROR("Failed to create ELF writer.\n");
+ buffer_delete(&rmod_data);
+ return -1;
+ }
+
+ /* Write out rmodule_header. */
+ ctx->xdr->put16(&rmod_header, RMODULE_MAGIC);
+ ctx->xdr->put8(&rmod_header, RMODULE_VERSION_1);
+ ctx->xdr->put8(&rmod_header, 0);
+ /* payload_begin_offset */
+ loc = sizeof(struct rmodule_header);
+ ctx->xdr->put32(&rmod_header, loc);
+ /* payload_end_offset */
+ loc += ctx->phdr->p_filesz;
+ ctx->xdr->put32(&rmod_header, loc);
+ /* relocations_begin_offset */
+ ctx->xdr->put32(&rmod_header, loc);
+ /* relocations_end_offset */
+ if (bit64)
+ loc += ctx->nrelocs * sizeof(Elf64_Addr);
+ else
+ loc += ctx->nrelocs * sizeof(Elf32_Addr);
+ ctx->xdr->put32(&rmod_header, loc);
+ /* module_link_start_address */
+ ctx->xdr->put32(&rmod_header, ctx->link_addr);
+ /* module_program_size */
+ ctx->xdr->put32(&rmod_header, ctx->size);
+ /* module_entry_point */
+ ctx->xdr->put32(&rmod_header, ctx->entry);
+ /* parameters_begin */
+ ctx->xdr->put32(&rmod_header, ctx->parameters_begin);
+ /* parameters_end */
+ ctx->xdr->put32(&rmod_header, ctx->parameters_end);
+ /* bss_begin */
+ ctx->xdr->put32(&rmod_header, ctx->bss_begin);
+ /* bss_end */
+ ctx->xdr->put32(&rmod_header, ctx->bss_end);
+ /* padding[4] */
+ ctx->xdr->put32(&rmod_header, 0);
+ ctx->xdr->put32(&rmod_header, 0);
+ ctx->xdr->put32(&rmod_header, 0);
+ ctx->xdr->put32(&rmod_header, 0);
+
+ /* Write the relocations. */
+ for (i = 0; i < ctx->nrelocs; i++) {
+ if (bit64)
+ ctx->xdr->put64(&relocs, ctx->emitted_relocs[i]);
+ else
+ ctx->xdr->put32(&relocs, ctx->emitted_relocs[i]);
+ }
+
+ total_size = 0;
+ addr = 0;
+
+ /*
+ * There are 2 cases to deal with. The program has a large NOBITS
+ * section and the relocations can fit entirely within occupied memory
+ * region for the program. Ther other is that the relocations increase
+ * the memory footprint of the program if it was loaded directly into
+ * the region it would run. The rmdoule header is a fixed cost that
+ * is considered a part of the program.
+ */
+ total_size += buffer_size(&rmod_header);
+ total_size += ctx->phdr->p_memsz;
+ if (buffer_size(&relocs) + ctx->phdr->p_filesz > total_size) {
+ total_size -= ctx->phdr->p_memsz;
+ total_size += buffer_size(&relocs);
+ total_size += ctx->phdr->p_filesz;
+ }
+
+ ret = 0;
+ ret = add_section(ew, &rmod_header, ".header", addr,
+ buffer_size(&rmod_header));
+ if (ret < 0)
+ goto out;
+ addr += buffer_size(&rmod_header);
+
+ ret = add_section(ew, &program, ".program", addr, ctx->phdr->p_filesz);
+ if (ret < 0)
+ goto out;
+ addr += ctx->phdr->p_filesz;
+
+ ret = add_section(ew, &relocs, ".relocs", addr, buffer_size(&relocs));
+ if (ret < 0)
+ goto out;
+ addr += buffer_size(&relocs);
+
+ if (total_size != addr) {
+ ret = add_section(ew, NULL, ".empty", addr, total_size - addr);
+ if (ret < 0)
+ goto out;
+ }
+
+ /*
+ * Ensure last section has a memory usage that meets the required
+ * total size of the program in memory.
+ */
+
+ ret = elf_writer_serialize(ew, out);
+ if (ret < 0)
+ ERROR("Failed to serialize ELF to buffer.\n");
+
+out:
+ buffer_delete(&rmod_data);
+ elf_writer_destroy(ew);
+
+ return ret;
+}
+
+int rmodule_create(const struct buffer *elfin, struct buffer *elfout)
+{
+ struct rmod_context ctx;
+ struct parsed_elf *pelf;
+ int i;
+ int ret;
+
+ ret = -1;
+ memset(&ctx, 0, sizeof(ctx));
+ pelf = &ctx.pelf;
+
+ if (parse_elf(elfin, pelf, ELF_PARSE_ALL)) {
+ ERROR("Couldn't parse elf!\n");
+ return -1;
+ }
+
+ /* Only allow executables to be turned into rmodules. */
+ if (pelf->ehdr.e_type != ET_EXEC) {
+ ERROR("elf is not an executable: %u.\n", pelf->ehdr.e_type);
+ goto out;
+ }
+
+ /* Determine if architecture is supported. */
+ for (i = 0; i < ARRAY_SIZE(reloc_ops); i++) {
+ if (reloc_ops[i].arch == pelf->ehdr.e_machine) {
+ ctx.ops = &reloc_ops[i];
+ break;
+ }
+ }
+
+ if (ctx.ops == NULL) {
+ ERROR("elf is unsupported arch: %u.\n", pelf->ehdr.e_machine);
+ goto out;
+ }
+
+ /* Set the endinan ops. */
+ if (ctx.pelf.ehdr.e_ident[EI_DATA] == ELFDATA2MSB)
+ ctx.xdr = &xdr_be;
+ else
+ ctx.xdr = &xdr_le;
+
+ if (find_program_segment(&ctx))
+ goto out;
+
+ if (filter_relocation_sections(&ctx))
+ goto out;
+
+ if (collect_relocations(&ctx))
+ goto out;
+
+ if (populate_program_info(&ctx))
+ goto out;
+
+ if (write_elf(&ctx, elfin, elfout))
+ goto out;
+
+ ret = 0;
+
+out:
+ free(ctx.emitted_relocs);
+ parsed_elf_destroy(pelf);
+ return ret;
+}
diff --git a/util/cbfstool/rmodule.h b/util/cbfstool/rmodule.h
new file mode 100644
index 0000000..04962f6
--- /dev/null
+++ b/util/cbfstool/rmodule.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2014 Google, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
+ */
+
+#ifndef TOOL_RMODULE_H
+#define TOOL_RMODULE_H
+
+#include "elf.h"
+#include "common.h"
+
+/*
+ * Parse an ELF file within the elfin buffer and fill in the elfout buffer
+ * with a created rmoudle in ELF format. Return 0 on success, < 0 on error.
+ */
+int rmodule_create(const struct buffer *elfin, struct buffer *elfout);
+
+#endif /* TOOL_RMODULE_H */
1
0
Patch merged into coreboot/master: b99f363 cbfstool: add ELF writing support
by gerritï¼ coreboot.org 18 Mar '14
by gerritï¼ coreboot.org 18 Mar '14
18 Mar '14
the following patch was just integrated into master:
commit b99f3635ed63c5269edc8df321d4f864b91b17ba
Author: Aaron Durbin <adurbin(a)chromium.org>
Date: Tue Mar 11 11:48:56 2014 -0500
cbfstool: add ELF writing support
In order to generate rmodules in the format of ELF files
there needs to be support for writing out ELF files. The
ELF writer is fairly simple. It accpets sections that can
be associated with an optional buffer (file data). For each
section flagged with SHF_ALLOC a PT_LOAD segment is generated.
There isn't smart merging of the sections into a single PT_LOAD
segment.
Change-Id: I4d1a11f2e65be2369fb3f8bff350cbb28e14c89d
Signed-off-by: Aaron Durbin <adurbin(a)chromium.org>
See http://review.coreboot.org/5377 for details.
-gerrit
1
0
Patch set updated for coreboot: 94e8afd rmodules: use rmodtool to create rmodules
by Stefan Reinauer 18 Mar '14
by Stefan Reinauer 18 Mar '14
18 Mar '14
Stefan Reinauer (stefan.reinauer(a)coreboot.org) just uploaded a new patch set to gerrit, which you can find at http://review.coreboot.org/5379
-gerrit
commit 94e8afdb5ca9af58c22cce2cdb1e28c3443d61e4
Author: Aaron Durbin <adurbin(a)chromium.org>
Date: Mon Mar 10 16:13:58 2014 -0500
rmodules: use rmodtool to create rmodules
Start using the rmodtool for generating rmodules.
rmodule_link() has been changed to create 2 rules:
one for the passed in <name>, the other for creating
<name>.rmod which is an ELF file in the format of
an rmodule.
Since the header is not compiled and linked together
with an rmodule there needs to be a way of marking
which symbol is the entry point. __rmodule_entry is
the symbol used for knowing the entry point. There
was a little churn in SMM modules to ensure an
rmodule entry point symbol takes a single argument.
Change-Id: Ie452ed866f6596bf13f137f5b832faa39f48d26e
Signed-off-by: Aaron Durbin <adurbin(a)chromium.org>
---
Makefile.inc | 6 +-
src/arch/x86/Makefile.inc | 8 ++-
src/arch/x86/boot/Makefile.inc | 1 -
src/arch/x86/boot/ramstage_module_header.c | 24 -------
src/arch/x86/lib/c_start.S | 2 +
src/cpu/intel/haswell/Makefile.inc | 6 +-
src/cpu/intel/haswell/sipi_header.c | 6 --
src/cpu/intel/haswell/sipi_vector.S | 2 +
src/cpu/intel/haswell/smmrelocate.c | 13 +++-
src/cpu/x86/Makefile.inc | 6 +-
src/cpu/x86/sipi_header.c | 6 --
src/cpu/x86/sipi_vector.S | 2 +
src/cpu/x86/smm/Makefile.inc | 6 +-
src/cpu/x86/smm/smm_module_handler.c | 13 +++-
src/cpu/x86/smm/smm_module_header.c | 24 -------
src/cpu/x86/smm/smm_stub.S | 6 +-
src/include/cpu/x86/smm.h | 12 +++-
src/include/rmodule-defs.h | 24 -------
src/include/rmodule.h | 25 +++-----
src/lib/Makefile.inc | 12 ++--
src/lib/rmodule.c | 86 +++++---------------------
src/lib/rmodule.ld | 66 +++-----------------
src/soc/intel/baytrail/cpu.c | 10 ++-
src/vendorcode/google/chromeos/Makefile.inc | 1 +
src/vendorcode/google/chromeos/vboot_wrapper.c | 9 ++-
25 files changed, 115 insertions(+), 261 deletions(-)
diff --git a/Makefile.inc b/Makefile.inc
index 19ba294..fcd680d 100644
--- a/Makefile.inc
+++ b/Makefile.inc
@@ -252,10 +252,14 @@ build-dirs:
#######################################################################
# Build the tools
CBFSTOOL:=$(obj)/cbfstool
+RMODTOOL:=$(obj)/rmodtool
$(CBFSTOOL): $(objutil)/cbfstool/cbfstool
cp $< $@
+$(RMODTOOL): $(objutil)/cbfstool/rmodtool
+ cp $< $@
+
_WINCHECK=$(shell uname -o 2> /dev/null)
STACK=
ifeq ($(_WINCHECK),Msys)
@@ -390,5 +394,5 @@ crosstools-arm: clean-for-update
crossgcc-clean: clean-for-update
$(MAKE) -C util/crossgcc clean
-tools: $(objutil)/kconfig/conf $(objutil)/cbfstool/cbfstool $(objutil)/nvramtool/nvramtool $(objutil)/romcc/romcc $(objutil)/sconfig/sconfig
+tools: $(objutil)/kconfig/conf $(objutil)/cbfstool/cbfstool $(objutil)/cbfstool/rmodtool $(objutil)/nvramtool/nvramtool $(objutil)/romcc/romcc $(objutil)/sconfig/sconfig
diff --git a/src/arch/x86/Makefile.inc b/src/arch/x86/Makefile.inc
index 4b28697..72bea1e 100644
--- a/src/arch/x86/Makefile.inc
+++ b/src/arch/x86/Makefile.inc
@@ -93,7 +93,7 @@ ifneq ($(strip $(call strip_quotes,$(CONFIG_LINUX_INITRD))),)
endif
endif
-$(obj)/coreboot.rom: $(obj)/coreboot.pre $(objcbfs)/coreboot_ram.elf $(CBFSTOOL) $(call strip_quotes,$(COREBOOT_ROM_DEPENDENCIES)) $$(INTERMEDIATE) $$(VBOOT_STUB_ELF)
+$(obj)/coreboot.rom: $(obj)/coreboot.pre $(objcbfs)/coreboot_ram.elf $(CBFSTOOL) $(call strip_quotes,$(COREBOOT_ROM_DEPENDENCIES)) $$(INTERMEDIATE) $$(VBOOT_STUB)
@printf " CBFS $(subst $(obj)/,,$(@))\n"
cp $(obj)/coreboot.pre $@.tmp
$(CBFSTOOL) $@.tmp add-stage -f $(objcbfs)/coreboot_ram.elf -n $(CONFIG_CBFS_PREFIX)/coreboot_ram -c $(CBFS_COMPRESS_FLAG)
@@ -140,7 +140,7 @@ ifeq ($(CONFIG_INCLUDE_CONFIG_FILE),y)
$(CBFSTOOL) $@.tmp add -f $(obj)/config.tmp -n config -t raw; rm -f $(obj)/config.tmp ; fi
endif
ifeq ($(CONFIG_VBOOT_VERIFY_FIRMWARE),y)
- $(CBFSTOOL) $@.tmp add-stage -f $(VBOOT_STUB_ELF) -n $(CONFIG_CBFS_PREFIX)/vboot -c $(CBFS_COMPRESS_FLAG)
+ $(CBFSTOOL) $@.tmp add-stage -f $(VBOOT_STUB) -n $(CONFIG_CBFS_PREFIX)/vboot -c $(CBFS_COMPRESS_FLAG)
endif
ifeq ($(CONFIG_HAVE_REFCODE_BLOB),y)
$(CBFSTOOL) $@.tmp add-stage -f $(CONFIG_REFCODE_BLOB_FILE) -n $(CONFIG_CBFS_PREFIX)/refcode -c $(CBFS_COMPRESS_FLAG)
@@ -205,6 +205,10 @@ ifeq ($(CONFIG_RELOCATABLE_RAMSTAGE),y)
$(eval $(call rmodule_link,$(objcbfs)/coreboot_ram.debug, $(objgenerated)/coreboot_ram.o, $(CONFIG_HEAP_SIZE)))
+# The rmodule_link defintion creates an elf file with .rmod extension.
+$(objcbfs)/coreboot_ram.elf: $(objcbfs)/coreboot_ram.debug.rmod
+ cp $< $@
+
else
$(objcbfs)/coreboot_ram.debug: $(objgenerated)/coreboot_ram.o $(src)/arch/x86/coreboot_ram.ld
diff --git a/src/arch/x86/boot/Makefile.inc b/src/arch/x86/boot/Makefile.inc
index 629c644..79c6417 100644
--- a/src/arch/x86/boot/Makefile.inc
+++ b/src/arch/x86/boot/Makefile.inc
@@ -11,7 +11,6 @@ ramstage-$(CONFIG_GENERATE_ACPI_TABLES) += acpi.c
ramstage-$(CONFIG_GENERATE_SMBIOS_TABLES) += smbios.c
ramstage-$(CONFIG_GENERATE_ACPI_TABLES) += acpigen.c
ramstage-$(CONFIG_HAVE_ACPI_RESUME) += wakeup.S
-ramstage-$(CONFIG_RELOCATABLE_RAMSTAGE) += ramstage_module_header.c
$(obj)/arch/x86/boot/smbios.ramstage.o: $(obj)/build.h
diff --git a/src/arch/x86/boot/ramstage_module_header.c b/src/arch/x86/boot/ramstage_module_header.c
deleted file mode 100644
index b958c16..0000000
--- a/src/arch/x86/boot/ramstage_module_header.c
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
- * This file is part of the coreboot project.
- *
- * Copyright (C) 2013 ChromeOS Authors
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#include <rmodule.h>
-
-extern char _start[];
-
-DEFINE_RMODULE_HEADER(ramstage_module, _start, RMODULE_TYPE_STAGE);
diff --git a/src/arch/x86/lib/c_start.S b/src/arch/x86/lib/c_start.S
index 01ffa7c..faea22d 100644
--- a/src/arch/x86/lib/c_start.S
+++ b/src/arch/x86/lib/c_start.S
@@ -19,6 +19,8 @@ thread_stacks:
.section ".textfirst", "ax", @progbits
.code32
.globl _start
+ .globl __rmodule_entry
+__rmodule_entry:
_start:
cli
lgdt %cs:gdtaddr
diff --git a/src/cpu/intel/haswell/Makefile.inc b/src/cpu/intel/haswell/Makefile.inc
index 60c061d..63c1939 100644
--- a/src/cpu/intel/haswell/Makefile.inc
+++ b/src/cpu/intel/haswell/Makefile.inc
@@ -25,12 +25,12 @@ ramstage-srcs += $(SIPI_BIN)
rmodules-y += sipi_vector.S
rmodules-y += sipi_header.c
-$(SIPI_DOTO): $(dir $(SIPI_ELF))sipi_vector.rmodules.o $(dir $(SIPI_ELF))sipi_header.rmodules.o
+$(SIPI_DOTO): $(dir $(SIPI_ELF))sipi_vector.rmodules.o
$(CC) $(LDFLAGS) -nostdlib -r -o $@ $^
-$(eval $(call rmodule_link,$(SIPI_ELF), $(SIPI_ELF:.elf=.o), 0))
+$(eval $(call rmodule_link,$(SIPI_ELF), $(SIPI_DOTO), 0))
-$(SIPI_BIN): $(SIPI_ELF)
+$(SIPI_BIN): $(SIPI_ELF).rmod
$(OBJCOPY) -O binary $< $@
$(SIPI_BIN).ramstage.o: $(SIPI_BIN)
diff --git a/src/cpu/intel/haswell/sipi_header.c b/src/cpu/intel/haswell/sipi_header.c
deleted file mode 100644
index 846a82d..0000000
--- a/src/cpu/intel/haswell/sipi_header.c
+++ /dev/null
@@ -1,6 +0,0 @@
-#include <rmodule.h>
-
-
-extern void *ap_start;
-
-DEFINE_RMODULE_HEADER(sipi_vector_header, ap_start, RMODULE_TYPE_SIPI_VECTOR);
diff --git a/src/cpu/intel/haswell/sipi_vector.S b/src/cpu/intel/haswell/sipi_vector.S
index 664a9ee..e0abb7c 100644
--- a/src/cpu/intel/haswell/sipi_vector.S
+++ b/src/cpu/intel/haswell/sipi_vector.S
@@ -58,6 +58,8 @@ apic_to_cpu_num:
.text
.code16
.global ap_start
+.global __rmodule_entry
+__rmodule_entry:
ap_start:
cli
xorl %eax, %eax
diff --git a/src/cpu/intel/haswell/smmrelocate.c b/src/cpu/intel/haswell/smmrelocate.c
index 3f4f45a..dfbcf2e 100644
--- a/src/cpu/intel/haswell/smmrelocate.c
+++ b/src/cpu/intel/haswell/smmrelocate.c
@@ -164,11 +164,18 @@ static int bsp_setup_msr_save_state(struct smm_relocation_params *relo_params)
/* The relocation work is actually performed in SMM context, but the code
* resides in the ramstage module. This occurs by trampolining from the default
* SMRAM entry point to here. */
-static void asmlinkage
-cpu_smm_do_relocation(void *arg, int cpu, const struct smm_runtime *runtime)
+static void asmlinkage cpu_smm_do_relocation(void *arg)
{
msr_t mtrr_cap;
- struct smm_relocation_params *relo_params = arg;
+ struct smm_relocation_params *relo_params;
+ const struct smm_module_params *p;
+ const struct smm_runtime *runtime;
+ int cpu;
+
+ p = arg;
+ runtime = p->runtime;
+ relo_params = p->arg;
+ cpu = p->cpu;
if (cpu >= CONFIG_MAX_CPUS) {
printk(BIOS_CRIT,
diff --git a/src/cpu/x86/Makefile.inc b/src/cpu/x86/Makefile.inc
index 277ba48..c0b50c5 100644
--- a/src/cpu/x86/Makefile.inc
+++ b/src/cpu/x86/Makefile.inc
@@ -6,6 +6,7 @@ ramstage-$(CONFIG_PARALLEL_MP) += mp_init.c
ramstage-$(CONFIG_MIRROR_PAYLOAD_TO_RAM_BEFORE_LOADING) += mirror_payload.c
SIPI_ELF=$(obj)/cpu/x86/sipi_vector.elf
+SIPI_RMOD=$(SIPI_ELF).rmod
SIPI_BIN=$(SIPI_ELF:.elf=)
SIPI_DOTO=$(SIPI_ELF:.elf=.o)
@@ -13,14 +14,13 @@ ifeq ($(CONFIG_PARALLEL_MP),y)
ramstage-srcs += $(SIPI_BIN)
endif
rmodules-$(CONFIG_PARALLEL_MP) += sipi_vector.S
-rmodules-$(CONFIG_PARALLEL_MP) += sipi_header.c
-$(SIPI_DOTO): $(dir $(SIPI_ELF))sipi_vector.rmodules.o $(dir $(SIPI_ELF))sipi_header.rmodules.o
+$(SIPI_DOTO): $(dir $(SIPI_ELF))sipi_vector.rmodules.o
$(CC) $(LDFLAGS) -nostdlib -r -o $@ $^
$(eval $(call rmodule_link,$(SIPI_ELF), $(SIPI_ELF:.elf=.o), 0))
-$(SIPI_BIN): $(SIPI_ELF)
+$(SIPI_BIN): $(SIPI_RMOD)
$(OBJCOPY) -O binary $< $@
$(SIPI_BIN).ramstage.o: $(SIPI_BIN)
diff --git a/src/cpu/x86/sipi_header.c b/src/cpu/x86/sipi_header.c
deleted file mode 100644
index 846a82d..0000000
--- a/src/cpu/x86/sipi_header.c
+++ /dev/null
@@ -1,6 +0,0 @@
-#include <rmodule.h>
-
-
-extern void *ap_start;
-
-DEFINE_RMODULE_HEADER(sipi_vector_header, ap_start, RMODULE_TYPE_SIPI_VECTOR);
diff --git a/src/cpu/x86/sipi_vector.S b/src/cpu/x86/sipi_vector.S
index 52b12d0..c08c391 100644
--- a/src/cpu/x86/sipi_vector.S
+++ b/src/cpu/x86/sipi_vector.S
@@ -58,6 +58,8 @@ ap_count:
.text
.code16
.global ap_start
+.global __rmodule_entry
+__rmodule_entry:
ap_start:
cli
xorl %eax, %eax
diff --git a/src/cpu/x86/smm/Makefile.inc b/src/cpu/x86/smm/Makefile.inc
index 8dcd130..bb9c11d 100644
--- a/src/cpu/x86/smm/Makefile.inc
+++ b/src/cpu/x86/smm/Makefile.inc
@@ -21,10 +21,8 @@ ramstage-$(CONFIG_BACKUP_DEFAULT_SMM_REGION) += backup_default_smm.c
ifeq ($(CONFIG_SMM_MODULES),y)
smmstub-y += smm_stub.S
-smmstub-y += smm_module_header.c
smm-y += smiutil.c
-smm-y += smm_module_header.c
smm-y += smm_module_handler.c
ramstage-y += smm_module_loader.c
@@ -40,7 +38,7 @@ $(obj)/cpu/x86/smm/smmstub.o: $$(smmstub-objs)
# Link the SMM stub module with a 0-byte heap.
$(eval $(call rmodule_link,$(obj)/cpu/x86/smm/smmstub.elf, $(obj)/cpu/x86/smm/smmstub.o, 0))
-$(obj)/cpu/x86/smm/smmstub: $(obj)/cpu/x86/smm/smmstub.elf
+$(obj)/cpu/x86/smm/smmstub: $(obj)/cpu/x86/smm/smmstub.elf.rmod
$(OBJCOPY) -O binary $< $@
$(obj)/cpu/x86/smm/smmstub.ramstage.o: $(obj)/cpu/x86/smm/smmstub
@@ -55,7 +53,7 @@ $(obj)/cpu/x86/smm/smm.o: $$(smm-objs) $(LIBGCC_FILE_NAME)
$(eval $(call rmodule_link,$(obj)/cpu/x86/smm/smm.elf, $(obj)/cpu/x86/smm/smm.o, $(CONFIG_SMM_MODULE_HEAP_SIZE)))
-$(obj)/cpu/x86/smm/smm: $(obj)/cpu/x86/smm/smm.elf
+$(obj)/cpu/x86/smm/smm: $(obj)/cpu/x86/smm/smm.elf.rmod
$(OBJCOPY) -O binary $< $@
$(obj)/cpu/x86/smm/smm.ramstage.o: $(obj)/cpu/x86/smm/smm
diff --git a/src/cpu/x86/smm/smm_module_handler.c b/src/cpu/x86/smm/smm_module_handler.c
index 444e335..79863d8 100644
--- a/src/cpu/x86/smm/smm_module_handler.c
+++ b/src/cpu/x86/smm/smm_module_handler.c
@@ -20,6 +20,7 @@
#include <arch/io.h>
#include <console/console.h>
#include <cpu/x86/smm.h>
+#include <rmodule.h>
typedef enum { SMI_LOCKED, SMI_UNLOCKED } smi_semaphore;
@@ -113,8 +114,16 @@ void *smm_get_save_state(int cpu)
return base;
}
-void smm_handler_start(void *arg, int cpu, const struct smm_runtime *runtime)
+void asmlinkage smm_handler_start(void *arg)
{
+ const struct smm_module_params *p;
+ const struct smm_runtime *runtime;
+ int cpu;
+
+ p = arg;
+ runtime = p->runtime;
+ cpu = p->cpu;
+
/* Make sure to set the global runtime. It's OK to race as the value
* will be the same across CPUs as well as multiple SMIs. */
if (smm_runtime == NULL)
@@ -157,6 +166,8 @@ void smm_handler_start(void *arg, int cpu, const struct smm_runtime *runtime)
smi_set_eos();
}
+RMODULE_ENTRY(smm_handler_start);
+
/* Provide a default implementation for all weak handlers so that relocation
* entries in the modules make sense. Without default implementations the
* weak relocations w/o a symbol have a 0 address which is where the modules
diff --git a/src/cpu/x86/smm/smm_module_header.c b/src/cpu/x86/smm/smm_module_header.c
deleted file mode 100644
index 3ee654f..0000000
--- a/src/cpu/x86/smm/smm_module_header.c
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
- * This file is part of the coreboot project.
- *
- * Copyright (C) 2013 ChromeOS Authors
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#include <rmodule.h>
-
-extern char smm_handler_start[];
-
-DEFINE_RMODULE_HEADER(smm_module, smm_handler_start, RMODULE_TYPE_SMM);
diff --git a/src/cpu/x86/smm/smm_stub.S b/src/cpu/x86/smm/smm_stub.S
index 07eb5dc..083cb57 100644
--- a/src/cpu/x86/smm/smm_stub.S
+++ b/src/cpu/x86/smm/smm_stub.S
@@ -61,6 +61,8 @@ fallback_stack_top:
.text
.code16
.global smm_handler_start
+.global __rmodule_entry
+__rmodule_entry:
smm_handler_start:
movl $(smm_relocate_gdt), %ebx
data32 lgdt (%ebx)
@@ -132,11 +134,13 @@ smm_trampoline32:
2:
/* Call into the c-based SMM relocation function with the platform
* parameters. Equivalent to:
- * c_handler(c_handler_params, cpu_num, smm_runtime);
+ * struct arg = { c_handler_params, cpu_num, smm_runtime {;
+ * c_handler(&arg)
*/
push $(smm_runtime)
push %ecx
push c_handler_arg
+ push %esp
mov c_handler, %eax
call *%eax
diff --git a/src/include/cpu/x86/smm.h b/src/include/cpu/x86/smm.h
index 3ab43ff..f63420f 100644
--- a/src/include/cpu/x86/smm.h
+++ b/src/include/cpu/x86/smm.h
@@ -517,14 +517,20 @@ struct smm_runtime {
u8 apic_id_to_cpu[CONFIG_MAX_CPUS];
} __attribute__ ((packed));
-typedef void asmlinkage (*smm_handler_t)(void *arg, int cpu,
- const struct smm_runtime *runtime);
+struct smm_module_params {
+ void *arg;
+ int cpu;
+ const struct smm_runtime *runtime;
+};
+
+/* smm_handler_t is called with arg of smm_module_params pointer. */
+typedef void asmlinkage (*smm_handler_t)(void *);
#ifdef __SMM__
/* SMM Runtime helpers. */
/* Entry point for SMM modules. */
-void smm_handler_start(void *arg, int cpu, const struct smm_runtime *runtime);
+void asmlinkage smm_handler_start(void *params);
/* Retrieve SMM save state for a given CPU. WARNING: This does not take into
* account CPUs which are configured to not save their state to RAM. */
diff --git a/src/include/rmodule-defs.h b/src/include/rmodule-defs.h
index ee2d3f7..4139ef3 100644
--- a/src/include/rmodule-defs.h
+++ b/src/include/rmodule-defs.h
@@ -25,30 +25,6 @@
#define RMODULE_MAGIC 0xf8fe
#define RMODULE_VERSION_1 1
-#define FIELD_ENTRY(x_) ((uint32_t)&x_)
-#define RMODULE_HEADER(entry_, type_) \
-{ \
- .magic = RMODULE_MAGIC, \
- .version = RMODULE_VERSION_1, \
- .type = type_, \
- .payload_begin_offset = FIELD_ENTRY(_payload_begin_offset), \
- .payload_end_offset = FIELD_ENTRY(_payload_end_offset), \
- .relocations_begin_offset = \
- FIELD_ENTRY(_relocations_begin_offset), \
- .relocations_end_offset = \
- FIELD_ENTRY(_relocations_end_offset), \
- .module_link_start_address = \
- FIELD_ENTRY(_module_link_start_addr), \
- .module_program_size = FIELD_ENTRY(_module_program_size), \
- .module_entry_point = FIELD_ENTRY(entry_), \
- .parameters_begin = FIELD_ENTRY(_module_params_begin), \
- .parameters_end = FIELD_ENTRY(_module_params_end), \
- .bss_begin = FIELD_ENTRY(_bss), \
- .bss_end = FIELD_ENTRY(_ebss), \
-}
-
-/* Private data structures below should not be used directly. */
-
/* All fields with '_offset' in the name are byte offsets into the flat blob.
* The linker and the linker script takes are of assigning the values. */
struct rmodule_header {
diff --git a/src/include/rmodule.h b/src/include/rmodule.h
index 2147ab0..d229cf8 100644
--- a/src/include/rmodule.h
+++ b/src/include/rmodule.h
@@ -21,6 +21,7 @@
#include <stdint.h>
#include <stddef.h>
+#include <string.h>
#include <rmodule-defs.h>
enum {
@@ -50,11 +51,6 @@ int rmodule_load_alignment(const struct rmodule *m);
int rmodule_calc_region(unsigned int region_alignment, size_t rmodule_size,
size_t *region_size, int *load_offset);
-#define DEFINE_RMODULE_HEADER(name_, entry_, type_) \
- struct rmodule_header name_ \
- __attribute__ ((section (".module_header"))) = \
- RMODULE_HEADER(entry_, type_)
-
/* Support for loading rmodule stages. This API is only available when
* using dynamic cbmem because it uses the dynamic cbmem API to obtain
* the backing store region for the stage. */
@@ -84,17 +80,12 @@ struct rmodule {
void *relocations;
};
-/* These are the symbols assumed that every module contains. The linker script
- * provides these symbols. */
-extern char _relocations_begin_offset[];
-extern char _relocations_end_offset[];
-extern char _payload_end_offset[];
-extern char _payload_begin_offset[];
-extern char _bss[];
-extern char _ebss[];
-extern char _module_program_size[];
-extern char _module_link_start_addr[];
-extern char _module_params_begin[];
-extern char _module_params_end[];
+#if IS_ENABLED(CONFIG_RELOCATABLE_MODULES)
+/* Rmodules have an entry point of named __rmodule_entry. */
+#define RMODULE_ENTRY(entry_) \
+ void __rmodule_entry(void *) __attribute__((alias (STRINGIFY(entry_))))
+#else
+#define RMODULE_ENTRY(entry_)
+#endif
#endif /* RMODULE_H */
diff --git a/src/lib/Makefile.inc b/src/lib/Makefile.inc
index acd334e..93babd3 100644
--- a/src/lib/Makefile.inc
+++ b/src/lib/Makefile.inc
@@ -133,17 +133,21 @@ ramstage-y += rmodule.c
romstage-$(CONFIG_RELOCATABLE_RAMSTAGE) += rmodule.c
RMODULE_LDSCRIPT := $(src)/lib/rmodule.ld
-RMODULE_LDFLAGS := -nostartfiles -shared -z defs -nostdlib -Bsymbolic -T $(RMODULE_LDSCRIPT)
+RMODULE_LDFLAGS := -nostartfiles -Wl,--emit-relocs -Wl,-z,defs -Wl,-Bsymbolic -Wl,-T,$(RMODULE_LDSCRIPT)
# rmodule_link_rules is a function that should be called with:
# (1) the object name to link
# (2) the dependencies
# (3) heap size of the relocatable module
-# It will create the necessary Make rules.
+# It will create the necessary Make rules to create a rmodule. The resulting
+# rmdoule is named $(1).rmod
define rmodule_link
-$(strip $(1)): $(strip $(2)) $$(RMODULE_LDSCRIPT) $$(obj)/ldoptions
- $$(LD) $$(RMODULE_LDFLAGS) --defsym=__heap_size=$(strip $(3)) -o $$@ $(strip $(2))
+$(strip $(1)): $(strip $(2)) $$(RMODULE_LDSCRIPT) $$(obj)/ldoptions $$(RMODTOOL)
+ $$(CC) $$(CFLAGS) $$(RMODULE_LDFLAGS) -Wl,--defsym=__heap_size=$(strip $(3)) -o $$@ -Wl,--start-group $(strip $(2)) $$(LIBGCC_FILE_NAME) -Wl,--end-group
$$(NM) -n $$@ > $$(basename $$(a)).map
+
+$(strip $(1)).rmod: $(strip $(1))
+ $$(RMODTOOL) -i $$^ -o $$@
endef
endif
diff --git a/src/lib/rmodule.c b/src/lib/rmodule.c
index 2cb70b8..a73e667 100644
--- a/src/lib/rmodule.c
+++ b/src/lib/rmodule.c
@@ -26,44 +26,6 @@
/* Change this define to get more verbose debugging for module loading. */
#define PK_ADJ_LEVEL BIOS_NEVER
-#if CONFIG_ARCH_X86
-/*
- * On X86, the only relocations currently allowed are R_386_RELATIVE which
- * have '0' for the symbol info in the relocation metadata (in r_info).
- * The reason is that the module is fully linked and just has the relocations'
- * locations.
- */
-typedef struct {
- uint32_t r_offset;
- uint32_t r_info;
-} Elf32_Rel;
-
-#define R_386_RELATIVE 8
-
-#define RELOCTION_ENTRY_SIZE sizeof(Elf32_Rel)
-static inline int rmodule_reloc_offset(const void *reloc)
-{
- const Elf32_Rel *rel = reloc;
- return rel->r_offset;
-}
-
-static inline int rmodule_reloc_valid(const void *reloc)
-{
- const Elf32_Rel *rel = reloc;
- return (rel->r_info == R_386_RELATIVE);
-}
-
-static inline void *remodule_next_reloc(const void *reloc)
-{
- const Elf32_Rel *rel = reloc;
- rel++;
- return (void *)rel;
-}
-
-#else
-#error Arch needs to add relocation information support for RMODULE
-#endif
-
static inline int rmodule_is_loaded(const struct rmodule *module)
{
return module->location != NULL;
@@ -71,7 +33,7 @@ static inline int rmodule_is_loaded(const struct rmodule *module)
/* Calculate a loaded program address based on the blob address. */
static inline void *rmodule_load_addr(const struct rmodule *module,
- uint32_t blob_addr)
+ uintptr_t blob_addr)
{
char *loc = module->location;
return &loc[blob_addr - module->header->module_link_start_address];
@@ -151,13 +113,13 @@ static void rmodule_clear_bss(struct rmodule *module)
memset(begin, 0, size);
}
-static inline int rmodule_number_relocations(const struct rmodule *module)
+static inline size_t rmodule_number_relocations(const struct rmodule *module)
{
- int r;
+ size_t r;
r = module->header->relocations_end_offset;
r -= module->header->relocations_begin_offset;
- r /= RELOCTION_ENTRY_SIZE;
+ r /= sizeof(uintptr_t);
return r;
}
@@ -176,51 +138,33 @@ static void rmodule_copy_payload(const struct rmodule *module)
memcpy(module->location, module->payload, module->payload_size);
}
-static inline uint32_t *rmodule_adjustment_location(const struct rmodule *module,
- const void *reloc)
-{
- int reloc_offset;
-
- /* Don't relocate header field entries -- only program relocations. */
- reloc_offset = rmodule_reloc_offset(reloc);
- if (reloc_offset < module->header->module_link_start_address)
- return NULL;
-
- return rmodule_load_addr(module, reloc_offset);
-}
-
static int rmodule_relocate(const struct rmodule *module)
{
- int num_relocations;
- const void *reloc;
- uint32_t adjustment;
+ size_t num_relocations;
+ const uintptr_t *reloc;
+ uintptr_t adjustment;
/* Each relocation needs to be adjusted relative to the beginning of
* the loaded program. */
- adjustment = (uint32_t)rmodule_load_addr(module, 0);
+ adjustment = (uintptr_t)rmodule_load_addr(module, 0);
reloc = module->relocations;
num_relocations = rmodule_number_relocations(module);
- printk(BIOS_DEBUG, "Processing %d relocs with adjust value of 0x%08x\n",
+ printk(BIOS_DEBUG, "Processing %zu relocs. Offset value of 0x%08x\n",
num_relocations, adjustment);
while (num_relocations > 0) {
- uint32_t *adjust_loc;
-
- if (!rmodule_reloc_valid(reloc))
- return -1;
+ uintptr_t *adjust_loc;
/* If the adjustment location is non-NULL adjust it. */
- adjust_loc = rmodule_adjustment_location(module, reloc);
- if (adjust_loc != NULL) {
- printk(PK_ADJ_LEVEL, "Adjusting %p: 0x%08x -> 0x%08x\n",
+ adjust_loc = rmodule_load_addr(module, *reloc);
+ printk(PK_ADJ_LEVEL, "Adjusting %p: 0x%08x -> 0x%08x\n",
adjust_loc, *adjust_loc,
*adjust_loc + adjustment);
*adjust_loc += adjustment;
- }
- reloc = remodule_next_reloc(reloc);
+ reloc++;
num_relocations--;
}
@@ -232,8 +176,8 @@ int rmodule_load_alignment(const struct rmodule *module)
/* The load alignment is the start of the program's linked address.
* The base address where the program is loaded needs to be a multiple
* of the program's starting link address. That way all data alignment
- * in the program is preserved. */
- return module->header->module_link_start_address;
+ * in the program is preserved. Default to 4KiB. */
+ return 4096;
}
int rmodule_load(void *base, struct rmodule *module)
diff --git a/src/lib/rmodule.ld b/src/lib/rmodule.ld
index 0cdbb2f..9222f3b 100644
--- a/src/lib/rmodule.ld
+++ b/src/lib/rmodule.ld
@@ -1,19 +1,15 @@
-OUTPUT_FORMAT("elf32-i386", "elf32-i386", "elf32-i386")
-OUTPUT_ARCH(i386)
-
/*
* This linker script is used to link rmodules (relocatable modules). It
* links at zero so that relocation fixups are easy when placing the binaries
* anywhere in the address space.
*
* NOTE: The program's loadable sections (text, module_params, and data) are
- * packed into the flat blob using the AT directive. The rmodule loader assumes
- * the entire program resides in one contiguous address space. Therefore,
- * alignment for a given section (if required) needs to be done at the end of
- * the preceeding section. e.g. if the data section should be aligned to an 8
- * byte address the text section should have ALIGN(8) at the end of its section.
- * Otherwise there won't be a consistent mapping between the flat blob and the
- * loaded program.
+ * packed into the flat blob. The rmodule loader assumes the entire program
+ * resides in one contiguous address space. Therefore, alignment for a given
+ * section (if required) needs to be done at the end of the preceeding section.
+ * e.g. if the data section should be aligned to an 8 byte address the text
+ * section should have ALIGN(8) at the end of its section. Otherwise there
+ * won't be a consistent mapping between the flat blob and the loaded program.
*/
BASE_ADDRESS = 0x00000;
@@ -22,21 +18,9 @@ SECTIONS
{
. = BASE_ADDRESS;
- .header : AT (0) {
- *(.module_header);
- . = ALIGN(8);
- }
-
- /* Align the start of the module program to a large enough alignment
- * so that any data in the program with an alignement property is met.
- * Essentially, this alignment is the maximum possible data alignment
- * property a program can have. */
- . = ALIGN(4096);
- _module_link_start_addr = .;
- _payload_begin_offset = LOADADDR(.header) + SIZEOF(.header);
-
- .payload : AT (_payload_begin_offset) {
+ .payload : {
/* C code of the module. */
+ _ram_seg = .;
*(.textfirst);
*(.text);
*(.text.*);
@@ -88,9 +72,6 @@ SECTIONS
. = ALIGN(8);
}
- /* _payload_end marks the end of the module's code and data. */
- _payload_end_offset = LOADADDR(.payload) + SIZEOF(.payload);
-
.bss (NOLOAD) : {
/* C uninitialized data of the module. */
_bss = .;
@@ -107,38 +88,11 @@ SECTIONS
_heap = .;
. = . + __heap_size;
_eheap = .;
+ _eram_seg = .;
}
- /* _module_program_size is the total memory used by the program. */
- _module_program_size = _eheap - _module_link_start_addr;
-
- /* coreboot's ramstage uses the _ram_seg and _eram_seg symbols
- * for determining its load location. Provide those to help it out.
- * It's a nop for any non-ramstage rmodule. */
- _ram_seg = _module_link_start_addr;
- _eram_seg = _module_link_start_addr + _module_program_size;
-
- /* The relocation information is linked on top of the BSS section
- * because the BSS section takes no space on disk. The relocation data
- * resides directly after the data section in the flat binary. */
- .relocations ADDR(.bss) : AT (_payload_end_offset) {
- *(.rel.*);
- }
- _relocations_begin_offset = LOADADDR(.relocations);
- _relocations_end_offset = _relocations_begin_offset +
- SIZEOF(.relocations);
-
/DISCARD/ : {
- /* Drop unnecessary sections. Since these modules are linked
- * as shared objects there are dynamic sections. These sections
- * aren't needed so drop them. */
- *(.comment);
- *(.note);
- *(.note.*);
- *(.dynamic);
- *(.dynsym);
- *(.dynstr);
- *(.gnu.hash);
+ /* Drop unnecessary sections. */
*(.eh_frame);
}
}
diff --git a/src/soc/intel/baytrail/cpu.c b/src/soc/intel/baytrail/cpu.c
index 1226e47..c550531 100644
--- a/src/soc/intel/baytrail/cpu.c
+++ b/src/soc/intel/baytrail/cpu.c
@@ -112,11 +112,17 @@ static void adjust_apic_id_map(struct smm_loader_params *smm_params)
runtime->apic_id_to_cpu[i] = mp_get_apic_id(i);
}
-static void asmlinkage
-cpu_smm_do_relocation(void *arg, int cpu, const struct smm_runtime *runtime)
+static void asmlinkage cpu_smm_do_relocation(void *arg)
{
msr_t smrr;
em64t100_smm_state_save_area_t *smm_state;
+ const struct smm_module_params *p;
+ const struct smm_runtime *runtime;
+ int cpu;
+
+ p = arg;
+ runtime = p->runtime;
+ cpu = p->cpu;
if (cpu >= CONFIG_MAX_CPUS) {
printk(BIOS_CRIT,
diff --git a/src/vendorcode/google/chromeos/Makefile.inc b/src/vendorcode/google/chromeos/Makefile.inc
index 007bd57..21e1750 100644
--- a/src/vendorcode/google/chromeos/Makefile.inc
+++ b/src/vendorcode/google/chromeos/Makefile.inc
@@ -51,6 +51,7 @@ VB_INCLUDES += -I$(VB_SOURCE)/firmware/include
INCLUDES += $(VB_INCLUDES)
VBOOT_STUB_ELF = $(obj)/vendorcode/google/chromeos/vbootstub.elf
+VBOOT_STUB = $(VBOOT_STUB_ELF).rmod
VBOOT_STUB_DOTO = $(VBOOT_STUB_ELF:.elf=.o)
# Dependency for the vboot rmodules. Ordering matters.
diff --git a/src/vendorcode/google/chromeos/vboot_wrapper.c b/src/vendorcode/google/chromeos/vboot_wrapper.c
index 66b7cfb..fe3c022 100644
--- a/src/vendorcode/google/chromeos/vboot_wrapper.c
+++ b/src/vendorcode/google/chromeos/vboot_wrapper.c
@@ -24,10 +24,6 @@
#include "vboot_context.h"
#include "vboot_handoff.h"
-static void vboot_wrapper(struct vboot_context *context);
-
-DEFINE_RMODULE_HEADER(vboot_wrapper_header, vboot_wrapper, RMODULE_TYPE_VBOOT);
-
/* Keep a global context pointer around for the callbacks to use. */
static struct vboot_context *gcontext;
@@ -63,12 +59,14 @@ static void parse_component(const struct components *components, int num,
fw->size = (uint32_t)components->entries[num].size;
}
-static void vboot_wrapper(struct vboot_context *context)
+static void vboot_wrapper(void *arg)
{
int i;
VbError_t res;
const struct components *components;
+ struct vboot_context *context;
+ context = arg;
gcontext = context;
VbExDebug("Calling VbInit()\n");
@@ -266,3 +264,4 @@ VbError_t VbExTpmSendReceive(const uint8_t *request, uint32_t request_length,
return VBERROR_SUCCESS;
}
+RMODULE_ENTRY(vboot_wrapper);
1
0
Aaron Durbin (adurbin(a)google.com) just uploaded a new patch set to gerrit, which you can find at http://review.coreboot.org/5394
-gerrit
commit da9a3e01f298f829fc5cbeefa1944d698e5b25bf
Author: Aaron Durbin <adurbin(a)chromium.org>
Date: Thu Mar 13 08:50:00 2014 -0500
regions support
Needs some cleanup work. Compile tested as of now.
Change-Id: I2a78278090ae928468e197ac73d1fb18596bf8cb
Signed-off-by: Aaron Durbin <adurbin(a)chromium.org>
---
src/Kconfig | 7 +
src/arch/x86/boot/smbios.c | 8 +-
src/arch/x86/lib/rom_media.c | 114 +++---
src/cpu/intel/microcode/microcode.c | 38 +-
src/cpu/x86/mirror_payload.c | 38 +-
src/device/pci_device.c | 7 +-
src/device/pci_rom.c | 232 +++++++-----
src/drivers/elog/elog.c | 142 +++-----
src/include/cbfs.h | 120 ++++---
src/include/cbfs_core.h | 44 ---
src/include/device/pci_rom.h | 4 +-
src/include/payload_loader.h | 3 +
src/include/region.h | 138 ++++++++
src/include/rmodule.h | 7 +-
src/lib/Makefile.inc | 10 +
src/lib/bootrw_spi_flash_region.c | 107 ++++++
src/lib/cbfs.c | 489 ++++++++++++++++++--------
src/lib/cbfs_boot_region.c | 133 +++++++
src/lib/cbfs_core.c | 224 ------------
src/lib/loaders/cbfs_payload_loader.c | 18 +-
src/lib/loaders/cbfs_ramstage_loader.c | 12 +-
src/lib/loaders/load_and_run_payload.c | 5 +-
src/lib/region.c | 293 +++++++++++++++
src/lib/rmodule.c | 46 ++-
src/lib/selfboot.c | 113 +++---
src/soc/intel/baytrail/Kconfig | 1 +
src/soc/intel/baytrail/mrc_cache.c | 20 +-
src/soc/intel/baytrail/nvm.c | 27 +-
src/soc/intel/baytrail/romstage/raminit.c | 9 +-
src/soc/intel/baytrail/romstage/romstage.c | 4 +
src/vendorcode/google/chromeos/Makefile.inc | 1 +
src/vendorcode/google/chromeos/chromeos.c | 4 +
src/vendorcode/google/chromeos/fmap.c | 174 +++++----
src/vendorcode/google/chromeos/fmap.h | 25 +-
src/vendorcode/google/chromeos/vboot_loader.c | 47 ++-
35 files changed, 1725 insertions(+), 939 deletions(-)
diff --git a/src/Kconfig b/src/Kconfig
index 531a8c8..b0b8d26 100644
--- a/src/Kconfig
+++ b/src/Kconfig
@@ -1094,3 +1094,10 @@ config REG_SCRIPT
default n
help
Internal option that controls whether we compile in register scripts.
+
+config BOOT_REGION_SPI_FLASH
+ def_bool n
+ depends on ARCH_X86
+ help
+ Use generic SPI flash boot region support. This will provide a
+ function to initialize the read-write boot region.
diff --git a/src/arch/x86/boot/smbios.c b/src/arch/x86/boot/smbios.c
index 0e84acc..0434715 100644
--- a/src/arch/x86/boot/smbios.c
+++ b/src/arch/x86/boot/smbios.c
@@ -27,7 +27,6 @@
#include <device/device.h>
#include <arch/cpu.h>
#include <cpu/x86/name.h>
-#include <cbfs_core.h>
#include <arch/byteorder.h>
#include <elog.h>
#if CONFIG_CHROMEOS
@@ -147,12 +146,7 @@ static int smbios_write_type0(unsigned long *current, int handle)
#endif
{
- const struct cbfs_header *header;
- u32 romsize = CONFIG_ROM_SIZE;
- header = cbfs_get_header(CBFS_DEFAULT_MEDIA);
- if (header != CBFS_HEADER_INVALID_ADDRESS)
- romsize = ntohl(header->romsize);
- t->bios_rom_size = (romsize / 65535) - 1;
+ t->bios_rom_size = (CONFIG_ROM_SIZE / 65535) - 1;
}
t->system_bios_major_release = 4;
diff --git a/src/arch/x86/lib/rom_media.c b/src/arch/x86/lib/rom_media.c
index ed2122c..aa17d64 100644
--- a/src/arch/x86/lib/rom_media.c
+++ b/src/arch/x86/lib/rom_media.c
@@ -18,84 +18,64 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
* MA 02110-1301 USA
*/
-#include <cbfs.h>
+#include <stdint.h>
#include <string.h>
+#include <console/console.h>
+#include <region.h>
-#ifdef LIBPAYLOAD
-# define printk(x...)
-# define init_default_cbfs_media libpayload_init_default_cbfs_media
- extern int libpayload_init_default_cbfs_media(struct cbfs_media *media);
-#else
-# include <console/console.h>
-#endif
-
-// Implementation of memory-mapped ROM media source on X86.
-
-static int x86_rom_open(struct cbfs_media *media) {
- return 0;
+static inline void *get_pointer(offset_t off)
+{
+ const uintptr_t base_address = (uintptr_t)-CONFIG_ROM_SIZE;
+ return (void *)(base_address + off);
}
-static void *x86_rom_map(struct cbfs_media *media, size_t offset, size_t count) {
- void *ptr;
- // Some address (ex, pointer to master header) may be given in memory
- // mapped location. To workaround that, we handle >0xf0000000 as real
- // memory pointer.
-
- if ((uint32_t)offset > (uint32_t)0xf0000000)
- ptr = (void*)offset;
- else
- ptr = (void*)(0 - (uint32_t)media->context + offset);
- return ptr;
+static void *
+boot_mmap(const struct region_device *rdev, offset_t off, size_t size)
+{
+ return get_pointer(off);
}
-static void *x86_rom_unmap(struct cbfs_media *media, const void *address) {
- return NULL;
+static void boot_munmap(const struct region_device *rdev, void *addr)
+{
}
-static size_t x86_rom_read(struct cbfs_media *media, void *dest, size_t offset,
- size_t count) {
- void *ptr = x86_rom_map(media, offset, count);
- memcpy(dest, ptr, count);
- x86_rom_unmap(media, ptr);
- return count;
+static ssize_t
+boot_readat(const struct region_device *rdev, void *buf,
+ offset_t off, size_t size)
+{
+ memcpy(buf, get_pointer(off), size);
+ return size;
}
-static int x86_rom_close(struct cbfs_media *media) {
- return 0;
-}
+static const struct region_device_ops boot_dev_ops = {
+ .mmap = boot_mmap,
+ .munmap = boot_munmap,
+ .readat = boot_readat,
+};
+
+static const struct region_device boot_dev = {
+ .ops = &boot_dev_ops,
+ .region = {
+ .offset = 0,
+ .size = CONFIG_ROM_SIZE,
+ },
+};
-int init_x86rom_cbfs_media(struct cbfs_media *media);
-int init_x86rom_cbfs_media(struct cbfs_media *media) {
- // On X86, we always keep a reference of pointer to CBFS header in
- // 0xfffffffc, and the pointer is still a memory-mapped address.
- // Since the CBFS core always use ROM offset, we need to figure out
- // header->romsize even before media is initialized.
- struct cbfs_header *header = (struct cbfs_header*)
- *(uint32_t*)(0xfffffffc);
- if (CBFS_HEADER_MAGIC != ntohl(header->magic)) {
-#if defined(CONFIG_ROM_SIZE)
- printk(BIOS_ERR, "Invalid CBFS master header at %p\n", header);
- media->context = (void*)CONFIG_ROM_SIZE;
-#else
- return -1;
-#endif
- } else {
- uint32_t romsize = ntohl(header->romsize);
- media->context = (void*)romsize;
-#if defined(CONFIG_ROM_SIZE)
- if (CONFIG_ROM_SIZE != romsize)
- printk(BIOS_INFO, "Warning: rom size unmatch (%d/%d)\n",
- CONFIG_ROM_SIZE, romsize);
-#endif
+void boot_media_initialize(void)
+{
+ rhandle_t rh;
+ const char *bootro_name = BOOTRO_REGION_NAME;
+
+ rh = region_locate(bootro_name);
+
+ /* Already registered. */
+ if (rhandle_valid(rh)) {
+ printk(BIOS_DEBUG, "Already Registered: '%s'\n", bootro_name);
+ return;
}
- media->open = x86_rom_open;
- media->close = x86_rom_close;
- media->map = x86_rom_map;
- media->unmap = x86_rom_unmap;
- media->read = x86_rom_read;
- return 0;
-}
-int init_default_cbfs_media(struct cbfs_media *media) {
- return init_x86rom_cbfs_media(media);
+ rh = region_register(bootro_name, &boot_dev);
+
+ if (!rhandle_valid(rh))
+ printk(BIOS_ERR, "Failed to register '%s'.\n", bootro_name);
}
diff --git a/src/cpu/intel/microcode/microcode.c b/src/cpu/intel/microcode/microcode.c
index 947dfd7..d6753c1 100644
--- a/src/cpu/intel/microcode/microcode.c
+++ b/src/cpu/intel/microcode/microcode.c
@@ -107,28 +107,48 @@ void intel_microcode_load_unlocked(const void *microcode_patch)
#endif
}
+#if !defined(__ROMCC__)
+static void *microcode_locate(u32 *len)
+{
+ const struct cbfs_file_descriptor *fd;
+ void *buf;
+
+ fd = cbfs_open_by_name(cbfs_default_descriptor(), MICROCODE_CBFS_FILE);
+ if (fd == NULL)
+ return NULL;
+
+ /*
+ * The following sequence relies on x86 having a persistent
+ * memory-mapped view of the SPI rom.
+ */
+ *len = cbfs_file_content_size(fd);
+ buf = cbfs_file_map_content(fd, 0, *len);
+ cbfs_file_close(fd);
+
+ return buf;
+}
+#endif
+
const void *intel_microcode_find(void)
{
- struct cbfs_file *microcode_file;
const struct microcode *ucode_updates;
u32 eax, microcode_len;
u32 pf, rev, sig, update_size;
unsigned int x86_model, x86_family;
msr_t msr;
+#if defined(__ROMCC__)
+ struct cbfs_file *file;
-#ifdef __PRE_RAM__
- microcode_file = walkcbfs_head((char *) MICROCODE_CBFS_FILE);
+ file = walkcbfs_head((char *) MICROCODE_CBFS_FILE);
+ microcode_len = ntohl(file->len);
+ ucode_updates = CBFS_SUBHEADER(file);
#else
- microcode_file = cbfs_get_file(CBFS_DEFAULT_MEDIA,
- MICROCODE_CBFS_FILE);
+ ucode_updates = microcode_locate(µcode_len);
#endif
- if (!microcode_file)
+ if (!ucode_updates)
return NULL;
- ucode_updates = CBFS_SUBHEADER(microcode_file);
- microcode_len = ntohl(microcode_file->len);
-
/* CPUID sets MSR 0x8B iff a microcode update has been loaded. */
msr.lo = 0;
msr.hi = 0;
diff --git a/src/cpu/x86/mirror_payload.c b/src/cpu/x86/mirror_payload.c
index edd2641..a6975e1 100644
--- a/src/cpu/x86/mirror_payload.c
+++ b/src/cpu/x86/mirror_payload.c
@@ -30,26 +30,12 @@ void mirror_payload(struct payload *payload)
size_t size;
char *src;
uintptr_t alignment_diff;
- const unsigned long cacheline_size = 64;
- const uintptr_t intra_cacheline_mask = cacheline_size - 1;
- const uintptr_t cacheline_mask = ~intra_cacheline_mask;
+ const unsigned long dword_size = sizeof(uint32_t);
+ const uintptr_t dword_mask = dword_size - 1;
src = payload->backing_store.data;
size = payload->backing_store.size;
- /*
- * Adjust size so that the start and end points are aligned to a
- * cacheline. The SPI hardware controllers on Intel machines should
- * cache full length cachelines as well as prefetch data. Once the
- * data is mirrored in memory all accesses should hit the CPU's cache.
- */
- alignment_diff = (intra_cacheline_mask & (uintptr_t)src);
- size += alignment_diff;
-
- size = ALIGN(size, cacheline_size);
-
- printk(BIOS_DEBUG, "Payload aligned size: 0x%zx\n", size);
-
buffer = bootmem_allocate_buffer(size);
if (buffer == NULL) {
@@ -57,7 +43,18 @@ void mirror_payload(struct payload *payload)
return;
}
- src = (void *)(cacheline_mask & (uintptr_t)src);
+ /*
+ * Do copies in 32-bit aligned reads from backing source.
+ * 1. Do a copy to align the source address.
+ * 2. Do remaining copy.
+ */
+ alignment_diff = dword_mask & (uintptr_t)src;
+ if (alignment_diff != 0) {
+ mempcy(buffer, src, alignment_diff);
+ src += alignment_diff;
+ buffer += alignment_diff;
+ size -= alignment_diff;
+ }
/*
* Note that if mempcy is not using 32-bit moves the performance will
@@ -66,6 +63,9 @@ void mirror_payload(struct payload *payload)
*/
memcpy(buffer, src, size);
- /* Update the payload's backing store. */
- payload->backing_store.data = &buffer[alignment_diff];
+ /*
+ * Update the payload's backing store. May leak resources depending
+ * cbfs stroage source.
+ */
+ payload->backing_store.data = buffer;
}
diff --git a/src/device/pci_device.c b/src/device/pci_device.c
index aa0d954..bcdbbe4 100644
--- a/src/device/pci_device.c
+++ b/src/device/pci_device.c
@@ -667,7 +667,7 @@ int oprom_is_loaded = 0;
void pci_dev_init(struct device *dev)
{
#if CONFIG_VGA_ROM_RUN
- struct rom_header *rom, *ram;
+ struct rom_header *ram;
/* Only execute VGA ROMs. */
if (((dev->class >> 8) != PCI_CLASS_DISPLAY_VGA))
@@ -694,11 +694,8 @@ void pci_dev_init(struct device *dev)
return;
#endif
- rom = pci_rom_probe(dev);
- if (rom == NULL)
- return;
+ ram = pci_load_vga_rom(dev);
- ram = pci_rom_load(dev, rom);
if (ram == NULL)
return;
diff --git a/src/device/pci_rom.c b/src/device/pci_rom.c
index 1bdccf0..bb17931 100644
--- a/src/device/pci_rom.c
+++ b/src/device/pci_rom.c
@@ -6,6 +6,7 @@
* (Written by Yinghai Lu <yhlu(a)tyan.com> for Tyan)
* Copyright (C) 2005 Ronald G. Minnich <rminnich(a)gmail.com>
* Copyright (C) 2005-2007 Stefan Reinauer <stepan(a)openbios.org>
+ * Copyright (C) 2014 Google Inc.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@@ -28,62 +29,15 @@
#include <device/pci_ops.h>
#include <string.h>
#include <cbfs.h>
+#include <cbfs_core.h>
-struct rom_header *pci_rom_probe(struct device *dev)
+static struct rom_header *
+pci_rom_verify_and_load(struct device *dev, struct rom_header *rom_header,
+ void *load_addr, int check_didvid)
{
- struct rom_header *rom_header;
struct pci_data *rom_data;
-
- /* If it's in FLASH, then don't check device for ROM. */
- rom_header = cbfs_load_optionrom(CBFS_DEFAULT_MEDIA, dev->vendor,
- dev->device, NULL);
-
- u32 vendev = (dev->vendor << 16) | dev->device;
- u32 mapped_vendev = vendev;
-
- if (map_oprom_vendev)
- mapped_vendev = map_oprom_vendev(vendev);
-
- if (!rom_header) {
- if (vendev != mapped_vendev) {
- rom_header = cbfs_load_optionrom(
- CBFS_DEFAULT_MEDIA,
- mapped_vendev >> 16,
- mapped_vendev & 0xffff, NULL);
- }
- }
-
- if (rom_header) {
- printk(BIOS_DEBUG, "In CBFS, ROM address for %s = %p\n",
- dev_path(dev), rom_header);
- } else {
- u32 rom_address;
-
- rom_address = pci_read_config32(dev, PCI_ROM_ADDRESS);
-
- if (rom_address == 0x00000000 || rom_address == 0xffffffff) {
-#if CONFIG_BOARD_EMULATION_QEMU_X86
- if ((dev->class >> 8) == PCI_CLASS_DISPLAY_VGA)
- rom_address = 0xc0000;
- else
-#endif
- return NULL;
- } else {
- /* Enable expansion ROM address decoding. */
- pci_write_config32(dev, PCI_ROM_ADDRESS,
- rom_address|PCI_ROM_ADDRESS_ENABLE);
- }
-
-#if CONFIG_ON_DEVICE_ROM_RUN
- printk(BIOS_DEBUG, "Option ROM address for %s = %lx\n",
- dev_path(dev), (unsigned long)rom_address);
- rom_header = (struct rom_header *)rom_address;
-#else
- printk(BIOS_DEBUG, "Option ROM execution disabled "
- "for %s\n", dev_path(dev));
- return NULL;
-#endif
- }
+ unsigned int rom_size;
+ unsigned int image_size;
printk(BIOS_SPEW, "PCI expansion ROM, signature 0x%04x, "
"INIT size 0x%04x, data ptr 0x%04x\n",
@@ -100,10 +54,11 @@ struct rom_header *pci_rom_probe(struct device *dev)
printk(BIOS_SPEW, "PCI ROM image, vendor ID %04x, device ID %04x,\n",
rom_data->vendor, rom_data->device);
+
/* If the device id is mapped, a mismatch is expected */
- if ((dev->vendor != rom_data->vendor
- || dev->device != rom_data->device)
- && (vendev == mapped_vendev)) {
+ if (check_didvid != 0 &&
+ (dev->vendor != rom_data->vendor ||
+ dev->device != rom_data->device)) {
printk(BIOS_ERR, "ID mismatch: vendor ID %04x, "
"device ID %04x\n", rom_data->vendor, rom_data->device);
return NULL;
@@ -117,29 +72,16 @@ struct rom_header *pci_rom_probe(struct device *dev)
printk(BIOS_DEBUG, "Class Code mismatch ROM %08x, dev %08x\n",
(rom_data->class_hi << 8) | rom_data->class_lo,
dev->class);
- // return NULL;
}
- return rom_header;
-}
-
-static void *pci_ram_image_start = (void *)PCI_RAM_IMAGE_START;
-
-struct rom_header *pci_rom_load(struct device *dev,
- struct rom_header *rom_header)
-{
- struct pci_data * rom_data;
- unsigned int rom_size;
- unsigned int image_size=0;
-
+ image_size = 0;
do {
/* Get next image. */
- rom_header = (struct rom_header *)((void *) rom_header
- + image_size);
-
- rom_data = (struct pci_data *)((void *) rom_header
- + le32_to_cpu(rom_header->data));
+ int data_offset;
+ rom_header = (void *)((char *)rom_header + image_size);
+ data_offset = le32_to_cpu(rom_header->data);
+ rom_data = (void *)((char *)rom_header + data_offset);
image_size = le32_to_cpu(rom_data->ilen) * 512;
} while ((rom_data->type != 0) && (rom_data->indicator != 0)); // make sure we got x86 version
@@ -148,30 +90,128 @@ struct rom_header *pci_rom_load(struct device *dev,
rom_size = rom_header->size * 512;
- /*
- * We check to see if the device thinks it is a VGA device not
- * whether the ROM image is for a VGA device because some
- * devices have a mismatch between the hardware and the ROM.
- */
- if (PCI_CLASS_DISPLAY_VGA == (dev->class >> 8)) {
+ if (load_addr != (void *)rom_header) {
+ printk(BIOS_DEBUG, "Copying ROM from %p to %p, 0x%x bytes.\n",
+ rom_header, load_addr, rom_size);
+ memcpy(load_addr, rom_header, rom_size);
+ }
+
+ return load_addr;
+}
+
+static inline int tohex4(unsigned int c)
+{
+ return (c <= 9) ? (c + '0') : (c - 10 + 'a');
+}
+
+static void tohex16(uint16_t val, char* dest)
+{
+ dest[0] = tohex4(val>>12);
+ dest[1] = tohex4((val>>8) & 0xf);
+ dest[2] = tohex4((val>>4) & 0xf);
+ dest[3] = tohex4(val & 0xf);
+}
+
+static const struct cbfs_file_descriptor *
+cbfs_open_optionrom(uint16_t vendor, uint16_t device)
+{
+ char name[17] = "pciXXXX,XXXX.rom";
+
+ tohex16(vendor, name+3);
+ tohex16(device, name+8);
+
+ return cbfs_open_by_name_type(cbfs_default_descriptor(), name,
+ CBFS_TYPE_OPTIONROM);
+}
+
+static void *cbfs_probe_and_load(struct device *dev, void *dest)
+{
+ const struct cbfs_file_descriptor *file;
+ uint32_t vendev;
+ int remapped;
+ struct rom_header *hdr;
+ void *load_addr;
+ ssize_t filesz;
+
+ load_addr = NULL;
+ remapped = 0;
+ file = cbfs_open_optionrom(dev->vendor, dev->device);
+
+ if (file == NULL && map_oprom_vendev != NULL) {
+ vendev = map_oprom_vendev((dev->vendor << 16) | dev->device);
+ file = cbfs_open_optionrom(vendev >> 16, vendev & 0xffff);
+ remapped = 1;
+ }
+
+ if (file == NULL)
+ return NULL;
+
+ filesz = cbfs_file_content_size(file);
+ hdr = cbfs_file_map_content(file, 0, filesz);
+ if (hdr == NULL)
+ goto out;
+
+ printk(BIOS_DEBUG, "In CBFS, ROM address for %s = %p\n",
+ dev_path(dev), hdr);
+
+ load_addr = pci_rom_verify_and_load(dev, hdr, dest, !remapped);
+ cbfs_file_unmap(file, hdr);
+
+out:
+ cbfs_file_close(file);
+ return load_addr;
+}
+
+#if CONFIG_ON_DEVICE_ROM_RUN
+static void *dev_probe_and_load(struct device *dev, void *dest)
+{
+ uint32_t rom_address;
+ struct rom_header *rom_header;
+
+ rom_address = pci_read_config32(dev, PCI_ROM_ADDRESS);
+
+ if (rom_address == 0x00000000 || rom_address == 0xffffffff) {
+ if (IS_ENABLED(CONFIG_BOARD_EMULATION_QEMU_X86))
+ rom_address = 0xc0000;
+ else
+ return NULL;
+ } else {
+ /* Enable expansion ROM address decoding. */
+ pci_write_config32(dev, PCI_ROM_ADDRESS,
+ rom_address|PCI_ROM_ADDRESS_ENABLE);
+ }
+ printk(BIOS_DEBUG, "Option ROM address for %s = %lx\n",
+ dev_path(dev), (unsigned long)rom_address);
+
+ rom_header = (struct rom_header *)rom_address;
+
+ return pci_rom_verify_and_load(dev, rom_header, dest, 1);
+}
+#endif
+
+struct rom_header *pci_load_vga_rom(struct device *dev)
+{
+ void *vga_load_addr = (void *)PCI_VGA_RAM_IMAGE_START;
+ void *load_addr;
+
+ if (PCI_CLASS_DISPLAY_VGA != (dev->class >> 8))
+ return NULL;
+
#if !CONFIG_MULTIPLE_VGA_ADAPTERS
- extern device_t vga_pri; /* Primary VGA device (device.c). */
- if (dev != vga_pri) return NULL; /* Only one VGA supported. */
+ extern device_t vga_pri; /* Primary VGA device (device.c). */
+ if (dev != vga_pri) return NULL; /* Only one VGA supported. */
#endif
- if ((void *)PCI_VGA_RAM_IMAGE_START != rom_header) {
- printk(BIOS_DEBUG, "Copying VGA ROM Image from %p to "
- "0x%x, 0x%x bytes\n", rom_header,
- PCI_VGA_RAM_IMAGE_START, rom_size);
- memcpy((void *)PCI_VGA_RAM_IMAGE_START, rom_header,
- rom_size);
- }
- return (struct rom_header *) (PCI_VGA_RAM_IMAGE_START);
- }
- printk(BIOS_DEBUG, "Copying non-VGA ROM image from %p to %p, 0x%x "
- "bytes\n", rom_header, pci_ram_image_start, rom_size);
+ load_addr = cbfs_probe_and_load(dev, vga_load_addr);
+
+ if (load_addr == NULL) {
+#if CONFIG_ON_DEVICE_ROM_RUN
+ load_addr = dev_probe_and_load(dev, vga_load_addr);
+#else
+ printk(BIOS_DEBUG, "Option ROM execution disabled for %s\n",
+ dev_path(dev));
+#endif
+ }
- memcpy(pci_ram_image_start, rom_header, rom_size);
- pci_ram_image_start += rom_size;
- return (struct rom_header *) (pci_ram_image_start-rom_size);
+ return load_addr;
}
diff --git a/src/drivers/elog/elog.c b/src/drivers/elog/elog.c
index de34928..597c32e 100644
--- a/src/drivers/elog/elog.c
+++ b/src/drivers/elog/elog.c
@@ -22,10 +22,9 @@
#include <console/console.h>
#include <pc80/mc146818rtc.h>
#include <smbios.h>
-#include <spi-generic.h>
-#include <spi_flash.h>
#include <stdint.h>
#include <string.h>
+#include <region.h>
#include <elog.h>
#include "elog_internal.h"
@@ -54,13 +53,15 @@
#define elog_debug(STR...)
#endif
+
+#define ELOG_REGION_NAME "elog"
+
/*
* Static variables for ELOG state
*/
static struct elog_area *elog_area;
static u16 total_size;
static u16 log_size;
-static u32 flash_base;
static elog_area_state area_state;
static elog_header_state header_state;
@@ -70,51 +71,10 @@ static u16 next_event_offset;
static u16 event_count;
static int elog_initialized;
-static struct spi_flash *elog_spi;
-
-
-static inline u32 get_rom_size(void)
-{
- u32 rom_size;
-
- /* Assume the used space of the ROM image starts from 0. The
- * physical size of the device may not be completely used. */
- rom_size = elog_spi->size;
- if (rom_size > CONFIG_ROM_SIZE)
- rom_size = CONFIG_ROM_SIZE;
-
- return rom_size;
-}
-
-/*
- * Convert a memory mapped flash address into a flash offset
- */
-static inline u32 elog_flash_address_to_offset(u8 *address)
-{
- u32 rom_size;
-
- if (!elog_spi)
- return 0;
- rom_size = get_rom_size();
-
- return (u32)address - ((u32)~0UL - rom_size + 1);
-}
-
-/*
- * Convert a flash offset into a memory mapped flash address
- */
-static inline u8* elog_flash_offset_to_address(u32 offset)
-{
- u32 rom_size;
-
- if (!elog_spi)
- return NULL;
-
- rom_size = get_rom_size();
-
- return (u8*)((u32)~0UL - rom_size + 1 + offset);
-}
+/* Region device for accessing the ELOG area. */
+static struct region_device elog_dev;
+static rhandle_t elog_rh = INVALID_RHANDLE;
/*
* Pointer to an event log header in the event data area
@@ -259,17 +219,16 @@ static void elog_flash_write(void *address, u32 size)
{
u32 offset;
- if (!address || !size || !elog_spi)
+ if (!address || !size)
return;
- offset = flash_base;
- offset += (u8 *)address - (u8 *)elog_area;
+ offset = (u8 *)address - (u8 *)elog_area;
elog_debug("elog_flash_write(address=0x%p offset=0x%08x size=%u)\n",
address, offset, size);
/* Write the data to flash */
- elog_spi->write(elog_spi, offset, size, address);
+ region_writeat(elog_rh, address, offset, size);
}
/*
@@ -280,17 +239,16 @@ static void elog_flash_erase(void *address, u32 size)
{
u32 offset;
- if (!address || !size || !elog_spi)
+ if (!address || !size)
return;
- offset = flash_base;
- offset += (u8 *)address - (u8*)elog_area;
+ offset = (u8 *)address - (u8*)elog_area;
elog_debug("elog_flash_erase(address=0x%p offset=0x%08x size=%u)\n",
address, offset, size);
/* Erase the sectors in this region */
- elog_spi->erase(elog_spi, offset, size);
+ region_eraseat(elog_rh, offset, size);
}
/*
@@ -348,7 +306,7 @@ static void elog_scan_flash(void)
event_buffer_state = ELOG_EVENT_BUFFER_OK;
/* Fill memory buffer by reading from SPI */
- elog_spi->read(elog_spi, flash_base, total_size, elog_area);
+ region_readat(elog_rh, elog_area, 0, total_size);
next_event_offset = 0;
event_count = 0;
@@ -449,13 +407,17 @@ int elog_smbios_write_type15(unsigned long *current, int handle)
{
struct smbios_type15 *t = (struct smbios_type15 *)*current;
int len = sizeof(struct smbios_type15);
+ void *backing_store;
#if CONFIG_ELOG_CBMEM
/* Save event log buffer into CBMEM for the OS to read */
- void *cbmem = cbmem_add(CBMEM_ID_ELOG, total_size);
- if (!cbmem)
+ backing_store = cbmem_add(CBMEM_ID_ELOG, total_size);
+ if (!backing_store)
return 0;
- memcpy(cbmem, elog_area, total_size);
+ memcpy(backing_store, elog_area, total_size);
+#else
+ /* This assumes x86 memory-mapped capabilities of flash. */
+ backing_store = region_mmap(elog_rh, 0, total_size);
#endif
memset(t, 0, len);
@@ -468,11 +430,7 @@ int elog_smbios_write_type15(unsigned long *current, int handle)
t->access_method = SMBIOS_EVENTLOG_ACCESS_METHOD_MMIO32;
t->log_status = SMBIOS_EVENTLOG_STATUS_VALID;
t->change_token = 0;
-#if CONFIG_ELOG_CBMEM
- t->address = (u32)cbmem;
-#else
- t->address = (u32)elog_flash_offset_to_address(flash_base);
-#endif
+ t->address = (u32)backing_store;
t->header_format = ELOG_HEADER_TYPE_OEM;
t->log_type_descriptors = 0;
t->log_type_descriptor_length = 2;
@@ -506,33 +464,46 @@ int elog_clear(void)
return 0;
}
-static void elog_find_flash(void)
+static int elog_find_flash(void)
{
-#if CONFIG_CHROMEOS
- u8 *flash_base_ptr;
-#endif
+ rhandle_t rh;
+
+ if (rhandle_valid(elog_rh))
+ return 0;
elog_debug("elog_find_flash()\n");
#if CONFIG_CHROMEOS
/* Find the ELOG base and size in FMAP */
- total_size = find_fmap_entry("RW_ELOG", (void **)&flash_base_ptr);
- if (total_size < 0) {
+ if (fmap_locate("RW_ELOG", &elog_dev.region.offset,
+ &elog_dev.region.size)) {
printk(BIOS_WARNING, "ELOG: Unable to find RW_ELOG in FMAP, "
"using CONFIG_ELOG_FLASH_BASE instead\n");
- total_size = CONFIG_ELOG_AREA_SIZE;
} else {
- flash_base = elog_flash_address_to_offset(flash_base_ptr);
-
/* Use configured size if smaller than FMAP size */
- if (total_size > CONFIG_ELOG_AREA_SIZE)
- total_size = CONFIG_ELOG_AREA_SIZE;
+ if (elog_dev.region.size > CONFIG_ELOG_AREA_SIZE)
+ elog_dev.region.size = CONFIG_ELOG_AREA_SIZE;
}
#else
- flash_base = CONFIG_ELOG_FLASH_BASE;
- total_size = CONFIG_ELOG_AREA_SIZE;
+ elog_dev.region.offset = CONFIG_ELOG_FLASH_BASE;
+ elog_dev.region.size = CONFIG_ELOG_AREA_SIZE;
#endif
+ total_size = elog_dev.region.size;
log_size = total_size - sizeof(struct elog_header);
+
+ rh = region_locate(BOOTRW_REGION_NAME);
+ if (!rhandle_valid(rh)) {
+ printk(BIOS_WARNING, "Unable to find writable boot region.\n");
+ return -1;
+ }
+ rh = region_register_subregion("elog", &elog_dev, rh);
+ if (!rhandle_valid(rh)) {
+ printk(BIOS_WARNING, "Unable to register ELOG region.\n");
+ return -1;
+ }
+
+ elog_rh = rh;
+ return 0;
}
/*
@@ -545,18 +516,9 @@ int elog_init(void)
elog_debug("elog_init()\n");
- /* Prepare SPI */
- spi_init();
- elog_spi = spi_flash_probe(0, 0, 0, 0);
- if (!elog_spi) {
- printk(BIOS_ERR, "ELOG: Unable to find SPI flash\n");
- return -1;
- }
-
/* Set up the backing store */
- elog_find_flash();
- if (flash_base == 0) {
- printk(BIOS_ERR, "ELOG: Invalid flash base\n");
+ if (elog_find_flash()) {
+ printk(BIOS_ERR, "ELOG: region not set up.\n");
return -1;
}
@@ -589,8 +551,8 @@ int elog_init(void)
elog_initialized = 1;
- printk(BIOS_INFO, "ELOG: FLASH @0x%p [SPI 0x%08x]\n",
- elog_area, flash_base);
+ printk(BIOS_INFO, "ELOG: FLASH @0x%p [SPI 0x%08zx]\n",
+ elog_area, (size_t)elog_dev.region.offset);
printk(BIOS_INFO, "ELOG: area is %d bytes, full threshold %d,"
" shrink size %d\n", total_size,
diff --git a/src/include/cbfs.h b/src/include/cbfs.h
index ebdbf43..bd000c9 100644
--- a/src/include/cbfs.h
+++ b/src/include/cbfs.h
@@ -1,14 +1,8 @@
/*
* This file is part of the coreboot project.
*
- * Copyright (C) 2008 Jordan Crouse <jordan(a)cosmicpenguin.net>
- * Copyright (C) 2013 The Chromium OS Authors. All rights reserved.
+ * Copyright (C) 2014 Google Inc.
*
- * This file is dual-licensed. You can choose between:
- * - The GNU GPL, version 2, as published by the Free Software Foundation
- * - The revised BSD license (without advertising clause)
- *
- * ---------------------------------------------------------------------------
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; version 2 of the License.
@@ -20,62 +14,84 @@
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
- * ---------------------------------------------------------------------------
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * 3. The name of the author may not be used to endorse or promote products
- * derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- * ---------------------------------------------------------------------------
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
-
#ifndef _CBFS_H_
#define _CBFS_H_
-#include <cbfs_core.h>
+#include <stdint.h>
+#include <region.h>
-void *cbfs_load_optionrom(struct cbfs_media *media, uint16_t vendor,
- uint16_t device, void * dest);
-void *cbfs_load_stage(struct cbfs_media *media, const char *name);
-
-/* Simple buffer for streaming media. */
-struct cbfs_simple_buffer {
- char *buffer;
- size_t allocated;
+/* Describe an instance of cbfs. */
+struct cbfs_descriptor {
+ rhandle_t rh;
+ size_t align;
size_t size;
- size_t last_allocate;
};
-void *cbfs_simple_buffer_map(struct cbfs_simple_buffer *buffer,
- struct cbfs_media *media,
- size_t offset, size_t count);
+struct cbfs_file_descriptor;
+
+/* Obtain the default cbfs_descriptor. */
+const struct cbfs_descriptor *cbfs_default_descriptor(void);
+
+/* Open a file by name. Return NULL on error. */
+const struct cbfs_file_descriptor *
+cbfs_open_by_name(const struct cbfs_descriptor *cbfs, const char *name);
+
+/* Open a file by name and type. */
+const struct cbfs_file_descriptor *
+cbfs_open_by_name_type(const struct cbfs_descriptor *cbfs,
+ const char *name, uint32_t type);
+
+/* Close a previously opened file. */
+void cbfs_file_close(const struct cbfs_file_descriptor *fd);
+
+/* Return the size of the file's contents. < 0 on error. */
+ssize_t cbfs_file_content_size(const struct cbfs_file_descriptor *fd);
+
+/* Return the size of the file's metadata contents. < 0 on error. */
+ssize_t cbfs_file_metadata_size(const struct cbfs_file_descriptor *fd);
+
+/*
+ * Read size bytes file contents from offset of into buffer. Returns < 0
+ * on error or bytes read.
+ */
+ssize_t cbfs_file_read_content(const struct cbfs_file_descriptor *fd,
+ void *buf, offset_t offset, size_t size);
+
+/* Attempt to map the file content. Returns NULL on error. */
+void *cbfs_file_map_content(const struct cbfs_file_descriptor *fd,
+ offset_t offset, size_t size);
+
+/*
+ * Read size bytes file metadata from offset of into buffer. Returns < 0
+ * on error or bytes read.
+ */
+ssize_t cbfs_file_read_metadata(const struct cbfs_file_descriptor *fd,
+ void *buf, offset_t offset, size_t size);
+/*
+ * Attempt to map all of the file's metadata. Depending on the file type there
+ * may be no metadata in which case NULL will be returned. File types of
+ * CBFS_TYPE_STAGE and CBFS_TYPE_PAYLOAD are currently the only files that
+ * contain metadata.
+ *
+ * Returns NULL on error.
+ */
+void *cbfs_file_map_metadata(const struct cbfs_file_descriptor *fd);
+
+/* Unmap the mapping associated with addr. No partial unmappings allowed. */
+void cbfs_file_unmap(const struct cbfs_file_descriptor *fd, void *addr);
+
-void *cbfs_simple_buffer_unmap(struct cbfs_simple_buffer *buffer,
- const void *address);
+void *cbfs_load_optionrom(const struct cbfs_descriptor *cbfs,
+ uint16_t vendor, uint16_t device, void * dest);
-// Utility functions
-int run_address(void *f);
+/* Return entry point to stage, or NULL on failure. */
+void *cbfs_load_stage(const struct cbfs_descriptor *cbfs, const char *name);
-/* Defined in individual arch / board implementation. */
-int init_default_cbfs_media(struct cbfs_media *media);
+/* Decompress range of file to destination. Returns bytes decompressed. */
+size_t cbfs_file_inflate(const struct cbfs_file_descriptor *fd,
+ offset_t offset, size_t src_sz, void *dest);
#if defined(__PRE_RAM__)
struct romstage_handoff;
diff --git a/src/include/cbfs_core.h b/src/include/cbfs_core.h
index a1d8127..6a91454 100644
--- a/src/include/cbfs_core.h
+++ b/src/include/cbfs_core.h
@@ -186,50 +186,6 @@ struct cbfs_optionrom {
uint32_t len;
} __attribute__((packed));
-#define CBFS_MEDIA_INVALID_MAP_ADDRESS ((void*)(0xffffffff))
-#define CBFS_DEFAULT_MEDIA ((void*)(0x0))
-
-/* Media for CBFS to load files. */
-struct cbfs_media {
-
- /* implementation dependent context, to hold resource references */
- void *context;
-
- /* opens media and returns 0 on success, -1 on failure */
- int (*open)(struct cbfs_media *media);
-
- /* returns number of bytes read from media into dest, starting from
- * offset for count of bytes */
- size_t (*read)(struct cbfs_media *media, void *dest, size_t offset,
- size_t count);
-
- /* returns a pointer to memory with count of bytes from media source
- * starting from offset, or CBFS_MEDIA_INVALID_MAP_ADDRESS on failure.
- * Note: mapped data can't be free unless unmap is called, even if you
- * do close first. */
- void * (*map)(struct cbfs_media *media, size_t offset, size_t count);
-
- /* returns NULL and releases the memory by address, which was allocated
- * by map */
- void * (*unmap)(struct cbfs_media *media, const void *address);
-
- /* closes media and returns 0 on success, -1 on failure. */
- int (*close)(struct cbfs_media *media);
-};
-
-/* returns pointer to a file entry inside CBFS or NULL */
-struct cbfs_file *cbfs_get_file(struct cbfs_media *media, const char *name);
-
-/* returns pointer to file content inside CBFS after if type is correct */
-void *cbfs_get_file_content(struct cbfs_media *media, const char *name,
- int type, size_t *sz);
-
-/* returns decompressed size on success, 0 on failure */
-int cbfs_decompress(int algo, void *src, void *dst, int len);
-
-/* returns a pointer to CBFS master header, or CBFS_HEADER_INVALID_ADDRESS
- * on failure */
-const struct cbfs_header *cbfs_get_header(struct cbfs_media *media);
#endif /* __ROMCC__ */
diff --git a/src/include/device/pci_rom.h b/src/include/device/pci_rom.h
index fe77276..4bd0bfd 100644
--- a/src/include/device/pci_rom.h
+++ b/src/include/device/pci_rom.h
@@ -6,7 +6,6 @@
#define PCI_ROM_HDR 0xAA55
#define PCI_DATA_HDR (uint32_t) ( ('R' << 24) | ('I' << 16) | ('C' << 8) | 'P' )
-#define PCI_RAM_IMAGE_START 0xD0000
#define PCI_VGA_RAM_IMAGE_START 0xC0000
struct rom_header {
@@ -33,8 +32,7 @@ struct pci_data {
uint16_t reserved_2;
};
-struct rom_header *pci_rom_probe(struct device *dev);
-struct rom_header *pci_rom_load(struct device *dev, struct rom_header *rom_header);
+struct rom_header *pci_load_vga_rom(struct device *dev);
u32 __attribute__((weak)) map_oprom_vendev(u32 vendev);
#endif
diff --git a/src/include/payload_loader.h b/src/include/payload_loader.h
index 7a3f045..7b6fc1c 100644
--- a/src/include/payload_loader.h
+++ b/src/include/payload_loader.h
@@ -22,6 +22,8 @@
#include <stdint.h>
#include <stddef.h>
+struct cbfs_file_descriptor;
+
struct buffer_area {
void *data;
size_t size;
@@ -29,6 +31,7 @@ struct buffer_area {
struct payload {
const char *name;
+ const struct cbfs_file_descriptor *fd;
struct buffer_area backing_store;
/* Used when payload wants memory coreboot ramstage is running at. */
struct buffer_area bounce;
diff --git a/src/include/region.h b/src/include/region.h
new file mode 100644
index 0000000..f1b99df
--- /dev/null
+++ b/src/include/region.h
@@ -0,0 +1,138 @@
+/*
+ * This file is part of the coreboot project.
+ *
+ * Copyright (C) 2014 Google Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef REGION_H
+#define REGION_H
+
+#include <stdint.h>
+#include <stddef.h>
+
+/*
+ * Region support.
+ *
+ * Regions are intended to abstract away the access mechanisms for blocks of
+ * data. This could be SPI, eMMC, or a memory region as the backing store.
+ * Subregions can be made by registering a region_device that is associated
+ * with another region. Regions can be addressed by name, but there is no
+ * hierarchy in the namespace. i.e. the operations through subregions are
+ * hierarchical but the namespace is not.
+ *
+ * There are two views to the boot media: read-only and read-write. On certain
+ * architectures the read-write availability is not available until late in
+ * ramstage. Therefore, users of each region need to be cognizant of the fact
+ * that different implementations may be backing a particular region. e.g. on
+ * x86 the read-only boot region doesn't have write and erase capabilities, but
+ * the read-write boot region would allow writes and erases but no mmap.
+ */
+
+/*
+ * Initialize the boot region. Called directly in pre-ramstage or
+ * automatically in ramstage.
+ */
+void boot_region_init(void);
+/* Initialize the boot media. Board/Arch specific code implements this. */
+void boot_media_initialize(void);
+/*
+ * A potential call for chipsets that can't bring their RW area online til
+ * after the device init in ramstage.
+ */
+void bootrw_media_initialize(void);
+/* Initialize the default CBFS region. */
+void cbfs_default_media_initialize(void);
+
+typedef uintptr_t offset_t;
+typedef long rhandle_t;
+#define INVALID_RHANDLE ((rhandle_t)~((uintptr_t)0))
+
+#define BOOTRO_REGION_NAME "bootro"
+#define BOOTRW_REGION_NAME "bootrw"
+#define DEFAULT_CBFS_REGION_NAME "cbfs"
+
+struct region_device;
+
+struct region_device_ops {
+ void *(*mmap)(const struct region_device *, offset_t, size_t);
+ void (*munmap)(const struct region_device *, void *);
+ ssize_t (*readat)(const struct region_device *, void *,
+ offset_t, size_t);
+ ssize_t (*writeat)(const struct region_device *, const void *,
+ offset_t, size_t);
+ ssize_t (*eraseat)(const struct region_device *, offset_t, size_t);
+};
+
+struct region {
+ offset_t offset;
+ size_t size;
+};
+
+struct region_device {
+ const struct region_device_ops *ops;
+ struct region region;
+};
+
+/* Return 1 if child is contained within parent else 0. */
+int region_contained(const struct region *parent, const struct region *child);
+
+static inline int rhandle_valid(rhandle_t rh)
+{
+ return !!(rh >= 0);
+}
+
+/* Register a region_device by name. */
+rhandle_t region_register(const char *name, const struct region_device *rdev);
+
+/* Register a subregion by name under parent. rdev->ops must be NULL. */
+rhandle_t region_register_subregion(const char *name,
+ const struct region_device *rdev,
+ rhandle_t parent);
+
+/* Locate a region of provided name. */
+rhandle_t region_locate(const char *name);
+
+/*
+ * Read subregion within provided region.
+ * Returns bytes read, < 0 on error.
+ */
+ssize_t region_readat(rhandle_t rh, void *buf, offset_t offset, size_t count);
+
+/*
+ * Write to subregion within provided region.
+ * Returns bytes written, < 0 on error.
+ */
+ssize_t region_writeat(rhandle_t rh, void *buf, offset_t offset, size_t count);
+
+/*
+ * Erase subregion within provide region.
+ * Returns bytes erased, < 0 on error.
+ */
+ssize_t region_eraseat(rhandle_t rh, offset_t offset, size_t count);
+
+/*
+ * Map subregion described by offset and size within the region provided.
+ * Returns pointer to mapped subregion or NULL on error.
+ */
+void *region_mmap(rhandle_t rh, offset_t offset, size_t count);
+
+/* Unmap previously mapped region. */
+void region_munmap(rhandle_t rh, void *addr);
+
+/* Get size of region represented by rh. < 0 on error. */
+ssize_t region_size(rhandle_t rh);
+
+#endif /* REGION_H */
diff --git a/src/include/rmodule.h b/src/include/rmodule.h
index 2147ab0..19f32e4 100644
--- a/src/include/rmodule.h
+++ b/src/include/rmodule.h
@@ -61,6 +61,7 @@ int rmodule_calc_region(unsigned int region_alignment, size_t rmodule_size,
#if CONFIG_DYNAMIC_CBMEM
struct cbfs_stage;
struct cbmem_entry;
+struct cbfs_descriptor;
struct rmod_stage_load {
/* Inputs */
@@ -72,8 +73,10 @@ struct rmod_stage_load {
};
/* Both of the following functions return 0 on success, -1 on error. */
-int rmodule_stage_load(struct rmod_stage_load *rsl, struct cbfs_stage *stage);
-int rmodule_stage_load_from_cbfs(struct rmod_stage_load *rsl);
+int rmodule_stage_load(struct rmod_stage_load *rsl, struct cbfs_stage *stage,
+ void *data);
+int rmodule_stage_load_from_cbfs(const struct cbfs_descriptor *cbfs,
+ struct rmod_stage_load *rsl);
#endif
struct rmodule {
diff --git a/src/lib/Makefile.inc b/src/lib/Makefile.inc
index acd334e..052dc9f 100644
--- a/src/lib/Makefile.inc
+++ b/src/lib/Makefile.inc
@@ -18,7 +18,9 @@
#
subdirs-y += loaders
+ifneq ($(CONFIG_ARCH_X86),y)
bootblock-y += cbfs.c
+endif
ifneq ($(CONFIG_HAVE_ARCH_MEMSET),y)
bootblock-y += memset.c
endif
@@ -109,6 +111,13 @@ ramstage-y += cbmem_info.c
ramstage-y += hexdump.c
romstage-y += hexdump.c
+ramstage-y += region.c
+romstage-y += region.c
+ramstage-y += cbfs_boot_region.c
+romstage-y += cbfs_boot_region.c
+smm-y += cbfs_boot_region.c
+ramstage-$(CONFIG_BOOT_REGION_SPI_FLASH) += bootrw_spi_flash_region.c
+smm-$(CONFIG_BOOT_REGION_SPI_FLASH) += bootrw_spi_flash_region.c
ramstage-$(CONFIG_REG_SCRIPT) += reg_script.c
@@ -125,6 +134,7 @@ smm-y += memmove.c
endif
smm-y += cbfs.c memcmp.c
smm-y += gcc.c
+smm-y += region.c
$(obj)/lib/version.ramstage.o : $(obj)/build.h
diff --git a/src/lib/bootrw_spi_flash_region.c b/src/lib/bootrw_spi_flash_region.c
new file mode 100644
index 0000000..80b1cd1
--- /dev/null
+++ b/src/lib/bootrw_spi_flash_region.c
@@ -0,0 +1,107 @@
+/*
+ * This file is part of the coreboot project.
+ *
+ * Copyright (C) 2014 Google Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+
+#include <stddef.h>
+#include <region.h>
+#include <spi-generic.h>
+#include <spi_flash.h>
+
+struct bootrw_flash_device {
+ struct spi_flash *spi;
+ struct region_device dev;
+};
+
+
+static ssize_t
+bootrw_readat(const struct region_device *rdev, void *buf,
+ offset_t offset, size_t size)
+{
+ struct bootrw_flash_device *dev;
+
+ dev = container_of(rdev, struct bootrw_flash_device, dev);
+ if (dev->spi->read(dev->spi, offset, size, buf))
+ return -1;
+ return size;
+}
+
+static ssize_t
+bootrw_writeat(const struct region_device *rdev, const void *buf,
+ offset_t offset, size_t size)
+{
+ struct bootrw_flash_device *dev;
+
+ dev = container_of(rdev, struct bootrw_flash_device, dev);
+ if (dev->spi->write(dev->spi, offset, size, buf))
+ return -1;
+ return size;
+}
+
+static ssize_t
+bootrw_eraseat(const struct region_device *rdev, offset_t offset, size_t size)
+{
+ struct bootrw_flash_device *dev;
+
+ dev = container_of(rdev, struct bootrw_flash_device, dev);
+ if (dev->spi->erase(dev->spi, offset, size))
+ return -1;
+ return size;
+}
+
+static const struct region_device_ops bootrw_ops = {
+ .readat = bootrw_readat,
+ .writeat = bootrw_writeat,
+ .eraseat = bootrw_eraseat,
+};
+
+static struct bootrw_flash_device flashdev = {
+ .dev = {
+ .ops = &bootrw_ops,
+ .region = {
+ .offset = 0,
+ .size = CONFIG_ROM_SIZE,
+ },
+ }
+};
+
+void bootrw_media_initialize(void)
+{
+ /* Reinitialize spi regs in case. */
+ spi_init();
+
+ if (flashdev.spi != NULL)
+ return;
+
+ flashdev.spi = spi_flash_probe(0, 0, 0, 0);
+ if (flashdev.spi == NULL) {
+ printk(BIOS_WARNING, "SPI probing failed for boot region.\n");
+ return;
+ }
+
+ if (flashdev.spi->size != CONFIG_ROM_SIZE) {
+ printk(BIOS_WARNING,
+ "SPI mismatch with CONFIG_ROM_SIZE: %zx vs %zx\n",
+ (size_t)CONFIG_ROM_SIZE, (size_t)flashdev.spi->size);
+ return;
+ }
+
+ if (!rhandle_valid(region_register(BOOTRW_REGION_NAME, &flashdev.dev)))
+ printk(BIOS_WARNING, "Couldn't register '%s' region.\n",
+ BOOTRW_REGION_NAME);
+}
diff --git a/src/lib/cbfs.c b/src/lib/cbfs.c
index dc08937..04f4034 100644
--- a/src/lib/cbfs.c
+++ b/src/lib/cbfs.c
@@ -1,8 +1,7 @@
/*
* This file is part of the coreboot project.
*
- * Copyright (C) 2008, Jordan Crouse <jordan(a)cosmicpenguin.net>
- * Copyright (C) 2013 The Chromium OS Authors. All rights reserved.
+ * Copyright (C) 2014-2014 Google Inc.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@@ -18,192 +17,390 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA, 02110-1301 USA
*/
-#ifdef LIBPAYLOAD
-# include <libpayload-config.h>
-# ifdef CONFIG_LZMA
-# include <lzma.h>
-# define CBFS_CORE_WITH_LZMA
-# endif
-# define CBFS_MINI_BUILD
-#elif defined(__SMM__)
-# define CBFS_MINI_BUILD
-#elif defined(__BOOT_BLOCK__)
- /* No LZMA in boot block. */
-#elif defined(__PRE_RAM__) && !CONFIG_COMPRESS_RAMSTAGE
- /* No LZMA in romstage if ramstage is not compressed. */
-#else
-# define CBFS_CORE_WITH_LZMA
-# include <lib.h>
+#if !defined(__BOOT_BLOCK__) && !(defined(__PRE_RAM__) && !IS_ENABLED(CONFIG_COMPRESS_RAMSTAGE))
+#define CBFS_WITH_LZMA
#endif
-#include <cbfs.h>
#include <string.h>
+#include <arch/early_variables.h>
+#include <cbfs.h>
+#include <cbfs_core.h>
#include <cbmem.h>
+#include <console/console.h>
+#include <lib.h>
-#ifdef LIBPAYLOAD
-# include <stdio.h>
-# define DEBUG(x...)
-# define LOG(x...) printf(x)
-# define ERROR(x...) printf(x)
-#else
-# include <console/console.h>
-# define ERROR(x...) printk(BIOS_ERR, "CBFS: " x)
-# define LOG(x...) printk(BIOS_INFO, "CBFS: " x)
-# if CONFIG_DEBUG_CBFS
-# define DEBUG(x...) printk(BIOS_SPEW, "CBFS: " x)
-# else
-# define DEBUG(x...)
-# endif
-#endif
+struct cbfs_file_descriptor {
+ rhandle_t rh;
+ struct region metadata;
+ struct region content;
+};
-#if defined(CONFIG_CBFS_HEADER_ROM_OFFSET) && (CONFIG_CBFS_HEADER_ROM_OFFSET)
-# define CBFS_HEADER_ROM_ADDRESS (CONFIG_CBFS_HEADER_ROM_OFFSET)
-#else
-// Indirect address: only works on 32bit top-aligned systems.
-# define CBFS_HEADER_ROM_ADDRESS (*(uint32_t *)0xfffffffc)
-#endif
+#define MAX_CBFS_OPEN_FILES 4
+struct cbfs_file_cache {
+ struct cbfs_file_descriptor files[MAX_CBFS_OPEN_FILES];
+};
-#include "cbfs_core.c"
+static struct cbfs_file_cache g_cbfs_files CAR_GLOBAL;
-#ifndef __SMM__
-static inline int tohex4(unsigned int c)
+static struct cbfs_file_cache *get_cache(void)
{
- return (c <= 9) ? (c + '0') : (c - 10 + 'a');
+ return car_get_var_ptr(&g_cbfs_files);
}
-static void tohex16(unsigned int val, char* dest)
+static int cbfs_fd_available(const struct cbfs_file_descriptor *fd)
{
- dest[0] = tohex4(val>>12);
- dest[1] = tohex4((val>>8) & 0xf);
- dest[2] = tohex4((val>>4) & 0xf);
- dest[3] = tohex4(val & 0xf);
+ return !!(fd->content.size == 0 && fd->metadata.size == 0);
}
-void *cbfs_load_optionrom(struct cbfs_media *media, uint16_t vendor,
- uint16_t device, void *dest)
+static void cbfs_fd_mark_free(const struct cbfs_file_descriptor *cfd)
{
- char name[17] = "pciXXXX,XXXX.rom";
- struct cbfs_optionrom *orom;
- uint8_t *src;
+ struct cbfs_file_descriptor *fd = (struct cbfs_file_descriptor *)cfd;
+ memset(fd, 0, sizeof(*fd));
+ fd->rh = INVALID_RHANDLE;
+}
- tohex16(vendor, name+3);
- tohex16(device, name+8);
+static struct cbfs_file_descriptor *get_available_file(void)
+{
+ int i;
+ struct cbfs_file_cache *cache = get_cache();
- orom = (struct cbfs_optionrom *)
- cbfs_get_file_content(media, name, CBFS_TYPE_OPTIONROM, NULL);
+ for (i = 0; i < MAX_CBFS_OPEN_FILES; i++) {
+ if (cbfs_fd_available(&cache->files[i]))
+ return &cache->files[i];
+ }
+
+ return NULL;
+}
- if (orom == NULL)
+static void cbfs_fd_add_metadata(struct cbfs_file_descriptor *fd, size_t sz)
+{
+ fd->metadata.size += sz;
+ fd->content.offset += sz;
+ fd->content.size -= sz;
+}
+
+static const struct cbfs_file_descriptor *
+allocate_file(const struct cbfs_descriptor *cbfs, const struct cbfs_file *file,
+ offset_t offset)
+{
+ struct cbfs_file_descriptor *fd;
+
+ fd = get_available_file();
+
+ if (fd == NULL)
return NULL;
- /* They might have specified a dest address. If so, we can decompress.
- * If not, there's not much hope of decompressing or relocating the rom.
- * in the common case, the expansion rom is uncompressed, we
- * pass 0 in for the dest, and all we have to do is find the rom and
- * return a pointer to it.
- */
+ fd->rh = cbfs->rh;
+ fd->metadata.offset = file->offset + offset;
+ fd->metadata.size = 0;
+ fd->content.offset = file->offset + offset;
+ fd->content.size = file->len;
- /* BUG: the cbfstool is (not yet) including a cbfs_optionrom header */
- src = (uint8_t *)orom; // + sizeof(struct cbfs_optionrom);
+ if (file->type != CBFS_TYPE_STAGE || file->type != CBFS_TYPE_PAYLOAD)
+ return fd;
- if (! dest)
- return src;
+ if (file->type == CBFS_TYPE_STAGE) {
+ cbfs_fd_add_metadata(fd, sizeof(struct cbfs_stage));
+ return fd;
+ }
- if (!cbfs_decompress(ntohl(orom->compression),
- src,
- dest,
- ntohl(orom->len)))
+ /* Parse payload segments. */
+ while (offset + sizeof(struct cbfs_payload_segment) <= file->len) {
+ struct cbfs_payload_segment segment;
+ ssize_t read_sz;
+
+ read_sz = region_readat(cbfs->rh, &segment, offset,
+ sizeof(segment));
+ if (read_sz != sizeof(segment)) {
+ cbfs_fd_mark_free(fd);
+ return NULL;
+ }
+
+ switch (segment.type) {
+ case PAYLOAD_SEGMENT_CODE:
+ case PAYLOAD_SEGMENT_DATA:
+ case PAYLOAD_SEGMENT_BSS:
+ case PAYLOAD_SEGMENT_PARAMS:
+ cbfs_fd_add_metadata(fd, sizeof(segment));
+ break;
+ case PAYLOAD_SEGMENT_ENTRY:
+ cbfs_fd_add_metadata(fd, sizeof(segment));
+ return fd;
+ default:
+ cbfs_fd_mark_free(fd);
+ return NULL;
+ }
+ }
+
+ cbfs_fd_mark_free(fd);
+ return NULL;
+}
+
+static offset_t
+cbfs_next_offset(offset_t offset, size_t align, size_t increment)
+{
+ offset += increment;
+ if (offset % align)
+ offset += align - (offset % align);
+ return offset;
+}
+
+static const struct cbfs_file_descriptor *
+__cbfs_open(const struct cbfs_descriptor *cbfs,const char *name,
+ uint32_t *type)
+{
+ const struct cbfs_file_descriptor *fd;
+ struct cbfs_file file;
+ ssize_t read_sz;
+ offset_t offset;
+ size_t cbfs_sz;
+ size_t align;
+ rhandle_t rh;
+
+ if (cbfs == NULL || name == NULL)
return NULL;
- return dest;
+ offset = 0;
+ rh = cbfs->rh;
+ align = cbfs->align;
+ cbfs_sz = cbfs->size;
+ fd = NULL;
+
+ while (offset + sizeof(file) < cbfs_sz) {
+ char *file_name;
+ size_t name_sz;
+ size_t entry_sz;
+ int found;
+
+ read_sz = region_readat(rh, &file, offset, sizeof(file));
+ if (read_sz != sizeof(file))
+ return NULL;
+
+ if (memcmp(CBFS_FILE_MAGIC, file.magic, sizeof(file.magic))) {
+ offset = cbfs_next_offset(offset, align, align);
+ continue;
+ }
+
+ file.len = ntohl(file.len);
+ file.type = ntohl(file.type);
+ file.offset = ntohl(file.offset);
+ entry_sz = file.len + file.offset;
+
+ /* File type doesn't match. */
+ if (type != NULL && *type != file.type) {
+ offset = cbfs_next_offset(offset, align, entry_sz);
+ continue;
+ }
+ name_sz = file.offset - sizeof(file);
+ file_name = region_mmap(rh, offset + sizeof(file), name_sz);
+ if (file_name == NULL) {
+ offset = cbfs_next_offset(offset, align, entry_sz);
+ continue;
+ }
+
+ found = !strcmp(file_name, name);
+ region_munmap(rh, file_name);
+
+ if (found) {
+ fd = allocate_file(cbfs, &file, offset);
+ break;
+ }
+ offset = cbfs_next_offset(offset, align, entry_sz);
+ }
+
+ return fd;
}
-void * cbfs_load_stage(struct cbfs_media *media, const char *name)
+const struct cbfs_file_descriptor *
+cbfs_open_by_name(const struct cbfs_descriptor *cbfs, const char *name)
{
- struct cbfs_stage *stage = (struct cbfs_stage *)
- cbfs_get_file_content(media, name, CBFS_TYPE_STAGE, NULL);
- /* this is a mess. There is no ntohll. */
- /* for now, assume compatible byte order until we solve this. */
- uint32_t entry;
- uint32_t final_size;
+ return __cbfs_open(cbfs, name, NULL);
+}
- if (stage == NULL)
- return (void *) -1;
+const struct cbfs_file_descriptor *
+cbfs_open_by_name_type(const struct cbfs_descriptor *cbfs,
+ const char *name, uint32_t type)
+{
+ return __cbfs_open(cbfs, name, &type);
+}
- LOG("loading stage %s @ 0x%x (%d bytes), entry @ 0x%llx\n",
- name,
- (uint32_t) stage->load, stage->memlen,
- stage->entry);
+void cbfs_file_close(const struct cbfs_file_descriptor *file)
+{
+ if (file != NULL)
+ cbfs_fd_mark_free(file);
+}
- final_size = cbfs_decompress(stage->compression,
- ((unsigned char *) stage) +
- sizeof(struct cbfs_stage),
- (void *) (uint32_t) stage->load,
- stage->len);
- if (!final_size)
- return (void *) -1;
+ssize_t cbfs_file_content_size(const struct cbfs_file_descriptor *fd)
+{
+ if (fd == NULL)
+ return -1;
- /* Stages rely the below clearing so that the bss is initialized. */
- memset((void *)((uintptr_t)stage->load + final_size), 0,
- stage->memlen - final_size);
+ return fd->content.size;
+}
+
+ssize_t cbfs_file_metadata_size(const struct cbfs_file_descriptor *fd)
+{
+ if (fd == NULL)
+ return -1;
+
+ return fd->metadata.size;
+}
+
+ssize_t cbfs_file_read_content(const struct cbfs_file_descriptor *fd,
+ void *buf, offset_t offset, size_t size)
+{
+ struct region region = {
+ .offset = offset,
+ .size = size,
+ };
- DEBUG("stage loaded.\n");
+ if (fd == NULL)
+ return -1;
- entry = stage->entry;
- // entry = ntohll(stage->entry);
+ if (!region_contained(&fd->content, ®ion))
+ return -1;
- return (void *) entry;
+ return region_readat(fd->rh, buf, fd->content.offset + offset, size);
}
-/* Simple buffer */
+void *cbfs_file_map_content(const struct cbfs_file_descriptor *fd,
+ offset_t offset, size_t size)
+{
+ struct region region = {
+ .offset = offset,
+ .size = size,
+ };
-void *cbfs_simple_buffer_map(struct cbfs_simple_buffer *buffer,
- struct cbfs_media *media,
- size_t offset, size_t count) {
- void *address = buffer->buffer + buffer->allocated;
- DEBUG("simple_buffer_map(offset=%zd, count=%zd): "
- "allocated=%zd, size=%zd, last_allocate=%zd\n",
- offset, count, buffer->allocated, buffer->size,
- buffer->last_allocate);
- if (buffer->allocated + count >= buffer->size)
- return CBFS_MEDIA_INVALID_MAP_ADDRESS;
- if (media->read(media, address, offset, count) != count) {
- ERROR("simple_buffer: fail to read %zd bytes from 0x%zx\n",
- count, offset);
- return CBFS_MEDIA_INVALID_MAP_ADDRESS;
- }
- buffer->allocated += count;
- buffer->last_allocate = count;
- return address;
-}
-
-void *cbfs_simple_buffer_unmap(struct cbfs_simple_buffer *buffer,
- const void *address) {
- // TODO Add simple buffer management so we can free more than last
- // allocated one.
- DEBUG("simple_buffer_unmap(address=0x%p): "
- "allocated=%zd, size=%zd, last_allocate=%zd\n",
- address, buffer->allocated, buffer->size,
- buffer->last_allocate);
- if ((buffer->buffer + buffer->allocated - buffer->last_allocate) ==
- address) {
- buffer->allocated -= buffer->last_allocate;
- buffer->last_allocate = 0;
- }
- return NULL;
+ if (fd == NULL)
+ return NULL;
+
+ if (!region_contained(&fd->content, ®ion))
+ return NULL;
+
+ return region_mmap(fd->rh, fd->content.offset + offset, size);
}
-/**
- * run_address is passed the address of a function taking no parameters and
- * jumps to it, returning the result.
- * @param f the address to call as a function.
- * @return value returned by the function.
- */
+ssize_t cbfs_file_read_metadata(const struct cbfs_file_descriptor *fd,
+ void *buf, offset_t offset, size_t size)
+{
+ struct region region = {
+ .offset = offset,
+ .size = size,
+ };
+
+ if (fd == NULL)
+ return -1;
-int run_address(void *f)
+ if (!region_contained(&fd->metadata, ®ion))
+ return -1;
+
+ return region_readat(fd->rh, buf, fd->metadata.offset + offset, size);
+}
+
+void *cbfs_file_map_metadata(const struct cbfs_file_descriptor *fd)
{
- int (*v) (void);
- v = f;
- return v();
+ if (fd == NULL)
+ return NULL;
+
+ return region_mmap(fd->rh, fd->metadata.offset, fd->metadata.size);
}
+void cbfs_file_unmap(const struct cbfs_file_descriptor *fd, void *addr)
+{
+ if (fd == NULL)
+ return;
+
+ region_munmap(fd->rh, addr);
+}
+
+#ifndef __SMM__
+size_t cbfs_file_inflate(const struct cbfs_file_descriptor *fd,
+ offset_t offset, size_t src_sz, void *dest)
+{
+#if defined(CBFS_WITH_LZMA)
+ void *src;
+ size_t dest_sz;
+
+ src = cbfs_file_map_content(fd, offset, src_sz);
+
+ if (src == NULL)
+ return 0;
+
+ dest_sz = ulzma(src, dest);
+
+ cbfs_file_unmap(fd, src);
+
+ return dest_sz;
+#else
+ return 0;
+#endif
+}
+
+void *cbfs_load_stage(const struct cbfs_descriptor *cbfs, const char *name)
+{
+ struct cbfs_stage stage;
+ const struct cbfs_file_descriptor *file;
+ size_t inflated_sz;
+ ssize_t metadata_sz;
+ ssize_t file_sz;
+ uint8_t *dest;
+ void *entry;
+
+ entry = NULL;
+ file = cbfs_open_by_name_type(cbfs, name, CBFS_TYPE_STAGE);
+
+ if (file == NULL)
+ return NULL;
+
+ metadata_sz = cbfs_file_read_metadata(file, &stage, 0, sizeof(stage));
+ if (metadata_sz != sizeof(stage))
+ goto out;
+
+ file_sz = cbfs_file_content_size(file);
+ if (file_sz < 0)
+ goto out;
+
+ printk(BIOS_INFO,
+ "Loading stage '%s' 0x%llx (%d bytes), entry point 0x%llx\n",
+ name, (long long) stage.load, stage.memlen,
+ (long long)stage.entry);
+
+ dest = (void *)(uintptr_t)stage.load;
+ inflated_sz = stage.memlen;
+
+ switch (stage.compression) {
+ case CBFS_COMPRESS_NONE:
+ if (cbfs_file_read_content(file, dest, 0, file_sz) != file_sz)
+ goto out;
+ break;
+#if defined(CBFS_WITH_LZMA)
+ case CBFS_COMPRESS_LZMA:
+ inflated_sz = cbfs_file_inflate(file, 0, file_sz, dest);
+ if (inflated_sz == 0)
+ goto out;
+ break;
+#endif
+ default:
+ printk(BIOS_ERR,"Invalid compression scheme: %d\n",
+ stage.compression);
+ goto out;
+ }
+
+ if (inflated_sz > stage.memlen) {
+ printk(BIOS_ERR,"Inflated size %zu > memory size %zu.\n",
+ inflated_sz, (size_t)stage.memlen);
+ goto out;
+ }
+
+ /* Stages rely the below clearing so that the bss is initialized. */
+ memset(dest + inflated_sz, 0, stage.memlen - inflated_sz);
+
+ printk(BIOS_DEBUG,"stage loaded.\n");
+
+ entry = (void *)(uintptr_t)stage.entry;
+
+out:
+ cbfs_file_close(file);
+ return entry;
+}
#endif
diff --git a/src/lib/cbfs_boot_region.c b/src/lib/cbfs_boot_region.c
new file mode 100644
index 0000000..6ab12f7
--- /dev/null
+++ b/src/lib/cbfs_boot_region.c
@@ -0,0 +1,133 @@
+/*
+ * This file is part of the coreboot project.
+ *
+ * Copyright (C) 2014 Google Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <stdint.h>
+#include <arch/early_variables.h>
+#include <arch/byteorder.h>
+#include <console/console.h>
+#include <cbfs.h>
+#include <cbfs_core.h>
+#include <region.h>
+
+static struct cbfs_descriptor g_cbfs_descriptor CAR_GLOBAL;
+
+const struct cbfs_descriptor *cbfs_default_descriptor(void)
+{
+ return car_get_var_ptr(&g_cbfs_descriptor);
+}
+
+static const struct region_device cbfs_dev = {
+ .region = {
+ .offset = CONFIG_ROM_SIZE - CONFIG_CBFS_SIZE,
+ .size = CONFIG_CBFS_SIZE,
+ },
+};
+
+#if IS_ENABLED(CONFIG_ARCH_X86)
+static offset_t get_header_offset(rhandle_t rh)
+{
+ int32_t header_offset;
+ offset_t off;
+ ssize_t rsize;
+
+ rsize = region_size(rh);
+ off = rsize - sizeof(header_offset);
+ region_readat(rh, &header_offset, off, sizeof(header_offset));
+ return rsize + header_offset;
+}
+#else
+static inline offset_t get_header_offset(rhandle_t rh)
+{
+ return CONFIG_CBFS_HEADER_ROM_OFFSET;
+}
+#endif
+
+void cbfs_default_media_initialize(void)
+{
+ rhandle_t rh;
+ offset_t header_offset;
+ struct cbfs_header *hdr;
+ size_t cbfs_size;
+ struct cbfs_descriptor *cbfs_desc;
+
+ /* Already initialized. */
+ rh = region_locate(DEFAULT_CBFS_REGION_NAME);
+ if (rhandle_valid(rh))
+ return;
+
+ /* Mark region as invalid. */
+ cbfs_desc = (struct cbfs_descriptor *)cbfs_default_descriptor();
+ cbfs_desc->rh = INVALID_RHANDLE;
+
+ /* CBFS provides a readonly view of the rom. */
+ rh = region_locate(BOOTRO_REGION_NAME);
+
+ if (!rhandle_valid(rh)) {
+ printk(BIOS_ERR, "Boot region not found to register cbfs.\n");
+ return;
+ }
+
+ header_offset = get_header_offset(rh);
+ hdr = region_mmap(rh, header_offset, sizeof(*hdr));
+
+ if (hdr == NULL) {
+ printk(BIOS_ERR, "Couldn't mmap() cbfs header.\n");
+ return;
+ }
+
+ if (CBFS_HEADER_MAGIC != ntohl(hdr->magic)) {
+ printk(BIOS_ERR, "Invalid CBFS magic @ 0x%zx: %x vs %x\n",
+ (size_t)header_offset, CBFS_HEADER_MAGIC,
+ ntohl(hdr->magic));
+ goto out;
+ }
+
+ if (cbfs_dev.region.offset != ntohl(hdr->offset)) {
+ printk(BIOS_ERR, "CBFS offset doesn't match: 0x%zx vs 0x%zx\n",
+ (size_t)cbfs_dev.region.offset,
+ (size_t)ntohl(hdr->offset));
+ goto out;
+ }
+
+ cbfs_size = ntohl(hdr->romsize) - ntohl(hdr->offset);
+
+ if (cbfs_dev.region.size != cbfs_size) {
+ printk(BIOS_ERR, "CBFS size doesn't match: 0x%zx vs 0x%zx\n",
+ cbfs_dev.region.size, cbfs_size);
+ goto out;
+ }
+
+#if IS_ENABLED(CONFIG_ARCH_X86)
+ cbfs_size -= htonl(hdr->bootblocksize);
+#endif
+
+ cbfs_desc->align = ntohl(hdr->align);
+ cbfs_desc->size = cbfs_size;
+
+ printk(BIOS_DEBUG, "%s: CBFS align 0x%zx size 0x%zx\n", __func__,
+ cbfs_desc->align, cbfs_desc->size);
+
+ cbfs_desc->rh = region_register_subregion(DEFAULT_CBFS_REGION_NAME,
+ &cbfs_dev, rh);
+ if (!rhandle_valid(cbfs_desc->rh))
+ printk(BIOS_ERR, "Unable to register default CBFS region.\n");
+
+out:
+ region_munmap(rh, hdr);
+}
diff --git a/src/lib/cbfs_core.c b/src/lib/cbfs_core.c
deleted file mode 100644
index 50c037e..0000000
--- a/src/lib/cbfs_core.c
+++ /dev/null
@@ -1,224 +0,0 @@
-/*
- * This file is part of the coreboot project.
- *
- * Copyright (C) 2011 secunet Security Networks AG
- * Copyright (C) 2013 The Chromium OS Authors. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * 3. The name of the author may not be used to endorse or promote products
- * derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-/* The CBFS core requires a couple of #defines or functions to adapt it to the
- * target environment:
- *
- * CBFS_CORE_WITH_LZMA (must be #define)
- * if defined, ulzma() must exist for decompression of data streams
- *
- * CBFS_HEADER_ROM_ADDRESS
- * ROM address (offset) of CBFS header. Underlying CBFS media may interpret
- * it in other way so we call this "address".
- *
- * ERROR(x...)
- * print an error message x (in printf format)
- *
- * LOG(x...)
- * print a message x (in printf format)
- *
- * DEBUG(x...)
- * print a debug message x (in printf format)
- *
- */
-
-#include <cbfs.h>
-#include <string.h>
-
-/* returns a pointer to CBFS master header, or CBFS_HEADER_INVALID_ADDRESS
- * on failure */
-const struct cbfs_header *cbfs_get_header(struct cbfs_media *media)
-{
- const struct cbfs_header *header;
- struct cbfs_media default_media;
-
- if (media == CBFS_DEFAULT_MEDIA) {
- media = &default_media;
- if (init_default_cbfs_media(media) != 0) {
- ERROR("Failed to initialize default media.\n");
- return CBFS_HEADER_INVALID_ADDRESS;
- }
- }
-
- media->open(media);
- DEBUG("CBFS_HEADER_ROM_ADDRESS: 0x%x/0x%x\n", CBFS_HEADER_ROM_ADDRESS,
- CONFIG_ROM_SIZE);
- header = media->map(media, CBFS_HEADER_ROM_ADDRESS, sizeof(*header));
- media->close(media);
-
- if (header == CBFS_MEDIA_INVALID_MAP_ADDRESS) {
- ERROR("Failed to load CBFS header from 0x%x\n",
- CBFS_HEADER_ROM_ADDRESS);
- return CBFS_HEADER_INVALID_ADDRESS;
- }
-
- if (CBFS_HEADER_MAGIC != ntohl(header->magic)) {
- ERROR("Could not find valid CBFS master header at %x: "
- "%x vs %x.\n", CBFS_HEADER_ROM_ADDRESS, CBFS_HEADER_MAGIC,
- ntohl(header->magic));
- if (header->magic == 0xffffffff) {
- ERROR("Maybe ROM is not mapped properly?\n");
- }
- return CBFS_HEADER_INVALID_ADDRESS;
- }
- return header;
-}
-
-/* public API starts here*/
-struct cbfs_file *cbfs_get_file(struct cbfs_media *media, const char *name)
-{
- const char *file_name;
- uint32_t offset, align, romsize, name_len;
- const struct cbfs_header *header;
- struct cbfs_file file, *file_ptr;
- struct cbfs_media default_media;
-
- if (media == CBFS_DEFAULT_MEDIA) {
- media = &default_media;
- if (init_default_cbfs_media(media) != 0) {
- ERROR("Failed to initialize default media.\n");
- return NULL;
- }
- }
-
- if (CBFS_HEADER_INVALID_ADDRESS == (header = cbfs_get_header(media)))
- return NULL;
-
- // Logical offset (for source media) of first file.
- offset = ntohl(header->offset);
- align = ntohl(header->align);
- romsize = ntohl(header->romsize);
-
- // TODO Add a "size" in CBFS header for a platform independent way to
- // determine the end of CBFS data.
-#if defined(CONFIG_ARCH_X86) && CONFIG_ARCH_X86
- romsize -= htonl(header->bootblocksize);
-#endif
- DEBUG("CBFS location: 0x%x~0x%x, align: %d\n", offset, romsize, align);
-
- DEBUG("Looking for '%s' starting from 0x%x.\n", name, offset);
- media->open(media);
- while (offset < romsize &&
- media->read(media, &file, offset, sizeof(file)) == sizeof(file)) {
- if (memcmp(CBFS_FILE_MAGIC, file.magic,
- sizeof(file.magic)) != 0) {
- uint32_t new_align = align;
- if (offset % align)
- new_align += align - (offset % align);
- ERROR("ERROR: No file header found at 0x%x - "
- "try next aligned address: 0x%x.\n", offset,
- offset + new_align);
- offset += new_align;
- continue;
- }
- name_len = ntohl(file.offset) - sizeof(file);
- DEBUG(" - load entry 0x%x file name (%d bytes)...\n", offset,
- name_len);
-
- // load file name (arbitrary length).
- file_name = (const char *)media->map(
- media, offset + sizeof(file), name_len);
- if (file_name == CBFS_MEDIA_INVALID_MAP_ADDRESS) {
- ERROR("ERROR: Failed to get filename: 0x%x.\n", offset);
- } else if (strcmp(file_name, name) == 0) {
- int file_offset = ntohl(file.offset),
- file_len = ntohl(file.len);
- DEBUG("Found file (offset=0x%x, len=%d).\n",
- offset + file_offset, file_len);
- media->unmap(media, file_name);
- file_ptr = media->map(media, offset,
- file_offset + file_len);
- media->close(media);
- return file_ptr;
- } else {
- DEBUG(" (unmatched file @0x%x: %s)\n", offset,
- file_name);
- media->unmap(media, file_name);
- }
-
- // Move to next file.
- offset += ntohl(file.len) + ntohl(file.offset);
- if (offset % align)
- offset += align - (offset % align);
- }
- media->close(media);
- LOG("WARNING: '%s' not found.\n", name);
- return NULL;
-}
-
-void *cbfs_get_file_content(struct cbfs_media *media, const char *name,
- int type, size_t *sz)
-{
- struct cbfs_file *file = cbfs_get_file(media, name);
-
- if (sz)
- *sz = 0;
-
- if (file == NULL) {
- ERROR("Could not find file '%s'.\n", name);
- return NULL;
- }
-
- if (ntohl(file->type) != type) {
- ERROR("File '%s' is of type %x, but we requested %x.\n", name,
- ntohl(file->type), type);
- return NULL;
- }
-
- if (sz)
- *sz = ntohl(file->len);
-
- return (void *)CBFS_SUBHEADER(file);
-}
-
-int cbfs_decompress(int algo, void *src, void *dst, int len)
-{
- switch (algo) {
- case CBFS_COMPRESS_NONE:
- /* Reads need to be aligned at 4 bytes to avoid
- poor flash performance. */
- while (len && ((u32)src & 3)) {
- *(u8*)dst++ = *(u8*)src++;
- len--;
- }
- memmove(dst, src, len);
- return len;
-#ifdef CBFS_CORE_WITH_LZMA
- case CBFS_COMPRESS_LZMA:
- return ulzma(src, dst);
-#endif
- default:
- ERROR("tried to decompress %d bytes with algorithm #%x,"
- "but that algorithm id is unsupported.\n", len,
- algo);
- return 0;
- }
-}
-
diff --git a/src/lib/loaders/cbfs_payload_loader.c b/src/lib/loaders/cbfs_payload_loader.c
index 2c1d179..31ad7e6 100644
--- a/src/lib/loaders/cbfs_payload_loader.c
+++ b/src/lib/loaders/cbfs_payload_loader.c
@@ -18,20 +18,30 @@
*/
#include <cbfs.h>
+#include <cbfs_core.h>
#include <payload_loader.h>
static int cbfs_locate_payload(struct payload *payload)
{
void *buffer;
size_t size;
- const int type = CBFS_TYPE_PAYLOAD;
+ const struct cbfs_file_descriptor *fd;
- buffer = cbfs_get_file_content(CBFS_DEFAULT_MEDIA, payload->name,
- type, &size);
+ fd = cbfs_open_by_name_type(cbfs_default_descriptor(), payload->name,
+ CBFS_TYPE_PAYLOAD);
- if (buffer == NULL)
+ if (fd == NULL)
return -1;
+ size = cbfs_file_content_size(fd);
+ buffer = cbfs_file_map_content(fd, 0, size);
+
+ if (buffer == NULL) {
+ cbfs_file_close(fd);
+ return -1;
+ }
+
+ payload->fd = fd;
payload->backing_store.data = buffer;
payload->backing_store.size = size;
diff --git a/src/lib/loaders/cbfs_ramstage_loader.c b/src/lib/loaders/cbfs_ramstage_loader.c
index 5d5cc0b..5d5edd8 100644
--- a/src/lib/loaders/cbfs_ramstage_loader.c
+++ b/src/lib/loaders/cbfs_ramstage_loader.c
@@ -34,7 +34,8 @@ static void *cbfs_load_ramstage(uint32_t cbmem_id, const char *name,
.name = name,
};
- if (rmodule_stage_load_from_cbfs(&rmod_ram)) {
+ if (rmodule_stage_load_from_cbfs(cbfs_default_descriptor(),
+ &rmod_ram)) {
printk(BIOS_DEBUG, "Could not load ramstage.\n");
return NULL;
}
@@ -49,14 +50,7 @@ static void *cbfs_load_ramstage(uint32_t cbmem_id, const char *name,
static void *cbfs_load_ramstage(uint32_t cbmem_id, const char *name,
const struct cbmem_entry **cbmem_entry)
{
- void *entry;
-
- entry = cbfs_load_stage(CBFS_DEFAULT_MEDIA, name);
-
- if ((void *)entry == (void *) -1)
- entry = NULL;
-
- return entry;
+ return cbfs_load_stage(cbfs_default_descriptor(), name);
}
#endif /* CONFIG_RELOCATABLE_RAMSTAGE */
diff --git a/src/lib/loaders/load_and_run_payload.c b/src/lib/loaders/load_and_run_payload.c
index 2204090..ac4e7bf 100644
--- a/src/lib/loaders/load_and_run_payload.c
+++ b/src/lib/loaders/load_and_run_payload.c
@@ -58,9 +58,8 @@ struct payload *payload_load(void)
ops->name);
continue;
}
- printk(BIOS_DEBUG, "%s: located payload @ %p, %zu bytes.\n",
- ops->name, payload->backing_store.data,
- payload->backing_store.size);
+ printk(BIOS_DEBUG, "%s: located payload, %zu bytes.\n",
+ ops->name, payload->backing_store.size);
break;
}
diff --git a/src/lib/region.c b/src/lib/region.c
new file mode 100644
index 0000000..4dadb12
--- /dev/null
+++ b/src/lib/region.c
@@ -0,0 +1,293 @@
+/*
+ * This file is part of the coreboot project.
+ *
+ * Copyright (C) 2014 Google Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <string.h>
+#include <console/console.h>
+#include <arch/early_variables.h>
+#include <region.h>
+#include <vendorcode/google/chromeos/fmap.h>
+
+/* MAX_REGIONS could be configurable. */
+#define MAX_REGIONS 6
+
+struct region_registry_entry {
+ rhandle_t parent_slot;
+ const char *name;
+ const struct region_device *rdev;
+};
+
+struct region_registry {
+ struct region_registry_entry entries[MAX_REGIONS];
+};
+
+static struct region_registry g_regions CAR_GLOBAL;
+
+static inline struct region_registry *get_registry(void)
+{
+ return car_get_var_ptr(&g_regions);
+}
+
+static const struct region_registry_entry *
+registry_entry_lookup(const struct region_registry *rr, rhandle_t rh)
+{
+ if (rh < 0 || rh >= MAX_REGIONS)
+ return NULL;
+
+ return &rr->entries[rh];
+}
+
+int region_contained(const struct region *parent, const struct region *child)
+{
+ if (child->size > parent->size)
+ return 0;
+
+ if (child->offset >= parent->size)
+ return 0;
+
+ if ((child->offset + child->size) > parent->size)
+ return 0;
+
+ return 1;
+}
+
+static rhandle_t __region_register(struct region_registry *rr, const char *name,
+ const struct region_device *rdev,
+ rhandle_t parent)
+{
+ rhandle_t slot;
+
+ for (slot = 0; slot < MAX_REGIONS; slot++) {
+ struct region_registry_entry *entry = &rr->entries[slot];
+
+ /* Find an empty slot. */
+ if (entry->rdev != NULL)
+ continue;
+
+ entry->parent_slot = parent;
+ entry->name = name;
+ entry->rdev = rdev;
+ printk(BIOS_DEBUG,
+ "Region '%s' registered: slot %u, %zu @ 0x%zx.\n",
+ name, (unsigned int)slot, rdev->region.size,
+ (size_t)rdev->region.offset);
+ return slot;
+ }
+
+ return INVALID_RHANDLE;
+}
+
+rhandle_t region_register(const char *name, const struct region_device *rdev)
+{
+ if (name == NULL || rdev == NULL || rdev->ops == NULL)
+ return INVALID_RHANDLE;
+
+ return __region_register(get_registry(), name, rdev, INVALID_RHANDLE);
+}
+
+rhandle_t region_register_subregion(const char *name,
+ const struct region_device *rdev,
+ rhandle_t parent)
+{
+ struct region_registry *rr;
+ const struct region_registry_entry *pentry;
+
+ /* Subregions require NULL ops. */
+ if (name == NULL || rdev == NULL || rdev->ops != NULL)
+ return INVALID_RHANDLE;
+
+ rr = get_registry();
+
+ /* Parent is invalid. */
+ pentry = registry_entry_lookup(rr, parent);
+ if (pentry == NULL)
+ return INVALID_RHANDLE;
+
+ /* Ensure subregion is within bounds. */
+ if (!region_contained(&pentry->rdev->region, &rdev->region))
+ return INVALID_RHANDLE;
+
+ return __region_register(rr, name, rdev, parent);
+}
+
+/* Locate a region of provided name. */
+rhandle_t region_locate(const char *name)
+{
+ rhandle_t slot;
+ struct region_registry *rr;
+
+ if (name == NULL)
+ return INVALID_RHANDLE;
+
+ rr = get_registry();
+
+ for (slot = 0; slot < MAX_REGIONS; slot++) {
+ const struct region_registry_entry *entry = &rr->entries[slot];
+
+ /* No more valid entries. */
+ if (entry->rdev == NULL)
+ break;
+
+ if (!strcmp(entry->name, name))
+ return slot;
+ }
+ return INVALID_RHANDLE;
+}
+
+/*
+ * Obtain the appropriate region_device while optionally translating the
+ * region into the parent's domain.
+ */
+static const struct region_device *
+find_parent(rhandle_t rh, struct region *region)
+{
+ const struct region_registry_entry *entry;
+ struct region_registry *rr;
+
+ rr = get_registry();
+ entry = registry_entry_lookup(rr, rh);
+
+ if (entry == NULL)
+ return NULL;
+
+ if (region != NULL && !region_contained(&entry->rdev->region, region))
+ return NULL;
+
+ while (entry->rdev->ops == NULL) {
+ /* Translate the region into the parent's view. */
+ if (region != NULL)
+ region->offset += entry->rdev->region.offset;
+ entry = &rr->entries[entry->parent_slot];
+ }
+
+ return entry->rdev;
+}
+
+ssize_t region_readat(rhandle_t rh, void *buf, offset_t offset, size_t count)
+{
+ const struct region_device *rdev;
+ struct region region = {
+ .offset = offset,
+ .size = count,
+ };
+
+ rdev = find_parent(rh, ®ion);
+
+ if (rdev == NULL || rdev->ops->readat == NULL)
+ return -1;
+
+ return rdev->ops->readat(rdev, buf, region.offset, region.size);
+}
+
+ssize_t region_writeat(rhandle_t rh, void *buf, offset_t offset, size_t count)
+{
+ const struct region_device *rdev;
+ struct region region = {
+ .offset = offset,
+ .size = count,
+ };
+
+ rdev = find_parent(rh, ®ion);
+
+ if (rdev == NULL || rdev->ops->writeat == NULL)
+ return -1;
+
+ return rdev->ops->writeat(rdev, buf, region.offset, region.size);
+}
+
+ssize_t region_eraseat(rhandle_t rh, offset_t offset, size_t count)
+{
+ const struct region_device *rdev;
+ struct region region = {
+ .offset = offset,
+ .size = count,
+ };
+
+ rdev = find_parent(rh, ®ion);
+
+ if (rdev == NULL || rdev->ops->eraseat == NULL)
+ return -1;
+
+ return rdev->ops->eraseat(rdev, region.offset, region.size);
+}
+
+void *region_mmap(rhandle_t rh, offset_t offset, size_t count)
+{
+ const struct region_device *rdev;
+ struct region region = {
+ .offset = offset,
+ .size = count,
+ };
+
+ if (count == 0)
+ return NULL;
+
+ rdev = find_parent(rh, ®ion);
+
+ if (rdev == NULL || rdev->ops->mmap == NULL)
+ return NULL;
+
+ return rdev->ops->mmap(rdev, region.offset, region.size);
+}
+
+void region_munmap(rhandle_t rh, void *addr)
+{
+ const struct region_device *rdev;
+
+ rdev = find_parent(rh, NULL);
+
+ if (rdev == NULL || rdev->ops->munmap == NULL)
+ return;
+
+ return rdev->ops->munmap(rdev, addr);
+}
+
+ssize_t region_size(rhandle_t rh)
+{
+ const struct region_registry_entry *entry;
+
+ entry = registry_entry_lookup(get_registry(), rh);
+
+ if (entry == NULL)
+ return -1;
+
+ return entry->rdev->region.size;
+}
+
+void boot_region_init(void)
+{
+ boot_media_initialize();
+ cbfs_default_media_initialize();
+ fmap_initialize();
+}
+
+/* Provide weak default. */
+void __attribute__((weak)) bootrw_media_initialize(void) {}
+
+#if !defined(__PRE_RAM__)
+#include <bootstate.h>
+static void regions_bscb(void *unused)
+{
+ boot_region_init();
+}
+
+BOOT_STATE_INIT_ENTRIES(regions_init) = {
+ BOOT_STATE_INIT_ENTRY(BS_DEV_INIT_CHIPS, BS_ON_ENTRY,
+ regions_bscb, NULL),
+};
+#endif
diff --git a/src/lib/rmodule.c b/src/lib/rmodule.c
index 2cb70b8..33481b2 100644
--- a/src/lib/rmodule.c
+++ b/src/lib/rmodule.c
@@ -21,6 +21,9 @@
#include <stdlib.h>
#include <string.h>
#include <console/console.h>
+#include <cbfs.h>
+#include <cbfs_core.h>
+#include <lib.h>
#include <rmodule.h>
/* Change this define to get more verbose debugging for module loading. */
@@ -305,11 +308,12 @@ int rmodule_calc_region(unsigned int region_alignment, size_t rmodule_size,
#include <cbmem.h>
#include <cbfs_core.h>
-int rmodule_stage_load(struct rmod_stage_load *rsl, struct cbfs_stage *stage)
+int rmodule_stage_load(struct rmod_stage_load *rsl, struct cbfs_stage *stage,
+ void *data)
{
struct rmodule rmod_stage;
size_t region_size;
- char *stage_region;
+ unsigned char *stage_region;
int rmodule_offset;
int load_offset;
const struct cbmem_entry *cbmem_entry;
@@ -331,8 +335,12 @@ int rmodule_stage_load(struct rmod_stage_load *rsl, struct cbfs_stage *stage)
printk(BIOS_INFO, "Decompressing stage %s @ 0x%p (%d bytes)\n",
rsl->name, &stage_region[rmodule_offset], stage->memlen);
- if (!cbfs_decompress(stage->compression, &stage[1],
- &stage_region[rmodule_offset], stage->len))
+ if (stage->compression == CBFS_COMPRESS_NONE) {
+ memcpy(data, &stage_region[rmodule_offset], stage->len);
+ } else if (stage->compression == CBFS_COMPRESS_LZMA) {
+ if (!ulzma(data, &stage_region[rmodule_offset]))
+ return -1;
+ } else
return -1;
if (rmodule_parse(&stage_region[rmodule_offset], &rmod_stage))
@@ -347,17 +355,35 @@ int rmodule_stage_load(struct rmod_stage_load *rsl, struct cbfs_stage *stage)
return 0;
}
-int rmodule_stage_load_from_cbfs(struct rmod_stage_load *rsl)
+int rmodule_stage_load_from_cbfs(const struct cbfs_descriptor *cbfs,
+ struct rmod_stage_load *rsl)
{
- struct cbfs_stage *stage;
+ const struct cbfs_file_descriptor *fd;
+ struct cbfs_stage stage;
+ size_t rdsz = sizeof(stage);
+ int ret;
+ void *buf;
- stage = cbfs_get_file_content(CBFS_DEFAULT_MEDIA,
- rsl->name, CBFS_TYPE_STAGE, NULL);
+ fd = cbfs_open_by_name_type(cbfs, rsl->name, CBFS_TYPE_STAGE);
- if (stage == NULL)
+ if (fd == NULL)
return -1;
- return rmodule_stage_load(rsl, stage);
+ ret = -1;
+ if (cbfs_file_read_metadata(fd, &stage, 0, rdsz) != rdsz)
+ goto out;
+
+ buf = cbfs_file_map_content(fd, 0, cbfs_file_content_size(fd));
+ if (buf == NULL)
+ goto out;
+
+ ret = rmodule_stage_load(rsl, &stage, buf);
+
+ cbfs_file_unmap(fd, buf);
+
+out:
+ cbfs_file_close(fd);
+ return ret;
}
#endif /* DYNAMIC_CBMEM */
diff --git a/src/lib/selfboot.c b/src/lib/selfboot.c
index feff03e..b6c8797 100644
--- a/src/lib/selfboot.c
+++ b/src/lib/selfboot.c
@@ -25,6 +25,7 @@
#include <stdlib.h>
#include <string.h>
#include <cbfs.h>
+#include <cbfs_core.h>
#include <lib.h>
#include <bootmem.h>
#include <payload_loader.h>
@@ -40,7 +41,7 @@ struct segment {
struct segment *next;
struct segment *prev;
unsigned long s_dstaddr;
- unsigned long s_srcaddr;
+ unsigned long s_srcoffset;
unsigned long s_memsz;
unsigned long s_filesz;
int compression;
@@ -140,7 +141,7 @@ static int relocate_segment(unsigned long buffer, struct segment *seg)
new->s_memsz = len;
seg->s_memsz -= len;
seg->s_dstaddr += len;
- seg->s_srcaddr += len;
+ seg->s_srcoffset += len;
if (seg->s_filesz > len) {
new->s_filesz = len;
seg->s_filesz -= len;
@@ -176,7 +177,7 @@ static int relocate_segment(unsigned long buffer, struct segment *seg)
seg->s_memsz = len;
new->s_memsz -= len;
new->s_dstaddr += len;
- new->s_srcaddr += len;
+ new->s_srcoffset += len;
if (seg->s_filesz > len) {
seg->s_filesz = len;
new->s_filesz -= len;
@@ -213,17 +214,12 @@ static int relocate_segment(unsigned long buffer, struct segment *seg)
static int build_self_segment_list(
- struct segment *head,
+ struct segment *head, struct cbfs_payload_segment *segment,
struct payload *payload, uintptr_t *entry)
{
struct segment *new;
- struct segment *ptr;
- struct cbfs_payload_segment *segment, *first_segment;
- struct cbfs_payload *cbfs_payload;
- cbfs_payload = payload->backing_store.data;
memset(head, 0, sizeof(*head));
head->next = head->prev = head;
- first_segment = segment = &cbfs_payload->segments;
while(1) {
printk(BIOS_DEBUG, "Loading segment from rom address 0x%p\n", segment);
@@ -237,43 +233,39 @@ static int build_self_segment_list(
case PAYLOAD_SEGMENT_DATA:
printk(BIOS_DEBUG, " %s (compression=%x)\n",
segment->type == PAYLOAD_SEGMENT_CODE ? "code" : "data",
- ntohl(segment->compression));
+ segment->compression);
new = malloc(sizeof(*new));
- new->s_dstaddr = ntohll(segment->load_addr);
- new->s_memsz = ntohl(segment->mem_len);
- new->compression = ntohl(segment->compression);
-
- new->s_srcaddr = (uintptr_t)
- ((unsigned char *)first_segment)
- + ntohl(segment->offset);
- new->s_filesz = ntohl(segment->len);
- printk(BIOS_DEBUG, " New segment dstaddr 0x%lx memsize 0x%lx srcaddr 0x%lx filesize 0x%lx\n",
- new->s_dstaddr, new->s_memsz, new->s_srcaddr, new->s_filesz);
+ new->s_dstaddr = segment->load_addr;
+ new->s_memsz = segment->mem_len;
+ new->compression = segment->compression;
+
+ new->s_srcoffset = segment->offset;
+ new->s_filesz = segment->len;
+ printk(BIOS_DEBUG, " New segment dstaddr 0x%lx memsize 0x%lx srcoffset 0x%lx filesize 0x%lx\n",
+ new->s_dstaddr, new->s_memsz, new->s_srcoffset, new->s_filesz);
/* Clean up the values */
if (new->s_filesz > new->s_memsz) {
new->s_filesz = new->s_memsz;
}
printk(BIOS_DEBUG, " (cleaned up) New segment addr 0x%lx size 0x%lx offset 0x%lx filesize 0x%lx\n",
- new->s_dstaddr, new->s_memsz, new->s_srcaddr, new->s_filesz);
+ new->s_dstaddr, new->s_memsz, new->s_srcoffset, new->s_filesz);
break;
case PAYLOAD_SEGMENT_BSS:
- printk(BIOS_DEBUG, " BSS 0x%p (%d byte)\n", (void *)
- (intptr_t)ntohll(segment->load_addr),
- ntohl(segment->mem_len));
+ printk(BIOS_DEBUG, " BSS 0x%p (%d byte)\n",
+ (void *)(intptr_t)segment->load_addr,
+ segment->mem_len);
new = malloc(sizeof(*new));
new->s_filesz = 0;
- new->s_srcaddr = (uintptr_t)
- ((unsigned char *)first_segment)
- + ntohl(segment->offset);
- new->s_dstaddr = ntohll(segment->load_addr);
- new->s_memsz = ntohl(segment->mem_len);
+ new->s_srcoffset = segment->offset;
+ new->s_dstaddr = segment->load_addr;
+ new->s_memsz = segment->mem_len;
break;
case PAYLOAD_SEGMENT_ENTRY:
printk(BIOS_DEBUG, " Entry Point 0x%p\n",
- (void *)(intptr_t)ntohll(segment->load_addr));
- *entry = ntohll(segment->load_addr);
+ (void *)(intptr_t)segment->load_addr);
+ *entry = segment->load_addr;
/* Per definition, a payload always has the entry point
* as last segment. Thus, we use the occurrence of the
* entry point as break condition for the loop.
@@ -292,17 +284,11 @@ static int build_self_segment_list(
/* We have found another CODE, DATA or BSS segment */
segment++;
- /* Find place where to insert our segment */
- for(ptr = head->next; ptr != head; ptr = ptr->next) {
- if (new->s_srcaddr < ntohll(segment->load_addr))
- break;
- }
-
- /* Order by stream offset */
- new->next = ptr;
- new->prev = ptr->prev;
- ptr->prev->next = new;
- ptr->prev = new;
+ /* Add to end of list. */
+ new->next = head;
+ new->prev = head->prev;
+ head->prev->next = new;
+ head->prev = new;
}
return 1;
@@ -315,6 +301,7 @@ static int load_self_segments(
struct segment *ptr;
const unsigned long one_meg = (1UL << 20);
unsigned long bounce_high = lb_end;
+ unsigned char *srcaddr = payload->backing_store.data;
for(ptr = head->next; ptr != head; ptr = ptr->next) {
if (bootmem_region_targets_usable_ram(ptr->s_dstaddr,
@@ -378,7 +365,7 @@ static int load_self_segments(
/* Compute the boundaries of the segment */
dest = (unsigned char *)(ptr->s_dstaddr);
- src = (unsigned char *)(ptr->s_srcaddr);
+ src = srcaddr + ptr->s_srcoffset;
/* Copy data from the initial buffer */
if (ptr->s_filesz) {
@@ -441,13 +428,51 @@ static int load_self_segments(
return 1;
}
+static void
+parse_cbfs_segments(struct cbfs_payload_segment *segments, size_t size)
+{
+ int i;
+ int num;
+
+ num = size / sizeof(struct cbfs_payload_segment);
+
+ for (i = 0; i < num; i++) {
+ /* Note: the type field is in host order. */
+ segments[i].compression = ntohl(segments[i].compression);
+ segments[i].offset = ntohl(segments[i].offset);
+ /* Fix up the offsets to be relative to the data stream. */
+ segments[i].offset -= size;
+ segments[i].load_addr = ntohll(segments[i].load_addr);
+ segments[i].len = ntohl(segments[i].len);
+ segments[i].mem_len = ntohl(segments[i].mem_len);
+ }
+}
+
void *selfload(struct payload *payload)
{
uintptr_t entry = 0;
struct segment head;
+ ssize_t metadata_sz;
+ struct cbfs_payload_segment *segments;
+
+ metadata_sz = cbfs_file_metadata_size(payload->fd);
+
+ if (metadata_sz <= 0)
+ return NULL;
+
+ segments = malloc(sizeof(struct cbfs_payload_segment));
+
+ if (segments == NULL)
+ return NULL;
+
+ if (cbfs_file_read_metadata(payload->fd, segments, 0, metadata_sz) !=
+ metadata_sz)
+ return NULL;
+
+ parse_cbfs_segments(segments, metadata_sz);
/* Preprocess the self segments */
- if (!build_self_segment_list(&head, payload, &entry))
+ if (!build_self_segment_list(&head, segments, payload, &entry))
goto out;
/* Load the segments */
diff --git a/src/soc/intel/baytrail/Kconfig b/src/soc/intel/baytrail/Kconfig
index 2360b36..63b5c89 100644
--- a/src/soc/intel/baytrail/Kconfig
+++ b/src/soc/intel/baytrail/Kconfig
@@ -8,6 +8,7 @@ if SOC_INTEL_BAYTRAIL
config CPU_SPECIFIC_OPTIONS
def_bool y
+ select BOOT_REGION_SPI_FLASH
select CACHE_MRC_SETTINGS
select CAR_MIGRATION
select COLLECT_TIMESTAMPS
diff --git a/src/soc/intel/baytrail/mrc_cache.c b/src/soc/intel/baytrail/mrc_cache.c
index 5613761..784952d 100644
--- a/src/soc/intel/baytrail/mrc_cache.c
+++ b/src/soc/intel/baytrail/mrc_cache.c
@@ -20,6 +20,7 @@
#include <string.h>
#include <console/console.h>
#include <cbmem.h>
+#include <region.h>
#include <ip_checksum.h>
#if CONFIG_CHROMEOS
#include <vendorcode/google/chromeos/fmap.h>
@@ -40,11 +41,20 @@ struct mrc_data_region {
static int mrc_cache_get_region(struct mrc_data_region *region)
{
#if CONFIG_CHROMEOS
- int ret;
- ret = find_fmap_entry("RW_MRC_CACHE", ®ion->base);
- if (ret >= 0) {
- region->size = ret;
- return 0;
+ offset_t offset;
+ size_t size;
+ if (!fmap_locate("RW_MRC_CACHE", &offset, &size)) {
+ void *mapping;
+ rhandle_t rh;
+
+ rh = region_locate(BOOTRO_REGION_NAME);
+ mapping = region_mmap(rh, offset, size);
+
+ if (mapping != NULL) {
+ region->base = mapping;
+ region->size = size;
+ return 0;
+ }
}
#endif
region->base = (void *)CONFIG_MRC_SETTINGS_CACHE_BASE;
diff --git a/src/soc/intel/baytrail/nvm.c b/src/soc/intel/baytrail/nvm.c
index dccc801..44d67ae 100644
--- a/src/soc/intel/baytrail/nvm.c
+++ b/src/soc/intel/baytrail/nvm.c
@@ -24,26 +24,25 @@
#include <spi-generic.h>
#include <spi_flash.h>
#include <baytrail/nvm.h>
+#include <region.h>
/* This module assumes the flash is memory mapped just below 4GiB in the
* address space for reading. Also this module assumes an area it erased
* when all bytes read as all 0xff's. */
-static struct spi_flash *flash;
+static rhandle_t rwrh = INVALID_RHANDLE;
static int nvm_init(void)
{
- if (flash != NULL)
+ if (rhandle_valid(rwrh))
return 0;
- spi_init();
- flash = spi_flash_probe(0, 0, 1000000, SPI_MODE_3);
- if (!flash) {
- printk(BIOS_DEBUG, "Could not find SPI device\n");
- return -1;
- }
+ rwrh = region_locate(BOOTRW_REGION_NAME);
- return 0;
+ if (rhandle_valid(rwrh))
+ return 0;
+
+ return -1;
}
/* Convert memory mapped pointer to flash offset. */
@@ -69,7 +68,10 @@ int nvm_erase(void *start, size_t size)
{
if (nvm_init() < 0)
return -1;
- flash->erase(flash, to_flash_offset(start), size);
+
+ if (region_eraseat(rwrh, to_flash_offset(start), size) != size)
+ return -1;
+
return 0;
}
@@ -78,6 +80,9 @@ int nvm_write(void *start, const void *data, size_t size)
{
if (nvm_init() < 0)
return -1;
- flash->write(flash, to_flash_offset(start), size, data);
+
+ if (region_eraseat(rwrh, to_flash_offset(start), size) != size)
+ return -1;
+
return 0;
}
diff --git a/src/soc/intel/baytrail/romstage/raminit.c b/src/soc/intel/baytrail/romstage/raminit.c
index 7bcd54f..496e755 100644
--- a/src/soc/intel/baytrail/romstage/raminit.c
+++ b/src/soc/intel/baytrail/romstage/raminit.c
@@ -105,6 +105,7 @@ void raminit(struct mrc_params *mp, int prev_sleep_state)
int ret;
mrc_wrapper_entry_t mrc_entry;
const struct mrc_saved_data *cache;
+ const struct cbfs_file_descriptor *fd;
/* Fill in default entries. */
mp->version = MRC_PARAMS_VER;
@@ -118,10 +119,11 @@ void raminit(struct mrc_params *mp, int prev_sleep_state)
printk(BIOS_DEBUG, "No MRC cache found.\n");
}
- mrc_entry = cbfs_get_file_content(CBFS_DEFAULT_MEDIA, "mrc.bin", 0xab,
- NULL);
+ fd = cbfs_open_by_name_type(cbfs_default_descriptor(), "mrc.bin", 0xab);
+ mrc_entry = cbfs_file_map_content(fd, 0, cbfs_file_content_size(fd));
if (mrc_entry == NULL) {
+ cbfs_file_close(fd);
printk(BIOS_DEBUG, "Couldn't find mrc.bin\n");
return;
}
@@ -130,6 +132,9 @@ void raminit(struct mrc_params *mp, int prev_sleep_state)
ret = mrc_entry(mp);
+ cbfs_file_unmap(fd, mrc_entry);
+ cbfs_file_close(fd);
+
print_dram_info();
cbmem_initialize_empty();
diff --git a/src/soc/intel/baytrail/romstage/romstage.c b/src/soc/intel/baytrail/romstage/romstage.c
index 5af9bf4..37aae10 100644
--- a/src/soc/intel/baytrail/romstage/romstage.c
+++ b/src/soc/intel/baytrail/romstage/romstage.c
@@ -29,6 +29,7 @@
#include <ec/google/chromeec/ec.h>
#endif
#include <elog.h>
+#include <region.h>
#include <ramstage_cache.h>
#include <romstage_handoff.h>
#include <timestamp.h>
@@ -133,6 +134,9 @@ void * asmlinkage romstage_main(unsigned long bist,
google_chromeec_early_init();
#endif
+ /* Initialize the boot media. */
+ boot_region_init();
+
/* Call into mainboard. */
mainboard_romstage_entry(&rp);
diff --git a/src/vendorcode/google/chromeos/Makefile.inc b/src/vendorcode/google/chromeos/Makefile.inc
index 007bd57..24afb2c 100644
--- a/src/vendorcode/google/chromeos/Makefile.inc
+++ b/src/vendorcode/google/chromeos/Makefile.inc
@@ -27,6 +27,7 @@ romstage-y += fmap.c
ramstage-y += fmap.c
ramstage-$(CONFIG_CHROMEOS_RAMOOPS) += ramoops.c
smm-y += fmap.c
+smm-y += ../../../lib/region.c
ifneq ($(wildcard src/mainboard/$(MAINBOARDDIR)/chromeos.c),)
ramstage-srcs += src/mainboard/$(MAINBOARDDIR)/chromeos.c
romstage-srcs += src/mainboard/$(MAINBOARDDIR)/chromeos.c
diff --git a/src/vendorcode/google/chromeos/chromeos.c b/src/vendorcode/google/chromeos/chromeos.c
index e917ba1..6f20109 100644
--- a/src/vendorcode/google/chromeos/chromeos.c
+++ b/src/vendorcode/google/chromeos/chromeos.c
@@ -121,10 +121,14 @@ static int vboot_locate_payload(struct payload *payload)
if (buffer == NULL)
return -1;
+#if 0
payload->backing_store.data = buffer;
payload->backing_store.size = size;
return 0;
+#endif
+ /* TODO: fake a cbfs. Also need this in rmodule loading. */
+ return -1;
}
const struct payload_loader_ops vboot_payload_loader = {
diff --git a/src/vendorcode/google/chromeos/fmap.c b/src/vendorcode/google/chromeos/fmap.c
index 538b8c3..e0ad7c0 100644
--- a/src/vendorcode/google/chromeos/fmap.c
+++ b/src/vendorcode/google/chromeos/fmap.c
@@ -20,97 +20,131 @@
#include <stdint.h>
#include <stddef.h>
#include <string.h>
+#include <arch/early_variables.h>
#include <console/console.h>
+#include <region.h>
#include "fmap.h"
-/* Find FMAP data structure in ROM.
+/*
* See http://code.google.com/p/flashmap/ for more information on FMAP.
*/
-const struct fmap *fmap_find(void)
-{
- /* FIXME: Get rid of the hard codes. The "easy" way would be to
- * do a binary search, but since ROM accesses are slow, we don't
- * want to spend a lot of time looking for the FMAP. An elegant
- * solution would be to store a pointer to the FMAP in the CBFS
- * master header; that would require some more changes to cbfstool
- * and possibly cros_bundle_firmware.
- */
-
- /* wrapping around 0x100000000 */
- const struct fmap *fmap = (void *)
- (CONFIG_FLASHMAP_OFFSET - CONFIG_ROM_SIZE);
- if (memcmp(fmap, FMAP_SIGNATURE, sizeof(FMAP_SIGNATURE)-1)) {
- printk(BIOS_DEBUG, "No FMAP found at %p.\n", fmap);
- return NULL;
- }
+/*
+ * The reason for the global state is that FMAP needs to be available in
+ * romstage on x86 machines. This necessitates keeping some global variables
+ * around because there is no malloc or global modifiable data without being
+ * placed in BSS. This code relies on CAR globals being migrated in romstage.
+ */
- printk(BIOS_DEBUG, "FMAP: Found \"%s\" version %d.%d at %p.\n",
- fmap->name, fmap->ver_major, fmap->ver_minor, fmap);
- printk(BIOS_DEBUG, "FMAP: base = %llx size = %x #areas = %d\n",
- (unsigned long long)fmap->base, fmap->size, fmap->nareas);
+#define FMAP_REGION_NAME "fmap"
+
+struct fmap_state {
+ int registered;
+ int num_entries;
+};
+
+static struct fmap_state g_fmap_state CAR_GLOBAL;
+static const offset_t fmap_offset = CONFIG_FLASHMAP_OFFSET;
- return fmap;
+static inline struct fmap_state *get_state(void)
+{
+ return car_get_var_ptr(&g_fmap_state);
}
-const struct fmap_area *find_fmap_area(const struct fmap *fmap,
- const char name[])
+static const struct region_device fmap_rdev = {
+ .region = {
+ .offset = 0,
+ .size = CONFIG_ROM_SIZE,
+ },
+};
+
+/* Return < 0 on failure, 0 on success */
+static int fmap_init(void)
{
- const struct fmap_area *area = NULL;
-
- if (fmap) {
- int i;
- for (i = 0; i < fmap->nareas; i++) {
- if (!strcmp((const char *)fmap->areas[i].name, name)) {
- area = &fmap->areas[i];
- break;
- }
- }
- }
+ struct fmap_state *gs;
+ rhandle_t rh;
+ struct fmap *fmap;
- if (area) {
- printk(BIOS_DEBUG, "FMAP: area %s found\n", name);
- printk(BIOS_DEBUG, "FMAP: offset: %x\n", area->offset);
- printk(BIOS_DEBUG, "FMAP: size: %d bytes\n", area->size);
- } else {
- printk(BIOS_DEBUG, "FMAP: area %s not found\n", name);
+ gs = get_state();
+
+ if (gs->registered)
+ return 1;
+
+ /* Execute this function only once. Default to invalid. */
+ gs->registered = 1;
+ rh = region_locate(BOOTRO_REGION_NAME);
+
+ if (!rhandle_valid(rh))
+ return -1;
+
+ fmap = region_mmap(rh, fmap_offset, sizeof(*fmap));
+
+ if (fmap == NULL)
+ return -1;
+
+ if (memcmp(fmap, FMAP_SIGNATURE, sizeof(FMAP_SIGNATURE)-1)) {
+ printk(BIOS_DEBUG, "No FMAP found at %zx.\n", fmap_offset);
+ region_munmap(rh, fmap);
+ return -1;
}
+ printk(BIOS_DEBUG, "FMAP: Found \"%s\" version %d.%d at %zx.\n",
+ fmap->name, fmap->ver_major, fmap->ver_minor, fmap_offset);
+ printk(BIOS_DEBUG, "FMAP: base = %llx size = %x #areas = %d\n",
+ (unsigned long long)fmap->base, fmap->size, fmap->nareas);
+
+ gs->num_entries = fmap->nareas;
+ region_munmap(rh, fmap);
+
+ /* Register fmap device under the boot region. */
+ if (!rhandle_valid(region_register_subregion(FMAP_REGION_NAME,
+ &fmap_rdev, rh)))
+ return -1;
- return area;
+ return 0;
}
-int find_fmap_entry(const char name[], void **pointer)
+int fmap_locate(const char *name, offset_t *offset, size_t *size)
{
-#ifndef __PRE_RAM__
- static
-#endif
- const struct fmap *fmap = NULL;
- const struct fmap_area *area;
- void *base = NULL;
+ rhandle_t rh;
+ struct fmap_area *areas;
+ struct fmap_state * gs;
+ int i;
+ int ret = -1;
- if (!fmap)
- fmap = fmap_find();
+ rh = region_locate(FMAP_REGION_NAME);
+ gs = get_state();
- area = find_fmap_area(fmap, name);
+ if (!rhandle_valid(rh) || gs == NULL)
+ return ret;
- if (!area)
- return -1;
+ areas = region_mmap(rh, sizeof(struct fmap) + fmap_offset,
+ gs->num_entries * sizeof(*areas));
+
+ if (areas == NULL) {
+ printk(BIOS_DEBUG, "FMAP: could not map areas.\n");
+ return ret;
+ }
+
+ for (i = 0; i < gs->num_entries; i++) {
+ if (strncmp((char *)&areas[i].name[0], name, FMAP_STRLEN))
+ continue;
+ printk(BIOS_DEBUG, "FMAP: area %s found\n", name);
+ printk(BIOS_DEBUG, "FMAP: offset: %x\n", areas[i].offset);
+ printk(BIOS_DEBUG, "FMAP: size: %d bytes\n", areas[i].size);
- /* Right now cros_bundle_firmware does not write a valid
- * base address into the FMAP. Hence, if base is 0, assume
- * 4GB-8MB as base address.
- */
- if (fmap->base) {
- base = (void *)(unsigned long)fmap->base;
- printk(BIOS_DEBUG, "FMAP: %s base at %p\n", name, base);
- } else {
- base = (void *)(0 - CONFIG_ROM_SIZE);
- printk(BIOS_WARNING, "FMAP: No valid base address, using"
- " 0x%p\n", base);
+ *offset = areas[i].offset;
+ *size = areas[i].size;
+ ret = 0;
+ break;
}
- *pointer = (void*) ((u32)base + area->offset);
- printk(BIOS_DEBUG, "FMAP: %s at %p (offset %x)\n",
- name, *pointer, area->offset);
- return area->size;
+ region_munmap(rh, areas);
+
+ return ret;
+}
+
+void fmap_initialize(void)
+{
+ if (fmap_init() < 0)
+ printk(BIOS_DEBUG, "FMAP region wasn't registered.\n");
}
diff --git a/src/vendorcode/google/chromeos/fmap.h b/src/vendorcode/google/chromeos/fmap.h
index a3d2abd..de935e7 100644
--- a/src/vendorcode/google/chromeos/fmap.h
+++ b/src/vendorcode/google/chromeos/fmap.h
@@ -37,6 +37,7 @@
#define FLASHMAP_LIB_FMAP_H__
#include <stdint.h>
+#include <region.h>
#define FMAP_SIGNATURE "__FMAP__"
#define FMAP_VER_MAJOR 1 /* this header's FMAP minor version */
@@ -70,10 +71,24 @@ struct fmap {
struct fmap_area areas[];
} __attribute__((packed));
+#if IS_ENABLED(CONFIG_CHROMEOS)
+/*
+ * Initialize the fmap state within coreboot.
+ */
+void fmap_initialize(void);
+
+/*
+ * Locate a region by name within the fmap. offset and size are filled in
+ * relative to the boot media the global fmap is located. Returns 0 on
+ * success, < 0 when unable to find the region.
+ */
+int fmap_locate(const char *name, offset_t *offset, size_t *size);
+#else /* IS_ENABLED(CONFIG_CHROMEOS) */
+static inline void fmap_initialize(void) {}
+static inline int fmap_locate(const char *name, offset_t *offset, size_t *size)
+{
+ return -1;
+}
+#endif /* IS_ENABLED(CONFIG_CHROMEOS) */
-/* coreboot specific function prototypes */
-const struct fmap *fmap_find(void);
-const struct fmap_area *find_fmap_area(const struct fmap *fmap,
- const char name[]);
-int find_fmap_entry(const char name[], void **pointer);
#endif /* FLASHMAP_LIB_FMAP_H__*/
diff --git a/src/vendorcode/google/chromeos/vboot_loader.c b/src/vendorcode/google/chromeos/vboot_loader.c
index 0c5220a..98bc1a5 100644
--- a/src/vendorcode/google/chromeos/vboot_loader.c
+++ b/src/vendorcode/google/chromeos/vboot_loader.c
@@ -21,6 +21,7 @@
#include <stdint.h>
#include <stddef.h>
#include <cbfs.h>
+#include <cbfs_core.h>
#include <cbmem.h>
#include <console/console.h>
#include <console/vtxprintf.h>
@@ -45,7 +46,8 @@ static void vboot_run_stub(struct vboot_context *context)
};
void (*entry)(struct vboot_context *context);
- if (rmodule_stage_load_from_cbfs(&rmod_stage)) {
+ if (rmodule_stage_load_from_cbfs(cbfs_default_descriptor(),
+ &rmod_stage)) {
printk(BIOS_DEBUG, "Could not load vboot stub.\n");
goto out;
}
@@ -74,6 +76,30 @@ static void fatal_error(void)
hard_reset();
}
+static void locate_region(const char *name, void **parea, uint32_t *psize)
+{
+ offset_t offset;
+ size_t size;
+ rhandle_t rh;
+
+ *psize = 0;
+ *parea = NULL;
+
+ if (fmap_locate(name, &offset, &size))
+ return;
+
+ rh = region_locate(BOOTRO_REGION_NAME);
+ if (!rhandle_valid(rh))
+ return;
+
+ /*
+ * This leaks the mappings on anything but x86 systems which have
+ * CBFS memory-mapped.
+ */
+ *psize = size;
+ *parea = region_mmap(rh, offset, size);
+}
+
static void vboot_invoke_wrapper(struct vboot_handoff *vboot_handoff)
{
VbCommonParams cparams;
@@ -105,20 +131,17 @@ static void vboot_invoke_wrapper(struct vboot_handoff *vboot_handoff)
context.cparams = &cparams;
context.fparams = &fparams;
- cparams.gbb_size = find_fmap_entry("GBB", &cparams.gbb_data);
+ locate_region("GBB", &cparams.gbb_data, &cparams.gbb_size);
cparams.shared_data_blob = &vboot_handoff->shared_data[0];
cparams.shared_data_size = VB_SHARED_DATA_MIN_SIZE;
cparams.caller_context = &context;
- fparams.verification_size_A =
- find_fmap_entry("VBLOCK_A", &fparams.verification_block_A);
- fparams.verification_size_B =
- find_fmap_entry("VBLOCK_B", &fparams.verification_block_B);
-
- context.fw_a_size =
- find_fmap_entry("FW_MAIN_A", (void **)&context.fw_a);
- context.fw_b_size =
- find_fmap_entry("FW_MAIN_B", (void **)&context.fw_b);
+ locate_region("VBLOCK_A", &fparams.verification_block_A,
+ &fparams.verification_size_A);
+ locate_region("VBLOCK_B", &fparams.verification_block_B,
+ &fparams.verification_size_B);
+ locate_region("FW_MAIN_A", (void **)&context.fw_a, &context.fw_a_size);
+ locate_region("FW_MAIN_B", (void **)&context.fw_b, &context.fw_b_size);
/* Check all fmap entries. */
if (context.fw_a == NULL || context.fw_b == NULL ||
@@ -195,7 +218,7 @@ static void *vboot_load_ramstage(uint32_t cbmem_id, const char *name,
stage = (void *)fwc->address;
- if (rmodule_stage_load(&rmod_load, stage)) {
+ if (rmodule_stage_load(&rmod_load, stage, &stage[1])) {
vboot_handoff->selected_firmware = VB_SELECT_FIRMWARE_READONLY;
printk(BIOS_DEBUG, "Could not load ramstage region.\n");
return NULL;
1
0
Patch set updated for coreboot: d0fcc23 drivers/hwm: Add a generic hwm driver.
by Edward O'Callaghan 18 Mar '14
by Edward O'Callaghan 18 Mar '14
18 Mar '14
Edward O'Callaghan (eocallaghan(a)alterapraxis.com) just uploaded a new patch set to gerrit, which you can find at http://review.coreboot.org/5385
-gerrit
commit d0fcc23897cbc4b4823500638a7e5fa80167a32e
Author: Edward O'Callaghan <eocallaghan(a)alterapraxis.com>
Date: Fri Mar 14 01:06:22 2014 +1100
drivers/hwm: Add a generic hwm driver.
Make generic, testing with Fintek Super I/O....
currently wired in to fintek superio, need to move arary of
values to mainboard.c??
Change-Id: Ic7bdea55907e379aad9e74b87b514e8038ef9fd0
Signed-off-by: Edward O'Callaghan <eocallaghan(a)alterapraxis.com>
---
src/drivers/Kconfig | 1 +
src/drivers/Makefile.inc | 1 +
src/drivers/hwm/Kconfig | 6 ++
src/drivers/hwm/Makefile.inc | 20 +++++
src/drivers/hwm/superio_hwm.c | 142 ++++++++++++++++++++++++++++++
src/include/hwm/superio_hwm.h | 32 +++++++
src/mainboard/jetway/nf81-t56n-lf/Kconfig | 4 +
src/superio/fintek/f71869ad/chip.h | 1 +
src/superio/fintek/f71869ad/superio.c | 5 +-
9 files changed, 211 insertions(+), 1 deletion(-)
diff --git a/src/drivers/Kconfig b/src/drivers/Kconfig
index 5267ff8..c09e57f 100644
--- a/src/drivers/Kconfig
+++ b/src/drivers/Kconfig
@@ -22,6 +22,7 @@ source src/drivers/dec/Kconfig
source src/drivers/elog/Kconfig
source src/drivers/emulation/Kconfig
source src/drivers/generic/Kconfig
+source src/drivers/hwm/Kconfig
source src/drivers/i2c/Kconfig
source src/drivers/ics/Kconfig
source src/drivers/intel/Kconfig
diff --git a/src/drivers/Makefile.inc b/src/drivers/Makefile.inc
index 197a900..4b944cb 100644
--- a/src/drivers/Makefile.inc
+++ b/src/drivers/Makefile.inc
@@ -39,3 +39,4 @@ subdirs-y += ipmi
subdirs-y += elog
subdirs-y += xpowers
subdirs-$(CONFIG_ARCH_X86) += pc80
+subdirs-$(CONFIG_ARCH_X86) += hwm
diff --git a/src/drivers/hwm/Kconfig b/src/drivers/hwm/Kconfig
new file mode 100644
index 0000000..dc60fd7
--- /dev/null
+++ b/src/drivers/hwm/Kconfig
@@ -0,0 +1,6 @@
+config DRIVERS_SUPERIO_HWM
+ bool "Super I/O HWM"
+ default n
+ help
+ Just enough of a driver to make coreboot control system fans.
+ No configuration is necessary for the OS to pick up the device.
diff --git a/src/drivers/hwm/Makefile.inc b/src/drivers/hwm/Makefile.inc
new file mode 100644
index 0000000..ccb6de0
--- /dev/null
+++ b/src/drivers/hwm/Makefile.inc
@@ -0,0 +1,20 @@
+##
+## This file is part of the coreboot project.
+##
+## Copyright (C) 2014 Edward O'Callaghan <eocallaghan(a)alterapraxis.com>
+##
+## This program is free software; you can redistribute it and/or modify
+## it under the terms of the GNU General Public License as published by
+## the Free Software Foundation; version 2 of the License.
+##
+## This program is distributed in the hope that it will be useful,
+## but WITHOUT ANY WARRANTY; without even the implied warranty of
+## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+## GNU General Public License for more details.
+##
+## You should have received a copy of the GNU General Public License
+## along with this program; if not, write to the Free Software
+## Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+##
+
+ramstage-$(CONFIG_DRIVERS_SUPERIO_HWM) += superio_hwm.c
diff --git a/src/drivers/hwm/superio_hwm.c b/src/drivers/hwm/superio_hwm.c
new file mode 100644
index 0000000..49bc90f
--- /dev/null
+++ b/src/drivers/hwm/superio_hwm.c
@@ -0,0 +1,142 @@
+/*
+ * This file is part of the coreboot project.
+ *
+ * Copyright (C) 2014 Edward O'Callaghan <eocallaghan(a)alterapraxis.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+/* This code should work for all Fintek Super I/O HWM's. */
+#include <arch/io.h>
+#include <console/console.h>
+#include <device/device.h>
+#include <device/pnp.h>
+#include <stdlib.h>
+#include <hwm/superio_hwm.h>
+
+/* Helper functions */
+static void write_index(u16 port, u8 reg, u8 value)
+{
+ outb(reg, port);
+ outb(value, port + 1);
+}
+
+static u8 read_index(u16 port, u8 reg)
+{
+ outb(reg, port);
+ return inb(port + 1);
+}
+/* .. */
+
+/* Initialize F71869AD hardware monitor registers, which are at 0x225. */
+/* XXX: make configurable.. */
+static void init_registers(u16 base)
+{
+ u8 reg, value;
+ int i;
+
+ /* XXX: work out correct values??? */
+ u8 hwm_reg_values[] = {
+ /* reg mask data */
+ 0x0a, 0x00, 0x02, /* Configure pins 57/58 as PECI_REQ#/PECI (AMD_TSI) p.54 */
+ 0x08, 0x00, 0x98, /* SMBus Address p.53 */
+ 0xe9, 0x00, 0xff, /* SMB Data Buff 9 ??? */
+ 0xed, 0x00, 0x01, /* SMB/TSI Command Byte p.83 */
+ 0xee, 0x00, 0xc0, /* SMB_Status p.83 */
+ 0xef, 0x00, 0x02, /* SMB_Protocal p.83 */
+ /* Tfan1 = Tnow + (Ta - Tb)*Ct where, */
+ 0xaf, 0x00, 0x8c, /* FAN1_TEMP_SEL_DIG, FAN1_TEMP_SEL (Tnow) set to come from CR7Ah p.73 */
+ 0x9f, 0x00, 0x8a, /* set FAN_PROG_SEL = 1 */
+ 0x94, 0x00, 0x00, /* FAN1_BASE_TEMP (Tb) set when FAN_PROG_SEL=1, p.64-65 */
+ 0x96, 0x00, 0x07, /* set TFAN1_ADJ_SEL (Ta) p.67 to use CR7Ah p.61 */
+ 0x95, 0x00, 0x22, /* TFAN1_ADJ_{UP,DOWN}_RATE (Ct=1/2 up & down) in 0x95 when FAN_PROG_SEL = 1, p.65-66 */
+ 0x9f, 0x00, 0x0a, /* set FAN_PROG_SEL = 0 */
+ /* .. */
+ 0x02, 0x00, 0x30, /* OVT_MODE p.52 */
+ 0x63, 0x00, 0x20, /* Temperature BEEP Enable Register p.58 */
+ 0x66, 0x00, 0x02, /* OVT and Alert Output Enable Register 1 p.59 */
+ 0x82, 0x00, 0x76, /* Temperature sensors 1 OVT limit p.61 */
+ 0x91, 0x00, 0x07, /* FAN Interrupt Status Register p.63 */
+ 0xa3, 0x00, 0x0e, /* FAN1 RPM mode p.70 */
+ 0xa9, 0x00, 0x14, /* VT1 Boundary 2 Temperature p.71 */
+ 0xaa, 0x00, 0xff, /* FAN1 Segment 1 Speed Count */
+ 0xab, 0x00, 0x0e, /* FAN1 Segment 2 Speed Count */
+ 0xae, 0x00, 0x07, /* FAN1 Segment 3 Speed Count */
+ };
+
+ for (i = 0; i < ARRAY_SIZE(hwm_reg_values); i += 3) {
+ reg = hwm_reg_values[i];
+ value = read_index(base, reg);
+ value &= 0xff & hwm_reg_values[i + 1];
+ value |= 0xff & hwm_reg_values[i + 2];
+ printk(BIOS_DEBUG, "Super I/O HWM: base = 0x%04x, reg = 0x%02x, "
+ "value = 0x%02x\n", base, reg, value);
+ write_index(base, reg, value);
+ value = read_index(base, reg);
+ printk(BIOS_DEBUG, "Super I/O HWM (read back): base = 0x%04x, reg = 0x%02x, "
+ "value = 0x%02x\n", base, reg, value);
+ }
+}
+/* .. */
+
+/* Main driver */
+void hwm_init(device_t dev)
+{
+ if (!CONFIG_DRIVERS_SUPERIO_HWM)
+ return;
+
+ /* return if hwm is disabled in devicetree.cb */
+ struct drivers_superio_hwm_config *config = dev->chip_info;
+ if (!dev->enabled || !config)
+ return;
+
+ u32 hwm_base = config->base;
+
+ printk(BIOS_DEBUG, "Super I/O HWM: Initializing Hardware Monitor at pnp %04x\n"
+ , hwm_base);
+
+ struct resource *res = find_resource(dev, PNP_IDX_IO0);
+ if (!res) {
+ printk(BIOS_WARNING, "Super I/O HWM: No HWM resource found.\n");
+ return;
+ }
+
+ printk(BIOS_DEBUG, "Super I/O HWM: Base Address at 0x%x\n", (u32)res->base);
+ printk(BIOS_WARNING, "Super I/O HWM: Configuring registers...\n");
+ init_registers(res->base);
+}
+
+/*
+static void hwm_noop(device_t dummy)
+{
+}
+
+static struct device_operations hwm_ops = {
+ .read_resources = hwm_noop,
+ .set_resources = hwm_noop,
+ .enable_resources = hwm_noop,
+ .init = hwm_init,
+};
+
+static void enable_dev(device_t dev)
+{
+ dev->ops = &hwm_ops;
+}
+
+struct chip_operations hwm_fintek_ops = {
+ CHIP_NAME("Super I/O Hardware Monitor.")
+ .enable_dev = enable_dev
+};
+*/
diff --git a/src/include/hwm/superio_hwm.h b/src/include/hwm/superio_hwm.h
new file mode 100644
index 0000000..49e431c
--- /dev/null
+++ b/src/include/hwm/superio_hwm.h
@@ -0,0 +1,32 @@
+/*
+ * This file is part of the coreboot project.
+ *
+ * Copyright (C) 2014 Edward O'Callaghan <eocallaghan(a)alterapraxis.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef DRIVERS_SUPERIO_HWM_H
+#define DRIVERS_SUPERIO_HWM_H
+
+#include <device/device.h>
+
+/* Initialization parameters?? */
+typedef struct drivers_superio_hwm_config {
+ u32 base;
+} hwm_config_t;
+
+void hwm_init(device_t dev);
+
+#endif /* DRIVERS_SUPERIO_HWM_H */
diff --git a/src/mainboard/jetway/nf81-t56n-lf/Kconfig b/src/mainboard/jetway/nf81-t56n-lf/Kconfig
index 2d0272f..dd0b528 100644
--- a/src/mainboard/jetway/nf81-t56n-lf/Kconfig
+++ b/src/mainboard/jetway/nf81-t56n-lf/Kconfig
@@ -114,4 +114,8 @@ config DRIVERS_PS2_KEYBOARD
bool
default y
+config DRIVERS_SUPERIO_HWM
+ bool
+ default y
+
endif # BOARD_JETWAY_NF81_T56N_LF
diff --git a/src/superio/fintek/f71869ad/chip.h b/src/superio/fintek/f71869ad/chip.h
index 5b18c33..fe5be17 100644
--- a/src/superio/fintek/f71869ad/chip.h
+++ b/src/superio/fintek/f71869ad/chip.h
@@ -21,6 +21,7 @@
#ifndef SUPERIO_FINTEK_F71869AD_CHIP_H
#define SUPERIO_FINTEK_F71869AD_CHIP_H
+#include <hwm/superio_hwm.h>
#include <pc80/keyboard.h>
#include <device/device.h>
diff --git a/src/superio/fintek/f71869ad/superio.c b/src/superio/fintek/f71869ad/superio.c
index dbcb812..3c2a303 100644
--- a/src/superio/fintek/f71869ad/superio.c
+++ b/src/superio/fintek/f71869ad/superio.c
@@ -37,6 +37,9 @@ static void f71869ad_init(device_t dev)
switch(dev->path.pnp.device) {
/* TODO: Might potentially need code for HWM or FDC etc. */
+ case F71869AD_HWM:
+ hwm_init(dev);
+ break;
case F71869AD_KBC:
pc_keyboard_init(&conf->keyboard);
break;
@@ -109,7 +112,7 @@ static struct pnp_info pnp_dev_info[] = {
{ &ops, F71869AD_SP1, PNP_IO0 | PNP_IRQ0, {0x07f8, 0}, },
{ &ops, F71869AD_SP2, PNP_IO0 | PNP_IRQ0, {0x07f8, 0}, },
{ &ops, F71869AD_PP, PNP_IO0 | PNP_IRQ0 | PNP_DRQ0, {0x07f8, 0}, },
- { &ops, F71869AD_HWM, PNP_IO0 | PNP_IRQ0, {0x0ff8, 0}, },
+ { &ops, F71869AD_HWM, PNP_IO0 | PNP_IRQ0, {0x07f8, 0}, },
{ &ops, F71869AD_KBC, PNP_IO0 | PNP_IRQ0 | PNP_IRQ1, {0x07ff, 0}, },
{ &ops, F71869AD_GPIO, PNP_IO0 | PNP_IRQ0, {0x07f8, 0}, },
{ &ops, F71869AD_BSEL, PNP_IO0, {0x07f8, 0}, },
1
0