[coreboot] [commit] r6314 - in trunk/util/nvramtool: . accessors

repository service svn at coreboot.org
Fri Jan 28 08:56:40 CET 2011


Author: oxygene
Date: Fri Jan 28 08:56:39 2011
New Revision: 6314
URL: https://tracker.coreboot.org/trac/coreboot/changeset/6314

Log:
Separate CMOS layout from lbtable handling

Signed-off-by: Patrick Georgi <patrick.georgi at secunet.com>
Acked-by: Stefan Reinauer <stefan.reinauer at coreboot.org>

Added:
   trunk/util/nvramtool/accessors/layout-bin.c
      - copied, changed from r6313, trunk/util/nvramtool/lbtable.c
Modified:
   trunk/util/nvramtool/Makefile
   trunk/util/nvramtool/lbtable.c
   trunk/util/nvramtool/lbtable.h

Modified: trunk/util/nvramtool/Makefile
==============================================================================
--- trunk/util/nvramtool/Makefile	Fri Jan 28 08:54:11 2011	(r6313)
+++ trunk/util/nvramtool/Makefile	Fri Jan 28 08:56:39 2011	(r6314)
@@ -30,7 +30,7 @@
 CLI_OBJS = cli/nvramtool.o cli/opts.o
 
 OBJS =  cmos_lowlevel.o cmos_ops.o common.o compute_ip_checksum.o \
-	hexdump.o input_file.o layout.o accessors/layout-text.o lbtable.o   \
+	hexdump.o input_file.o layout.o accessors/layout-text.o accessors/layout-bin.o lbtable.o   \
 	reg_expr.o cbfs.o accessors/cmos-hw-unix.o accessors/cmos-mem.o
 
 OBJS += $(CLI_OBJS)

Copied and modified: trunk/util/nvramtool/accessors/layout-bin.c (from r6313, trunk/util/nvramtool/lbtable.c)
==============================================================================
--- trunk/util/nvramtool/lbtable.c	Fri Jan 28 08:54:11 2011	(r6313, copy source)
+++ trunk/util/nvramtool/accessors/layout-bin.c	Fri Jan 28 08:56:39 2011	(r6314)
@@ -41,35 +41,11 @@
 #include "hexdump.h"
 #include "cbfs.h"
 
-typedef void (*lbtable_print_fn_t) (const struct lb_record * rec);
-
-/* This structure represents an item in the coreboot table that may be
- * displayed using the -l option.
- */
-typedef struct {
-	uint32_t tag;
-	const char *name;
-	const char *description;
-	const char *nofound_msg;
-	lbtable_print_fn_t print_fn;
-} lbtable_choice_t;
-
-typedef struct {
-	unsigned long start;	/* address of first byte of memory range */
-	unsigned long end;	/* address of last byte of memory range */
-} mem_range_t;
-
-static const struct lb_header *lbtable_scan(unsigned long start,
-					    unsigned long end,
-					    int *bad_header_count,
-					    int *bad_table_count);
 static void process_cmos_table(void);
 static void get_cmos_checksum_info(void);
 static void try_convert_checksum_layout(cmos_checksum_layout_t * layout);
 static void try_add_cmos_table_enum(cmos_enum_t * cmos_enum);
 static void try_add_cmos_table_entry(cmos_entry_t * cmos_entry);
-static const struct lb_record *find_lbrec(uint32_t tag);
-static const char *lbrec_tag_to_str(uint32_t tag);
 static const struct cmos_entries *first_cmos_table_entry(void);
 static const struct cmos_entries *next_cmos_table_entry(const struct
 							cmos_entries *last);
@@ -79,244 +55,13 @@
 static const struct lb_record *first_cmos_rec(uint32_t tag);
 static const struct lb_record *next_cmos_rec(const struct lb_record *last,
 					     uint32_t tag);
