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

/*****************************************************************************\
 * nvramtool.c
 *****************************************************************************
 *  Copyright (C) 2002-2005 The Regents of the University of California.
 *  Produced at the Lawrence Livermore National Laboratory.
 *  Written by Dave Peterson <dsp@llnl.gov> <dave_peterson@pobox.com>.
 *  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.
\*****************************************************************************/

#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#ifndef __MINGW32__
#include <sys/mman.h>
#endif
#include "common.h"
#include "opts.h"
#include "lbtable.h"
#include "layout.h"
#include "accessors/layout-text.h"
#include "input_file.h"
#include "cmos_ops.h"
#include "cmos_lowlevel.h"
#include "reg_expr.h"
#include "hexdump.h"
#include "cbfs.h"
#ifdef __MINGW32__
#include <windows.h>
#endif

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 void op_write_cmos_layout_bin(void);
static void op_write_cmos_layout_header(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,
	op_write_cmos_layout_bin,
	op_write_cmos_layout_header
};

static void op_write_cmos_layout_bin(void)
{
	get_layout_from_file();
	write_cmos_output_bin(nvramtool_op.param);
}

static void op_write_cmos_layout_header(void)
{
	get_layout_from_file();
	write_cmos_layout_header(nvramtool_op.param);
}

static const hexdump_format_t cmos_dump_format =
    { 16, 2, "", " | ", " ", " | ", '.' };

/****************************************************************************
 * main
 ****************************************************************************/
int main(int argc, char *argv[])
{
	void *cmos_default = NULL;
	cmos_layout_get_fn_t fn = get_layout_from_cmos_table;

	parse_nvramtool_args(argc, argv);

	/* If we should operate on a CBFS file default to reading the layout
	 * and CMOS contents from it. */
	if (nvramtool_op_modifiers[NVRAMTOOL_MOD_USE_CBFS_FILE].found) {
		open_cbfs(nvramtool_op_modifiers[NVRAMTOOL_MOD_USE_CBFS_FILE].param);
		if (!nvramtool_op_modifiers[NVRAMTOOL_MOD_USE_CMOS_FILE].found) {
			cmos_default = cbfs_find_file("cmos.default", CBFS_COMPONENT_CMOS_DEFAULT, NULL);
			if (cmos_default == NULL) {
				fprintf(stderr, "Need a cmos.default in the CBFS image or separate cmos file (-D).\n");
				exit(1);
			}
		}
		fn = get_layout_from_cbfs_file;
	}

	/* If the user wants to use a specific layout file or explicitly use
	 * the coreboot option table allow him to override previous settings. */
	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 if (nvramtool_op_modifiers[NVRAMTOOL_MOD_USE_CMOS_OPT_TABLE].found) {
		fn = get_layout_from_cmos_table;
	}

	/* Allow the user to use a file for the CMOS contents, possibly
	 * overriding a previously opened "cmos.default" file from the CBFS. */
	if (nvramtool_op_modifiers[NVRAMTOOL_MOD_USE_CMOS_FILE].found) {
		struct stat fd_stat;
		int fd;

		if ((fd = open(nvramtool_op_modifiers[NVRAMTOOL_MOD_USE_CMOS_FILE].param, O_RDWR | O_CREAT, 0666)) < 0) {
			fprintf(stderr, "Couldn't open '%s'\n", nvramtool_op_modifiers[NVRAMTOOL_MOD_USE_CMOS_FILE].param);
			exit(1);
		}

		if (fstat(fd, &fd_stat) == -1) {
			fprintf(stderr, "Couldn't stat '%s'\n", nvramtool_op_modifiers[NVRAMTOOL_MOD_USE_CMOS_FILE].param);
			exit(1);
		}

		if (fd_stat.st_size < CMOS_SIZE) {
			if ((lseek(fd, CMOS_SIZE - 1, SEEK_SET) == -1) ||
			    (write(fd, "\0", 1) != 1)) {
				fprintf(stderr, "Unable to extended '%s' to its full size.\n",
						nvramtool_op_modifiers[NVRAMTOOL_MOD_USE_CMOS_FILE].param);
				exit(1);
			}
#ifndef __MINGW32__
			fsync(fd);
#else
			FlushFileBuffers ((HANDLE) _get_osfhandle (fd));
#endif
		}

		cmos_default = mmap(NULL, CMOS_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
		if (cmos_default == MAP_FAILED) {
			fprintf(stderr, "Couldn't map '%s'\n", nvramtool_op_modifiers[NVRAMTOOL_MOD_USE_CMOS_FILE].param);
			exit(1);
		}
	}

	/* Switch to memory based CMOS access. */
	if (cmos_default) {
		select_hal(HAL_MEMORY, cmos_default);
	}

	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, "wb")) == 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, "rb")) == 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.\n", 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_expr(REG_EXTENDED | REG_NEWLINE, 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];

	regfree(&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;
	char *w;

	/* 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:
		w = (char *)(unsigned long)value;
		while (*w) {
			if(!isprint((int)(unsigned char)*w)) {
				if (show_name)
					printf("# Bad value -> %s\n", e->name);
				else
					printf("Bad value\n");
				break;
			}
			w++;
		}

		if (!*w) {

			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((int)(unsigned char)*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;
}