nvramtool-0.0+r3669.orig/0000700000175000017500000000000011076664371013301 5ustar uweuwenvramtool-0.0+r3669.orig/coreboot_tables.h0000600000175000017500000001737610746375565016647 0ustar uweuwe/*****************************************************************************\ * coreboot_tables.h \*****************************************************************************/ #ifndef COREBOOT_TABLES_H #define COREBOOT_TABLES_H #include /* Note: The contents of this file were borrowed from the coreboot source * code which may be obtained from http://www.coreboot.org/. * Specifically, this code was obtained from LinuxBIOS version 1.1.8. */ /* The coreboot table information is for conveying information * from the firmware to the loaded OS image. Primarily this * is expected to be information that cannot be discovered by * other means, such as quering the hardware directly. * * All of the information should be Position Independent Data. * That is it should be safe to relocated any of the information * without it's meaning/correctnes changing. For table that * can reasonably be used on multiple architectures the data * size should be fixed. This should ease the transition between * 32 bit and 64 bit architectures etc. * * The completeness test for the information in this table is: * - Can all of the hardware be detected? * - Are the per motherboard constants available? * - Is there enough to allow a kernel to run that was written before * a particular motherboard is constructed? (Assuming the kernel * has drivers for all of the hardware but it does not have * assumptions on how the hardware is connected together). * * With this test it should be straight forward to determine if a * table entry is required or not. This should remove much of the * long term compatibility burden as table entries which are * irrelevant or have been replaced by better alternatives may be * dropped. Of course it is polite and expidite to include extra * table entries and be backwards compatible, but it is not required. */ /* Since coreboot is usually compiled 32bit, gcc will align 64bit * types to 32bit boundaries. If the coreboot table is dumped on a * 64bit system, a uint64_t would be aligned to 64bit boundaries, * breaking the table format. * * lb_uint64 will keep 64bit coreboot table values aligned to 32bit * to ensure compatibility. They can be accessed with the two functions * below: unpack_lb64() and pack_lb64() * * See also: util/lbtdump/lbtdump.c */ struct lb_uint64 { uint32_t lo; uint32_t hi; }; static inline uint64_t unpack_lb64(struct lb_uint64 value) { uint64_t result; result = value.hi; result = (result << 32) + value.lo; return result; } static inline struct lb_uint64 pack_lb64(uint64_t value) { struct lb_uint64 result; result.lo = (value >> 0) & 0xffffffff; result.hi = (value >> 32) & 0xffffffff; return result; } struct lb_header { uint8_t signature[4]; /* LBIO */ uint32_t header_bytes; uint32_t header_checksum; uint32_t table_bytes; uint32_t table_checksum; uint32_t table_entries; }; /* Every entry in the boot enviroment list will correspond to a boot * info record. Encoding both type and size. The type is obviously * so you can tell what it is. The size allows you to skip that * boot enviroment record if you don't know what it easy. This allows * forward compatibility with records not yet defined. */ struct lb_record { uint32_t tag; /* tag ID */ uint32_t size; /* size of record (in bytes) */ }; #define LB_TAG_UNUSED 0x0000 #define LB_TAG_MEMORY 0x0001 struct lb_memory_range { struct lb_uint64 start; struct lb_uint64 size; uint32_t type; #define LB_MEM_RAM 1 /* Memory anyone can use */ #define LB_MEM_RESERVED 2 /* Don't use this memory region */ #define LB_MEM_TABLE 16 /* Ram configuration tables are kept in */ }; struct lb_memory { uint32_t tag; uint32_t size; struct lb_memory_range map[0]; }; #define LB_TAG_HWRPB 0x0002 struct lb_hwrpb { uint32_t tag; uint32_t size; uint64_t hwrpb; }; #define LB_TAG_MAINBOARD 0x0003 struct lb_mainboard { uint32_t tag; uint32_t size; uint8_t vendor_idx; uint8_t part_number_idx; uint8_t strings[0]; }; #define LB_TAG_VERSION 0x0004 #define LB_TAG_EXTRA_VERSION 0x0005 #define LB_TAG_BUILD 0x0006 #define LB_TAG_COMPILE_TIME 0x0007 #define LB_TAG_COMPILE_BY 0x0008 #define LB_TAG_COMPILE_HOST 0x0009 #define LB_TAG_COMPILE_DOMAIN 0x000a #define LB_TAG_COMPILER 0x000b #define LB_TAG_LINKER 0x000c #define LB_TAG_ASSEMBLER 0x000d struct lb_string { uint32_t tag; uint32_t size; uint8_t string[0]; }; /* The following structures are for the cmos definitions table */ #define LB_TAG_CMOS_OPTION_TABLE 200 /* cmos header record */ struct cmos_option_table { uint32_t tag; /* CMOS definitions table type */ uint32_t size; /* size of the entire table */ uint32_t header_length; /* length of header */ }; /* cmos entry record This record is variable length. The name field may be shorter than CMOS_MAX_NAME_LENGTH. The entry may start anywhere in the byte, but can not span bytes unless it starts at the beginning of the byte and the length is fills complete bytes. */ #define LB_TAG_OPTION 201 struct cmos_entries { uint32_t tag; /* entry type */ uint32_t size; /* length of this record */ uint32_t bit; /* starting bit from start of image */ uint32_t length; /* length of field in bits */ uint32_t config; /* e=enumeration, h=hex, r=reserved */ uint32_t config_id; /* a number linking to an enumeration record */ #define CMOS_MAX_NAME_LENGTH 32 uint8_t name[CMOS_MAX_NAME_LENGTH]; /* name of entry in ascii, variable length int aligned */ }; /* cmos enumerations record This record is variable length. The text field may be shorter than CMOS_MAX_TEXT_LENGTH. */ #define LB_TAG_OPTION_ENUM 202 struct cmos_enums { uint32_t tag; /* enumeration type */ uint32_t size; /* length of this record */ uint32_t config_id; /* a number identifying the config id */ uint32_t value; /* the value associated with the text */ #define CMOS_MAX_TEXT_LENGTH 32 uint8_t text[CMOS_MAX_TEXT_LENGTH]; /* enum description in ascii, variable length int aligned */ }; /* cmos defaults record This record contains default settings for the cmos ram. */ #define LB_TAG_OPTION_DEFAULTS 203 struct cmos_defaults { uint32_t tag; /* default type */ uint32_t size; /* length of this record */ uint32_t name_length; /* length of the following name field */ uint8_t name[CMOS_MAX_NAME_LENGTH]; /* name identifying the default */ #define CMOS_IMAGE_BUFFER_SIZE 128 uint8_t default_set[CMOS_IMAGE_BUFFER_SIZE]; /* default settings */ }; #define LB_TAG_OPTION_CHECKSUM 204 struct cmos_checksum { uint32_t tag; uint32_t size; /* In practice everything is byte aligned, but things are measured * in bits to be consistent. */ uint32_t range_start; /* First bit that is checksummed (byte aligned) */ uint32_t range_end; /* Last bit that is checksummed (byte aligned) */ uint32_t location; /* First bit of the checksum (byte aligned) */ uint32_t type; /* Checksum algorithm that is used */ #define CHECKSUM_NONE 0 #define CHECKSUM_PCBIOS 1 }; #endif /* COREBOOT_TABLES_H */ nvramtool-0.0+r3669.orig/ip_checksum.h0000600000175000017500000000106411067403034015732 0ustar uweuwe/*****************************************************************************\ * ip_checksum.h \*****************************************************************************/ #ifndef IP_CHECKSUM_H #define IP_CHECKSUM_H /* Note: The contents of this file were borrowed from the coreboot source * code which may be obtained from http://www.coreboot.org. * Specifically, this code was obtained from coreboot (LinuxBIOS) * version 1.0.0.8. */ unsigned long compute_ip_checksum(void *addr, unsigned long length); #endif /* IP_CHECKSUM_H */ nvramtool-0.0+r3669.orig/input_file.c0000600000175000017500000002342311067403034015574 0ustar uweuwe/*****************************************************************************\ * input_file.c ***************************************************************************** * Copyright (C) 2002-2005 The Regents of the University of California. * Produced at the Lawrence Livermore National Laboratory. * Written by David S. Peterson . * UCRL-CODE-2003-012 * All rights reserved. * * This file is part of nvramtool, a utility for reading/writing coreboot * parameters and displaying information from the coreboot table. * For details, see http://coreboot.org/nvramtool. * * Please also read the file DISCLAIMER which is included in this software * distribution. * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License (as published by the * Free Software Foundation) version 2, dated June 1991. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and * conditions of the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. \*****************************************************************************/ #include "common.h" #include "input_file.h" #include "layout.h" #include "cmos_ops.h" #include "cmos_lowlevel.h" #include "reg_expr.h" static int get_input_file_line (FILE *f, char line[], int line_buf_size); static unsigned long long try_prepare_cmos_write (const cmos_entry_t *e, const char value_str[]); /* matches either a blank line or a comment line */ static const char blank_or_comment_regex[] = /* a blank line */ "(^[[:space:]]+$)" "|" /* or ... */ /* a line consisting of: optional whitespace followed by */ "(^[[:space:]]*" /* a '#' character and optionally, additional characters */ "#.*$)"; /* matches an assignment line */ const char assignment_regex[] = /* optional whitespace */ "^[[:space:]]*" /* followed by a coreboot parameter name */ "([^[:space:]]+)" /* followed by optional whitespace */ "[[:space:]]*" /* followed by an '=' character */ "=" /* followed by optional whitespace */ "[[:space:]]*" /* followed by a value that may contain embedded whitespace */ "([^[:space:]]+([[:space:]]+[^[:space:]]+)*)+" /* followed by optional whitespace */ "[[:space:]]*$"; static int line_num; /**************************************************************************** * process_input_file * * Read the contents of file 'f' and return a pointer to a list of pending * write operations. Perform sanity checking on all write operations and * exit with an error message if there is a problem. ****************************************************************************/ cmos_write_t * process_input_file (FILE *f) { static const int LINE_BUF_SIZE = 256; static const size_t N_MATCHES = 4; char line[LINE_BUF_SIZE]; const char *name, *value; cmos_write_t *list, *item, **p; regex_t blank_or_comment, assignment; regmatch_t match[N_MATCHES]; const cmos_entry_t *e; list = NULL; p = &list; compile_reg_exprs(REG_EXTENDED | REG_NEWLINE, 2, blank_or_comment_regex, &blank_or_comment, assignment_regex, &assignment); /* each iteration processes one line from input file */ for (line_num = 1; get_input_file_line(f, line, LINE_BUF_SIZE) == OK; line_num++) { /* skip comments and blank lines */ if (!regexec(&blank_or_comment, line, 0, NULL, 0)) continue; /* Is this a valid assignment line? If not, then it's a syntax * error. */ if (regexec(&assignment, line, N_MATCHES, match, 0)) { fprintf(stderr, "%s: Syntax error on line %d of input file.\n", prog_name, line_num); exit(1); } /* OK, we found an assignment. Break the line into substrings * representing the lefthand and righthand sides of the assignment. */ line[match[1].rm_eo] = '\0'; line[match[2].rm_eo] = '\0'; name = &line[match[1].rm_so]; value = &line[match[2].rm_so]; /* now look up the coreboot parameter name */ if (is_checksum_name(name) || (e = find_cmos_entry(name)) == NULL) { fprintf(stderr, "%s: Error on line %d of input file: CMOS parameter " "%s not found.\n", prog_name, line_num, name); exit(1); } /* At this point, we figure out what numeric value needs to be written * to which location. At the same time, we perform sanity checking on * the write operation. */ if ((item = (cmos_write_t *) malloc(sizeof(*item))) == NULL) out_of_memory(); item->bit = e->bit; item->length = e->length; item->config = e->config; item->value = try_prepare_cmos_write(e, value); /* Append write operation to pending write list. */ item->next = NULL; *p = item; p = &item->next; } free_reg_exprs(2, &blank_or_comment, &assignment); return list; } /**************************************************************************** * do_cmos_writes * * 'list' is a linked list of pending CMOS write operations that have passed * all sanity checks. Perform all write operations, destroying the list as * we go. ****************************************************************************/ void do_cmos_writes (cmos_write_t *list) { cmos_write_t *item; set_iopl(3); while (list != NULL) { cmos_entry_t e; item = list; e.bit = item->bit; e.length = item->length; e.config = item->config; list = item->next; cmos_write(&e, item->value); free(item); } cmos_checksum_write(cmos_checksum_compute()); set_iopl(0); } /**************************************************************************** * get_input_file_line * * Get a line of input from file 'f'. Store result in 'line' which is an * array of 'line_buf_size' bytes. Return OK on success or an error code on * error. ****************************************************************************/ static int get_input_file_line (FILE *f, char line[], int line_buf_size) { switch (get_line_from_file(f, line, line_buf_size)) { case OK: return OK; case LINE_EOF: return LINE_EOF; case LINE_TOO_LONG: fprintf(stderr, "%s: Error on line %d of input file: Maximum line " "length exceeded. Max is %d characters.\n", prog_name, line_num, line_buf_size - 2); break; default: BUG(); } exit(1); return 1; /* keep compiler happy */ } /**************************************************************************** * try_prepare_cmos_write * * Attempt to convert 'value_str' to an integer representation for storage in * CMOS memory. On success, return the converted value. On error, exit with * an error message. ****************************************************************************/ static unsigned long long try_prepare_cmos_write (const cmos_entry_t *e, const char value_str[]) { unsigned long long value; switch (prepare_cmos_write(e, value_str, &value)) { case OK: return value; case CMOS_OP_BAD_ENUM_VALUE: fprintf(stderr, "%s: Error on line %d of input file: Bad value for " "parameter %s.", prog_name, line_num, e->name); break; case CMOS_OP_NEGATIVE_INT: fprintf(stderr, "%s: Error on line %d of input file: This program " "does not support assignment of negative numbers to " "coreboot parameters.", prog_name, line_num); break; case CMOS_OP_INVALID_INT: fprintf(stderr, "%s: Error on line %d of input file: %s is not a " "valid integer.", prog_name, line_num, value_str); break; case CMOS_OP_RESERVED: fprintf(stderr, "%s: Error on line %d of input file: Can not modify " "reserved coreboot parameter %s.", prog_name, line_num, e->name); break; case CMOS_OP_VALUE_TOO_WIDE: fprintf(stderr, "%s: Error on line %d of input file: Can not write " "value %s to CMOS parameter %s that is only %d bits wide.", prog_name, line_num, value_str, e->name, e->length); break; case CMOS_OP_NO_MATCHING_ENUM: fprintf(stderr, "%s: coreboot parameter %s has no matching enums.", prog_name, e->name); break; case CMOS_AREA_OUT_OF_RANGE: fprintf(stderr, "%s: The CMOS area specified by the layout info for " "coreboot parameter %s is out of range.", prog_name, e->name); break; case CMOS_AREA_OVERLAPS_RTC: fprintf(stderr, "%s: The CMOS area specified by the layout info for " "coreboot parameter %s overlaps the realtime clock area.", prog_name, e->name); break; case CMOS_AREA_TOO_WIDE: fprintf(stderr, "%s: The CMOS area specified by the layout info for " "coreboot parameter %s is too wide.", prog_name, e->name); break; default: fprintf(stderr, "%s: Unknown error encountered while attempting to modify " "coreboot parameter %s.", prog_name, e->name); break; } fprintf(stderr, " No CMOS writes performed.\n"); exit(1); return 0; /* keep compiler happy */ } nvramtool-0.0+r3669.orig/nvramtool.10000600000175000017500000001702611067403034015377 0ustar uweuwe.\"***************************************************************************\ .\" nvramtool.1 .\"*************************************************************************** .\" Copyright (C) 2002, 2003 The Regents of the University of California. .\" Produced at the Lawrence Livermore National Laboratory. .\" Written by David S. Peterson . .\" UCRL-CODE-2003-012 .\" All rights reserved. .\" .\" This file is part of nvramtool, a utility for reading/writing coreboot .\" parameters and displaying information from the coreboot table. .\" For details, see http://coreboot.org/nvramtool. .\" .\" Please also read the file DISCLAIMER which is included in this software .\" distribution. .\" .\" This program is free software; you can redistribute it and/or modify it .\" under the terms of the GNU General Public License (as published by the .\" Free Software Foundation) version 2, dated June 1991. .\" .\" This program is distributed in the hope that it will be useful, but .\" WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF .\" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and .\" conditions of the GNU General Public License for more details. .\" .\" You should have received a copy of the GNU General Public License along .\" with this program; if not, write to the Free Software Foundation, Inc., .\" 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. .\"***************************************************************************/ .TH NVRAMTOOL 1 "September 2008" Linux .SH NAME nvramtool \- read/write coreboot-related information .SH SYNOPSIS .B "nvramtool [OPTS] [-n] -r NAME" .br .B "nvramtool [OPTS] -e NAME" .br .B "nvramtool [OPTS] -a" .br .B "nvramtool [OPTS] -w NAME=VALUE" .br .B "nvramtool [OPTS] -p INPUT_FILE" .br .B "nvramtool [OPTS] -i" .br .B "nvramtool [OPTS] -c [VALUE]" .br .B "nvramtool [OPTS] -l [ARG]" .br .B "nvramtool [OPTS] -d" .br .B "nvramtool [OPTS] -Y" .br .B "nvramtool [OPTS] -b OUTPUT_FILE" .br .B "nvramtool [OPTS] -B INPUT_FILE" .br .B "nvramtool [OPTS] -x" .br .B "nvramtool [OPTS] -X DUMPFILE" .br .B "nvramtool [OPTS] -v" .br .B "nvramtool [OPTS] -h" .SH DESCRIPTION .B "nvramtool" is a utility for reading/writing coreboot parameters and displaying information from the coreboot table. The coreboot table resides in low physical memory. It is created at boot time by coreboot, and contains various system information such as the type of mainboard in use. It specifies locations in the CMOS (nonvolatile RAM) where the coreboot parameters are stored. This program is intended for (x86-based) systems that use coreboot. For information about coreboot, see .br http://www.coreboot.org/. .SH PARAMETERS .TP .B "[-n] -r NAME" Show the value of the coreboot parameter given by .B "NAME." If .B "-n" is specified, show only the value. Otherwise show both parameter name and value. .TP .B "-e NAME" Show all possible values for parameter given by .B "NAME." .TP .B "-a" Show the names and values for all coreboot parameters. .TP .B "-w NAME=VALUE" Assign .B "VALUE" to coreboot parameter given by .B "NAME." .TP .B "-p INPUT_FILE" Assign values to coreboot parameters according to the contents of .B "INPUT_FILE." The format of this file is described below. .TP .B "-i" This is similar to the .B "-p" option, except that the contents of the input file are taken from standard input. .TP .B "-c [VALUE]" If .B "VALUE" is present then set the CMOS checksum for the coreboot parameters to .B "VALUE." Otherwise, show the checksum value. .TP .B "-l [ARG]" If .B "ARG" is present then show information from the coreboot table as specified by .B "ARG." Otherwise show all possible values for .B "ARG." .TP .B "-d" Do a low-level dump of the coreboot table. .TP .B "-Y" Write CMOS layout information to standard output. If redirected to a file, the layout information may be used as input for the .B "'-y LAYOUT_FILE'" option (see below). .TP .B "-b OUTPUT_FILE" Write the contents of CMOS memory to the binary file .B "OUTPUT_FILE." The first 14 bytes of .B "OUTPUT_FILE" do not contain actual CMOS data, and are always written as zeros. This is because the first 14 bytes of the CMOS area do not contain CMOS memory. These bytes are involved with the functioning of the real time clock. .TP .B "-B INPUT_FILE" Read binary data from .B "INPUT_FILE" and write the data to CMOS memory. The first 14 bytes of .B "INPUT_FILE" are skipped and data is written to CMOS starting at the 15th byte of the CMOS area. This is because the first 14 bytes of the CMOS area do not contain CMOS memory. These bytes are involved with the functioning of the real time clock. .TP .B "-x" Show a hex dump of all CMOS data. The first 14 bytes of the dump do not contain actual CMOS data, and are always shown as zeros. This is because the first 14 bytes of the CMOS area do not contain CMOS memory. These bytes are involved with the functioning of the real time clock. .TP .B "-X DUMPFILE" Read binary data from .B "DUMPFILE" (presumably a CMOS dumpfile created using the .B "-b OUTPUT_FILE" option) and show a hex dump of the data. .TP .B "-v" Show version information for this program. .TP .B "-h" Show a help message for this program. .SH "OPTIONS" In all cases above, .B "[OPTS]" evaluates to the following: .B " [-y LAYOUT_FILE | -t]" The .B "'-y LAYOUT_FILE'" option tells nvramtool to obtain CMOS layout information from the contents of .B "LAYOUT_FILE." Likewise, the .B "'-t'" option tells nvramtool to obtain CMOS layout information from the CMOS option table (contained within the coreboot table). If neither option is specified, the CMOS option table is used by default. .B "LAYOUT_FILE" follows the format of the .B "cmos.layout" files provided by coreboot. If the coreboot installed on your system was built without specifying .B "HAVE_OPTION_TABLE," then the coreboot table will not contain a CMOS option table. In this case, the .B "'-y LAYOUT_FILE'" option must be used. These two options are silently ignored when used in combination with other options (such as .B "-h," for instance) for which they are not applicable. .SH FILE FORMAT For the .B "-p" option, .B "INPUT_FILE" must consist of a sequence of lines such that each line is either a blank line, a comment, or an assignment. A blank line consists only of zero or more whitespace characters (spaces and tabs). A comment is constructed as follows: .B " [ws]#[text]" Here, .B "[ws]" indicates optional whitespace characters and .B "[text]" indicates optional text. Blank lines and comments are both ignored. An assignment is constructed as follows: .B " [ws]NAME[ws]=[ws]VALUE[ws]" Here, .B "NAME" is the name of a coreboot parameter and .B "VALUE" is the value that will be assigned to .B "NAME." .B "VALUE" is allowed to contain whitespace characters, but it must begin and end with nonwhitespace characters. Note that each comment must appear on a line by itself. If you attempt to add a comment to the end of an assignment, then the comment will be interpreted as part of .B "VALUE." It is useful to observe that the output produced by both the .B "-a" and the .B "'[-n] NAME'" options (without .B "-n" specified) adheres to this file format. .SH BUGS This program does not implement any type of synchronization to ensure that different processes don't stomp on each other when trying to access the nonvolatile RAM simultaneously. Therefore, corruption of the BIOS parameter values may occur if multiple instances of this program are executed concurrently. .SH AUTHORS David S. Peterson .br Stefan Reinauer nvramtool-0.0+r3669.orig/cmos_lowlevel.c0000600000175000017500000003100711067403034016305 0ustar uweuwe/*****************************************************************************\ * cmos_lowlevel.c ***************************************************************************** * Copyright (C) 2002-2005 The Regents of the University of California. * Produced at the Lawrence Livermore National Laboratory. * Written by David S. Peterson . * UCRL-CODE-2003-012 * All rights reserved. * * This file is part of nvramtool, a utility for reading/writing coreboot * parameters and displaying information from the coreboot table. * For details, see http://coreboot.org/nvramtool. * * Please also read the file DISCLAIMER which is included in this software * distribution. * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License (as published by the * Free Software Foundation) version 2, dated June 1991. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and * conditions of the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. \*****************************************************************************/ #include #include "common.h" #include "cmos_lowlevel.h" typedef struct { unsigned byte_index; unsigned bit_offset; } cmos_bit_op_location_t; static unsigned cmos_bit_op_strategy (unsigned bit, unsigned bits_left, cmos_bit_op_location_t *where); static unsigned char cmos_read_bits (const cmos_bit_op_location_t *where, unsigned nr_bits); static void cmos_write_bits (const cmos_bit_op_location_t *where, unsigned nr_bits, unsigned char value); static unsigned char get_bits (unsigned long long value, unsigned bit, unsigned nr_bits); static void put_bits (unsigned char value, unsigned bit, unsigned nr_bits, unsigned long long *result); /**************************************************************************** * get_bits * * Extract a value 'nr_bits' bits wide starting at bit position 'bit' from * 'value' and return the result. It is assumed that 'nr_bits' is at most 8. ****************************************************************************/ static inline unsigned char get_bits (unsigned long long value, unsigned bit, unsigned nr_bits) { return (value >> bit) & ((unsigned char) ((1 << nr_bits) - 1)); } /**************************************************************************** * put_bits * * Extract the low order 'nr_bits' bits from 'value' and store them in the * value pointed to by 'result' starting at bit position 'bit'. The bit * positions in 'result' where the result is stored are assumed to be * initially zero. ****************************************************************************/ static inline void put_bits (unsigned char value, unsigned bit, unsigned nr_bits, unsigned long long *result) { *result += ((unsigned long long)(value & ((unsigned char) ((1 << nr_bits) - 1)))) << bit; } /**************************************************************************** * cmos_read * * Read value from nonvolatile RAM at position given by 'bit' and 'length' * and return this value. The I/O privilege level of the currently executing * process must be set appropriately. ****************************************************************************/ unsigned long long cmos_read (const cmos_entry_t *e) { cmos_bit_op_location_t where; unsigned bit = e->bit, length=e->length; unsigned next_bit, bits_left, nr_bits; unsigned long long result = 0; unsigned char value; assert(!verify_cmos_op(bit, length, e->config)); result = 0; if (e->config == CMOS_ENTRY_STRING) { char *newstring = malloc((length+7)/8); unsigned usize = (8 * sizeof(unsigned long long)); if(!newstring) { out_of_memory(); } for (next_bit = 0, bits_left = length; bits_left; next_bit += nr_bits, bits_left -= nr_bits) { nr_bits = cmos_bit_op_strategy(bit + next_bit, bits_left>usize?usize:bits_left, &where); value = cmos_read_bits(&where, nr_bits); put_bits(value, next_bit % usize, nr_bits, &((unsigned long long *)newstring)[next_bit/usize]); result = (unsigned long)newstring; } } else { for (next_bit = 0, bits_left = length; bits_left; next_bit += nr_bits, bits_left -= nr_bits) { nr_bits = cmos_bit_op_strategy(bit + next_bit, bits_left, &where); value = cmos_read_bits(&where, nr_bits); put_bits(value, next_bit, nr_bits, &result); } } return result; } /**************************************************************************** * cmos_write * * Write 'data' to nonvolatile RAM at position given by 'bit' and 'length'. * The I/O privilege level of the currently executing process must be set * appropriately. ****************************************************************************/ void cmos_write (const cmos_entry_t *e, unsigned long long value) { cmos_bit_op_location_t where; unsigned bit = e->bit, length=e->length; unsigned next_bit, bits_left, nr_bits; assert(!verify_cmos_op(bit, length, e->config)); if (e->config == CMOS_ENTRY_STRING) { unsigned long long *data = (unsigned long long *)(unsigned long)value; unsigned usize = (8 * sizeof(unsigned long long)); for (next_bit = 0, bits_left = length; bits_left; next_bit += nr_bits, bits_left -= nr_bits) { nr_bits = cmos_bit_op_strategy(bit + next_bit, bits_left>usize?usize:bits_left, &where); value = data[next_bit/usize]; cmos_write_bits(&where, nr_bits, get_bits(value, next_bit % usize, nr_bits)); } } else { for (next_bit = 0, bits_left = length; bits_left; next_bit += nr_bits, bits_left -= nr_bits) { nr_bits = cmos_bit_op_strategy(bit + next_bit, bits_left, &where); cmos_write_bits(&where, nr_bits, get_bits(value, next_bit, nr_bits)); } } } /**************************************************************************** * cmos_read_byte * * Read a byte from nonvolatile RAM at a position given by 'index' and return * the result. An 'index' value of 0 represents the first byte of * nonvolatile RAM. * * Note: the first 14 bytes of nonvolatile RAM provide an interface to the * real time clock. ****************************************************************************/ unsigned char cmos_read_byte (unsigned index) { unsigned short port_0, port_1; assert(!verify_cmos_byte_index(index)); if (index < 128) { port_0 = 0x70; port_1 = 0x71; } else { port_0 = 0x72; port_1 = 0x73; } outb(index, port_0); return inb(port_1); } /**************************************************************************** * cmos_write_byte * * Write 'value' to nonvolatile RAM at a position given by 'index'. An * 'index' of 0 represents the first byte of nonvolatile RAM. * * Note: the first 14 bytes of nonvolatile RAM provide an interface to the * real time clock. Writing to any of these bytes will therefore * affect its functioning. ****************************************************************************/ void cmos_write_byte (unsigned index, unsigned char value) { unsigned short port_0, port_1; assert(!verify_cmos_byte_index(index)); if (index < 128) { port_0 = 0x70; port_1 = 0x71; } else { port_0 = 0x72; port_1 = 0x73; } outb(index, port_0); outb(value, port_1); } /**************************************************************************** * cmos_read_all * * Read all contents of CMOS memory into array 'data'. The first 14 bytes of * 'data' are set to zero since this corresponds to the real time clock area. ****************************************************************************/ void cmos_read_all (unsigned char data[]) { unsigned i; for (i = 0; i < CMOS_RTC_AREA_SIZE; i++) data[i] = 0; for (; i < CMOS_SIZE; i++) data[i] = cmos_read_byte(i); } /**************************************************************************** * cmos_write_all * * Update all of CMOS memory with the contents of array 'data'. The first 14 * bytes of 'data' are ignored since this corresponds to the real time clock * area. ****************************************************************************/ void cmos_write_all (unsigned char data[]) { unsigned i; for (i = CMOS_RTC_AREA_SIZE; i < CMOS_SIZE; i++) cmos_write_byte(i, data[i]); } /**************************************************************************** * set_iopl * * Set the I/O privilege level of the executing process. Root privileges are * required for performing this action. A sufficient I/O privilege level * allows the process to access x86 I/O address space and to disable/reenable * interrupts while executing in user space. Messing with the I/O privilege * level is therefore somewhat dangerous. ****************************************************************************/ void set_iopl (int level) { assert((level >= 0) && (level <= 3)); if (iopl(level)) { fprintf(stderr, "%s: iopl() system call failed. You must be root to do " "this.\n", prog_name); exit(1); } } /**************************************************************************** * verify_cmos_op * * 'bit' represents a bit position in the nonvolatile RAM. The first bit * (i.e. the lowest order bit of the first byte) of nonvolatile RAM is * labeled as bit 0. 'length' represents the width in bits of a value we * wish to read or write. Perform sanity checking on 'bit' and 'length'. If * no problems were encountered, return OK. Else return an error code. ****************************************************************************/ int verify_cmos_op (unsigned bit, unsigned length, cmos_entry_config_t config) { if ((bit >= (8 * CMOS_SIZE)) || ((bit + length) > (8 * CMOS_SIZE))) return CMOS_AREA_OUT_OF_RANGE; if (bit < (8 * CMOS_RTC_AREA_SIZE)) return CMOS_AREA_OVERLAPS_RTC; if (config == CMOS_ENTRY_STRING) return OK; if (length > (8 * sizeof(unsigned long long))) return CMOS_AREA_TOO_WIDE; return OK; } /**************************************************************************** * cmos_bit_op_strategy * * Helper function used by cmos_read() and cmos_write() to determine which * bits to read or write next. ****************************************************************************/ static unsigned cmos_bit_op_strategy (unsigned bit, unsigned bits_left, cmos_bit_op_location_t *where) { unsigned max_bits; where->byte_index = bit >> 3; where->bit_offset = bit & 0x07; max_bits = 8 - where->bit_offset; return (bits_left > max_bits) ? max_bits : bits_left; } /**************************************************************************** * cmos_read_bits * * Read a chunk of bits from a byte location within CMOS memory. Return the * value represented by the chunk of bits. ****************************************************************************/ static unsigned char cmos_read_bits (const cmos_bit_op_location_t *where, unsigned nr_bits) { return (cmos_read_byte(where->byte_index) >> where->bit_offset) & ((unsigned char) ((1 << nr_bits) - 1)); } /**************************************************************************** * cmos_write_bits * * Write a chunk of bits (the low order 'nr_bits' bits of 'value') to an area * within a particular byte of CMOS memory. ****************************************************************************/ static void cmos_write_bits (const cmos_bit_op_location_t *where, unsigned nr_bits, unsigned char value) { unsigned char n, mask; if (nr_bits == 8) { cmos_write_byte(where->byte_index, value); return; } n = cmos_read_byte(where->byte_index); mask = ((unsigned char) ((1 << nr_bits) - 1)) << where->bit_offset; n = (n & ~mask) + ((value << where->bit_offset) & mask); cmos_write_byte(where->byte_index, n); } nvramtool-0.0+r3669.orig/input_file.h0000600000175000017500000000423711067403034015603 0ustar uweuwe/*****************************************************************************\ * input_file.h ***************************************************************************** * Copyright (C) 2002-2005 The Regents of the University of California. * Produced at the Lawrence Livermore National Laboratory. * Written by David S. Peterson . * UCRL-CODE-2003-012 * All rights reserved. * * This file is part of nvramtool, a utility for reading/writing coreboot * parameters and displaying information from the coreboot table. * For details, see http://coreboot.org/nvramtool. * * Please also read the file DISCLAIMER which is included in this software * distribution. * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License (as published by the * Free Software Foundation) version 2, dated June 1991. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and * conditions of the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. \*****************************************************************************/ #ifndef INPUT_FILE_H #define INPUT_FILE_H #include "common.h" #include "layout.h" typedef struct cmos_write_t cmos_write_t; /* This represents a pending CMOS write operation. When changing multiple * CMOS parameter values, we first represent the changes as a list of pending * write operations. This allows us to sanity check all write operations * before any of them are performed. */ struct cmos_write_t { unsigned bit; unsigned length; cmos_entry_config_t config; unsigned long long value; cmos_write_t *next; }; cmos_write_t * process_input_file (FILE *f); void do_cmos_writes (cmos_write_t *list); extern const char assignment_regex[]; #endif /* INPUT_FILE_H */ nvramtool-0.0+r3669.orig/lbtable.c0000600000175000017500000012647011067403034015051 0ustar uweuwe/*****************************************************************************\ * lbtable.c ***************************************************************************** * Copyright (C) 2002-2005 The Regents of the University of California. * Produced at the Lawrence Livermore National Laboratory. * Written by Dave Peterson * and Stefan Reinauer . * UCRL-CODE-2003-012 * All rights reserved. * * This file is part of nvramtool, a utility for reading/writing coreboot * parameters and displaying information from the coreboot table. * For details, see http://coreboot.org/nvramtool. * * Please also read the file DISCLAIMER which is included in this software * distribution. * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License (as published by the * Free Software Foundation) version 2, dated June 1991. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and * conditions of the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. \*****************************************************************************/ #include #include #include "common.h" #include "coreboot_tables.h" #include "ip_checksum.h" #include "lbtable.h" #include "layout.h" #include "cmos_lowlevel.h" #include "hexdump.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); 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); 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 " "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"; /* 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; /* 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 }; /**************************************************************************** * 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)) /**************************************************************************** * 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)) /**************************************************************************** * 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(); } /**************************************************************************** * 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"); } } /**************************************************************************** * 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[] = { '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, (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) { /* 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 * 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_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 * 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. ****************************************************************************/ 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"); } } /**************************************************************************** * 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); } /**************************************************************************** * 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; str[0] = '0'; str[1] = 'x'; /* 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); } nvramtool-0.0+r3669.orig/ChangeLog0000600000175000017500000000736111067403034015047 0ustar uweuweTue Sep 23 19:14:27 CEST 2008 Stefan Reinauer (stepan@coresystems.de) Version 2.1 * Fix a number of off by one errors when accessing arrays * Add support for reading/writing strings from/to CMOS. Mon Jan 23 16:00:00 PST 2006 David S. Peterson (dsp@llnl.gov) Version 2.0.1 * Postpone most sanity checking of CMOS layout information until right before a CMOS read or write operation is attempted. This fixes a problem discovered by Stefan Reinauer in which lxbios was failing on Opteron due to the existence of a "user_data" parameter that is 256 bits long. In general, postponing the sanity checks will make lxbios more adaptable to changes in how LinuxBIOS stores CMOS parameters. * Merge fix from Stefan Reinauer that makes hex dumps look a bit nicer. * Merge fix from Stefan Reinauer that allows lxbios to access CMOS memory beyond the first 128 bytes. Fri Dec 16 14:30:00 PST 2005 David S. Peterson (dsp@llnl.gov) Version 2.0.0 * Added the following options: -Y Write CMOS layout information to standard output. -b OUTPUT_FILE Write the contents of CMOS memory to a binary file. -B INPUT_FILE Read binary data from file and write it to CMOS memory. -x Show a hex dump of all CMOS data. -X DUMPFILE Read binary data from a CMOS dumpfile and show a hex dump of the data. Thanks to Stefan Reinauer for suggesting the ideas for the "-Y", "-b OUTPUT_FILE", and "-B INPUT_FILE" options. * Added support for reading/writing CMOS parameters between 1 and 64 bits in size that are not necessarily aligned on byte boundaries. * Reworked much of the code, cleaning up some ugly parts. * Made a number of minor improvements. Wed Nov 30 16:30:00 PST 2005 David S. Peterson (dsp@llnl.gov) Version 1.4.0 * Merge patch from Stefan Reinauer that makes lxbios recognize the LB_TAG_OPTION_CHECKSUM entry placed in the coreboot table by newer versions of LinuxBIOS. * Tweak formatting of code to facilitate merging future patches. * Minor code cleanup. Fri Jun 25 18:30:00 PDT 2004 David S. Peterson (dsp@llnl.gov) Version 1.3.2. * Changed default_is_printable_fn to avoid problems displaying hex dumps. Thu Jun 10 14:00:00 PDT 2004 David S. Peterson (dsp@llnl.gov) Version 1.3.1. * Minor code cleanup. Fri Mar 7 18:00:00 PST 2003 David S. Peterson (dsp@llnl.gov) Version 1.3.0. * Added -y option that tells lxbios to get CMOS layout information from a file instead of from the CMOS option table. * Modified command syntax so that -r flag is required for reading a single CMOS parameter. * Fixed bug where CMOS checksum was being displayed with bytes reversed. Thu Dec 5 14:30:00 PST 2002 David S. Peterson (dsp@llnl.gov) Version 1.2.3. * Fixed bug where checksum was not being updated after changing CMOS parameter values. * Added code to verify checksum when reading CMOS parameters. * Modified program so that check_sum parameter is treated differently from other CMOS parameters. Now, -c option must be used to read/write check_sum parameter. Thu Nov 14 15:15:00 PST 2002 David S. Peterson (dsp@llnl.gov) Version 1.2.2. * Shortened output of usage message. Mon Nov 11 18:00:00 PST 2002 David S. Peterson (dsp@llnl.gov) Version 1.2.1. * Fixed typo in man page. Mon Nov 11 10:00:00 PST 2002 David S. Peterson (dsp@llnl.gov) Version 1.2.0. * Added hex dump stuff. Fri Nov 8 17:00:00 PST 2002 David S. Peterson (dsp@llnl.gov) Version 1.1.0. * Added -l option for displaying entries from coreboot table. * Added -d option for low-level dump of coreboot table. * Improved code that searches for coreboot table. Wed Nov 6 09:30:00 PST 2002 David S. Peterson (dsp@llnl.gov) Version 1.0.0. nvramtool-0.0+r3669.orig/lbtable.h0000600000175000017500000000333611067403034015051 0ustar uweuwe/*****************************************************************************\ * lbtable.h ***************************************************************************** * Copyright (C) 2002-2005 The Regents of the University of California. * Produced at the Lawrence Livermore National Laboratory. * Written by Dave Peterson . * UCRL-CODE-2003-012 * All rights reserved. * * This file is part of nvramtool, a utility for reading/writing coreboot * parameters and displaying information from the coreboot table. * For details, see http://coreboot.org/nvramtool. * * Please also read the file DISCLAIMER which is included in this software * distribution. * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License (as published by the * Free Software Foundation) version 2, dated June 1991. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and * conditions of the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. \*****************************************************************************/ #ifndef LBTABLE_H #define LBTABLE_H #include "common.h" void get_lbtable (void); void get_layout_from_cmos_table (void); void dump_lbtable (void); void list_lbtable_choices (void); void list_lbtable_item (const char item[]); #endif /* LBTABLE_H */ nvramtool-0.0+r3669.orig/layout_file.c0000600000175000017500000007125011067403034015753 0ustar uweuwe/*****************************************************************************\ * layout_file.c ***************************************************************************** * Copyright (C) 2002-2005 The Regents of the University of California. * Produced at the Lawrence Livermore National Laboratory. * Written by Dave Peterson . * UCRL-CODE-2003-012 * All rights reserved. * * This file is part of nvramtool, a utility for reading/writing coreboot * parameters and displaying information from the coreboot table. * For details, see http://coreboot.org/nvramtool. * * Please also read the file DISCLAIMER which is included in this software * distribution. * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License (as published by the * Free Software Foundation) version 2, dated June 1991. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and * conditions of the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. \*****************************************************************************/ #include "common.h" #include "layout_file.h" #include "layout.h" #include "cmos_lowlevel.h" #include "reg_expr.h" static void process_layout_file (FILE *f); static void skip_past_start (FILE *f); static int process_entry (FILE *f, int skip_add); static int process_enum (FILE *f, int skip_add); static void process_checksum_info (FILE *f); static void skip_remaining_lines (FILE *f); static void create_entry (cmos_entry_t *cmos_entry, const char start_bit_str[], const char length_str[], const char config_str[], const char config_id_str[], const char name_str[]); static void try_add_layout_file_entry (const cmos_entry_t *cmos_entry); static void create_enum (cmos_enum_t *cmos_enum, const char id_str[], const char value_str[], const char text_str[]); static void try_add_cmos_enum (const cmos_enum_t *cmos_enum); static void set_checksum_info (const char start_str[], const char end_str[], const char index_str[]); static char cmos_entry_char_value (cmos_entry_config_t config); static int get_layout_file_line (FILE *f, char line[], int line_buf_size); static unsigned string_to_unsigned (const char str[], const char str_name[]); static unsigned long string_to_unsigned_long (const char str[], const char str_name[]); static unsigned long do_string_to_unsigned_long (const char str[], const char str_name[], const char blurb[]); /* matches either a blank line or a comment line */ static const char blank_or_comment_regex[] = /* a blank line */ "(^[[:space:]]+$)" "|" /* or ... */ /* a line consisting of: optional whitespace followed by */ "(^[[:space:]]*" /* a '#' character and optionally, additional characters */ "#.*$)"; static regex_t blank_or_comment_expr; /* matches the line in a CMOS layout file indicating the start of the * "entries" section. */ static const char start_entries_regex[] = /* optional whitespace */ "^[[:space:]]*" /* followed by "entries" */ "entries" /* followed by optional whitespace */ "[[:space:]]*$"; static regex_t start_entries_expr; /* matches the line in a CMOS layout file indicating the start of the * "enumerations" section */ static const char start_enums_regex[] = /* optional whitespace */ "^[[:space:]]*" /* followed by "enumerations" */ "enumerations" /* followed by optional whitespace */ "[[:space:]]*$"; static regex_t start_enums_expr; /* matches the line in a CMOS layout file indicating the start of the * "checksums" section */ static const char start_checksums_regex[] = /* optional whitespace */ "^[[:space:]]*" /* followed by "checksums" */ "checksums" /* followed by optional whitespace */ "[[:space:]]*$"; static regex_t start_checksums_expr; /* matches a line in a CMOS layout file specifying a CMOS entry */ static const char entries_line_regex[] = /* optional whitespace */ "^[[:space:]]*" /* followed by a chunk of nonwhitespace for start-bit field */ "([^[:space:]]+)" /* followed by one or more whitespace characters */ "[[:space:]]+" /* followed by a chunk of nonwhitespace for length field */ "([^[:space:]]+)" /* followed by one or more whitespace characters */ "[[:space:]]+" /* followed by a chunk of nonwhitespace for config field */ "([^[:space:]]+)" /* followed by one or more whitespace characters */ "[[:space:]]+" /* followed by a chunk of nonwhitespace for config-ID field */ "([^[:space:]]+)" /* followed by one or more whitespace characters */ "[[:space:]]+" /* followed by a chunk of nonwhitespace for name field */ "([^[:space:]]+)" /* followed by optional whitespace */ "[[:space:]]*$"; static regex_t entries_line_expr; /* matches a line in a CMOS layout file specifying a CMOS enumeration */ static const char enums_line_regex[] = /* optional whitespace */ "^[[:space:]]*" /* followed by a chunk of nonwhitespace for ID field */ "([^[:space:]]+)" /* followed by one or more whitespace characters */ "[[:space:]]+" /* followed by a chunk of nonwhitespace for value field */ "([^[:space:]]+)" /* followed by one or more whitespace characters */ "[[:space:]]+" /* followed by a chunk of nonwhitespace for text field */ "([^[:space:]]+)" /* followed by optional whitespace */ "[[:space:]]*$"; static regex_t enums_line_expr; /* matches the line in a CMOS layout file specifying CMOS checksum * information */ static const char checksum_line_regex[] = /* optional whitespace */ "^[[:space:]]*" /* followed by "checksum" */ "checksum" /* followed by one or more whitespace characters */ "[[:space:]]+" /* followed by a chunk of nonwhitespace for first bit of summed area */ "([^[:space:]]+)" /* followed by one or more whitespace characters */ "[[:space:]]+" /* followed by a chunk of nonwhitespace for last bit of summed area */ "([^[:space:]]+)" /* followed by one or more whitespace characters */ "[[:space:]]+" /* followed by a chunk of nonwhitespace for checksum location bit */ "([^[:space:]]+)" /* followed by optional whitespace */ "[[:space:]]*$"; static regex_t checksum_line_expr; static const int LINE_BUF_SIZE = 256; static int line_num; static const char *layout_filename = NULL; /**************************************************************************** * set_layout_filename * * Set the name of the file we will obtain CMOS layout information from. ****************************************************************************/ void set_layout_filename (const char filename[]) { layout_filename = filename; } /**************************************************************************** * get_layout_from_file * * Read CMOS layout information from the user-specified CMOS layout file. ****************************************************************************/ void get_layout_from_file (void) { FILE *f; assert(layout_filename != NULL); if ((f = fopen(layout_filename, "r")) == NULL) { fprintf(stderr, "%s: Can not open CMOS layout file %s for reading: " "%s\n", prog_name, layout_filename, strerror(errno)); exit(1); } process_layout_file(f); fclose(f); } /**************************************************************************** * write_cmos_layout * * Write CMOS layout information to file 'f'. The output is written in the * format that CMOS layout files adhere to. ****************************************************************************/ void write_cmos_layout (FILE *f) { const cmos_entry_t *cmos_entry; const cmos_enum_t *cmos_enum; cmos_checksum_layout_t layout; fprintf(f, "entries\n"); for (cmos_entry = first_cmos_entry(); cmos_entry != NULL; cmos_entry = next_cmos_entry(cmos_entry)) fprintf(f, "%u %u %c %u %s\n", cmos_entry->bit, cmos_entry->length, cmos_entry_char_value(cmos_entry->config), cmos_entry->config_id, cmos_entry->name); fprintf(f, "\nenumerations\n"); for (cmos_enum = first_cmos_enum(); cmos_enum != NULL; cmos_enum = next_cmos_enum(cmos_enum)) fprintf(f, "%u %llu %s\n", cmos_enum->config_id, cmos_enum->value, cmos_enum->text); layout.summed_area_start = cmos_checksum_start; layout.summed_area_end = cmos_checksum_end; layout.checksum_at = cmos_checksum_index; checksum_layout_to_bits(&layout); fprintf(f, "\nchecksums\nchecksum %u %u %u\n", layout.summed_area_start, layout.summed_area_end, layout.checksum_at); } /**************************************************************************** * process_layout_file * * Read CMOS layout information from file 'f' and add it to our internal * repository. ****************************************************************************/ static void process_layout_file (FILE *f) { compile_reg_exprs(REG_EXTENDED | REG_NEWLINE, 7, blank_or_comment_regex, &blank_or_comment_expr, start_entries_regex, &start_entries_expr, entries_line_regex, &entries_line_expr, start_enums_regex, &start_enums_expr, enums_line_regex, &enums_line_expr, start_checksums_regex, &start_checksums_expr, checksum_line_regex, &checksum_line_expr); line_num = 1; skip_past_start(f); /* Skip past all entries. We will process these later when we make a * second pass through the file. */ while (!process_entry(f, 1)); /* Process all enums, adding them to our internal repository as we go. */ if (process_enum(f, 0)) { fprintf(stderr, "%s: Error: CMOS layout file contains no " "enumerations.\n", prog_name); exit(1); } while (!process_enum(f, 0)); /* Go back to start of file. */ line_num = 1; fseek(f, 0, SEEK_SET); skip_past_start(f); /* Process all entries, adding them to the repository as we go. We must * add the entries after the enums, even though they appear in the layout * file before the enums. This is because the entries are sanity checked * against the enums as they are added. */ if (process_entry(f, 0)) { fprintf(stderr, "%s: Error: CMOS layout file contains no entries.\n", prog_name); exit(1); } while (!process_entry(f, 0)); /* Skip past all enums. They have already been processed. */ while (!process_enum(f, 1)); /* Process CMOS checksum info. */ process_checksum_info(f); /* See if there are any lines left to process. If so, verify that they are * all either blank lines or comments. */ skip_remaining_lines(f); free_reg_exprs(7, &blank_or_comment_expr, &start_entries_expr, &entries_line_expr, &start_enums_expr, &enums_line_expr, &start_checksums_expr, &checksum_line_expr); } /**************************************************************************** * skip_past_start * * Skip past the line that marks the start of the "entries" section. ****************************************************************************/ static void skip_past_start (FILE *f) { char line[LINE_BUF_SIZE]; for (; ; line_num++) { if (get_layout_file_line(f, line, LINE_BUF_SIZE)) { fprintf(stderr, "%s: \"entries\" line not found in CMOS layout file.\n", prog_name); exit(1); } if (!regexec(&blank_or_comment_expr, line, 0, NULL, 0)) continue; if (!regexec(&start_entries_expr, line, 0, NULL, 0)) break; fprintf(stderr, "%s: Syntax error on line %d of CMOS layout file. " "\"entries\" line expected.\n", prog_name, line_num); exit(1); } line_num++; } /**************************************************************************** * process_entry * * Get an entry from "entries" section of file and add it to our repository * of layout information. Return 0 if an entry was found and processed. * Return 1 if there are no more entries. ****************************************************************************/ static int process_entry (FILE *f, int skip_add) { static const size_t N_MATCHES = 6; char line[LINE_BUF_SIZE]; regmatch_t match[N_MATCHES]; cmos_entry_t cmos_entry; int result; result = 1; for (; ; line_num++) { if (get_layout_file_line(f, line, LINE_BUF_SIZE)) { fprintf(stderr, "%s: Unexpected end of CMOS layout file reached while " "reading \"entries\" section.\n", prog_name); exit(1); } if (!regexec(&blank_or_comment_expr, line, 0, NULL, 0)) continue; if (regexec(&entries_line_expr, line, N_MATCHES, match, 0)) { if (regexec(&start_enums_expr, line, 0, NULL, 0)) { fprintf(stderr, "%s: Syntax error on line %d of CMOS layout " "file.\n", prog_name, line_num); exit(1); } break; /* start of enumerations reached: no more entries */ } result = 0; /* next layout entry found */ if (skip_add) break; line[match[1].rm_eo] = '\0'; line[match[2].rm_eo] = '\0'; line[match[3].rm_eo] = '\0'; line[match[4].rm_eo] = '\0'; line[match[5].rm_eo] = '\0'; create_entry(&cmos_entry, &line[match[1].rm_so], &line[match[2].rm_so], &line[match[3].rm_so], &line[match[4].rm_so], &line[match[5].rm_so]); try_add_layout_file_entry(&cmos_entry); break; } line_num++; return result; } /**************************************************************************** * process_enum * * Get an enuneration from "enumerations" section of file and add it to our * repository of layout information. Return 0 if an enumeration was found * and processed. Return 1 if there are no more enumerations. ****************************************************************************/ static int process_enum (FILE *f, int skip_add) { static const size_t N_MATCHES = 4; char line[LINE_BUF_SIZE]; regmatch_t match[N_MATCHES]; cmos_enum_t cmos_enum; int result; result = 1; for (; ; line_num++) { if (get_layout_file_line(f, line, LINE_BUF_SIZE)) { fprintf(stderr, "%s: Unexpected end of CMOS layout file reached while " "reading \"enumerations\" section.\n", prog_name); exit(1); } if (!regexec(&blank_or_comment_expr, line, 0, NULL, 0)) continue; if (regexec(&enums_line_expr, line, N_MATCHES, match, 0)) { if (regexec(&start_checksums_expr, line, 0, NULL, 0)) { fprintf(stderr, "%s: Syntax error on line %d of CMOS layout " "file.\n", prog_name, line_num); exit(1); } break; /* start of checksums reached: no more enumerations */ } result = 0; /* next layout enumeration found */ if (skip_add) break; line[match[1].rm_eo] = '\0'; line[match[2].rm_eo] = '\0'; line[match[3].rm_eo] = '\0'; create_enum(&cmos_enum, &line[match[1].rm_so], &line[match[2].rm_so], &line[match[3].rm_so]); try_add_cmos_enum(&cmos_enum); break; } line_num++; return result; } /**************************************************************************** * process_checksum_info * * Get line conatining CMOS checksum information. ****************************************************************************/ static void process_checksum_info (FILE *f) { static const size_t N_MATCHES = 4; char line[LINE_BUF_SIZE]; regmatch_t match[N_MATCHES]; for (; ; line_num++) { if (get_layout_file_line(f, line, LINE_BUF_SIZE)) { fprintf(stderr, "%s: Unexpected end of CMOS layout file reached while " "reading \"checksums\" section.\n", prog_name); exit(1); } if (!regexec(&blank_or_comment_expr, line, 0, NULL, 0)) continue; if (regexec(&checksum_line_expr, line, N_MATCHES, match, 0)) { fprintf(stderr, "%s: Syntax error on line %d of CMOS layout " "file. \"checksum\" line expected.\n", prog_name, line_num); exit(1); } /* checksum line found */ line[match[1].rm_eo] = '\0'; line[match[2].rm_eo] = '\0'; line[match[3].rm_eo] = '\0'; set_checksum_info(&line[match[1].rm_so], &line[match[2].rm_so], &line[match[3].rm_so]); break; } } /**************************************************************************** * skip_remaining_lines * * Get any remaining lines of unprocessed input. Complain if we find a line * that contains anything other than comments and whitespace. ****************************************************************************/ static void skip_remaining_lines (FILE *f) { char line[LINE_BUF_SIZE]; for (line_num++; get_layout_file_line(f, line, LINE_BUF_SIZE) == OK; line_num++) { if (regexec(&blank_or_comment_expr, line, 0, NULL, 0)) { fprintf(stderr, "%s: Syntax error on line %d of CMOS layout file: " "Only comments and/or whitespace allowed after " "\"checksum\" line.\n", prog_name, line_num); exit(1); } } } /**************************************************************************** * create_entry * * Create a CMOS entry structure representing the given information. Perform * sanity checking on input parameters. ****************************************************************************/ static void create_entry (cmos_entry_t *cmos_entry, const char start_bit_str[], const char length_str[], const char config_str[], const char config_id_str[], const char name_str[]) { cmos_entry->bit = string_to_unsigned(start_bit_str, "start-bit"); cmos_entry->length = string_to_unsigned(length_str, "length"); if (config_str[1] != '\0') goto bad_config_str; switch (config_str[0]) { case 'e': cmos_entry->config = CMOS_ENTRY_ENUM; break; case 'h': cmos_entry->config = CMOS_ENTRY_HEX; break; case 's': cmos_entry->config = CMOS_ENTRY_STRING; break; case 'r': cmos_entry->config = CMOS_ENTRY_RESERVED; break; default: goto bad_config_str; } cmos_entry->config_id = string_to_unsigned(config_id_str, "config-ID"); if (strlen(name_str) >= CMOS_MAX_NAME_LENGTH) { fprintf(stderr, "%s: Error on line %d of CMOS layout file: name too " "long (max length is %d).\n", prog_name, line_num, CMOS_MAX_NAME_LENGTH - 1); exit(1); } strcpy(cmos_entry->name, name_str); return; bad_config_str: fprintf(stderr, "%s: Error on line %d of CMOS layout file: 'e', 'h', or " "'r' expected for config value.\n", prog_name, line_num); exit(1); } /**************************************************************************** * try_add_layout_file_entry * * Attempt to add the given CMOS entry to our internal repository. Exit with * an error message on failure. ****************************************************************************/ static void try_add_layout_file_entry (const 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: Error on line %d of CMOS layout file. Area " "covered by entry %s is out of range.\n", prog_name, line_num, cmos_entry->name); break; case CMOS_AREA_TOO_WIDE: fprintf(stderr, "%s: Error on line %d of CMOS layout file. Area " "covered by entry %s is too wide.\n", prog_name, line_num, cmos_entry->name); break; case LAYOUT_ENTRY_OVERLAP: fprintf(stderr, "%s: Error on line %d of CMOS layout file. Layouts " "overlap for entries %s and %s.\n", prog_name, line_num, 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); } /**************************************************************************** * create_enum * * Create a CMOS enumeration structure representing the given information. * Perform sanity checking on input parameters. ****************************************************************************/ static void create_enum (cmos_enum_t *cmos_enum, const char id_str[], const char value_str[], const char text_str[]) { cmos_enum->config_id = string_to_unsigned(id_str, "ID"); cmos_enum->value = string_to_unsigned_long(value_str, "value"); if (strlen(text_str) >= CMOS_MAX_TEXT_LENGTH) { fprintf(stderr, "%s: Error on line %d of CMOS layout file: text too " "long (max length is %d).\n", prog_name, line_num, CMOS_MAX_TEXT_LENGTH - 1); exit(1); } strcpy(cmos_enum->text, text_str); } /**************************************************************************** * try_add_cmos_enum * * Attempt to add the given CMOS enum to our internal repository. Exit with * an error message on failure. ****************************************************************************/ static void try_add_cmos_enum (const cmos_enum_t *cmos_enum) { switch (add_cmos_enum(cmos_enum)) { case OK: return; case LAYOUT_DUPLICATE_ENUM: fprintf(stderr, "%s: Error on line %d of CMOS layout file: " "Enumeration found with duplicate ID/value combination.\n", prog_name, line_num); break; default: BUG(); } exit(1); } /**************************************************************************** * set_checksum_info * * Set CMOS checksum information according to input parameters and perform * sanity checking on input parameters. ****************************************************************************/ static void set_checksum_info (const char start_str[], const char end_str[], const char index_str[]) { cmos_checksum_layout_t layout; /* These are bit positions that we want to convert to byte positions. */ layout.summed_area_start = string_to_unsigned(start_str, "CMOS checksummed area start"); layout.summed_area_end = string_to_unsigned(end_str, "CMOS checksummed area end"); layout.checksum_at = string_to_unsigned(index_str, "CMOS checksum location"); switch (checksum_layout_to_bytes(&layout)) { case OK: break; case LAYOUT_SUMMED_AREA_START_NOT_ALIGNED: fprintf(stderr, "%s: Error on line %d of CMOS layout file. CMOS " "checksummed area start is not byte-aligned.\n", prog_name, line_num); goto fail; case LAYOUT_SUMMED_AREA_END_NOT_ALIGNED: fprintf(stderr, "%s: Error on line %d of CMOS layout file. CMOS " "checksummed area end is not byte-aligned.\n", prog_name, line_num); goto fail; case LAYOUT_CHECKSUM_LOCATION_NOT_ALIGNED: fprintf(stderr, "%s: Error on line %d of CMOS layout file. CMOS " "checksum location is not byte-aligned.\n", prog_name, line_num); goto fail; case LAYOUT_INVALID_SUMMED_AREA: fprintf(stderr, "%s: Error on line %d of CMOS layout file. CMOS " "checksummed area end must be greater than CMOS checksummed " "area start.\n", prog_name, line_num); goto fail; case LAYOUT_CHECKSUM_OVERLAPS_SUMMED_AREA: fprintf(stderr, "%s: Error on line %d of CMOS layout file. CMOS " "checksum overlaps checksummed area.\n", prog_name, line_num); goto fail; case LAYOUT_SUMMED_AREA_OUT_OF_RANGE: fprintf(stderr, "%s: Error on line %d of CMOS layout file. CMOS " "checksummed area out of range.\n", prog_name, line_num); goto fail; case LAYOUT_CHECKSUM_LOCATION_OUT_OF_RANGE: fprintf(stderr, "%s: Error on line %d of CMOS layout file. CMOS " "checksum location out of range.\n", prog_name, line_num); goto fail; default: BUG(); } cmos_checksum_start = layout.summed_area_start; cmos_checksum_end = layout.summed_area_end; cmos_checksum_index = layout.checksum_at; return; fail: exit(1); } /**************************************************************************** * cmos_entry_char_value * * Return the character representation of 'config'. ****************************************************************************/ static char cmos_entry_char_value (cmos_entry_config_t config) { switch (config) { case CMOS_ENTRY_ENUM: return 'e'; case CMOS_ENTRY_HEX: return 'h'; case CMOS_ENTRY_RESERVED: return 'r'; case CMOS_ENTRY_STRING: return 's'; default: BUG(); } return 0; /* not reached */ } /**************************************************************************** * get_layout_file_line * * Get a line of input from file 'f'. Store result in 'line' which is an * array of 'line_buf_size' bytes. Return OK on success or an error code on * failure. ****************************************************************************/ static int get_layout_file_line (FILE *f, char line[], int line_buf_size) { switch (get_line_from_file(f, line, line_buf_size)) { case OK: return OK; case LINE_EOF: return LINE_EOF; case LINE_TOO_LONG: fprintf(stderr, "%s: Error on line %d of CMOS layout file: Maximum " "line length exceeded. Max is %d characters.\n", prog_name, line_num, line_buf_size - 2); break; } exit(1); return 1; /* keep compiler happy */ } /**************************************************************************** * string_to_unsigned * * Convert the string 'str' to an unsigned and return the result. ****************************************************************************/ static unsigned string_to_unsigned (const char str[], const char str_name[]) { unsigned long n; unsigned z; n = do_string_to_unsigned_long(str, str_name, ""); if ((z = (unsigned) n) != n) { /* This could happen on an architecture in which sizeof(unsigned) < * sizeof(unsigned long). */ fprintf(stderr, "%s: Error on line %d of CMOS layout file: %s value is " "out of range.\n", prog_name, line_num, str_name); exit(1); } return z; } /**************************************************************************** * string_to_unsigned_long * * Convert the string 'str' to an unsigned long and return the result. ****************************************************************************/ static unsigned long string_to_unsigned_long (const char str[], const char str_name[]) { return do_string_to_unsigned_long(str, str_name, " long"); } /**************************************************************************** * do_string_to_unsigned_long * * Convert the string 'str' to an unsigned long and return the result. Exit * with an appropriate error message on failure. ****************************************************************************/ static unsigned long do_string_to_unsigned_long (const char str[], const char str_name[], const char blurb[]) { unsigned long n; char *p; n = strtoul(str, &p, 0); if (*p != '\0') { fprintf(stderr, "%s: Error on line %d of CMOS layout file: %s is not a " "valid unsigned%s integer.\n", prog_name, line_num, str_name, blurb); exit(1); } return n; } nvramtool-0.0+r3669.orig/hexdump.c0000600000175000017500000002153211067403034015107 0ustar uweuwe/*****************************************************************************\ * hexdump.c \*****************************************************************************/ #include "hexdump.h" /* hexdump.c * * Copyright (C) 2002 * David S. Peterson. All rights reserved. * * Author: David S. Peterson * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are * met: * 1. Redistributions of source code must retain the above copyright notice, * this list of conditions, and the entire permission notice, including * the following disclaimer of warranties. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions, and the entire permission notice, * including the following disclaimer in the documentation and/or other * materials provided with the distribution. * 3. The name(s) of the author(s) may not be used to endorse or promote * products derived from this software without specific prior written * permission. * * ALTERNATIVELY, this product may be distributed under the terms of the GNU * General Public License, in which case the provisions of the GPL are * required INSTEAD OF the above restrictions. (This clause is necessary due * to a potential bad interaction between the GPL and the restrictions * contained in a BSD-style copyright.) * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ static void addrprint (FILE *outfile, uint64_t address, int width); static void hexprint (FILE *outfile, unsigned char byte); static void charprint (FILE *outfile, unsigned char byte, unsigned char nonprintable, is_printable_fn_t is_printable_fn); /*-------------------------------------------------------------------------- * hexdump * * Write a hex dump of 'mem' to 'outfile'. * * parameters: * mem: a pointer to the memory to display * bytes: the number of bytes of data to display * addrprint_start: The address to associate with the first byte of * data. For instance, a value of 0 indicates that the * first byte displayed should be labeled as byte 0. * outfile: The place where the hex dump should be written. * For instance, stdout or stderr may be passed here. * format: A structure specifying how the hex dump should be * formatted. *--------------------------------------------------------------------------*/ void hexdump (const void *mem, int bytes, uint64_t addrprint_start, FILE *outfile, const hexdump_format_t *format) { int bytes_left, index, i; const unsigned char *p; is_printable_fn_t is_printable_fn; /* Quietly return if the caller asks us to do something unreasonable. */ if ((format->bytes_per_line <= 0) || (bytes < 0)) return; is_printable_fn = format->is_printable_fn; if (is_printable_fn == NULL) is_printable_fn = default_is_printable_fn; p = (const unsigned char *) mem; index = 0; /* Each iteration handles one full line of output. When loop terminates, * the number of remaining bytes to display (if any) will not be enough to * fill an entire line. */ for (bytes_left = bytes; bytes_left >= format->bytes_per_line; bytes_left -= format->bytes_per_line) { /* print start address for current line */ fprintf(outfile, format->indent); addrprint(outfile, addrprint_start + index, format->addrprint_width); fprintf(outfile, format->sep1); /* display the bytes in hex */ for (i = 0; ; ) { hexprint(outfile, p[index++]); if (++i >= format->bytes_per_line) break; fprintf(outfile, format->sep2); } index -= format->bytes_per_line; fprintf(outfile, format->sep3); /* display the bytes as characters */ for (i = 0; i < format->bytes_per_line; i++) charprint(outfile, p[index++], format->nonprintable, is_printable_fn); fprintf(outfile, "\n"); } if (bytes_left == 0) return; /* print start address for last line */ fprintf(outfile, format->indent); addrprint(outfile, addrprint_start + index, format->addrprint_width); fprintf(outfile, format->sep1); /* display bytes for last line in hex */ for (i = 0; i < bytes_left; i++) { hexprint(outfile, p[index++]); fprintf(outfile, format->sep2); } index -= bytes_left; /* pad the rest of the hex byte area with spaces */ for (; ; ) { fprintf(outfile, " "); if (++i >= format->bytes_per_line) break; fprintf(outfile, format->sep2); } fprintf(outfile, format->sep3); /* display bytes for last line as characters */ for (i = 0; i < bytes_left; i++) charprint(outfile, p[index++], format->nonprintable, is_printable_fn); /* pad the rest of the character area with spaces */ for (; i < format->bytes_per_line; i++) fprintf(outfile, " "); fprintf(outfile, "\n"); } /*-------------------------------------------------------------------------- * default_is_printable_fn * * Determine whether the input character is printable. The proper behavior * for this type of function may be system-dependent. This function takes a * conservative approach. If it is not adequate for your purposes, you can * write your own. * * parameters: * c: the input character * * return value: * Return 1 if the input character is printable. Otherwise return 0. *--------------------------------------------------------------------------*/ int default_is_printable_fn (unsigned char c) { return (c >= 0x20) && (c <= 0x7e); } /*-------------------------------------------------------------------------- * addrprint * * Display an address as a hexadecimal number. * * parameters: * outfile: the place where the output should be written * address: the address to display * width: The number of bytes wide the address should be displayed as. * Must be a value from 1 to 8. *--------------------------------------------------------------------------*/ static void addrprint (FILE *outfile, uint64_t address, int width) { char s[17]; int i; /* force the user's input to be valid */ if (width < 1) width = 1; else if (width > 8) width = 8; /* convert address to string */ sprintf(s, "%016llx", (unsigned long long) address); /* write it out, with colons separating consecutive 16-bit chunks of the * address */ for (i = 16 - (2 * width); ; ) { fprintf(outfile, "%c", s[i]); if (++i >= 16) break; if ((i % 4) == 0) fprintf(outfile, ":"); } } /*-------------------------------------------------------------------------- * hexprint * * Display a byte as a two digit hex value. * * parameters: * outfile: the place where the output should be written * byte: the byte to display *--------------------------------------------------------------------------*/ static void hexprint (FILE *outfile, unsigned char byte) { static const char tbl[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' }; fprintf(outfile, "%c%c", tbl[byte >> 4], tbl[byte & 0x0f]); } /*-------------------------------------------------------------------------- * charprint * * Display a byte as its character representation. * * parameters: * outfile: the place where the output should be written * byte: the byte to display * nonprintable: a substitute character to display if the byte * represents a nonprintable character * is_printable_fn: a function that returns a boolean value indicating * whether a given character is printable *--------------------------------------------------------------------------*/ static void charprint (FILE *outfile, unsigned char byte, unsigned char nonprintable, is_printable_fn_t is_printable_fn) { fprintf(outfile, "%c", is_printable_fn(byte) ? byte : nonprintable); } nvramtool-0.0+r3669.orig/reg_expr.c0000600000175000017500000000550211067403034015247 0ustar uweuwe/*****************************************************************************\ * reg_expr.c ***************************************************************************** * Copyright (C) 2002-2005 The Regents of the University of California. * Produced at the Lawrence Livermore National Laboratory. * Written by Dave Peterson . * UCRL-CODE-2003-012 * All rights reserved. * * This file is part of nvramtool, a utility for reading/writing coreboot * parameters and displaying information from the coreboot table. * For details, see http://coreboot.org/nvramtool. * * Please also read the file DISCLAIMER which is included in this software * distribution. * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License (as published by the * Free Software Foundation) version 2, dated June 1991. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and * conditions of the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. \*****************************************************************************/ #include #include "common.h" #include "reg_expr.h" /**************************************************************************** * compile_reg_exprs * * Compile a bunch of regular expressions. ****************************************************************************/ void compile_reg_exprs (int cflags, int num_exprs, /* const char *expr1, regex_t *reg1, */ ...) { static const size_t ERROR_BUF_SIZE = 256; char error_msg[ERROR_BUF_SIZE]; va_list ap; regex_t *reg; const char *expr; int i, result; va_start(ap, num_exprs); for (i = 0; i < num_exprs; i++) { expr = va_arg(ap, const char *); reg = va_arg(ap, regex_t *); if ((result = regcomp(reg, expr, cflags)) != 0) { regerror(result, reg, error_msg, ERROR_BUF_SIZE); fprintf(stderr, "%s: %s\n", prog_name, error_msg); exit(1); } } va_end(ap); } /**************************************************************************** * free_reg_exprs * * Destroy a bunch of previously compiled regular expressions. ****************************************************************************/ void free_reg_exprs (int num_exprs, /* regex_t *reg1, */ ...) { va_list ap; int i; va_start(ap, num_exprs); for (i = 0; i < num_exprs; i++) regfree(va_arg(ap, regex_t *)); va_end(ap); } nvramtool-0.0+r3669.orig/hexdump.h0000600000175000017500000001363711067403034015123 0ustar uweuwe/*****************************************************************************\ * hexdump.h \*****************************************************************************/ #ifndef _HEXDUMP_H #define _HEXDUMP_H /* hexdump.h * * Copyright (C) 2002 * David S. Peterson. All rights reserved. * * Author: David S. Peterson * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are * met: * 1. Redistributions of source code must retain the above copyright notice, * this list of conditions, and the entire permission notice, including * the following disclaimer of warranties. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions, and the entire permission notice, * including the following disclaimer in the documentation and/or other * materials provided with the distribution. * 3. The name(s) of the author(s) may not be used to endorse or promote * products derived from this software without specific prior written * permission. * * ALTERNATIVELY, this product may be distributed under the terms of the GNU * General Public License, in which case the provisions of the GPL are * required INSTEAD OF the above restrictions. (This clause is necessary due * to a potential bad interaction between the GPL and the restrictions * contained in a BSD-style copyright.) * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include #include #include typedef int (*is_printable_fn_t) (unsigned char c); /*-------------------------------------------------------------------------- * hexdump_format_t * * This specifies how the output of the 'hexdump' function should look. * * fields: * bytes_per_line: the number of data bytes to display per line of * output * addrprint_width: Each line of output begins with the address of the * first data byte displayed on that line. This * specifies the number of bytes wide the address * should be displayed as. This value must be from 1 * to 8. * indent: This is a string to display at the start of each * output line. Its purpose is to indent the output. * sep1: This is a string to display between the address and * the bytes of data displayed in hex. It serves as a * separator. * sep2: This is a string to display between individual hex * values. It serves as a separator. * sep3: This is a string to display between the bytes of * data in hex and the bytes of data displayed as * characters. It serves as a separator. * nonprintable: This is a substitute character to display in place * of nonprintable characters. * is_printable_fn: This is a user-supplied function that takes a byte * value as input and returns a boolean value * indicating whether the corresponding character is * printable. A value of NULL will cause * default_is_printable_fn to be used. *--------------------------------------------------------------------------*/ typedef struct { int bytes_per_line; int addrprint_width; const char *indent; const char *sep1; const char *sep2; const char *sep3; unsigned char nonprintable; is_printable_fn_t is_printable_fn; } hexdump_format_t; /*-------------------------------------------------------------------------- * hexdump * * Write a hex dump of 'mem' to 'outfile'. * * parameters: * mem: a pointer to the memory to display * bytes: the number of bytes of data to display * addrprint_start: The address to associate with the first byte of * data. For instance, a value of 0 indicates that the * first byte displayed should be labeled as byte 0. * outfile: The place where the hex dump should be written. * For instance, stdout or stderr may be passed here. * format: A structure specifying how the hex dump should be * formatted. *--------------------------------------------------------------------------*/ void hexdump (const void *mem, int bytes, uint64_t addrprint_start, FILE *outfile, const hexdump_format_t *format); /*-------------------------------------------------------------------------- * default_is_printable_fn * * Determine whether the input character is printable. The proper behavior * for this type of function may be system-dependent. This function appears * to work well on a Linux system. However, if it is not adequate for your * purposes, you can write your own. * * parameters: * c: the input character * * return value: * Return 1 if the input character is printable. Otherwise return 0. *--------------------------------------------------------------------------*/ int default_is_printable_fn (unsigned char c); #endif /* _HEXDUMP_H */ nvramtool-0.0+r3669.orig/layout.c0000600000175000017500000004233311067403034014754 0ustar uweuwe/*****************************************************************************\ * layout.c ***************************************************************************** * Copyright (C) 2002-2005 The Regents of the University of California. * Produced at the Lawrence Livermore National Laboratory. * Written by Dave Peterson . * UCRL-CODE-2003-012 * All rights reserved. * * This file is part of nvramtool, a utility for reading/writing coreboot * parameters and displaying information from the coreboot table. * For details, see http://coreboot.org/nvramtool. * * Please also read the file DISCLAIMER which is included in this software * distribution. * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License (as published by the * Free Software Foundation) version 2, dated June 1991. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and * conditions of the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. \*****************************************************************************/ #include "common.h" #include "layout.h" #include "cmos_lowlevel.h" typedef struct cmos_entry_item_t cmos_entry_item_t; struct cmos_entry_item_t { cmos_entry_t item; cmos_entry_item_t *next; }; typedef struct cmos_enum_item_t cmos_enum_item_t; struct cmos_enum_item_t { cmos_enum_t item; cmos_enum_item_t *next; }; static void default_cmos_layout_get_fn (void); static int areas_overlap (unsigned area_0_start, unsigned area_0_length, unsigned area_1_start, unsigned area_1_length); static int entries_overlap (const cmos_entry_t *p, const cmos_entry_t *q); static const cmos_enum_item_t * find_first_cmos_enum_id (unsigned config_id); const char checksum_param_name[] = "check_sum"; /* Newer versions of coreboot store the 3 pieces of information below in the * coreboot table so we don't have to rely on hardcoded values. */ /* This is the offset from the start of CMOS of the first byte that the * checksum is calculated over. */ #define CMOS_CHECKSUM_START 49 /* This is the offset from the start of CMOS of the last byte that the * checksum is calculated over. */ #define CMOS_CHECKSUM_END 125 /* This is the offset from the start of CMOS where the coreboot checksum is * stored. */ #define CMOS_CHECKSUM_INDEX 126 /* index of first byte of checksummed area */ unsigned cmos_checksum_start = CMOS_CHECKSUM_START; /* index of last byte of checksummed area */ unsigned cmos_checksum_end = CMOS_CHECKSUM_END; /* index of first byte of CMOS checksum (a big-endian 16-bit value) */ unsigned cmos_checksum_index = CMOS_CHECKSUM_INDEX; /* List is sorted in ascending order according to 'bit' field in * cmos_entry_t. */ static cmos_entry_item_t *cmos_entry_list = NULL; /* List is sorted in ascending order: first by 'config_id' and then by * 'value'. */ static cmos_enum_item_t *cmos_enum_list = NULL; static cmos_layout_get_fn_t cmos_layout_get_fn = default_cmos_layout_get_fn; /**************************************************************************** * entries_overlap * * Return 1 if cmos entries 'p' and 'q' overlap. Else return 0. ****************************************************************************/ static inline int entries_overlap (const cmos_entry_t *p, const cmos_entry_t *q) { return areas_overlap(p->bit, p->length, q->bit, q->length); } /**************************************************************************** * cmos_entry_to_const_item * * Return a pointer to the cmos_entry_item_t that 'p' is embedded within. ****************************************************************************/ static inline const cmos_entry_item_t * cmos_entry_to_const_item (const cmos_entry_t *p) { static const cmos_entry_t *pos = &((cmos_entry_item_t *) 0)->item; unsigned long offset, address; offset = (unsigned long) pos; address = ((unsigned long) p) - offset; return (const cmos_entry_item_t *) address; } /**************************************************************************** * cmos_enum_to_const_item * * Return a pointer to the cmos_enum_item_t that 'p' is embedded within. ****************************************************************************/ static inline const cmos_enum_item_t * cmos_enum_to_const_item (const cmos_enum_t *p) { static const cmos_enum_t *pos = &((cmos_enum_item_t *) 0)->item; unsigned long offset, address; offset = (unsigned long) pos; address = ((unsigned long) p) - offset; return (const cmos_enum_item_t *) address; } /**************************************************************************** * register_cmos_layout_get_fn * * Set 'fn' as the function that will be called to retrieve CMOS layout * information. ****************************************************************************/ void register_cmos_layout_get_fn (cmos_layout_get_fn_t fn) { cmos_layout_get_fn = fn; } /**************************************************************************** * get_cmos_layout * * Retrieve CMOS layout information and store it in our internal repository. ****************************************************************************/ void get_cmos_layout (void) { cmos_layout_get_fn(); } /**************************************************************************** * add_cmos_entry * * Attempt to add CMOS entry 'e' to our internal repository of layout * information. Return OK on success or an error code on failure. If * operation fails because 'e' overlaps an existing CMOS entry, '*conflict' * will be set to point to the overlapping entry. ****************************************************************************/ int add_cmos_entry (const cmos_entry_t *e, const cmos_entry_t **conflict) { cmos_entry_item_t *item, *prev, *new_entry; *conflict = NULL; if (e->length < 1) return LAYOUT_ENTRY_BAD_LENGTH; if ((new_entry = (cmos_entry_item_t *) malloc(sizeof(*new_entry))) == NULL) out_of_memory(); new_entry->item = *e; if (cmos_entry_list == NULL) { new_entry->next = NULL; cmos_entry_list = new_entry; return OK; } /* Find place in list to insert new entry. List is sorted in ascending * order. */ for (item = cmos_entry_list, prev = NULL; (item != NULL) && (item->item.bit < e->bit); prev = item, item = item->next); if (prev == NULL) { if (entries_overlap(e, &cmos_entry_list->item)) { *conflict = &cmos_entry_list->item; goto fail; } new_entry->next = cmos_entry_list; cmos_entry_list = new_entry; return OK; } if (entries_overlap(&prev->item, e)) { *conflict = &prev->item; goto fail; } if ((item != NULL) && entries_overlap(e, &item->item)) { *conflict = &item->item; goto fail; } new_entry->next = item; prev->next = new_entry; return OK; fail: free(new_entry); return LAYOUT_ENTRY_OVERLAP; } /**************************************************************************** * find_cmos_entry * * Search for a CMOS entry whose name is 'name'. Return pointer to matching * entry or NULL if entry not found. ****************************************************************************/ const cmos_entry_t * find_cmos_entry (const char name[]) { cmos_entry_item_t *item; for (item = cmos_entry_list; item != NULL; item = item->next) { if (!strcmp(item->item.name, name)) return &item->item; } return NULL; } /**************************************************************************** * first_cmos_entry * * Return a pointer to the first CMOS entry in our list or NULL if list is * empty. ****************************************************************************/ const cmos_entry_t * first_cmos_entry (void) { return (cmos_entry_list == NULL) ? NULL : &cmos_entry_list->item; } /**************************************************************************** * next_cmos_entry * * Return a pointer to next entry in list after 'last' or NULL if no more * entries. ****************************************************************************/ const cmos_entry_t * next_cmos_entry (const cmos_entry_t *last) { const cmos_entry_item_t *last_item, *next_item; last_item = cmos_entry_to_const_item(last); next_item = last_item->next; return (next_item == NULL) ? NULL : &next_item->item; } /**************************************************************************** * add_cmos_enum * * Attempt to add CMOS enum 'e' to our internal repository of layout * information. Return OK on success or an error code on failure. ****************************************************************************/ int add_cmos_enum (const cmos_enum_t *e) { cmos_enum_item_t *item, *prev, *new_enum; if ((new_enum = (cmos_enum_item_t *) malloc(sizeof(*new_enum))) == NULL) out_of_memory(); new_enum->item = *e; if (cmos_enum_list == NULL) { new_enum->next = NULL; cmos_enum_list = new_enum; return OK; } /* The list of enums is sorted in ascending order, first by 'config_id' and * then by 'value'. Look for the first enum whose 'config_id' field * matches 'e'. */ for (item = cmos_enum_list, prev = NULL; (item != NULL) && (item->item.config_id < e->config_id); prev = item, item = item->next); if (item == NULL) { new_enum->next = NULL; prev->next = new_enum; return OK; } if (item->item.config_id > e->config_id) { new_enum->next = item; if (prev == NULL) cmos_enum_list = new_enum; else prev->next = new_enum; return OK; } /* List already contains at least one enum whose 'config_id' matches 'e'. * Now find proper place to insert 'e' based on 'value'. */ while (item->item.value < e->value) { prev = item; item = item->next; if ((item == NULL) || (item->item.config_id != e->config_id)) { new_enum->next = item; prev->next = new_enum; return OK; } } if (item->item.value == e->value) { free(new_enum); return LAYOUT_DUPLICATE_ENUM; } new_enum->next = item; if (prev == NULL) cmos_enum_list = new_enum; else prev->next = new_enum; return OK; } /**************************************************************************** * find_cmos_enum * * Search for an enum that matches 'config_id' and 'value'. If found, return * a pointer to the mathcing enum. Else return NULL. ****************************************************************************/ const cmos_enum_t * find_cmos_enum (unsigned config_id, unsigned long long value) { const cmos_enum_item_t *item; if ((item = find_first_cmos_enum_id(config_id)) == NULL) return NULL; while (item->item.value < value) { item = item->next; if ((item == NULL) || (item->item.config_id != config_id)) return NULL; } return (item->item.value == value) ? &item->item : NULL; } /**************************************************************************** * first_cmos_enum * * Return a pointer to the first CMOS enum in our list or NULL if list is * empty. ****************************************************************************/ const cmos_enum_t * first_cmos_enum (void) { return (cmos_enum_list == NULL) ? NULL : &cmos_enum_list->item; } /**************************************************************************** * next_cmos_enum * * Return a pointer to next enum in list after 'last' or NULL if no more * enums. ****************************************************************************/ const cmos_enum_t * next_cmos_enum (const cmos_enum_t *last) { const cmos_enum_item_t *last_item, *next_item; last_item = cmos_enum_to_const_item(last); next_item = last_item->next; return (next_item == NULL) ? NULL : &next_item->item; } /**************************************************************************** * first_cmos_enum_id * * Return a pointer to the first CMOS enum in our list that matches * 'config_id' or NULL if there are no matching enums. ****************************************************************************/ const cmos_enum_t * first_cmos_enum_id (unsigned config_id) { const cmos_enum_item_t *item; item = find_first_cmos_enum_id(config_id); return (item == NULL) ? NULL : &item->item; } /**************************************************************************** * next_cmos_enum_id * * Return a pointer to next enum in list after 'last' that matches the * 'config_id' field of 'last' or NULL if there are no more matching enums. ****************************************************************************/ const cmos_enum_t * next_cmos_enum_id (const cmos_enum_t *last) { const cmos_enum_item_t *item; item = cmos_enum_to_const_item(last)->next; return ((item == NULL) || (item->item.config_id != last->config_id)) ? NULL : &item->item; } /**************************************************************************** * is_checksum_name * * Return 1 if 'name' matches the name of the parameter representing the CMOS * checksum. Else return 0. ****************************************************************************/ int is_checksum_name (const char name[]) { return !strcmp(name, checksum_param_name); } /**************************************************************************** * checksum_layout_to_bytes * * On entry, '*layout' contains checksum-related layout information expressed * in bits. Perform sanity checking on the information and convert it from * bit positions to byte positions. Return OK on success or an error code if * a sanity check fails. ****************************************************************************/ int checksum_layout_to_bytes (cmos_checksum_layout_t *layout) { unsigned start, end, index; start = layout->summed_area_start; end = layout->summed_area_end; index = layout->checksum_at; if (start % 8) return LAYOUT_SUMMED_AREA_START_NOT_ALIGNED; if ((end % 8) != 7) return LAYOUT_SUMMED_AREA_END_NOT_ALIGNED; if (index % 8) return LAYOUT_CHECKSUM_LOCATION_NOT_ALIGNED; if (end <= start) return LAYOUT_INVALID_SUMMED_AREA; /* Convert bit positions to byte positions. */ start /= 8; end /= 8; /* equivalent to "end = ((end - 7) / 8)" */ index /= 8; if (verify_cmos_byte_index(start) || verify_cmos_byte_index(end)) return LAYOUT_SUMMED_AREA_OUT_OF_RANGE; if (verify_cmos_byte_index(index)) return LAYOUT_CHECKSUM_LOCATION_OUT_OF_RANGE; /* checksum occupies 16 bits */ if (areas_overlap(start, end - start + 1, index, index + 1)) return LAYOUT_CHECKSUM_OVERLAPS_SUMMED_AREA; layout->summed_area_start = start; layout->summed_area_end = end; layout->checksum_at = index; return OK; } /**************************************************************************** * checksum_layout_to_bits * * On entry, '*layout' contains checksum-related layout information expressed * in bytes. Convert this information to bit positions. ****************************************************************************/ void checksum_layout_to_bits (cmos_checksum_layout_t *layout) { layout->summed_area_start *= 8; layout->summed_area_end = (layout->summed_area_end * 8) + 7; layout->checksum_at *= 8; } /**************************************************************************** * default_cmos_layout_get_fn * * If this function is ever called, it means that an appropriate callback for * obtaining CMOS layout information was not set before attempting to * retrieve layout information. ****************************************************************************/ static void default_cmos_layout_get_fn (void) { BUG(); } /**************************************************************************** * areas_overlap * * Return 1 if the two given areas overlap. Else return 0. ****************************************************************************/ static int areas_overlap (unsigned area_0_start, unsigned area_0_length, unsigned area_1_start, unsigned area_1_length) { unsigned area_0_end, area_1_end; area_0_end = area_0_start + area_0_length - 1; area_1_end = area_1_start + area_1_length - 1; return ((area_1_start <= area_0_end) && (area_0_start <= area_1_end)); } /**************************************************************************** * find_first_cmos_enum_id * * Return a pointer to the first item in our list of enums that matches * 'config_id'. Return NULL if there is no matching enum. ****************************************************************************/ static const cmos_enum_item_t * find_first_cmos_enum_id (unsigned config_id) { cmos_enum_item_t *item; for (item = cmos_enum_list; (item != NULL) && (item->item.config_id < config_id); item = item->next); return ((item == NULL) || (item->item.config_id > config_id)) ? NULL : item; } nvramtool-0.0+r3669.orig/README0000600000175000017500000000157611067403034014157 0ustar uweuweSummary of Operation -------------------- nvramtool is a utility for reading/writing coreboot parameters and displaying information from the coreboot table. It is intended for x86-based systems (both 32-bit and 64-bit) that use coreboot. The coreboot table resides in low physical memory, and may be accessed through the /dev/mem interface. It is created at boot time by coreboot, and contains various system information such as the type of mainboard in use. It specifies locations in the CMOS (nonvolatile RAM) where the coreboot parameters are stored. For information about coreboot, see http://www.coreboot.org/. Ideas for Future Improvements ----------------------------- 1. Move the core functionality of this program into a shared library. 2. Consider adding options for displaying other BIOS-provided information such as the MP table, ACPI table, PCI IRQ routing table, etc. nvramtool-0.0+r3669.orig/nvramtool.spec0000600000175000017500000000221411067403034016162 0ustar uweuwe## Name: nvramtool Version: 2.1 Release: 0 Summary: coreboot utility program Group: System Environment/Base License: GPL Provides: nvramtool BuildRoot: %{_tmppath}/%{name}-%{version} Source0: %{name}-%{version}.tgz %description nvramtool is a utility for reading/writing coreboot parameters and displaying information from the coreboot table. At boot time, coreboot places a table (known as the coreboot table) in low physical memory. The contents of this table are preserved even after coreboot transfers control to the kernel and the kernel initializes itself. The coreboot table contains various system information such as the type of mainboard in use. It also specifies locations in the CMOS (nonvolatile RAM) where the coreboot parameters are stored. %prep %setup -n %{name}-%{version} %build make %install rm -rf "$RPM_BUILD_ROOT" mkdir -p "$RPM_BUILD_ROOT/usr/bin" mkdir -p "$RPM_BUILD_ROOT/usr/man/man1" cp nvramtool "$RPM_BUILD_ROOT/usr/bin" cp nvramtool.1.gz $RPM_BUILD_ROOT/usr/man/man1 %clean rm -rf "$RPM_BUILD_ROOT" %files %defattr(-,root,root,0755) %doc ChangeLog README %doc README /usr/bin/nvramtool /usr/man/man1/nvramtool.1.gz nvramtool-0.0+r3669.orig/cmos_ops.h0000600000175000017500000000435211067403034015265 0ustar uweuwe/*****************************************************************************\ * cmos_ops.h ***************************************************************************** * Copyright (C) 2002-2005 The Regents of the University of California. * Produced at the Lawrence Livermore National Laboratory. * Written by David S. Peterson . * UCRL-CODE-2003-012 * All rights reserved. * * This file is part of nvramtool, a utility for reading/writing coreboot * parameters and displaying information from the coreboot table. * For details, see http://coreboot.org/nvramtool. * * Please also read the file DISCLAIMER which is included in this software * distribution. * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License (as published by the * Free Software Foundation) version 2, dated June 1991. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and * conditions of the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. \*****************************************************************************/ #ifndef CMOS_OPS_H #define CMOS_OPS_H #include "common.h" #include "layout.h" #define CMOS_OP_BAD_ENUM_VALUE (CMOS_OP_RESULT_START + 0) #define CMOS_OP_NEGATIVE_INT (CMOS_OP_RESULT_START + 1) #define CMOS_OP_INVALID_INT (CMOS_OP_RESULT_START + 2) #define CMOS_OP_RESERVED (CMOS_OP_RESULT_START + 3) #define CMOS_OP_VALUE_TOO_WIDE (CMOS_OP_RESULT_START + 4) #define CMOS_OP_NO_MATCHING_ENUM (CMOS_OP_RESULT_START + 5) int prepare_cmos_read (const cmos_entry_t *e); int prepare_cmos_write (const cmos_entry_t *e, const char value_str[], unsigned long long *value); uint16_t cmos_checksum_read (void); void cmos_checksum_write (uint16_t checksum); uint16_t cmos_checksum_compute (void); void cmos_checksum_verify (void); #endif /* CMOS_OPS_H */ nvramtool-0.0+r3669.orig/layout.h0000600000175000017500000001034411067403034014756 0ustar uweuwe/*****************************************************************************\ * layout.h ***************************************************************************** * Copyright (C) 2002-2005 The Regents of the University of California. * Produced at the Lawrence Livermore National Laboratory. * Written by Dave Peterson . * UCRL-CODE-2003-012 * All rights reserved. * * This file is part of nvramtool, a utility for reading/writing coreboot * parameters and displaying information from the coreboot table. * For details, see http://coreboot.org/nvramtool. * * Please also read the file DISCLAIMER which is included in this software * distribution. * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License (as published by the * Free Software Foundation) version 2, dated June 1991. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and * conditions of the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. \*****************************************************************************/ #ifndef LAYOUT_H #define LAYOUT_H #include "common.h" #include "coreboot_tables.h" #define LAYOUT_ENTRY_OVERLAP (LAYOUT_RESULT_START + 0) #define LAYOUT_ENTRY_BAD_LENGTH (LAYOUT_RESULT_START + 1) #define LAYOUT_DUPLICATE_ENUM (LAYOUT_RESULT_START + 2) #define LAYOUT_SUMMED_AREA_START_NOT_ALIGNED (LAYOUT_RESULT_START + 3) #define LAYOUT_SUMMED_AREA_END_NOT_ALIGNED (LAYOUT_RESULT_START + 4) #define LAYOUT_CHECKSUM_LOCATION_NOT_ALIGNED (LAYOUT_RESULT_START + 5) #define LAYOUT_INVALID_SUMMED_AREA (LAYOUT_RESULT_START + 6) #define LAYOUT_CHECKSUM_OVERLAPS_SUMMED_AREA (LAYOUT_RESULT_START + 7) #define LAYOUT_SUMMED_AREA_OUT_OF_RANGE (LAYOUT_RESULT_START + 8) #define LAYOUT_CHECKSUM_LOCATION_OUT_OF_RANGE (LAYOUT_RESULT_START + 9) typedef enum { CMOS_ENTRY_ENUM, CMOS_ENTRY_HEX, CMOS_ENTRY_STRING, CMOS_ENTRY_RESERVED } cmos_entry_config_t; /* This represents a CMOS parameter. */ typedef struct { unsigned bit; unsigned length; cmos_entry_config_t config; unsigned config_id; char name[CMOS_MAX_NAME_LENGTH + 1]; } cmos_entry_t; /* This represents a possible value for a CMOS parameter of type * CMOS_ENTRY_ENUM. */ typedef struct { unsigned config_id; unsigned long long value; char text[CMOS_MAX_TEXT_LENGTH + 1]; } cmos_enum_t; /* This represents the location of the CMOS checksum and the area over which * it is computed. Depending on the context, the values may be represented as * either bit positions or byte positions. */ typedef struct { unsigned summed_area_start; /* first checksummed location */ unsigned summed_area_end; /* last checksummed location */ unsigned checksum_at; /* location of checksum */ } cmos_checksum_layout_t; extern const char checksum_param_name[]; extern unsigned cmos_checksum_start; extern unsigned cmos_checksum_end; extern unsigned cmos_checksum_index; typedef void (*cmos_layout_get_fn_t) (void); void register_cmos_layout_get_fn (cmos_layout_get_fn_t fn); void get_cmos_layout (void); int add_cmos_entry (const cmos_entry_t *e, const cmos_entry_t **conflict); const cmos_entry_t * find_cmos_entry (const char name[]); const cmos_entry_t * first_cmos_entry (void); const cmos_entry_t * next_cmos_entry (const cmos_entry_t *last); int add_cmos_enum (const cmos_enum_t *e); const cmos_enum_t * find_cmos_enum (unsigned config_id, unsigned long long value); const cmos_enum_t * first_cmos_enum (void); const cmos_enum_t * next_cmos_enum (const cmos_enum_t *last); const cmos_enum_t * first_cmos_enum_id (unsigned config_id); const cmos_enum_t * next_cmos_enum_id (const cmos_enum_t *last); int is_checksum_name (const char name[]); int checksum_layout_to_bytes (cmos_checksum_layout_t *layout); void checksum_layout_to_bits (cmos_checksum_layout_t *layout); #endif /* LAYOUT_H */ nvramtool-0.0+r3669.orig/cmos_lowlevel.h0000600000175000017500000000534211067403034016315 0ustar uweuwe/*****************************************************************************\ * cmos_lowlevel.h ***************************************************************************** * Copyright (C) 2002-2005 The Regents of the University of California. * Produced at the Lawrence Livermore National Laboratory. * Written by David S. Peterson . * UCRL-CODE-2003-012 * All rights reserved. * * This file is part of nvramtool, a utility for reading/writing coreboot * parameters and displaying information from the coreboot table. * For details, see http://coreboot.org/nvramtool. * * Please also read the file DISCLAIMER which is included in this software * distribution. * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License (as published by the * Free Software Foundation) version 2, dated June 1991. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and * conditions of the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. \*****************************************************************************/ #ifndef NVRAMTOOL_CMOS_LOWLEVEL_H #define NVRAMTOOL_CMOS_LOWLEVEL_H #include "common.h" #include "layout.h" #define CMOS_AREA_OUT_OF_RANGE (CMOS_RESULT_START + 0) #define CMOS_AREA_OVERLAPS_RTC (CMOS_RESULT_START + 1) #define CMOS_AREA_TOO_WIDE (CMOS_RESULT_START + 2) unsigned long long cmos_read (const cmos_entry_t *e); void cmos_write (const cmos_entry_t *e, unsigned long long value); unsigned char cmos_read_byte (unsigned index); void cmos_write_byte (unsigned index, unsigned char value); void cmos_read_all (unsigned char data[]); void cmos_write_all (unsigned char data[]); void set_iopl (int level); int verify_cmos_op (unsigned bit, unsigned length, cmos_entry_config_t config); #define CMOS_SIZE 256 /* size of CMOS memory in bytes */ #define CMOS_RTC_AREA_SIZE 14 /* first 14 bytes control real time clock */ /**************************************************************************** * verify_cmos_byte_index * * Return 1 if 'index' does NOT specify a valid CMOS memory location. Else * return 0. ****************************************************************************/ static inline int verify_cmos_byte_index (unsigned index) { return (index < CMOS_RTC_AREA_SIZE) || (index >= CMOS_SIZE); } #endif /* NVRAMTOOL_CMOS_LOWLEVEL_H */ nvramtool-0.0+r3669.orig/reg_expr.h0000600000175000017500000000340411067403034015253 0ustar uweuwe/*****************************************************************************\ * reg_expr.h ***************************************************************************** * Copyright (C) 2002-2005 The Regents of the University of California. * Produced at the Lawrence Livermore National Laboratory. * Written by Dave Peterson . * UCRL-CODE-2003-012 * All rights reserved. * * This file is part of nvramtool, a utility for reading/writing coreboot * parameters and displaying information from the coreboot table. * For details, see http://coreboot.org/nvramtool. * * Please also read the file DISCLAIMER which is included in this software * distribution. * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License (as published by the * Free Software Foundation) version 2, dated June 1991. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and * conditions of the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. \*****************************************************************************/ #ifndef REG_EXPR_H #define REG_EXPR_H #include #include "common.h" void compile_reg_exprs (int cflags, int num_exprs, /* const char *expr1, regex_t *reg1, */ ...); void free_reg_exprs (int num_exprs, /* regex_t *reg1, */ ...); #endif /* REG_EXPR_H */ nvramtool-0.0+r3669.orig/layout_file.h0000600000175000017500000000333011067403034015752 0ustar uweuwe/*****************************************************************************\ * layout_file.h ***************************************************************************** * Copyright (C) 2002-2005 The Regents of the University of California. * Produced at the Lawrence Livermore National Laboratory. * Written by Dave Peterson . * UCRL-CODE-2003-012 * All rights reserved. * * This file is part of nvramtool, a utility for reading/writing coreboot * parameters and displaying information from the coreboot table. * For details, see http://coreboot.org/nvramtool. * * Please also read the file DISCLAIMER which is included in this software * distribution. * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License (as published by the * Free Software Foundation) version 2, dated June 1991. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and * conditions of the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. \*****************************************************************************/ #ifndef LAYOUT_FILE_H #define LAYOUT_FILE_H #include "common.h" #include "coreboot_tables.h" void set_layout_filename (const char filename[]); void get_layout_from_file (void); void write_cmos_layout (FILE *f); #endif /* LAYOUT_FILE_H */ nvramtool-0.0+r3669.orig/nvramtool.c0000600000175000017500000005620211067403034015460 0ustar uweuwe/*****************************************************************************\ * nvramtool.c ***************************************************************************** * Copyright (C) 2002-2005 The Regents of the University of California. * Produced at the Lawrence Livermore National Laboratory. * Written by Dave Peterson . * UCRL-CODE-2003-012 * All rights reserved. * * This file is part of nvramtool, a utility for reading/writing coreboot * parameters and displaying information from the coreboot table. * For details, see http://coreboot.org/nvramtool. * * Please also read the file DISCLAIMER which is included in this software * distribution. * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License (as published by the * Free Software Foundation) version 2, dated June 1991. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and * conditions of the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. \*****************************************************************************/ #include "common.h" #include "opts.h" #include "lbtable.h" #include "layout.h" #include "layout_file.h" #include "input_file.h" #include "cmos_ops.h" #include "cmos_lowlevel.h" #include "reg_expr.h" #include "hexdump.h" typedef void (*op_fn_t) (void); static void op_show_version (void); static void op_show_usage (void); static void op_lbtable_show_info (void); static void op_lbtable_dump (void); static void op_show_param_values (void); static void op_cmos_show_one_param (void); static void op_cmos_show_all_params (void); static void op_cmos_set_one_param (void); static void op_cmos_set_params_stdin (void); static void op_cmos_set_params_file (void); static void op_cmos_checksum (void); static void op_show_layout (void); static void op_write_cmos_dump (void); static void op_read_cmos_dump (void); static void op_show_cmos_hex_dump (void); static void op_show_cmos_dumpfile (void); static int list_one_param (const char name[], int show_name); static int list_all_params (void); static void list_param_enums (const char name[]); static void set_one_param (const char name[], const char value[]); static void set_params (FILE *f); static void parse_assignment (char arg[], const char **name, const char **value); static int list_cmos_entry (const cmos_entry_t *e, int show_name); static uint16_t convert_checksum_value (const char value[]); static const op_fn_t op_fns[] = { op_show_version, op_show_usage, op_lbtable_show_info, op_lbtable_dump, op_show_param_values, op_cmos_show_one_param, op_cmos_show_all_params, op_cmos_set_one_param, op_cmos_set_params_stdin, op_cmos_set_params_file, op_cmos_checksum, op_show_layout, op_write_cmos_dump, op_read_cmos_dump, op_show_cmos_hex_dump, op_show_cmos_dumpfile }; static const hexdump_format_t cmos_dump_format = { 16, 2, "", " | ", " ", " | ", '.', NULL }; /**************************************************************************** * main ****************************************************************************/ int main (int argc, char *argv[]) { cmos_layout_get_fn_t fn; parse_nvramtool_args(argc, argv); if (nvramtool_op_modifiers[NVRAMTOOL_MOD_USE_CMOS_LAYOUT_FILE].found) { set_layout_filename( nvramtool_op_modifiers[NVRAMTOOL_MOD_USE_CMOS_LAYOUT_FILE].param); fn = get_layout_from_file; } else fn = get_layout_from_cmos_table; register_cmos_layout_get_fn(fn); op_fns[nvramtool_op.op](); return 0; } /**************************************************************************** * op_show_version * * -v * * Show version information for this program. ****************************************************************************/ static void op_show_version (void) { printf("This is %s version %s.\n", prog_name, prog_version); } /**************************************************************************** * op_show_usage * * -h * * Show a usage message for this program. ****************************************************************************/ static void op_show_usage (void) { usage(stdout); } /**************************************************************************** * op_lbtable_show_info * * -l [ARG] * * If ARG is present, show coreboot table information specified by ARG. * Else show all possible values for ARG. ****************************************************************************/ static void op_lbtable_show_info (void) { if (nvramtool_op.param == NULL) list_lbtable_choices(); else { get_lbtable(); list_lbtable_item(nvramtool_op.param); } } /**************************************************************************** * op_lbtable_dump * * -d * * Do low-level dump of coreboot table. ****************************************************************************/ static void op_lbtable_dump (void) { get_lbtable(); dump_lbtable(); } /**************************************************************************** * op_show_param_values * * -e NAME option * * Show all possible values for parameter NAME. ****************************************************************************/ static void op_show_param_values (void) { get_cmos_layout(); list_param_enums(nvramtool_op.param); } /**************************************************************************** * op_cmos_show_one_param * * [-n] -r NAME * * Show parameter NAME. If -n is specified, show value only. Else show name * and value. ****************************************************************************/ static void op_cmos_show_one_param (void) { int result; get_cmos_layout(); result = list_one_param(nvramtool_op.param, !nvramtool_op_modifiers[NVRAMTOOL_MOD_SHOW_VALUE_ONLY].found); cmos_checksum_verify(); if (result) exit(1); } /**************************************************************************** * op_cmos_show_all_params * * -a * * Show names and values for all parameters. ****************************************************************************/ static void op_cmos_show_all_params (void) { int result; get_cmos_layout(); result = list_all_params(); cmos_checksum_verify(); if (result) exit(1); } /**************************************************************************** * op_cmos_set_one_param * * -w NAME=VALUE * * Set parameter NAME to VALUE. ****************************************************************************/ static void op_cmos_set_one_param (void) { const char *name, *value; get_cmos_layout(); /* Separate 'NAME=VALUE' syntax into two strings representing NAME and * VALUE. */ parse_assignment(nvramtool_op.param, &name, &value); set_one_param(name, value); } /**************************************************************************** * op_cmos_set_params_stdin * * -i * * Set parameters according to standard input. ****************************************************************************/ static void op_cmos_set_params_stdin (void) { get_cmos_layout(); set_params(stdin); } /**************************************************************************** * op_cmos_set_params_file * * -p INPUT_FILE * * Set parameters according to INPUT_FILE. ****************************************************************************/ static void op_cmos_set_params_file (void) { FILE *f; if ((f = fopen(nvramtool_op.param, "r")) == NULL) { fprintf(stderr, "%s: Can not open file %s for reading: %s\n", prog_name, nvramtool_op.param, strerror(errno)); exit(1); } get_cmos_layout(); set_params(f); fclose(f); } /**************************************************************************** * op_cmos_checksum * * -c [VALUE] * * If VALUE is present, set coreboot CMOS checksum to VALUE. Else show * checksum value. ****************************************************************************/ static void op_cmos_checksum (void) { uint16_t checksum; get_cmos_layout(); if (nvramtool_op.param == NULL) { set_iopl(3); checksum = cmos_checksum_read(); set_iopl(0); printf("0x%x\n", checksum); } else { checksum = convert_checksum_value(nvramtool_op.param); set_iopl(3); cmos_checksum_write(checksum); set_iopl(0); } } /**************************************************************************** * op_show_layout * * -Y * * Write CMOS layout information to standard output. ****************************************************************************/ static void op_show_layout (void) { get_cmos_layout(); write_cmos_layout(stdout); } /**************************************************************************** * op_write_cmos_dump * * -b OUTPUT_FILE * * Write the contents of CMOS memory to a binary file. ****************************************************************************/ static void op_write_cmos_dump (void) { unsigned char data[CMOS_SIZE]; FILE *f; if ((f = fopen(nvramtool_op.param, "w")) == NULL) { fprintf(stderr, "%s: Can not open file %s for writing: %s\n", prog_name, nvramtool_op.param, strerror(errno)); exit(1); } set_iopl(3); cmos_read_all(data); set_iopl(0); if (fwrite(data, 1, CMOS_SIZE, f) != CMOS_SIZE) { fprintf(stderr, "%s: Error writing CMOS data to file %s: %s\n", prog_name, nvramtool_op.param, strerror(errno)); exit(1); } fclose(f); } /**************************************************************************** * op_read_cmos_dump * * -B INPUT_FILE * * Read binary data from a file and write the data to CMOS memory. ****************************************************************************/ static void op_read_cmos_dump (void) { unsigned char data[CMOS_SIZE]; size_t nr_bytes; FILE *f; if ((f = fopen(nvramtool_op.param, "r")) == NULL) { fprintf(stderr, "%s: Can not open file %s for reading: %s\n", prog_name, nvramtool_op.param, strerror(errno)); exit(1); } if ((nr_bytes = fread(data, 1, CMOS_SIZE, f)) != CMOS_SIZE) { fprintf(stderr, "%s: Error: Only able to read %d bytes of CMOS data " "from file %s. CMOS data is unchanged.\n", prog_name, (int) nr_bytes, nvramtool_op.param); exit(1); } fclose(f); set_iopl(3); cmos_write_all(data); set_iopl(0); } /**************************************************************************** * op_show_cmos_hex_dump * * -x * * Write a hex dump of CMOS memory to standard output. ****************************************************************************/ static void op_show_cmos_hex_dump (void) { unsigned char data[CMOS_SIZE]; set_iopl(3); cmos_read_all(data); set_iopl(0); hexdump(data, CMOS_SIZE, 0, stdout, &cmos_dump_format); } /**************************************************************************** * op_show_cmos_dumpfile * * -X DUMP_FILE * * Read binary data from a file (presumably a CMOS dump file) and display a * hex dump of the CMOS data from the file. ****************************************************************************/ static void op_show_cmos_dumpfile (void) { unsigned char data[CMOS_SIZE]; size_t nr_bytes; FILE *f; if ((f = fopen(nvramtool_op.param, "r")) == NULL) { fprintf(stderr, "%s: Can not open file %s for reading: %s\n", prog_name, nvramtool_op.param, strerror(errno)); exit(1); } nr_bytes = fread(data, 1, CMOS_SIZE, f); fclose(f); hexdump(data, nr_bytes, 0, stdout, &cmos_dump_format); } /**************************************************************************** * list_one_param * * Attempt to list one CMOS parameter given by 'name'. 'show_name' is a * boolean value indicating whether the parameter name should be displayed * along with its value. Return 1 if error was encountered. Else return OK. ****************************************************************************/ static int list_one_param (const char name[], int show_name) { const cmos_entry_t *e; if (is_checksum_name(name) || ((e = find_cmos_entry(name)) == NULL)) { fprintf(stderr, "%s: CMOS parameter %s not found.\n", prog_name, name); exit(1); } if (e->config == CMOS_ENTRY_RESERVED) { fprintf(stderr, "%s: Parameter %s is reserved.\n", prog_name, name); exit(1); } return (list_cmos_entry(e, show_name) != 0); } /**************************************************************************** * list_all_params * * Attempt to list all CMOS parameters. Return 1 if error was encountered. * Else return OK. ****************************************************************************/ static int list_all_params (void) { const cmos_entry_t *e; int result; result = OK; for (e = first_cmos_entry(); e != NULL; e = next_cmos_entry(e)) { if ((e->config == CMOS_ENTRY_RESERVED) || is_checksum_name(e->name)) continue; if (list_cmos_entry(e, TRUE)) result = 1; } return result; } /**************************************************************************** * list_param_enums * * List all possible values for CMOS parameter given by 'name'. ****************************************************************************/ static void list_param_enums (const char name[]) { const cmos_entry_t *e; const cmos_enum_t *p; if (is_checksum_name(name) || (e = find_cmos_entry(name)) == NULL) { fprintf(stderr, "%s: CMOS parameter %s not found.\n", prog_name, name); exit(1); } switch (e->config) { case CMOS_ENTRY_ENUM: for (p = first_cmos_enum_id(e->config_id); p != NULL; p = next_cmos_enum_id(p)) printf("%s\n", p->text); break; case CMOS_ENTRY_HEX: printf("Parameter %s requires a %u-bit unsigned integer.\n", name, e->length); break; case CMOS_ENTRY_STRING: printf("Parameter %s requires a %u-byte string.\n", name, e->length / 8); break; case CMOS_ENTRY_RESERVED: printf("Parameter %s is reserved.\n", name); break; default: BUG(); } } /**************************************************************************** * set_one_param * * Set the CMOS parameter given by 'name' to 'value'. The 'name' parameter * is case-sensitive. If we are setting an enum parameter, then 'value' is * interpreted as a case-sensitive string that must match the option name * exactly. If we are setting a 'hex' parameter, then 'value' is treated as * a string representation of an unsigned integer that may be specified in * decimal, hex, or octal. ****************************************************************************/ static void set_one_param (const char name[], const char value[]) { const cmos_entry_t *e; unsigned long long n; if (is_checksum_name(name) || (e = find_cmos_entry(name)) == NULL) { fprintf(stderr, "%s: CMOS parameter %s not found.", prog_name, name); exit(1); } switch (prepare_cmos_write(e, value, &n)) { case OK: break; case CMOS_OP_BAD_ENUM_VALUE: fprintf(stderr, "%s: Bad value for parameter %s.", prog_name, name); goto fail; case CMOS_OP_NEGATIVE_INT: fprintf(stderr, "%s: This program does not support assignment of negative " "numbers to coreboot parameters.", prog_name); goto fail; case CMOS_OP_INVALID_INT: fprintf(stderr, "%s: %s is not a valid integer.", prog_name, value); goto fail; case CMOS_OP_RESERVED: fprintf(stderr, "%s: Can not modify reserved coreboot parameter %s.", prog_name, name); goto fail; case CMOS_OP_VALUE_TOO_WIDE: fprintf(stderr, "%s: Can not write value %s to CMOS parameter %s that is " "only %d bits wide.", prog_name, value, name, e->length); goto fail; case CMOS_OP_NO_MATCHING_ENUM: fprintf(stderr, "%s: coreboot parameter %s has no matching enums.", prog_name, name); goto fail; case CMOS_AREA_OUT_OF_RANGE: fprintf(stderr, "%s: The CMOS area specified by the layout info for " "coreboot parameter %s is out of range.", prog_name, name); goto fail; case CMOS_AREA_OVERLAPS_RTC: fprintf(stderr, "%s: The CMOS area specified by the layout info for " "coreboot parameter %s overlaps the realtime clock area.", prog_name, name); goto fail; case CMOS_AREA_TOO_WIDE: fprintf(stderr, "%s: The CMOS area specified by the layout info for " "coreboot parameter %s is too wide.", prog_name, name); goto fail; default: fprintf(stderr, "%s: Unknown error encountered while attempting to modify " "coreboot parameter %s.", prog_name, name); goto fail; } /* write the value to nonvolatile RAM */ set_iopl(3); cmos_write(e, n); cmos_checksum_write(cmos_checksum_compute()); set_iopl(0); return; fail: fprintf(stderr, " CMOS write not performed.\n"); exit(1); } /**************************************************************************** * set_params * * Set coreboot parameters according to the contents of file 'f'. ****************************************************************************/ static void set_params (FILE *f) { /* First process the input file. Then perform writes only if there were * no problems processing the input. Either all values will be written * successfully or no values will be written. */ do_cmos_writes(process_input_file(f)); } /**************************************************************************** * parse_assignment * * Parse the string 'arg' (which supposedly represents an assignment) into a * NAME and a VALUE. If 'arg' does not conform to the proper assignment * syntax, exit with a usage message. Otherwise, on return, 'arg' is broken * into substrings representing NAME and VALUE, and *name and *value are set * to point to these two substrings. ****************************************************************************/ static void parse_assignment (char arg[], const char **name, const char **value) { static const size_t N_MATCHES = 4; regmatch_t match[N_MATCHES]; regex_t assignment; compile_reg_exprs(REG_EXTENDED | REG_NEWLINE, 1, assignment_regex, &assignment); /* Does 'arg' conform to proper assignment syntax? If not, exit with a * usage message. */ if (regexec(&assignment, arg, N_MATCHES, match, 0)) usage(stderr); /* Ok, we found a valid assignment. Break it into two strings * representing NAME and VALUE. */ arg[match[1].rm_eo] = '\0'; arg[match[2].rm_eo] = '\0'; *name = &arg[match[1].rm_so]; *value = &arg[match[2].rm_so]; free_reg_exprs(1, &assignment); } /**************************************************************************** * list_cmos_entry * * Attempt to list the CMOS entry represented by 'e'. 'show_name' is a * boolean value indicating whether the parameter name should be displayed * along with its value. On success, return OK. On error, print an error * message and return 1. ****************************************************************************/ static int list_cmos_entry (const cmos_entry_t *e, int show_name) { const cmos_enum_t *p; unsigned long long value; /* sanity check CMOS entry */ switch (prepare_cmos_read(e)) { case OK: break; case CMOS_OP_RESERVED: BUG(); case CMOS_AREA_OUT_OF_RANGE: fprintf(stderr, "%s: Can not read coreboot parameter %s because " "layout info specifies out of range CMOS area.\n", prog_name, e->name); return 1; case CMOS_AREA_OVERLAPS_RTC: fprintf(stderr, "%s: Can not read coreboot parameter %s because " "layout info specifies CMOS area that overlaps realtime " "clock area.\n", prog_name, e->name); return 1; case CMOS_AREA_TOO_WIDE: fprintf(stderr, "%s: Can not read coreboot parameter %s because " "layout info specifies CMOS area that is too wide.\n", prog_name, e->name); return 1; default: fprintf(stderr, "%s: Unknown error encountered while attempting to " "read coreboot parameter %s\n", prog_name, e->name); return 1; } /* read the value from CMOS */ set_iopl(3); value = cmos_read(e); set_iopl(0); /* display the value */ switch (e->config) { case CMOS_ENTRY_ENUM: if ((p = find_cmos_enum(e->config_id, value)) == NULL) { if (show_name) printf("# Bad value -> %s = 0x%llx\n", e->name, value); else printf("Bad value -> 0x%llx\n", value); } else { if (show_name) printf("%s = %s\n", e->name, p->text); else printf("%s\n", p->text); } break; case CMOS_ENTRY_HEX: if (show_name) printf("%s = 0x%llx\n", e->name, value); else printf("0x%llx\n", value); break; case CMOS_ENTRY_STRING: if (show_name) printf("%s = %s\n", e->name, (char *)(unsigned long)value); else printf("%s\n", (char *)(unsigned long)value); free((void *)(unsigned long)value); break; case CMOS_ENTRY_RESERVED: default: BUG(); } return OK; } /**************************************************************************** * convert_checksum_value * * 'value' is the string representation of a checksum value that the user * wishes to set using the -c option. Convert the string to a 16-bit * unsigned integer and return the result. Exit with an error message if * 'value' is invalid. ****************************************************************************/ static uint16_t convert_checksum_value (const char value[]) { unsigned long n; const char *p; uint16_t result; int negative; for (p = value; isspace(*p); p++); negative = (*p == '-'); n = strtoul(value, (char **) &p, 0); if (*p) { fprintf(stderr, "%s: Checksum value %s is not a valid integer.\n", prog_name, value); exit(1); } if (negative) { fprintf(stderr, "%s: Checksum must be an unsigned integer.\n", prog_name); exit(1); } result = (uint16_t) n; if (result != n) { fprintf(stderr, "%s: Checksum value must fit within 16 bits.\n", prog_name); exit(1); } return result; } nvramtool-0.0+r3669.orig/cmos_ops.c0000600000175000017500000001660611067403034015265 0ustar uweuwe/*****************************************************************************\ * cmos_ops.c ***************************************************************************** * Copyright (C) 2002-2005 The Regents of the University of California. * Produced at the Lawrence Livermore National Laboratory. * Written by David S. Peterson . * UCRL-CODE-2003-012 * All rights reserved. * * This file is part of nvramtool, a utility for reading/writing coreboot * parameters and displaying information from the coreboot table. * For details, see http://coreboot.org/nvramtool. * * Please also read the file DISCLAIMER which is included in this software * distribution. * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License (as published by the * Free Software Foundation) version 2, dated June 1991. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and * conditions of the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. \*****************************************************************************/ #include "common.h" #include "cmos_ops.h" #include "cmos_lowlevel.h" static int prepare_cmos_op_common (const cmos_entry_t *e); /**************************************************************************** * prepare_cmos_op_common * * Perform a few checks common to both reads and writes. ****************************************************************************/ static int prepare_cmos_op_common (const cmos_entry_t *e) { int result; if (e->config == CMOS_ENTRY_RESERVED) /* Access to reserved parameters is not permitted. */ return CMOS_OP_RESERVED; if ((result = verify_cmos_op(e->bit, e->length, e->config)) != OK) return result; assert(e->length > 0); return OK; } /**************************************************************************** * prepare_cmos_read * * The caller wishes to read a CMOS parameter represented by 'e'. Perform * sanity checking on 'e'. If a problem was found with e, return an error * code. Else return OK. ****************************************************************************/ int prepare_cmos_read (const cmos_entry_t *e) { int result; if ((result = prepare_cmos_op_common(e)) != OK) return result; switch (e->config) { case CMOS_ENTRY_ENUM: case CMOS_ENTRY_HEX: case CMOS_ENTRY_STRING: break; default: BUG(); } return OK; } /**************************************************************************** * prepare_cmos_write * * The caller wishes to set a CMOS parameter represented by 'e' to a value * whose string representation is stored in 'value_str'. Perform sanity * checking on 'value_str'. On error, return an error code. Else store the * numeric equivalent of 'value_str' in '*value' and return OK. ****************************************************************************/ int prepare_cmos_write (const cmos_entry_t *e, const char value_str[], unsigned long long *value) { const cmos_enum_t *q; unsigned long long out; const char *p; char *memory; int negative, result, found_one; if ((result = prepare_cmos_op_common(e)) != OK) return result; switch (e->config) { case CMOS_ENTRY_ENUM: /* Make sure the user's input corresponds to a valid option. */ for (q = first_cmos_enum_id(e->config_id), found_one = 0; q != NULL; q = next_cmos_enum_id(q)) { found_one = 1; if (!strncmp(q->text, value_str, CMOS_MAX_TEXT_LENGTH)) break; } if (!found_one) return CMOS_OP_NO_MATCHING_ENUM; if (q == NULL) return CMOS_OP_BAD_ENUM_VALUE; out = q->value; break; case CMOS_ENTRY_HEX: /* See if the first character of 'value_str' (excluding any initial * whitespace) is a minus sign. */ for (p = value_str; isspace(*p); p++); negative = (*p == '-'); out = strtoull(value_str, (char **) &p, 0); if (*p) return CMOS_OP_INVALID_INT; /* If we get this far, the user specified a valid integer. However * we do not currently support the use of negative numbers as CMOS * parameter values. */ if (negative) return CMOS_OP_NEGATIVE_INT; break; case CMOS_ENTRY_STRING: if (e->length < (8 * strlen(value_str))) return CMOS_OP_VALUE_TOO_WIDE; memory = malloc(e->length / 8); memset(memory, 0, e->length / 8); strcpy(memory, value_str); out = (unsigned long)memory; break; default: BUG(); } if ((e->length < (8 * sizeof(*value))) && (out >= (1ull << e->length))) return CMOS_OP_VALUE_TOO_WIDE; *value = out; return OK; } /**************************************************************************** * cmos_checksum_read * * Read the checksum for the coreboot parameters stored in CMOS and return * this value. ****************************************************************************/ uint16_t cmos_checksum_read (void) { uint16_t lo, hi; /* The checksum is stored in a big-endian format. */ hi = cmos_read_byte(cmos_checksum_index); lo = cmos_read_byte(cmos_checksum_index + 1); return (hi << 8) + lo; } /**************************************************************************** * cmos_checksum_write * * Set the checksum for the coreboot parameters stored in CMOS to * 'checksum'. ****************************************************************************/ void cmos_checksum_write (uint16_t checksum) { unsigned char lo, hi; /* The checksum is stored in a big-endian format. */ hi = (unsigned char) (checksum >> 8); lo = (unsigned char) (checksum & 0x00ff); cmos_write_byte(cmos_checksum_index, hi); cmos_write_byte(cmos_checksum_index + 1, lo); } /**************************************************************************** * cmos_checksum_compute * * Compute a checksum for the coreboot parameter values currently stored in * CMOS and return this checksum. ****************************************************************************/ uint16_t cmos_checksum_compute (void) { unsigned i, sum; sum = 0; for (i = cmos_checksum_start; i <= cmos_checksum_end; i++) sum += cmos_read_byte(i); return ~((uint16_t) (sum & 0xffff)); } /**************************************************************************** * cmos_checksum_verify * * Verify that the coreboot CMOS checksum is valid. If checksum is not * valid then print warning message and exit. ****************************************************************************/ void cmos_checksum_verify (void) { uint16_t computed, actual; set_iopl(3); computed = cmos_checksum_compute(); actual = cmos_checksum_read(); set_iopl(0); if (computed != actual) { fprintf(stderr, "%s: Warning: Coreboot CMOS checksum is bad.\n", prog_name); exit(1); } } nvramtool-0.0+r3669.orig/opts.c0000600000175000017500000002054511067403034014425 0ustar uweuwe/*****************************************************************************\ * opts.c ***************************************************************************** * Copyright (C) 2002-2005 The Regents of the University of California. * Produced at the Lawrence Livermore National Laboratory. * Written by Dave Peterson . * UCRL-CODE-2003-012 * All rights reserved. * * This file is part of nvramtool, a utility for reading/writing coreboot * parameters and displaying information from the coreboot table. * For details, see http://coreboot.org/nvramtool. * * Please also read the file DISCLAIMER which is included in this software * distribution. * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License (as published by the * Free Software Foundation) version 2, dated June 1991. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and * conditions of the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. \*****************************************************************************/ #include "common.h" #include "opts.h" nvramtool_op_info_t nvramtool_op; nvramtool_op_modifier_info_t nvramtool_op_modifiers[NVRAMTOOL_NUM_OP_MODIFIERS]; static char * handle_optional_arg (int argc, char *argv[]); static void register_op (int *op_found, nvramtool_op_t op, char op_param[]); static void register_op_modifier (nvramtool_op_modifier_t mod, char mod_param[]); static void resolve_op_modifiers (void); static void sanity_check_args (void); static const char getopt_string[] = "-ab:B:c::de:hil::np:r:tvw:xX:y:Y"; /**************************************************************************** * parse_nvramtool_args * * Parse command line arguments. ****************************************************************************/ void parse_nvramtool_args (int argc, char *argv[]) { nvramtool_op_modifier_info_t *mod_info; int i, op_found; char c; for (i = 0, mod_info = nvramtool_op_modifiers; i < NVRAMTOOL_NUM_OP_MODIFIERS; i++, mod_info++) { mod_info->found = FALSE; mod_info->found_seq = 0; mod_info->param = NULL; } op_found = FALSE; opterr = 0; do { switch (c = getopt(argc, argv, getopt_string)) { case 'a': register_op(&op_found, NVRAMTOOL_OP_CMOS_SHOW_ALL_PARAMS, NULL); break; case 'b': register_op(&op_found, NVRAMTOOL_OP_WRITE_CMOS_DUMP, optarg); break; case 'B': register_op(&op_found, NVRAMTOOL_OP_READ_CMOS_DUMP, optarg); break; case 'c': register_op(&op_found, NVRAMTOOL_OP_CMOS_CHECKSUM, handle_optional_arg(argc, argv)); break; case 'd': register_op(&op_found, NVRAMTOOL_OP_LBTABLE_DUMP, NULL); break; case 'e': register_op(&op_found, NVRAMTOOL_OP_SHOW_PARAM_VALUES, optarg); break; case 'h': register_op(&op_found, NVRAMTOOL_OP_SHOW_USAGE, NULL); break; case 'i': register_op(&op_found, NVRAMTOOL_OP_CMOS_SET_PARAMS_STDIN, NULL); break; case 'l': register_op(&op_found, NVRAMTOOL_OP_LBTABLE_SHOW_INFO, handle_optional_arg(argc, argv)); break; case 'n': register_op_modifier(NVRAMTOOL_MOD_SHOW_VALUE_ONLY, NULL); break; case 'p': register_op(&op_found, NVRAMTOOL_OP_CMOS_SET_PARAMS_FILE, optarg); break; case 'r': register_op(&op_found, NVRAMTOOL_OP_CMOS_SHOW_ONE_PARAM, optarg); break; case 't': register_op_modifier(NVRAMTOOL_MOD_USE_CMOS_OPT_TABLE, NULL); break; case 'v': register_op(&op_found, NVRAMTOOL_OP_SHOW_VERSION, NULL); break; case 'w': register_op(&op_found, NVRAMTOOL_OP_CMOS_SET_ONE_PARAM, optarg); break; case 'x': register_op(&op_found, NVRAMTOOL_OP_SHOW_CMOS_HEX_DUMP, NULL); break; case 'X': register_op(&op_found, NVRAMTOOL_OP_SHOW_CMOS_DUMPFILE, optarg); break; case 'y': register_op_modifier(NVRAMTOOL_MOD_USE_CMOS_LAYOUT_FILE, optarg); break; case 'Y': register_op(&op_found, NVRAMTOOL_OP_SHOW_LAYOUT, NULL); break; case -1: /* no more command line args */ break; case '?': /* unknown option found */ case 1: /* nonoption command line arg found */ default: usage(stderr); break; } } while (c != -1); if (!op_found) usage(stderr); resolve_op_modifiers(); sanity_check_args(); } /**************************************************************************** * handle_optional_arg * * Handle a command line option with an optional argument. ****************************************************************************/ static char * handle_optional_arg (int argc, char *argv[]) { char *arg; if (optarg != NULL) { /* optional arg is present and arg was specified as "-zarg" (with no * whitespace between "z" and "arg"), where -z is the option and "arg" * is the value of the optional arg */ return optarg; } if ((argv[optind] == NULL) || (argv[optind][0] == '-')) return NULL; arg = argv[optind]; /* optional arg is present */ /* This call to getopt yields the optional arg we just found, which we want * to skip. */ getopt(argc, argv, getopt_string); return arg; } /**************************************************************************** * register_op * * Store the user's selection of which operation this program should perform. ****************************************************************************/ static void register_op (int *op_found, nvramtool_op_t op, char op_param[]) { if (*op_found && (op != nvramtool_op.op)) usage(stderr); *op_found = TRUE; nvramtool_op.op = op; nvramtool_op.param = op_param; } /**************************************************************************** * register_op_modifier * * Store information regarding an optional argument specified in addition to * the user's selection of which operation this program should perform. ****************************************************************************/ static void register_op_modifier (nvramtool_op_modifier_t mod, char mod_param[]) { static int found_seq = 0; nvramtool_op_modifier_info_t *mod_info; mod_info = &nvramtool_op_modifiers[mod]; mod_info->found = TRUE; mod_info->found_seq = ++found_seq; mod_info->param = mod_param; } /**************************************************************************** * resolve_op_modifiers * * If the user specifies multiple arguments that conflict with each other, * the last specified argument overrides previous conflicting arguments. ****************************************************************************/ static void resolve_op_modifiers (void) { if (nvramtool_op_modifiers[NVRAMTOOL_MOD_USE_CMOS_LAYOUT_FILE].found && nvramtool_op_modifiers[NVRAMTOOL_MOD_USE_CMOS_OPT_TABLE].found) { if (nvramtool_op_modifiers[NVRAMTOOL_MOD_USE_CMOS_LAYOUT_FILE].found_seq > nvramtool_op_modifiers[NVRAMTOOL_MOD_USE_CMOS_OPT_TABLE].found_seq) nvramtool_op_modifiers[NVRAMTOOL_MOD_USE_CMOS_OPT_TABLE].found = FALSE; else nvramtool_op_modifiers[NVRAMTOOL_MOD_USE_CMOS_LAYOUT_FILE].found = FALSE; } } /**************************************************************************** * sanity_check_args * * Perform sanity checking on command line arguments. ****************************************************************************/ static void sanity_check_args (void) { if ((nvramtool_op_modifiers[NVRAMTOOL_MOD_SHOW_VALUE_ONLY].found) && (nvramtool_op.op != NVRAMTOOL_OP_CMOS_SHOW_ONE_PARAM)) usage(stderr); } nvramtool-0.0+r3669.orig/DISCLAIMER0000600000175000017500000000652611067403034014636 0ustar uweuwe#################################################################### Copyright (C) 2002 The Regents of the University of California. Copyright (C) 2008 coresystems GmbH Produced at the Lawrence Livermore National Laboratory. Written by David S. Peterson . UCRL-CODE-2003-012 All rights reserved. This file is part of nvramtool, a utility for reading/writing coreboot parameters and displaying information from the coreboot table. For details, see http://coreboot.org/nvramtool. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License (as published by the Free Software Foundation) version 2, dated June 1991. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and conditions of the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. This work was produced at the University of California, Lawrence Livermore National Laboratory (UC LLNL) under contract no. W-7405-ENG-48 (Contract 48) between the U.S. Department of Energy (DOE) and The Regents of the University of California (University) for the operation of UC LLNL. The rights of the Federal Government are reserved under Contract 48 subject to the restrictions agreed upon by the DOE and University as allowed under DOE Acquisition Letter 97-1. ############################################################################# OUR NOTICE AND TERMS AND CONDITIONS OF THE GNU GENERAL PUBLIC LICENSE Our Preamble Notice ------------------- A. This notice is required to be provided under our contract with the U.S. Department of Energy (DOE). This work was produced at the University of California, Lawrence Livermore National Laboratory under Contract No. W-7405-ENG-48 with the DOE. B. Neither the United States Government nor the University of California nor any of their employees, makes any warranty, express or implied, or assumes any liability or responsibility for the accuracy, completeness, or usefulness of any information, apparatus, product, or process disclosed, or represents that its use would not infringe privately-owned rights. C. Also, reference herein to any specific commercial products, process, or services by trade name, trademark, manufacturer or otherwise does not necessarily constitute or imply its endorsement, recommendation, or favoring by the United States Government or the University of California. The views and opinions of authors expressed herein do not necessarily state or reflect those of the United States Government or the University of California, and shall not be used for advertising or product endorsement purposes. The precise terms and conditions for copying, distribution and modification follows. GNU Terms and Conditions for Copying, Distribution, and Modification -------------------------------------------------------------------- The precise terms and conditions of the GNU General Public License (version 2, dated June 1991) are contained in the file COPYING which is included in this software distribution. nvramtool-0.0+r3669.orig/opts.h0000600000175000017500000000521511067403034014427 0ustar uweuwe/*****************************************************************************\ * opts.h ***************************************************************************** * Copyright (C) 2002-2005 The Regents of the University of California. * Produced at the Lawrence Livermore National Laboratory. * Written by Dave Peterson . * UCRL-CODE-2003-012 * All rights reserved. * * This file is part of nvramtool, a utility for reading/writing coreboot * parameters and displaying information from the coreboot table. * For details, see http://coreboot.org/nvramtool. * * Please also read the file DISCLAIMER which is included in this software * distribution. * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License (as published by the * Free Software Foundation) version 2, dated June 1991. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and * conditions of the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. \*****************************************************************************/ #ifndef OPTS_H #define OPTS_H #include "common.h" typedef enum { NVRAMTOOL_OP_SHOW_VERSION = 0, NVRAMTOOL_OP_SHOW_USAGE, NVRAMTOOL_OP_LBTABLE_SHOW_INFO, NVRAMTOOL_OP_LBTABLE_DUMP, NVRAMTOOL_OP_SHOW_PARAM_VALUES, NVRAMTOOL_OP_CMOS_SHOW_ONE_PARAM, NVRAMTOOL_OP_CMOS_SHOW_ALL_PARAMS, NVRAMTOOL_OP_CMOS_SET_ONE_PARAM, NVRAMTOOL_OP_CMOS_SET_PARAMS_STDIN, NVRAMTOOL_OP_CMOS_SET_PARAMS_FILE, NVRAMTOOL_OP_CMOS_CHECKSUM, NVRAMTOOL_OP_SHOW_LAYOUT, NVRAMTOOL_OP_WRITE_CMOS_DUMP, NVRAMTOOL_OP_READ_CMOS_DUMP, NVRAMTOOL_OP_SHOW_CMOS_HEX_DUMP, NVRAMTOOL_OP_SHOW_CMOS_DUMPFILE } nvramtool_op_t; typedef struct { nvramtool_op_t op; char *param; } nvramtool_op_info_t; typedef enum { NVRAMTOOL_MOD_SHOW_VALUE_ONLY = 0, NVRAMTOOL_MOD_USE_CMOS_LAYOUT_FILE, NVRAMTOOL_MOD_USE_CMOS_OPT_TABLE, NVRAMTOOL_NUM_OP_MODIFIERS /* must always be last */ } nvramtool_op_modifier_t; typedef struct { int found; int found_seq; char *param; } nvramtool_op_modifier_info_t; extern nvramtool_op_info_t nvramtool_op; extern nvramtool_op_modifier_info_t nvramtool_op_modifiers[]; void parse_nvramtool_args (int argc, char *argv[]); #endif /* OPTS_H */ nvramtool-0.0+r3669.orig/compute_ip_checksum.c0000600000175000017500000000261311067403034017462 0ustar uweuwe/*****************************************************************************\ * compute_ip_checksum.c \*****************************************************************************/ #include #include "ip_checksum.h" /* Note: The contents of this file were borrowed from the coreboot source * code which may be obtained from http://www.coreboot.org. * Specifically, this code was obtained from coreboot (LinuxBIOS) * version 1.0.0.8. */ unsigned long compute_ip_checksum(void *addr, unsigned long length) { uint8_t *ptr; volatile union { uint8_t byte[2]; uint16_t word; } value; unsigned long sum; unsigned long i; /* In the most straight forward way possible, * compute an ip style checksum. */ sum = 0; ptr = addr; for(i = 0; i < length; i++) { unsigned long value; value = ptr[i]; if (i & 1) { value <<= 8; } /* Add the new value */ sum += value; /* Wrap around the carry */ if (sum > 0xFFFF) { sum = (sum + (sum >> 16)) & 0xFFFF; } } value.byte[0] = sum & 0xff; value.byte[1] = (sum >> 8) & 0xff; return (~value.word) & 0xFFFF; } nvramtool-0.0+r3669.orig/COPYING0000600000175000017500000004310310746375565014346 0ustar uweuwe GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Lesser General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. , 1 April 1989 Ty Coon, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. nvramtool-0.0+r3669.orig/common.c0000600000175000017500000001127611067403034014731 0ustar uweuwe/*****************************************************************************\ * common.c ***************************************************************************** * Copyright (C) 2002-2005 The Regents of the University of California. * Produced at the Lawrence Livermore National Laboratory. * Written by Dave Peterson . * UCRL-CODE-2003-012 * All rights reserved. * * This file is part of nvramtool, a utility for reading/writing coreboot * parameters and displaying information from the coreboot table. * For details, see http://coreboot.org/nvramtool. * * Please also read the file DISCLAIMER which is included in this software * distribution. * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License (as published by the * Free Software Foundation) version 2, dated June 1991. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and * conditions of the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. \*****************************************************************************/ #include "common.h" /* basename of this program, as reported by argv[0] */ const char prog_name[] = "nvramtool"; /* version of this program */ const char prog_version[] = "2.1"; /**************************************************************************** * get_line_from_file * * Get a line of input from file 'f'. Store result in 'line' which is an * array of 'line_buf_size' bytes. ****************************************************************************/ int get_line_from_file (FILE *f, char line[], int line_buf_size) { if (fgets(line, line_buf_size, f) == NULL) return LINE_EOF; /* If the file contains a line that is too long, then it's best to let the * user know right away rather than passing back a truncated result that * will lead to problems later on. */ return (strlen(line) == ((size_t) (line_buf_size - 1))) ? LINE_TOO_LONG : OK; } /**************************************************************************** * out_of_memory * * We ran out of memory. Print an error message and die. ****************************************************************************/ void out_of_memory (void) { fprintf(stderr, "%s: Out of memory.\n", prog_name); exit(1); } /**************************************************************************** * usage * * Write a usage message to 'outfile'. If 'outfile' is 'stderr' then exit * with a value of 1. Otherwise exit with a value of 0. ****************************************************************************/ void usage (FILE *outfile) { fprintf(outfile, "Usage: %s [-y LAYOUT_FILE | -t] PARAMETER ...\n\n" " Read/write coreboot parameters or show info from " "coreboot table.\n\n" " -y LAYOUT_FILE: Use CMOS layout specified by " "LAYOUT_FILE.\n" " -t: Use CMOS layout specified by CMOS option " "table.\n" " [-n] -r NAME: Show parameter NAME. If -n is given, " "show value only.\n" " -e NAME: Show all possible values for parameter " "NAME.\n" " -a: Show names and values for all " "parameters.\n" " -w NAME=VALUE: Set parameter NAME to VALUE.\n" " -p INPUT_FILE: Set parameters according to INPUT_FILE.\n" " -i: Same as -p but file contents taken from " "standard input.\n" " -c [VALUE]: Show CMOS checksum or set checksum to " "VALUE.\n" " -l [ARG]: Show coreboot table info for ARG, or " "all ARG choices.\n" " -d: Show low-level dump of coreboot table.\n" " -Y: Show CMOS layout info.\n" " -b OUTPUT_FILE: Dump CMOS memory contents to file.\n" " -B INPUT_FILE: Write file contents to CMOS memory.\n" " -x: Show hex dump of CMOS memory.\n" " -X DUMPFILE: Show hex dump of CMOS dumpfile.\n" " -v: Show version info for this program.\n" " -h: Show this message.\n", prog_name); exit(outfile == stderr); } nvramtool-0.0+r3669.orig/Makefile0000600000175000017500000000152511067403034014731 0ustar uweuwe# # Makefile for nvram utility # # (C) 2005-2008 coresystems GmbH # written by Stefan Reinauer # PROGRAM = nvramtool CC = gcc STRIP = strip INSTALL = /usr/bin/install PREFIX = /usr/local CFLAGS = -O2 -g -Wall -W #CFLAGS = -Os -Wall OBJS = cmos_lowlevel.o cmos_ops.o common.o compute_ip_checksum.o \ hexdump.o input_file.o layout.o layout_file.o lbtable.o \ nvramtool.o opts.o reg_expr.o all: dep $(PROGRAM) $(PROGRAM): $(OBJS) $(CC) -o $(PROGRAM) $(OBJS) $(LDFLAGS) $(STRIP) $(STRIP_ARGS) $(PROGRAM) clean: rm -f $(PROGRAM) *.o distclean: clean rm -f .dependencies dep: @$(CC) -MM *.c > .dependencies install: $(PROGRAM) $(INSTALL) $(PROGRAM) $(PREFIX)/sbin mkdir -p $(PREFIX)/share/man/man1 $(INSTALL) $(PROGRAM).1 $(PREFIX)/share/man/man1 .PHONY: all clean distclean dep -include .dependencies nvramtool-0.0+r3669.orig/common.h0000600000175000017500000000456011067403034014734 0ustar uweuwe/*****************************************************************************\ * common.h ***************************************************************************** * Copyright (C) 2002-2005 The Regents of the University of California. * Produced at the Lawrence Livermore National Laboratory. * Written by Dave Peterson . * UCRL-CODE-2003-012 * All rights reserved. * * This file is part of nvramtool, a utility for reading/writing coreboot * parameters and displaying information from the coreboot table. * For details, see http://coreboot.org/nvramtool. * * Please also read the file DISCLAIMER which is included in this software * distribution. * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License (as published by the * Free Software Foundation) version 2, dated June 1991. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and * conditions of the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. \*****************************************************************************/ #ifndef COMMON_H #define COMMON_H #include #include #include #include #include #include #include #include #include #include #include #define FALSE 0 #define TRUE 1 #define BUG() assert(0) #define COMMON_RESULT_START 0x10000 #define LAYOUT_RESULT_START 0x20000 #define CMOS_RESULT_START 0x30000 #define CMOS_OP_RESULT_START 0x40000 #define OK 0 /* 0 is used universally to indicate success. */ #define LINE_EOF (COMMON_RESULT_START + 0) #define LINE_TOO_LONG (COMMON_RESULT_START + 1) /* basename of this program, as reported by argv[0] */ extern const char prog_name[]; /* version of this program */ extern const char prog_version[]; int get_line_from_file (FILE *f, char line[], int line_buf_size); void out_of_memory (void); void usage (FILE *outfile); #endif /* COMMON_H */