-static void memory_print_fn(const struct lb_record *rec);
-static void mainboard_print_fn(const struct lb_record *rec);
-static void cmos_opt_table_print_fn(const struct lb_record *rec);
-static void print_option_record(const struct cmos_entries *cmos_entry);
-static void print_enum_record(const struct cmos_enums *cmos_enum);
-static void print_defaults_record(const struct cmos_defaults *cmos_defaults);
-static void print_unknown_record(const struct lb_record *cmos_item);
-static void option_checksum_print_fn(const struct lb_record *rec);
-static void string_print_fn(const struct lb_record *rec);
-
-static const char memory_desc[] =
-    "    This shows information about system memory.\n";
-
-static const char mainboard_desc[] =
-    "    This shows information about your mainboard.\n";
-
-static const char version_desc[] =
-    "    This shows coreboot version information.\n";
-
-static const char extra_version_desc[] =
-    "    This shows extra coreboot version information.\n";
-
-static const char build_desc[] = "    This shows coreboot build information.\n";
-
-static const char compile_time_desc[] =
-    "    This shows when coreboot was compiled.\n";
-
-static const char compile_by_desc[] = "    This shows who compiled coreboot.\n";
-
-static const char compile_host_desc[] =
-    "    This shows the name of the machine that compiled coreboot.\n";
-
-static const char compile_domain_desc[] =
-    "    This shows the domain name of the machine that compiled coreboot.\n";
-
-static const char compiler_desc[] =
-    "    This shows the name of the compiler used to build coreboot.\n";
-
-static const char linker_desc[] =
-    "    This shows the name of the linker used to build coreboot.\n";
-
-static const char assembler_desc[] =
-    "    This shows the name of the assembler used to build coreboot.\n";
-
-static const char cmos_opt_table_desc[] =
-    "    This does a low-level dump of the CMOS option table.  The table "
-    "contains\n"
-    "    information about the layout of the values that coreboot stores in\n"
-    "    nonvolatile RAM.\n";
-
-static const char option_checksum_desc[] =
-    "    This shows the location of the CMOS checksum and the area over which it "
-    "is\n" "    calculated.\n";
-
-static const char generic_nofound_msg[] =
-    "%s: Item %s not found in coreboot table.\n";
-
-static const char nofound_msg_cmos_opt_table[] =
-    "%s: Item %s not found in coreboot table.  Apparently, the "
-    "coreboot installed on this system was built without specifying "
-    "CONFIG_HAVE_OPTION_TABLE.\n";
-
-static const char nofound_msg_option_checksum[] =
-    "%s: Item %s not found in coreboot table. Apparently, you are "
-    "using coreboot v1.\n";
-
-int fd;
-
-/* This is the number of items from the coreboot table that may be displayed
- * using the -l option.
- */
-#define NUM_LBTABLE_CHOICES 14
-
-/* These represent the various items from the coreboot table that may be
- * displayed using the -l option.
- */
-static const lbtable_choice_t lbtable_choices[NUM_LBTABLE_CHOICES] =
-    { {LB_TAG_MEMORY, "memory",
-       memory_desc, generic_nofound_msg,
-       memory_print_fn},
-{LB_TAG_MAINBOARD, "mainboard",
- mainboard_desc, generic_nofound_msg,
- mainboard_print_fn},
-{LB_TAG_VERSION, "version",
- version_desc, generic_nofound_msg,
- string_print_fn},
-{LB_TAG_EXTRA_VERSION, "extra_version",
- extra_version_desc, generic_nofound_msg,
- string_print_fn},
-{LB_TAG_BUILD, "build",
- build_desc, generic_nofound_msg,
- string_print_fn},
-{LB_TAG_COMPILE_TIME, "compile_time",
- compile_time_desc, generic_nofound_msg,
- string_print_fn},
-{LB_TAG_COMPILE_BY, "compile_by",
- compile_by_desc, generic_nofound_msg,
- string_print_fn},
-{LB_TAG_COMPILE_HOST, "compile_host",
- compile_host_desc, generic_nofound_msg,
- string_print_fn},
-{LB_TAG_COMPILE_DOMAIN, "compile_domain",
- compile_domain_desc, generic_nofound_msg,
- string_print_fn},
-{LB_TAG_COMPILER, "compiler",
- compiler_desc, generic_nofound_msg,
- string_print_fn},
-{LB_TAG_LINKER, "linker",
- linker_desc, generic_nofound_msg,
- string_print_fn},
-{LB_TAG_ASSEMBLER, "assembler",
- assembler_desc, generic_nofound_msg,
- string_print_fn},
-{LB_TAG_CMOS_OPTION_TABLE, "cmos_opt_table",
- cmos_opt_table_desc, nofound_msg_cmos_opt_table,
- cmos_opt_table_print_fn},
-{LB_TAG_OPTION_CHECKSUM, "option_checksum",
- option_checksum_desc, nofound_msg_option_checksum,
- option_checksum_print_fn}
-};
-
-/* The coreboot table resides in low physical memory, which we access using
- * /dev/mem.  These are ranges of physical memory that should be scanned for a
- * coreboot table.
- */
-
-#define NUM_MEM_RANGES 2
-
-static const mem_range_t mem_ranges[NUM_MEM_RANGES] =
-    { {0x00000000, 0x00000fff},
-{0x000f0000, 0x000fffff}
-};
-
-/* This is the number of bytes of physical memory to map, starting at physical
- * address 0.  This value must be large enough to contain all memory ranges
- * specified in mem_ranges above plus the maximum possible size of the
- * coreboot table (since the start of the table could potentially occur at
- * the end of the last memory range).
- */
-static const size_t BYTES_TO_MAP = (1024 * 1024);
-
-/* Pointer to low physical memory that we access by calling mmap() on
- * /dev/mem.
- */
-static const void *low_phys_mem;
-static unsigned long low_phys_base = 0;
-
-/* Pointer to coreboot table. */
-static const struct lb_header *lbtable = NULL;
 
 /* The CMOS option table is located within the coreboot table.  It tells us
  * where the CMOS parameters are located in the nonvolatile RAM.
  */
 static const struct cmos_option_table *cmos_table = NULL;
 
