coreboot-kgpe-d16/util/nvramtool/lbtable.c

865 lines
26 KiB
C

/* SPDX-License-Identifier: GPL-2.0-only */
#include <stdint.h>
#include <inttypes.h>
#include <string.h>
#ifndef __MINGW32__
#include <sys/mman.h>
#endif
#include "common.h"
#include "coreboot_tables.h"
#include "ip_checksum.h"
#include "lbtable.h"
#include "layout.h"
#include "cmos_lowlevel.h"
#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 const char *lbrec_tag_to_str(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}
};
/* Pointer to low physical memory that we access by calling mmap() on
* /dev/mem.
*/
static const void *low_phys_mem;
/* impossible value since not page aligned: first map request will happen */
static unsigned long low_phys_base = 0x1;
/* count of mapped pages */
static unsigned long mapped_pages = 0;
/* Pointer to coreboot table. */
static const struct lb_header *lbtable = 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)
/****************************************************************************
* map_pages
*
* Maps just enough pages to cover base_address + length
* and updates affected variables
****************************************************************************/
static void map_pages(unsigned long base_address, unsigned long length)
{
unsigned long num_pages = (length +
(base_address & (getpagesize() - 1)) +
getpagesize() - 1) >> 12;
base_address &= ~(getpagesize() - 1);
/* no need to do anything */
if ((low_phys_base == base_address) && (mapped_pages == num_pages)) {
return;
}
if (low_phys_mem) {
munmap((void *)low_phys_mem, mapped_pages << 12);
}
if ((low_phys_mem = mmap(NULL, num_pages << 12, PROT_READ, MAP_SHARED, fd,
(off_t) base_address)) == MAP_FAILED) {
fprintf(stderr,
"%s: Failed to mmap /dev/mem at %lx: %s\n",
prog_name, base_address, strerror(errno));
exit(1);
}
low_phys_base = base_address;
}
/****************************************************************************
* 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);
}
bad_header_count = 0;
bad_table_count = 0;
for (i = 0; i < NUM_MEM_RANGES; i++) {
lbtable = lbtable_scan(mem_ranges[i].start, 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);
}
/****************************************************************************
* 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
* physical addresses.
*
* 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;
unsigned long 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.
*/
map_pages(start, end - start);
for (p = start;
(p <= end) &&
(end - p >= (sizeof(uint32_t) - 1)); p += 4) {
if (*(uint32_t*)phystov(p) != sig)
continue;
/* We found a valid signature. */
table = (const struct lb_header *)phystov(p);
/* validate header checksum */
if (compute_ip_checksum((void *)table, sizeof(*table))) {
(*bad_header_count)++;
continue;
}
map_pages(p, table->table_bytes + sizeof(*table));
table = (const struct lb_header *)phystov(p);
/* 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;
table = lbtable_scan(new_phys, new_phys + getpagesize(),
bad_header_count, bad_table_count);
}
return table;
}
return NULL;
}
/****************************************************************************
* find_lbrec
*
* Find the record in the coreboot table that matches 'tag'. Return pointer
* to record on success or NULL if record not found.
****************************************************************************/
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";
}
/****************************************************************************
* 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%016" PRIx64
" to 0x%016" PRIx64 "\n size is 0x%016" PRIx64
" bytes (%" PRId64 " in decimal)\n",
mem_type, start, end, size, 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);
}