X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=util%2Fnvramtool%2Flbtable.c;h=71c32447a9229bea83a1ed618959c7508f9cf1ec;hb=77adc5e03cd72ba4091ebf446abc3b19a73ee8fb;hp=ec2cc8545dc8e76110a1b0586e5cc7c757fce394;hpb=cbb5ba8633c2ad143366c3bc367f8c4f6434c084;p=coreboot.git diff --git a/util/nvramtool/lbtable.c b/util/nvramtool/lbtable.c index ec2cc8545..71c32447a 100644 --- a/util/nvramtool/lbtable.c +++ b/util/nvramtool/lbtable.c @@ -1,6 +1,5 @@ /*****************************************************************************\ * lbtable.c - * $Id$ ***************************************************************************** * Copyright (C) 2002-2005 The Regents of the University of California. * Produced at the Lawrence Livermore National Laboratory. @@ -27,9 +26,11 @@ * * 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., - * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. \*****************************************************************************/ +#include +#include #include #include "common.h" #include "coreboot_tables.h" @@ -38,116 +39,98 @@ #include "layout.h" #include "cmos_lowlevel.h" #include "hexdump.h" +#include "cbfs.h" -typedef void (*lbtable_print_fn_t) (const struct lb_record *rec); +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); -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); -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 void uint64_to_hex_string (char str[], uint64_t n); +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"; + " This shows information about system memory.\n"; static const char mainboard_desc[] = -" This shows information about your mainboard.\n"; + " This shows information about your mainboard.\n"; static const char version_desc[] = -" This shows coreboot version information.\n"; + " This shows coreboot version information.\n"; static const char extra_version_desc[] = -" This shows extra coreboot version information.\n"; + " This shows extra coreboot version information.\n"; -static const char build_desc[] = -" This shows coreboot build 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"; + " This shows when coreboot was compiled.\n"; -static const char compile_by_desc[] = -" This shows who compiled coreboot.\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"; + " 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"; + " 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"; + " 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"; + " 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"; + " 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"; + " 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"; + " 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"; + "%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 " -"HAVE_OPTION_TABLE.\n"; + "%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"; + "%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. @@ -158,63 +141,49 @@ static const char nofound_msg_option_checksum[] = * 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 - } - }; + { {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 @@ -224,9 +193,9 @@ static const lbtable_choice_t lbtable_choices[NUM_LBTABLE_CHOICES] = #define NUM_MEM_RANGES 2 static const mem_range_t mem_ranges[NUM_MEM_RANGES] = - { { 0x00000000, 0x00000fff }, - { 0x000f0000, 0x000fffff } - }; + { {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 @@ -240,17 +209,13 @@ static const size_t BYTES_TO_MAP = (1024 * 1024); * /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, " ", " | ", " ", " | ", '.', NULL }; + { 12, 4, " ", " | ", " ", " | ", '.' }; /**************************************************************************** * vtophys @@ -261,7 +226,7 @@ static const hexdump_format_t format = * /dev/mem. This macro converts 'vaddr' to a physical address. ****************************************************************************/ #define vtophys(vaddr) (((unsigned long) vaddr) - \ - ((unsigned long) low_phys_mem)) + ((unsigned long) low_phys_mem) + low_phys_base) /**************************************************************************** * phystov @@ -272,148 +237,126 @@ static const hexdump_format_t format = * by calling mmap() on /dev/mem. ****************************************************************************/ #define phystov(paddr) (((unsigned long) low_phys_mem) + \ - ((unsigned long) paddr)) + ((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 fd, 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); - } - -/**************************************************************************** - * 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); - - 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 HAVE_OPTION_TABLE.\n", - prog_name); - exit(1); - } - - process_cmos_table(); - get_cmos_checksum_info(); - } +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); +} /**************************************************************************** * 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), *((uint32_t *) lbtable->signature), - 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"); - } - } +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 @@ -421,48 +364,50 @@ void dump_lbtable (void) * 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; +void list_lbtable_choices(void) +{ + int i; - for (i = 0; ; ) - { printf("%s:\n%s", - lbtable_choices[i].name, lbtable_choices[i].description); + for (i = 0;;) { + printf("%s:\n%s", + lbtable_choices[i].name, lbtable_choices[i].description); - if (++i >= NUM_LBTABLE_CHOICES) - break; + if (++i >= NUM_LBTABLE_CHOICES) + break; - printf("\n"); - } - } + 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); - } +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 @@ -488,303 +433,83 @@ void list_lbtable_item (const char item[]) * 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[] = { 'L', 'B', 'I', 'O' }; - const struct lb_header *table; - const uint32_t *p; - uint32_t sig; - - assert(end >= start); - sig = (*((const uint32_t *) signature)); - 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! */ - return table; - } - - return NULL; - } - -/**************************************************************************** - * 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, 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; - - 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, 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) - { /* 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); - } +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; +} /**************************************************************************** * find_lbrec @@ -792,24 +517,25 @@ static void try_add_cmos_table_entry (cmos_entry_t *cmos_entry) * 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; +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; + 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]; + 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; - } + if (lbrec->tag == tag) + return lbrec; + } - return NULL; - } + return NULL; +} /**************************************************************************** * lbrec_tag_to_str @@ -817,423 +543,330 @@ static const struct lb_record * find_lbrec (uint32_t tag) * 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"; +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_MEMORY: + return "MEMORY"; - case LB_TAG_HWRPB: - return "HWRPB"; + case LB_TAG_HWRPB: + return "HWRPB"; - case LB_TAG_MAINBOARD: - return "MAINBOARD"; + case LB_TAG_MAINBOARD: + return "MAINBOARD"; - case LB_TAG_VERSION: - return "VERSION"; + case LB_TAG_VERSION: + return "VERSION"; - case LB_TAG_EXTRA_VERSION: - return "EXTRA_VERSION"; + case LB_TAG_EXTRA_VERSION: + return "EXTRA_VERSION"; - case LB_TAG_BUILD: - return "BUILD"; + case LB_TAG_BUILD: + return "BUILD"; - case LB_TAG_COMPILE_TIME: - return "COMPILE_TIME"; + case LB_TAG_COMPILE_TIME: + return "COMPILE_TIME"; - case LB_TAG_COMPILE_BY: - return "COMPILE_BY"; + case LB_TAG_COMPILE_BY: + return "COMPILE_BY"; - case LB_TAG_COMPILE_HOST: - return "COMPILE_HOST"; + case LB_TAG_COMPILE_HOST: + return "COMPILE_HOST"; - case LB_TAG_COMPILE_DOMAIN: - return "COMPILE_DOMAIN"; + case LB_TAG_COMPILE_DOMAIN: + return "COMPILE_DOMAIN"; - case LB_TAG_COMPILER: - return "COMPILER"; + case LB_TAG_COMPILER: + return "COMPILER"; - case LB_TAG_LINKER: - return "LINKER"; + case LB_TAG_LINKER: + return "LINKER"; - case LB_TAG_ASSEMBLER: - return "ASSEMBLER"; + case LB_TAG_ASSEMBLER: + return "ASSEMBLER"; - case LB_TAG_CMOS_OPTION_TABLE: - return "CMOS_OPTION_TABLE"; + case LB_TAG_SERIAL: + return "SERIAL"; - case LB_TAG_OPTION_CHECKSUM: - return "OPTION_CHECKSUM"; + case LB_TAG_CONSOLE: + return "CONSOLE"; - default: - break; - } + case LB_TAG_FORWARD: + return "FORWARD"; - return "UNKNOWN"; - } + case LB_TAG_CMOS_OPTION_TABLE: + return "CMOS_OPTION_TABLE"; -/**************************************************************************** - * 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); } + case LB_TAG_OPTION_CHECKSUM: + return "OPTION_CHECKSUM"; -/**************************************************************************** - * 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); - } + default: + break; + } -/**************************************************************************** - * 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; - } + return "UNKNOWN"; +} /**************************************************************************** * memory_print_fn * * Display function for 'memory' item of coreboot table. ****************************************************************************/ -static void memory_print_fn (const struct lb_record *rec) - { char start_str[19], end_str[19], size_str[19]; - 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; - uint64_to_hex_string(start_str, start); - uint64_to_hex_string(end_str, end); - uint64_to_hex_string(size_str, size); - printf("%s memory:\n" - " from physical addresses %s to %s\n" - " size is %s bytes (%lld in decimal)\n", - mem_type, start_str, end_str, size_str, - (unsigned long long) size); - - if (++i >= entries) - break; - - printf("\n"); - } - } +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; +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]); - } + 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"); - } - } +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); - } +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); - } +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); - } +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); - } +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; +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"); - } + 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 @@ -1241,30 +874,11 @@ static void option_checksum_print_fn (const struct lb_record *rec) * 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); - } - -/**************************************************************************** - * uint64_to_hex_string - * - * Convert the 64-bit integer 'n' to its hexadecimal string representation, - * storing the result in 's'. 's' must point to a buffer at least 19 bytes - * long. The result is displayed with as many leading zeros as needed to - * make a 16-digit hex number including a 0x prefix (example: the number 1 - * will be displayed as "0x0000000000000001"). - ****************************************************************************/ -static void uint64_to_hex_string (char str[], uint64_t n) - { int chars_printed; +static void string_print_fn(const struct lb_record *rec) +{ + const struct lb_string *p; - str[0] = '0'; - str[1] = 'x'; + p = (const struct lb_string *)rec; + printf("%s\n", p->string); +} - /* Print the result right-justified with leading spaces in a - * 16-character field. */ - chars_printed = sprintf(&str[2], "%016llx", (unsigned long long) n); - assert(chars_printed == 16); - }