-static const hexdump_format_t format =
-    { 12, 4, "            ", " | ", " ", " | ", '.' };
-
-/****************************************************************************
- * vtophys
- *
- * Convert a virtual address to a physical address.  'vaddr' is a virtual
- * address in the address space of the current process.  It points to
- * somewhere in the chunk of memory that we mapped by calling mmap() on
- * /dev/mem.  This macro converts 'vaddr' to a physical address.
- ****************************************************************************/
-#define vtophys(vaddr) (((unsigned long) vaddr) -       \
-                        ((unsigned long) low_phys_mem) + low_phys_base)
-
-/****************************************************************************
- * phystov
- *
- * Convert a physical address to a virtual address.  'paddr' is a physical
- * address.  This macro converts 'paddr' to a virtual address in the address
- * space of the current process.  The virtual to physical mapping was set up
- * by calling mmap() on /dev/mem.
- ****************************************************************************/
-#define phystov(paddr) (((unsigned long) low_phys_mem) + \
-                        ((unsigned long) paddr) - low_phys_base)
-
-/****************************************************************************
- * get_lbtable
- *
- * Find the coreboot table and set global variable lbtable to point to it.
- ****************************************************************************/
-void get_lbtable(void)
-{
-	int i, bad_header_count, bad_table_count, bad_headers, bad_tables;
-
-	if (lbtable != NULL)
-		return;
-
-	/* The coreboot table is located in low physical memory, which may be
-	 * conveniently accessed by calling mmap() on /dev/mem.
-	 */
-
-	if ((fd = open("/dev/mem", O_RDONLY, 0)) < 0) {
-		fprintf(stderr, "%s: Can not open /dev/mem for reading: %s\n",
-			prog_name, strerror(errno));
-		exit(1);
-	}
-
-	if ((low_phys_mem =
-	     mmap(NULL, BYTES_TO_MAP, PROT_READ, MAP_SHARED, fd, 0))
-	    == MAP_FAILED) {
-		fprintf(stderr, "%s: Failed to mmap /dev/mem: %s\n", prog_name,
-			strerror(errno));
-		exit(1);
-	}
-
-	bad_header_count = 0;
-	bad_table_count = 0;
-
-	for (i = 0; i < NUM_MEM_RANGES; i++) {
-		lbtable = lbtable_scan(phystov(mem_ranges[i].start),
-				       phystov(mem_ranges[i].end),
-				       &bad_headers, &bad_tables);
-
-		if (lbtable != NULL)
-			return;	/* success: we found it! */
-
-		bad_header_count += bad_headers;
-		bad_table_count += bad_tables;
-	}
-
-	fprintf(stderr,
-		"%s: coreboot table not found.  coreboot does not appear to\n"
-		"        be installed on this system.  Scanning for the table "
-		"produced the\n"
-		"        following results:\n\n"
-		"            %d valid signatures were found with bad header "
-		"checksums.\n"
-		"            %d valid headers were found with bad table "
-		"checksums.\n", prog_name, bad_header_count, bad_table_count);
-	exit(1);
-}
-
-static void process_layout(void)
+void process_layout(void)
 {
 	if ((cmos_table) == NULL) {
 		fprintf(stderr,
@@ -331,248 +76,14 @@
 	get_cmos_checksum_info();
 }
 
-/****************************************************************************
- * get_layout_from_cmos_table
- *
- * Find the CMOS table which is stored within the coreboot table and set the
- * global variable cmos_table to point to it.
- ****************************************************************************/
-void get_layout_from_cmos_table(void)
-{
-
-	get_lbtable();
-	cmos_table = (const struct cmos_option_table *)
-	    find_lbrec(LB_TAG_CMOS_OPTION_TABLE);
-	process_layout();
-}
-
 void get_layout_from_cbfs_file(void)
 {
-	static struct lb_header header;
-	u32 len;
+	uint32_t len;
 	cmos_table = cbfs_find_file("cmos_layout.bin", CBFS_COMPONENT_CMOS_LAYOUT, &len);
-	lbtable = &header;
-	header.header_bytes = (u32)cmos_table-(u32)lbtable;
-	header.table_bytes = ntohl(len);
 	process_layout();
 }
 
 /****************************************************************************
- * dump_lbtable
- *
- * Do a low-level dump of the coreboot table.
- ****************************************************************************/
-void dump_lbtable(void)
-{
-	const char *p, *data;
-	uint32_t bytes_processed;
-	const struct lb_record *lbrec;
-
-	p = ((const char *)lbtable) + lbtable->header_bytes;
-	printf("Coreboot table at physical address 0x%lx:\n"
-	       "    signature:       0x%x (ASCII: %c%c%c%c)\n"
-	       "    header_bytes:    0x%x (decimal: %d)\n"
-	       "    header_checksum: 0x%x (decimal: %d)\n"
-	       "    table_bytes:     0x%x (decimal: %d)\n"
-	       "    table_checksum:  0x%x (decimal: %d)\n"
-	       "    table_entries:   0x%x (decimal: %d)\n\n",
-	       vtophys(lbtable), lbtable->signature32,
-	       lbtable->signature[0], lbtable->signature[1],
-	       lbtable->signature[2], lbtable->signature[3],
-	       lbtable->header_bytes, lbtable->header_bytes,
-	       lbtable->header_checksum, lbtable->header_checksum,
-	       lbtable->table_bytes, lbtable->table_bytes,
-	       lbtable->table_checksum, lbtable->table_checksum,
-	       lbtable->table_entries, lbtable->table_entries);
-
-	if ((lbtable->table_bytes == 0) != (lbtable->table_entries == 0)) {
-		printf
-		    ("Inconsistent values for table_bytes and table_entries!!!\n"
-		     "They should be either both 0 or both nonzero.\n");
-		return;
-	}
-
-	if (lbtable->table_bytes == 0) {
-		printf("The coreboot table is empty!!!\n");
-		return;
-	}
-
-	for (bytes_processed = 0;;) {
-		lbrec = (const struct lb_record *)&p[bytes_processed];
-		printf("    %s record at physical address 0x%lx:\n"
-		       "        tag:  0x%x (decimal: %d)\n"
-		       "        size: 0x%x (decimal: %d)\n"
-		       "        data:\n",
-		       lbrec_tag_to_str(lbrec->tag), vtophys(lbrec), lbrec->tag,
-		       lbrec->tag, lbrec->size, lbrec->size);
-
-		data = ((const char *)lbrec) + sizeof(*lbrec);
-		hexdump(data, lbrec->size - sizeof(*lbrec), vtophys(data),
-			stdout, &format);
-
-		bytes_processed += lbrec->size;
-
-		if (bytes_processed >= lbtable->table_bytes)
-			break;
-
-		printf("\n");
-	}
-}
-
-/****************************************************************************
- * list_lbtable_choices
- *
- * List names and informational blurbs for items from the coreboot table
- * that may be displayed using the -l option.
- ****************************************************************************/
-void list_lbtable_choices(void)
-{
-	int i;
-
-	for (i = 0;;) {
-		printf("%s:\n%s",
-		       lbtable_choices[i].name, lbtable_choices[i].description);
-
-		if (++i >= NUM_LBTABLE_CHOICES)
-			break;
-
-		printf("\n");
-	}
-}
-
-/****************************************************************************
- * list_lbtable_item
- *
- * Show the coreboot table item specified by 'item'.
- ****************************************************************************/
-void list_lbtable_item(const char item[])
-{
-	int i;
-	const struct lb_record *rec;
-
-	for (i = 0; i < NUM_LBTABLE_CHOICES; i++) {
-		if (strcmp(item, lbtable_choices[i].name) == 0)
-			break;
-	}
-
-	if (i == NUM_LBTABLE_CHOICES) {
-		fprintf(stderr, "%s: Invalid coreboot table item %s.\n",
-			prog_name, item);
-		exit(1);
-	}
-
-	if ((rec = find_lbrec(lbtable_choices[i].tag)) == NULL) {
-		fprintf(stderr, lbtable_choices[i].nofound_msg, prog_name,
-			lbtable_choices[i].name);
-		exit(1);
-	}
-
-	lbtable_choices[i].print_fn(rec);
-}
-
-/****************************************************************************
- * lbtable_scan
- *
- * Scan the chunk of memory specified by 'start' and 'end' for a coreboot
- * table.  The first 4 bytes of the table are marked by the signature
- * { 'L', 'B', 'I', 'O' }.  'start' and 'end' indicate the addresses of the
- * first and last bytes of the chunk of memory to be scanned.  For instance,
- * values of 0x10000000 and 0x1000ffff for 'start' and 'end' specify a 64k
- * chunk of memory starting at address 0x10000000.  'start' and 'end' are
- * virtual addresses in the address space of the current process.  They
- * represent a chunk of memory obtained by calling mmap() on /dev/mem.
- *
- * If a coreboot table is found, return a pointer to it.  Otherwise return
- * NULL.  On return, *bad_header_count and *bad_table_count are set as
- * follows:
- *
- *     *bad_header_count:
- *         Indicates the number of times in which a valid signature was found
- *         but the header checksum was invalid.
- *
- *     *bad_table_count:
- *         Indicates the number of times in which a header with a valid
- *         checksum was found but the table checksum was invalid.
- ****************************************************************************/
-static const struct lb_header *lbtable_scan(unsigned long start,
-					    unsigned long end,
-					    int *bad_header_count,
-					    int *bad_table_count)
-{
-	static const char signature[4] = { 'L', 'B', 'I', 'O' };
-	const struct lb_header *table;
-	const struct lb_forward *forward;
-	const uint32_t *p;
-	uint32_t sig;
-
-	assert(end >= start);
-	memcpy(&sig, signature, sizeof(sig));
-	table = NULL;
-	*bad_header_count = 0;
-	*bad_table_count = 0;
-
-	/* Look for signature.  Table is aligned on 16-byte boundary.  Therefore
-	 * only check every fourth 32-bit memory word.  As the loop is coded below,
-	 * this function will behave in a reasonable manner for ALL possible values
-	 * for 'start' and 'end': even weird boundary cases like 0x00000000 and
-	 * 0xffffffff on a 32-bit architecture.
-	 */
-	for (p = (const uint32_t *)start;
-	     (((unsigned long)p) <= end) &&
-	     ((end - (unsigned long)p) >= (sizeof(uint32_t) - 1)); p += 4) {
-		if (*p != sig)
-			continue;
-
-		/* We found a valid signature. */
-		table = (const struct lb_header *)p;
-
-		/* validate header checksum */
-		if (compute_ip_checksum((void *)table, sizeof(*table))) {
-			(*bad_header_count)++;
-			continue;
-		}
-
-		/* validate table checksum */
-		if (table->table_checksum !=
-		    compute_ip_checksum(((char *)table) + sizeof(*table),
-					table->table_bytes)) {
-			(*bad_table_count)++;
-			continue;
-		}
-
-		/* checksums are ok: we found it! */
-		/* But it may just be a forwarding table, so look if there's a forwarder */
-		lbtable = table;
-		forward = (struct lb_forward *)find_lbrec(LB_TAG_FORWARD);
-		lbtable = NULL;
-
-		if (forward) {
-			uint64_t new_phys = forward->forward;
-
-			new_phys &= ~(getpagesize() - 1);
-
-			munmap((void *)low_phys_mem, BYTES_TO_MAP);
-			if ((low_phys_mem =
-			     mmap(NULL, BYTES_TO_MAP, PROT_READ, MAP_SHARED, fd,
-				  (off_t) new_phys)) == MAP_FAILED) {
-				fprintf(stderr,
-					"%s: Failed to mmap /dev/mem: %s\n",
-					prog_name, strerror(errno));
-				exit(1);
-			}
-			low_phys_base = new_phys;
-			table =
-			    lbtable_scan(phystov(low_phys_base),
-					 phystov(low_phys_base + BYTES_TO_MAP),
-					 bad_header_count, bad_table_count);
-		}
-		return table;
-	}
-
-	return NULL;
-}
-
-/****************************************************************************
  * process_cmos_table
  *
  * Extract layout information from the CMOS option table and store it in our
@@ -646,11 +157,7 @@
 	cmos_checksum_layout_t layout;
 	unsigned index, index2;
 
-	checksum = (struct cmos_checksum *)find_lbrec(LB_TAG_OPTION_CHECKSUM);
-
-	if (checksum == NULL) {
-		checksum = (struct cmos_checksum *)next_cmos_rec((const struct lb_record *)first_cmos_table_enum(), LB_TAG_OPTION_CHECKSUM);
-	}
+	checksum = (struct cmos_checksum *)next_cmos_rec((const struct lb_record *)first_cmos_table_enum(), LB_TAG_OPTION_CHECKSUM);
 
 	if (checksum != NULL) {	/* We are lucky.  The coreboot table hints us to the checksum.
 				 * We might have to check the type field here though.
@@ -836,105 +343,6 @@
 }
 
 /****************************************************************************
- * find_lbrec
- *
- * Find the record in the coreboot table that matches 'tag'.  Return pointer
- * to record on success or NULL if record not found.
- ****************************************************************************/
-static const struct lb_record *find_lbrec(uint32_t tag)
-{
-	const char *p;
-	uint32_t bytes_processed;
-	const struct lb_record *lbrec;
-
-	p = ((const char *)lbtable) + lbtable->header_bytes;
-
-	for (bytes_processed = 0;
-	     bytes_processed < lbtable->table_bytes;
-	     bytes_processed += lbrec->size) {
-		lbrec = (const struct lb_record *)&p[bytes_processed];
-
-		if (lbrec->tag == tag)
-			return lbrec;
-	}
-
-	return NULL;
-}
-
-/****************************************************************************
- * lbrec_tag_to_str
- *
- * Return a pointer to the string representation of the given coreboot table
- * tag.
- ****************************************************************************/
-static const char *lbrec_tag_to_str(uint32_t tag)
-{
-	switch (tag) {
-	case LB_TAG_UNUSED:
-		return "UNUSED";
-
-	case LB_TAG_MEMORY:
-		return "MEMORY";
-
-	case LB_TAG_HWRPB:
-		return "HWRPB";
-
-	case LB_TAG_MAINBOARD:
-		return "MAINBOARD";
-
-	case LB_TAG_VERSION:
-		return "VERSION";
-
-	case LB_TAG_EXTRA_VERSION:
-		return "EXTRA_VERSION";
-
-	case LB_TAG_BUILD:
-		return "BUILD";
-
-	case LB_TAG_COMPILE_TIME:
-		return "COMPILE_TIME";
-
-	case LB_TAG_COMPILE_BY:
-		return "COMPILE_BY";
-
-	case LB_TAG_COMPILE_HOST:
-		return "COMPILE_HOST";
-
-	case LB_TAG_COMPILE_DOMAIN:
-		return "COMPILE_DOMAIN";
-
-	case LB_TAG_COMPILER:
-		return "COMPILER";
-
-	case LB_TAG_LINKER:
-		return "LINKER";
-
-	case LB_TAG_ASSEMBLER:
-		return "ASSEMBLER";
-
-	case LB_TAG_SERIAL:
-		return "SERIAL";
-
-	case LB_TAG_CONSOLE:
-		return "CONSOLE";
-
-	case LB_TAG_FORWARD:
-		return "FORWARD";
-
-	case LB_TAG_CMOS_OPTION_TABLE:
-		return "CMOS_OPTION_TABLE";
-
-	case LB_TAG_OPTION_CHECKSUM:
-		return "OPTION_CHECKSUM";
-
-	default:
-		break;
-	}
-
-	return "UNKNOWN";
-}
-
-/****************************************************************************
  * first_cmos_table_entry
  *
  * Return a pointer to the first entry in the CMOS table that represents a
@@ -1050,275 +458,3 @@
 	return NULL;
 }
 
-/****************************************************************************
- * memory_print_fn
- *
- * Display function for 'memory' item of coreboot table.
- ****************************************************************************/
-static void memory_print_fn(const struct lb_record *rec)
-{
-	const struct lb_memory *p;
-	const char *mem_type;
-	const struct lb_memory_range *ranges;
-	uint64_t size, start, end;
-	int i, entries;
-
-	p = (const struct lb_memory *)rec;
-	entries = (p->size - sizeof(*p)) / sizeof(p->map[0]);
-	ranges = p->map;
-
-	if (entries == 0) {
-		printf("No memory ranges were found.\n");
-		return;
-	}
-
-	for (i = 0;;) {
-		switch (ranges[i].type) {
-		case LB_MEM_RAM:
-			mem_type = "AVAILABLE";
-			break;
-
-		case LB_MEM_RESERVED:
-			mem_type = "RESERVED";
-			break;
-
-		case LB_MEM_TABLE:
-			mem_type = "CONFIG_TABLE";
-			break;
-
-		default:
-			mem_type = "UNKNOWN";
-			break;
-		}
-
-		size = unpack_lb64(ranges[i].size);
-		start = unpack_lb64(ranges[i].start);
-		end = start + size - 1;
-		printf("%s memory:\n"
-		       "    from physical addresses 0x%016llx to 0x%016llx\n"
-		       "    size is 0x%016llx bytes (%lld in decimal)\n",
-		       mem_type, start, end, size,
-		       (unsigned long long)size);
-
-		if (++i >= entries)
-			break;
-
-		printf("\n");
-	}
-}
-
-/****************************************************************************
- * mainboard_print_fn
- *
- * Display function for 'mainboard' item of coreboot table.
- ****************************************************************************/
-static void mainboard_print_fn(const struct lb_record *rec)
-{
-	const struct lb_mainboard *p;
-
-	p = (const struct lb_mainboard *)rec;
-	printf("Vendor:      %s\n"
-	       "Part number: %s\n",
-	       &p->strings[p->vendor_idx], &p->strings[p->part_number_idx]);
-}
-
-/****************************************************************************
- * cmos_opt_table_print_fn
- *
- * Display function for 'cmos_opt_table' item of coreboot table.
- ****************************************************************************/
-static void cmos_opt_table_print_fn(const struct lb_record *rec)
-{
-	const struct cmos_option_table *p;
-	const struct lb_record *cmos_item;
-	uint32_t bytes_processed, bytes_for_entries;
-	const char *q;
-
-	p = (const struct cmos_option_table *)rec;
-	q = ((const char *)p) + p->header_length;
-	bytes_for_entries = p->size - p->header_length;
-
-	printf("CMOS option table at physical address 0x%lx:\n"
-	       "    tag:           0x%x (decimal: %d)\n"
-	       "    size:          0x%x (decimal: %d)\n"
-	       "    header_length: 0x%x (decimal: %d)\n\n",
-	       vtophys(p), p->tag, p->tag, p->size, p->size, p->header_length,
-	       p->header_length);
-
-	if (p->header_length > p->size) {
-		printf
-		    ("Header length for CMOS option table is greater than the size "
-		     "of the entire table including header!!!\n");
-		return;
-	}
-
-	if (bytes_for_entries == 0) {
-		printf("The CMOS option table is empty!!!\n");
-		return;
-	}
-
-	for (bytes_processed = 0;;) {
-		cmos_item = (const struct lb_record *)&q[bytes_processed];
-
-		switch (cmos_item->tag) {
-		case LB_TAG_OPTION:
-			print_option_record((const struct cmos_entries *)
-					    cmos_item);
-			break;
-
-		case LB_TAG_OPTION_ENUM:
-			print_enum_record((const struct cmos_enums *)cmos_item);
-			break;
-
-		case LB_TAG_OPTION_DEFAULTS:
-			print_defaults_record((const struct cmos_defaults *)
-					      cmos_item);
-			break;
-
-		default:
-			print_unknown_record(cmos_item);
-			break;
-		}
-
-		bytes_processed += cmos_item->size;
-
-		if (bytes_processed >= bytes_for_entries)
-			break;
-
-		printf("\n");
-	}
-}
-
-/****************************************************************************
- * print_option_record
- *
- * Display "option" record from CMOS option table.
- ****************************************************************************/
-static void print_option_record(const struct cmos_entries *cmos_entry)
-{
-	static const size_t S_BUFSIZE = 80;
-	char s[S_BUFSIZE];
-
-	switch (cmos_entry->config) {
-	case 'e':
-		strcpy(s, "ENUM");
-		break;
-
-	case 'h':
-		strcpy(s, "HEX");
-		break;
-
-	case 'r':
-		strcpy(s, "RESERVED");
-		break;
-
-	default:
-		snprintf(s, S_BUFSIZE, "UNKNOWN: value is 0x%x (decimal: %d)",
-			 cmos_entry->config, cmos_entry->config);
-		break;
-	}
-
-	printf("    OPTION record at physical address 0x%lx:\n"
-	       "        tag:       0x%x (decimal: %d)\n"
-	       "        size:      0x%x (decimal: %d)\n"
-	       "        bit:       0x%x (decimal: %d)\n"
-	       "        length:    0x%x (decimal: %d)\n"
-	       "        config:    %s\n"
-	       "        config_id: 0x%x (decimal: %d)\n"
-	       "        name:      %s\n",
-	       vtophys(cmos_entry), cmos_entry->tag, cmos_entry->tag,
-	       cmos_entry->size, cmos_entry->size, cmos_entry->bit,
-	       cmos_entry->bit, cmos_entry->length, cmos_entry->length, s,
-	       cmos_entry->config_id, cmos_entry->config_id, cmos_entry->name);
-}
-
-/****************************************************************************
- * print_enum_record
- *
- * Display "enum" record from CMOS option table.
- ****************************************************************************/
-static void print_enum_record(const struct cmos_enums *cmos_enum)
-{
-	printf("    ENUM record at physical address 0x%lx:\n"
-	       "        tag:       0x%x (decimal: %d)\n"
-	       "        size:      0x%x (decimal: %d)\n"
-	       "        config_id: 0x%x (decimal: %d)\n"
-	       "        value:     0x%x (decimal: %d)\n"
-	       "        text:      %s\n",
-	       vtophys(cmos_enum), cmos_enum->tag, cmos_enum->tag,
-	       cmos_enum->size, cmos_enum->size, cmos_enum->config_id,
-	       cmos_enum->config_id, cmos_enum->value, cmos_enum->value,
-	       cmos_enum->text);
-}
-
-/****************************************************************************
- * print_defaults_record
- *
- * Display "defaults" record from CMOS option table.
- ****************************************************************************/
-static void print_defaults_record(const struct cmos_defaults *cmos_defaults)
-{
-	printf("    DEFAULTS record at physical address 0x%lx:\n"
-	       "        tag:         0x%x (decimal: %d)\n"
-	       "        size:        0x%x (decimal: %d)\n"
-	       "        name_length: 0x%x (decimal: %d)\n"
-	       "        name:        %s\n"
-	       "        default_set:\n",
-	       vtophys(cmos_defaults), cmos_defaults->tag, cmos_defaults->tag,
-	       cmos_defaults->size, cmos_defaults->size,
-	       cmos_defaults->name_length, cmos_defaults->name_length,
-	       cmos_defaults->name);
-	hexdump(cmos_defaults->default_set, CMOS_IMAGE_BUFFER_SIZE,
-		vtophys(cmos_defaults->default_set), stdout, &format);
-}
-
-/****************************************************************************
- * print_unknown_record
- *
- * Display record of unknown type from CMOS option table.
- ****************************************************************************/
-static void print_unknown_record(const struct lb_record *cmos_item)
-{
-	const char *data;
-
-	printf("    UNKNOWN record at physical address 0x%lx:\n"
-	       "        tag:  0x%x (decimal: %d)\n"
-	       "        size: 0x%x (decimal: %d)\n"
-	       "        data:\n",
-	       vtophys(cmos_item), cmos_item->tag, cmos_item->tag,
-	       cmos_item->size, cmos_item->size);
-	data = ((const char *)cmos_item) + sizeof(*cmos_item);
-	hexdump(data, cmos_item->size - sizeof(*cmos_item), vtophys(data),
-		stdout, &format);
-}
-
-/****************************************************************************
- * option_checksum_print_fn
- *
- * Display function for 'option_checksum' item of coreboot table.
- ****************************************************************************/
-static void option_checksum_print_fn(const struct lb_record *rec)
-{
-	struct cmos_checksum *p;
-
-	p = (struct cmos_checksum *)rec;
-	printf("CMOS checksum from bit %d to bit %d\n"
-	       "at position %d is type %s.\n",
-	       p->range_start, p->range_end, p->location,
-	       (p->type == CHECKSUM_PCBIOS) ? "PC BIOS" : "NONE");
-}
-
-/****************************************************************************
- * string_print_fn
- *
- * Display function for a generic item of coreboot table that simply
- * consists of a string.
- ****************************************************************************/
-static void string_print_fn(const struct lb_record *rec)
-{
-	const struct lb_string *p;
-
-	p = (const struct lb_string *)rec;
-	printf("%s\n", p->string);
-}
-

Modified: trunk/util/nvramtool/lbtable.c
==============================================================================
--- trunk/util/nvramtool/lbtable.c	Fri Jan 28 08:54:11 2011	(r6313)
+++ trunk/util/nvramtool/lbtable.c	Fri Jan 28 08:56:39 2011	(r6314)
@@ -63,22 +63,8 @@
 					    unsigned long end,
 					    int *bad_header_count,
 					    int *bad_table_count);
-static void process_cmos_table(void);
-static void get_cmos_checksum_info(void);
-static void try_convert_checksum_layout(cmos_checksum_layout_t * layout);
-static void try_add_cmos_table_enum(cmos_enum_t * cmos_enum);
-static void try_add_cmos_table_entry(cmos_entry_t * cmos_entry);
 static const struct lb_record *find_lbrec(uint32_t tag);
 static const char *lbrec_tag_to_str(uint32_t tag);
-static const struct cmos_entries *first_cmos_table_entry(void);
-static const struct cmos_entries *next_cmos_table_entry(const struct
-							cmos_entries *last);
-static const struct cmos_enums *first_cmos_table_enum(void);
-static const struct cmos_enums *next_cmos_table_enum
-    (const struct cmos_enums *last);
-static const struct lb_record *first_cmos_rec(uint32_t tag);
-static const struct lb_record *next_cmos_rec(const struct lb_record *last,
-					     uint32_t tag);
 static void memory_print_fn(const struct lb_record *rec);
 static void mainboard_print_fn(const struct lb_record *rec);
 static void cmos_opt_table_print_fn(const struct lb_record *rec);
@@ -316,21 +302,6 @@
 	exit(1);
 }
 
-static void process_layout(void)
-{
-	if ((cmos_table) == NULL) {
-		fprintf(stderr,
-			"%s: CMOS option table not found in coreboot table.  "
-			"Apparently, the coreboot installed on this system was "
-			"built without specifying CONFIG_HAVE_OPTION_TABLE.\n",
-			prog_name);
-		exit(1);
-	}
-
-	process_cmos_table();
-	get_cmos_checksum_info();
-}
-
 /****************************************************************************
  * get_layout_from_cmos_table
  *
@@ -346,17 +317,6 @@
 	process_layout();
 }
 
-void get_layout_from_cbfs_file(void)
-{
-	static struct lb_header header;
-	u32 len;
-	cmos_table = cbfs_find_file("cmos_layout.bin", CBFS_COMPONENT_CMOS_LAYOUT, &len);
-	lbtable = &header;
-	header.header_bytes = (u32)cmos_table-(u32)lbtable;
-	header.table_bytes = ntohl(len);
-	process_layout();
-}
-
 /****************************************************************************
  * dump_lbtable
  *
@@ -573,269 +533,6 @@
 }
 
 /****************************************************************************
- * process_cmos_table
- *
- * Extract layout information from the CMOS option table and store it in our
- * internal repository.
- ****************************************************************************/
-static void process_cmos_table(void)
-{
-	const struct cmos_enums *p;
-	const struct cmos_entries *q;
-	cmos_enum_t cmos_enum;
-	cmos_entry_t cmos_entry;
-
-	/* First add the enums. */
-	for (p = first_cmos_table_enum(); p != NULL;
-	     p = next_cmos_table_enum(p)) {
-		cmos_enum.config_id = p->config_id;
-		cmos_enum.value = p->value;
-		strncpy(cmos_enum.text, (char *)p->text, CMOS_MAX_TEXT_LENGTH);
-		cmos_enum.text[CMOS_MAX_TEXT_LENGTH] = '\0';
-		try_add_cmos_table_enum(&cmos_enum);
-	}
-
-	/* Now add the entries.  We must add the entries after the enums because
-	 * the entries are sanity checked against the enums as they are added.
-	 */
-	for (q = first_cmos_table_entry(); q != NULL;
-	     q = next_cmos_table_entry(q)) {
-		cmos_entry.bit = q->bit;
-		cmos_entry.length = q->length;
-
-		switch (q->config) {
-		case 'e':
-			cmos_entry.config = CMOS_ENTRY_ENUM;
-			break;
-
-		case 'h':
-			cmos_entry.config = CMOS_ENTRY_HEX;
-			break;
-
-		case 'r':
-			cmos_entry.config = CMOS_ENTRY_RESERVED;
-			break;
-
-		case 's':
-			cmos_entry.config = CMOS_ENTRY_STRING;
-			break;
-
-		default:
-			fprintf(stderr,
-				"%s: Entry in CMOS option table has unknown config "
-				"value.\n", prog_name);
-			exit(1);
-		}
-
-		cmos_entry.config_id = q->config_id;
-		strncpy(cmos_entry.name, (char *)q->name, CMOS_MAX_NAME_LENGTH);
-		cmos_entry.name[CMOS_MAX_NAME_LENGTH] = '\0';
-		try_add_cmos_table_entry(&cmos_entry);
-	}
-}
-
-/****************************************************************************
- * get_cmos_checksum_info
- *
- * Get layout information for CMOS checksum.
- ****************************************************************************/
-static void get_cmos_checksum_info(void)
-{
-	const cmos_entry_t *e;
-	struct cmos_checksum *checksum;
-	cmos_checksum_layout_t layout;
-	unsigned index, index2;
-
-	checksum = (struct cmos_checksum *)find_lbrec(LB_TAG_OPTION_CHECKSUM);
-
-	if (checksum == NULL) {
-		checksum = (struct cmos_checksum *)next_cmos_rec((const struct lb_record *)first_cmos_table_enum(), LB_TAG_OPTION_CHECKSUM);
-	}
-
-	if (checksum != NULL) {	/* We are lucky.  The coreboot table hints us to the checksum.
-				 * We might have to check the type field here though.
-				 */
-		layout.summed_area_start = checksum->range_start;
-		layout.summed_area_end = checksum->range_end;
-		layout.checksum_at = checksum->location;
-		try_convert_checksum_layout(&layout);
-		cmos_checksum_start = layout.summed_area_start;
-		cmos_checksum_end = layout.summed_area_end;
-		cmos_checksum_index = layout.checksum_at;
-		return;
-	}
-
-	if ((e = find_cmos_entry(checksum_param_name)) == NULL)
-		return;
-
-	/* If we get here, we are unlucky.  The CMOS option table contains the
-	 * location of the CMOS checksum.  However, there is no information
-	 * regarding which bytes of the CMOS area the checksum is computed over.
-	 * Thus we have to hope our presets will be fine.
-	 */
-
-	if (e->bit % 8) {
-		fprintf(stderr,
-			"%s: Error: CMOS checksum is not byte-aligned.\n",
-			prog_name);
-		exit(1);
-	}
-
-	index = e->bit / 8;
-	index2 = index + 1;	/* The CMOS checksum occupies 16 bits. */
-
-	if (verify_cmos_byte_index(index) || verify_cmos_byte_index(index2)) {
-		fprintf(stderr,
-			"%s: Error: CMOS checksum location out of range.\n",
-			prog_name);
-		exit(1);
-	}
-
-	if (((index >= cmos_checksum_start) && (index <= cmos_checksum_end)) ||
-	    (((index2) >= cmos_checksum_start)
-	     && ((index2) <= cmos_checksum_end))) {
-		fprintf(stderr,
-			"%s: Error: CMOS checksum overlaps checksummed area.\n",
-			prog_name);
-		exit(1);
-	}
-
-	cmos_checksum_index = index;
-}
-
-/****************************************************************************
- * try_convert_checksum_layout
- *
- * Perform sanity checking on CMOS checksum layout information and attempt to
- * convert information from bit positions to byte positions.  Return OK on
- * success or an error code on failure.
- ****************************************************************************/
-static void try_convert_checksum_layout(cmos_checksum_layout_t * layout)
-{
-	switch (checksum_layout_to_bytes(layout)) {
-	case OK:
-		return;
-
-	case LAYOUT_SUMMED_AREA_START_NOT_ALIGNED:
-		fprintf(stderr,
-			"%s: CMOS checksummed area start is not byte-aligned.\n",
-			prog_name);
-		break;
-
-	case LAYOUT_SUMMED_AREA_END_NOT_ALIGNED:
-		fprintf(stderr,
-			"%s: CMOS checksummed area end is not byte-aligned.\n",
-			prog_name);
-		break;
-
-	case LAYOUT_CHECKSUM_LOCATION_NOT_ALIGNED:
-		fprintf(stderr,
-			"%s: CMOS checksum location is not byte-aligned.\n",
-			prog_name);
-		break;
-
-	case LAYOUT_INVALID_SUMMED_AREA:
-		fprintf(stderr,
-			"%s: CMOS checksummed area end must be greater than "
-			"CMOS checksummed area start.\n", prog_name);
-		break;
-
-	case LAYOUT_CHECKSUM_OVERLAPS_SUMMED_AREA:
-		fprintf(stderr,
-			"%s: CMOS checksum overlaps checksummed area.\n",
-			prog_name);
-		break;
-
-	case LAYOUT_SUMMED_AREA_OUT_OF_RANGE:
-		fprintf(stderr,
-			"%s: CMOS checksummed area out of range.\n", prog_name);
-		break;
-
-	case LAYOUT_CHECKSUM_LOCATION_OUT_OF_RANGE:
-		fprintf(stderr,
-			"%s: CMOS checksum location out of range.\n",
-			prog_name);
-		break;
-
-	default:
-		BUG();
-	}
-
-	exit(1);
-}
-
-/****************************************************************************
- * try_add_cmos_table_enum
- *
- * Attempt to add a CMOS enum to our internal repository.  Exit with an error
- * message on failure.
- ****************************************************************************/
-static void try_add_cmos_table_enum(cmos_enum_t * cmos_enum)
-{
-	switch (add_cmos_enum(cmos_enum)) {
-	case OK:
-		return;
-
-	case LAYOUT_DUPLICATE_ENUM:
-		fprintf(stderr, "%s: Duplicate enum %s found in CMOS option "
-			"table.\n", prog_name, cmos_enum->text);
-		break;
-
-	default:
-		BUG();
-	}
-
-	exit(1);
-}
-
-/****************************************************************************
- * try_add_cmos_table_entry
- *
- * Attempt to add a CMOS entry to our internal repository.  Exit with an
- * error message on failure.
- ****************************************************************************/
-static void try_add_cmos_table_entry(cmos_entry_t * cmos_entry)
-{
-	const cmos_entry_t *conflict;
-
-	switch (add_cmos_entry(cmos_entry, &conflict)) {
-	case OK:
-		return;
-
-	case CMOS_AREA_OUT_OF_RANGE:
-		fprintf(stderr,
-			"%s: Bad CMOS option layout in CMOS option table entry "
-			"%s.\n", prog_name, cmos_entry->name);
-		break;
-
-	case CMOS_AREA_TOO_WIDE:
-		fprintf(stderr,
-			"%s: Area too wide for CMOS option table entry %s.\n",
-			prog_name, cmos_entry->name);
-		break;
-
-	case LAYOUT_ENTRY_OVERLAP:
-		fprintf(stderr,
-			"%s: CMOS option table entries %s and %s have overlapping "
-			"layouts.\n", prog_name, cmos_entry->name,
-			conflict->name);
-		break;
-
-	case LAYOUT_ENTRY_BAD_LENGTH:
-		/* Silently ignore entries with zero length.  Although this should
-		 * never happen in practice, we should handle the case in a
-		 * reasonable manner just to be safe.
-		 */
-		return;
-
-	default:
-		BUG();
-	}
-
-	exit(1);
-}
-
-/****************************************************************************
  * find_lbrec
  *
  * Find the record in the coreboot table that matches 'tag'.  Return pointer
@@ -935,122 +632,6 @@
 }
 
 /****************************************************************************
- * first_cmos_table_entry
- *
- * Return a pointer to the first entry in the CMOS table that represents a
- * CMOS parameter.  Return NULL if CMOS table is empty.
- ****************************************************************************/
-static const struct cmos_entries *first_cmos_table_entry(void)
-{
-	return (const struct cmos_entries *)first_cmos_rec(LB_TAG_OPTION);
-}
-
-/****************************************************************************
- * next_cmos_table_entry
- *
- * Return a pointer to the next entry after 'last' in the CMOS table that
- * represents a CMOS parameter.  Return NULL if there are no more parameters.
- ****************************************************************************/
-static const struct cmos_entries *next_cmos_table_entry(const struct
-							cmos_entries *last)
-{
-	return (const struct cmos_entries *)
-	    next_cmos_rec((const struct lb_record *)last, LB_TAG_OPTION);
-}
-
-/****************************************************************************
- * first_cmos_table_enum
- *
- * Return a pointer to the first entry in the CMOS table that represents a
- * possible CMOS parameter value.  Return NULL if the table does not contain
- * any such entries.
- ****************************************************************************/
-static const struct cmos_enums *first_cmos_table_enum(void)
-{
-	return (const struct cmos_enums *)first_cmos_rec(LB_TAG_OPTION_ENUM);
-}
-
-/****************************************************************************
- * next_cmos_table_enum
- *
- * Return a pointer to the next entry after 'last' in the CMOS table that
- * represents a possible CMOS parameter value.  Return NULL if there are no
- * more parameter values.
- ****************************************************************************/
-static const struct cmos_enums *next_cmos_table_enum
-    (const struct cmos_enums *last) {
-	return (const struct cmos_enums *)
-	    next_cmos_rec((const struct lb_record *)last, LB_TAG_OPTION_ENUM);
-}
-
-/****************************************************************************
- * first_cmos_rec
- *
- * Return a pointer to the first entry in the CMOS table whose type matches
- * 'tag'.  Return NULL if CMOS table contains no such entry.
- *
- * Possible values for 'tag' are as follows:
- *
- *     LB_TAG_OPTION:      The entry represents a CMOS parameter.
- *     LB_TAG_OPTION_ENUM: The entry represents a possible value for a CMOS
- *                         parameter of type 'enum'.
- *
- * The CMOS table tells us where in the nonvolatile RAM to look for CMOS
- * parameter values and specifies their types as 'enum', 'hex', or
- * 'reserved'.
- ****************************************************************************/
-static const struct lb_record *first_cmos_rec(uint32_t tag)
-{
-	const char *p;
-	uint32_t bytes_processed, bytes_for_entries;
-	const struct lb_record *lbrec;
-
-	p = ((const char *)cmos_table) + cmos_table->header_length;
-	bytes_for_entries = cmos_table->size - cmos_table->header_length;
-
-	for (bytes_processed = 0;
-	     bytes_processed < bytes_for_entries;
-	     bytes_processed += lbrec->size) {
-		lbrec = (const struct lb_record *)&p[bytes_processed];
-
-		if (lbrec->tag == tag)
-			return lbrec;
-	}
-
-	return NULL;
-}
-
-/****************************************************************************
- * next_cmos_rec
- *
- * Return a pointer to the next entry after 'last' in the CMOS table whose
- * type matches 'tag'.  Return NULL if the table contains no more entries of
- * this type.
- ****************************************************************************/
-static const struct lb_record *next_cmos_rec(const struct lb_record *last,
-					     uint32_t tag)
-{
-	const char *p;
-	uint32_t bytes_processed, bytes_for_entries, last_offset;
-	const struct lb_record *lbrec;
-
-	p = ((const char *)cmos_table) + cmos_table->header_length;
-	bytes_for_entries = cmos_table->size - cmos_table->header_length;
-	last_offset = ((const char *)last) - p;
-
-	for (bytes_processed = last_offset + last->size;
-	     bytes_processed < bytes_for_entries;
-	     bytes_processed += lbrec->size) {
-		lbrec = (const struct lb_record *)&p[bytes_processed];
-
-		if (lbrec->tag == tag)
-			return lbrec;
-	}
-
-	return NULL;
-}
-
-/****************************************************************************
  * memory_print_fn
  *
  * Display function for 'memory' item of coreboot table.

Modified: trunk/util/nvramtool/lbtable.h
==============================================================================
--- trunk/util/nvramtool/lbtable.h	Fri Jan 28 08:54:11 2011	(r6313)
+++ trunk/util/nvramtool/lbtable.h	Fri Jan 28 08:56:39 2011	(r6314)
@@ -40,4 +40,5 @@
 void list_lbtable_choices(void);
 void list_lbtable_item(const char item[]);
 
+void process_layout(void);
 #endif				/* LBTABLE_H */




More information about the coreboot mailing list