1  /* SPDX-License-Identifier: GPL-2.0-only */
  2  
  3  #include <fcntl.h>
  4  #include <stdio.h>
  5  #include <stdlib.h>
  6  #ifndef __MINGW32__
  7  #include <sys/mman.h>
  8  #endif
  9  #include "common.h"
 10  #include "opts.h"
 11  #include "lbtable.h"
 12  #include "layout.h"
 13  #include "accessors/layout-text.h"
 14  #include "input_file.h"
 15  #include "cmos_ops.h"
 16  #include "cmos_lowlevel.h"
 17  #include "reg_expr.h"
 18  #include "hexdump.h"
 19  #include "cbfs.h"
 20  #ifdef __MINGW32__
 21  #include <windows.h>
 22  #endif
 23  
 24  typedef void (*op_fn_t) (void);
 25  
 26  static void op_show_version(void);
 27  static void op_show_usage(void);
 28  static void op_lbtable_show_info(void);
 29  static void op_lbtable_dump(void);
 30  static void op_show_param_values(void);
 31  static void op_cmos_show_one_param(void);
 32  static void op_cmos_show_all_params(void);
 33  static void op_cmos_set_one_param(void);
 34  static void op_cmos_set_params_stdin(void);
 35  static void op_cmos_set_params_file(void);
 36  static void op_cmos_checksum(void);
 37  static void op_show_layout(void);
 38  static void op_write_cmos_dump(void);
 39  static void op_read_cmos_dump(void);
 40  static void op_show_cmos_hex_dump(void);
 41  static void op_show_cmos_dumpfile(void);
 42  static void op_write_cmos_layout_bin(void);
 43  static void op_write_cmos_layout_header(void);
 44  static int list_one_param(const char name[], int show_name);
 45  static int list_all_params(void);
 46  static void list_param_enums(const char name[]);
 47  static void set_one_param(const char name[], const char value[]);
 48  static void set_params(FILE * f);
 49  static void parse_assignment(char arg[], const char **name, const char **value);
 50  static int list_cmos_entry(const cmos_entry_t * e, int show_name);
 51  static uint16_t convert_checksum_value(const char value[]);
 52  
 53  static const op_fn_t op_fns[] = { op_show_version,
 54  	op_show_usage,
 55  	op_lbtable_show_info,
 56  	op_lbtable_dump,
 57  	op_show_param_values,
 58  	op_cmos_show_one_param,
 59  	op_cmos_show_all_params,
 60  	op_cmos_set_one_param,
 61  	op_cmos_set_params_stdin,
 62  	op_cmos_set_params_file,
 63  	op_cmos_checksum,
 64  	op_show_layout,
 65  	op_write_cmos_dump,
 66  	op_read_cmos_dump,
 67  	op_show_cmos_hex_dump,
 68  	op_show_cmos_dumpfile,
 69  	op_write_cmos_layout_bin,
 70  	op_write_cmos_layout_header
 71  };
 72  
 73  static void op_write_cmos_layout_bin(void)
 74  {
 75  	get_layout_from_file();
 76  	write_cmos_output_bin(nvramtool_op.param);
 77  }
 78  
 79  static void op_write_cmos_layout_header(void)
 80  {
 81  	get_layout_from_file();
 82  	write_cmos_layout_header(nvramtool_op.param);
 83  }
 84  
 85  static const hexdump_format_t cmos_dump_format =
 86      { 16, 2, "", " | ", " ", " | ", '.' };
 87  
 88  /****************************************************************************
 89   * main
 90   ****************************************************************************/
 91  int main(int argc, char *argv[])
 92  {
 93  	void *cmos_default = NULL;
 94  	cmos_layout_get_fn_t fn = get_layout_from_cmos_table;
 95  
 96  	parse_nvramtool_args(argc, argv);
 97  
 98  	/* If we should operate on a CBFS file default to reading the layout
 99  	 * and CMOS contents from it. */
100  	if (nvramtool_op_modifiers[NVRAMTOOL_MOD_USE_CBFS_FILE].found) {
101  		open_cbfs(nvramtool_op_modifiers[NVRAMTOOL_MOD_USE_CBFS_FILE].param);
102  		if (!nvramtool_op_modifiers[NVRAMTOOL_MOD_USE_CMOS_FILE].found) {
103  			cmos_default = cbfs_find_file("cmos.default", CBFS_COMPONENT_CMOS_DEFAULT, NULL);
104  			if (cmos_default == NULL) {
105  				fprintf(stderr, "Need a cmos.default in the CBFS image or separate CMOS file (-D).\n");
106  				exit(1);
107  			}
108  		}
109  		fn = get_layout_from_cbfs_file;
110  	}
111  
112  	/* If the user wants to use a specific layout file or explicitly use
113  	 * the coreboot option table allow him to override previous settings. */
114  	if (nvramtool_op_modifiers[NVRAMTOOL_MOD_USE_CMOS_LAYOUT_FILE].found) {
115  		set_layout_filename(nvramtool_op_modifiers[NVRAMTOOL_MOD_USE_CMOS_LAYOUT_FILE].param);
116  		fn = get_layout_from_file;
117  	} else if (nvramtool_op_modifiers[NVRAMTOOL_MOD_USE_CMOS_OPT_TABLE].found) {
118  		fn = get_layout_from_cmos_table;
119  	}
120  
121  	/* Allow the user to use a file for the CMOS contents, possibly
122  	 * overriding a previously opened "cmos.default" file from the CBFS. */
123  	if (nvramtool_op_modifiers[NVRAMTOOL_MOD_USE_CMOS_FILE].found) {
124  		struct stat fd_stat;
125  		int fd;
126  
127  		if ((fd = open(nvramtool_op_modifiers[NVRAMTOOL_MOD_USE_CMOS_FILE].param, O_RDWR | O_CREAT, 0666)) < 0) {
128  			fprintf(stderr, "Couldn't open '%s'\n", nvramtool_op_modifiers[NVRAMTOOL_MOD_USE_CMOS_FILE].param);
129  			exit(1);
130  		}
131  
132  		if (fstat(fd, &fd_stat) == -1) {
133  			fprintf(stderr, "Couldn't stat '%s'\n", nvramtool_op_modifiers[NVRAMTOOL_MOD_USE_CMOS_FILE].param);
134  			exit(1);
135  		}
136  
137  		if (fd_stat.st_size < CMOS_SIZE) {
138  			if ((lseek(fd, CMOS_SIZE - 1, SEEK_SET) == -1) ||
139  			    (write(fd, "\0", 1) != 1)) {
140  				fprintf(stderr, "Unable to extended '%s' to its full size.\n",
141  						nvramtool_op_modifiers[NVRAMTOOL_MOD_USE_CMOS_FILE].param);
142  				exit(1);
143  			}
144  #ifndef __MINGW32__
145  			fsync(fd);
146  #else
147  			FlushFileBuffers ((HANDLE) _get_osfhandle (fd));
148  #endif
149  		}
150  
151  		cmos_default = mmap(NULL, CMOS_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
152  		if (cmos_default == MAP_FAILED) {
153  			fprintf(stderr, "Couldn't map '%s'\n", nvramtool_op_modifiers[NVRAMTOOL_MOD_USE_CMOS_FILE].param);
154  			exit(1);
155  		}
156  	}
157  
158  	/* Switch to memory based CMOS access. */
159  	if (cmos_default) {
160  		select_hal(HAL_MEMORY, cmos_default);
161  	}
162  
163  	register_cmos_layout_get_fn(fn);
164  	op_fns[nvramtool_op.op]();
165  
166  	return 0;
167  }
168  
169  /****************************************************************************
170   * op_show_version
171   *
172   * -v
173   *
174   * Show version information for this program.
175   ****************************************************************************/
176  static void op_show_version(void)
177  {
178  	printf("This is %s version %s.\n", prog_name, prog_version);
179  }
180  
181  /****************************************************************************
182   * op_show_usage
183   *
184   * -h
185   *
186   * Show a usage message for this program.
187   ****************************************************************************/
188  static void op_show_usage(void)
189  {
190  	usage(stdout);
191  }
192  
193  /****************************************************************************
194   * op_lbtable_show_info
195   *
196   * -l [ARG]
197   *
198   * If ARG is present, show coreboot table information specified by ARG.
199   * Else show all possible values for ARG.
200   ****************************************************************************/
201  static void op_lbtable_show_info(void)
202  {
203  	if (nvramtool_op.param == NULL)
204  		list_lbtable_choices();
205  	else {
206  		get_lbtable();
207  		list_lbtable_item(nvramtool_op.param);
208  	}
209  }
210  
211  /****************************************************************************
212   * op_lbtable_dump
213   *
214   * -d
215   *
216   * Do low-level dump of coreboot table.
217   ****************************************************************************/
218  static void op_lbtable_dump(void)
219  {
220  	get_lbtable();
221  	dump_lbtable();
222  }
223  
224  /****************************************************************************
225   * op_show_param_values
226   *
227   * -e NAME option
228   *
229   * Show all possible values for parameter NAME.
230   ****************************************************************************/
231  static void op_show_param_values(void)
232  {
233  	get_cmos_layout();
234  	list_param_enums(nvramtool_op.param);
235  }
236  
237  /****************************************************************************
238   * op_cmos_show_one_param
239   *
240   * [-n] -r NAME
241   *
242   * Show parameter NAME.  If -n is specified, show value only.  Else show name
243   * and value.
244   ****************************************************************************/
245  static void op_cmos_show_one_param(void)
246  {
247  	int result;
248  
249  	get_cmos_layout();
250  	result = list_one_param(nvramtool_op.param,
251  				!nvramtool_op_modifiers
252  				[NVRAMTOOL_MOD_SHOW_VALUE_ONLY].found);
253  	cmos_checksum_verify();
254  
255  	if (result)
256  		exit(1);
257  }
258  
259  /****************************************************************************
260   * op_cmos_show_all_params
261   *
262   * -a
263   *
264   * Show names and values for all parameters.
265   ****************************************************************************/
266  static void op_cmos_show_all_params(void)
267  {
268  	int result;
269  
270  	get_cmos_layout();
271  	result = list_all_params();
272  	cmos_checksum_verify();
273  
274  	if (result)
275  		exit(1);
276  }
277  
278  /****************************************************************************
279   * op_cmos_set_one_param
280   *
281   * -w NAME=VALUE
282   *
283   * Set parameter NAME to VALUE.
284   ****************************************************************************/
285  static void op_cmos_set_one_param(void)
286  {
287  	const char *name, *value;
288  
289  	get_cmos_layout();
290  
291  	/* Separate 'NAME=VALUE' syntax into two strings representing NAME and
292  	 * VALUE.
293  	 */
294  	parse_assignment(nvramtool_op.param, &name, &value);
295  
296  	set_one_param(name, value);
297  }
298  
299  /****************************************************************************
300   * op_cmos_set_params_stdin
301   *
302   * -i
303   *
304   * Set parameters according to standard input.
305   ****************************************************************************/
306  static void op_cmos_set_params_stdin(void)
307  {
308  	get_cmos_layout();
309  	set_params(stdin);
310  }
311  
312  /****************************************************************************
313   * op_cmos_set_params_file
314   *
315   * -p INPUT_FILE
316   *
317   * Set parameters according to INPUT_FILE.
318   ****************************************************************************/
319  static void op_cmos_set_params_file(void)
320  {
321  	FILE *f;
322  
323  	if ((f = fopen(nvramtool_op.param, "r")) == NULL) {
324  		fprintf(stderr, "%s: Can not open file %s for reading: %s\n",
325  			prog_name, nvramtool_op.param, strerror(errno));
326  		exit(1);
327  	}
328  
329  	get_cmos_layout();
330  	set_params(f);
331  	fclose(f);
332  }
333  
334  /****************************************************************************
335   * op_cmos_checksum
336   *
337   * -c [VALUE]
338   *
339   * If VALUE is present, set coreboot CMOS checksum to VALUE.  Else show
340   * checksum value.
341   ****************************************************************************/
342  static void op_cmos_checksum(void)
343  {
344  	uint16_t checksum;
345  
346  	get_cmos_layout();
347  
348  	if (nvramtool_op.param == NULL) {
349  		set_iopl(3);
350  		checksum = cmos_checksum_read();
351  		set_iopl(0);
352  		printf("0x%x\n", checksum);
353  	} else {
354  		checksum = convert_checksum_value(nvramtool_op.param);
355  		set_iopl(3);
356  		cmos_checksum_write(checksum);
357  		set_iopl(0);
358  	}
359  }
360  
361  /****************************************************************************
362   * op_show_layout
363   *
364   * -Y
365   *
366   * Write CMOS layout information to standard output.
367   ****************************************************************************/
368  static void op_show_layout(void)
369  {
370  	get_cmos_layout();
371  	write_cmos_layout(stdout);
372  }
373  
374  /****************************************************************************
375   * op_write_cmos_dump
376   *
377   * -b OUTPUT_FILE
378   *
379   * Write the contents of CMOS memory to a binary file.
380   ****************************************************************************/
381  static void op_write_cmos_dump(void)
382  {
383  	unsigned char data[CMOS_SIZE];
384  	FILE *f;
385  
386  	if ((f = fopen(nvramtool_op.param, "wb")) == NULL) {
387  		fprintf(stderr, "%s: Can not open file %s for writing: %s\n",
388  			prog_name, nvramtool_op.param, strerror(errno));
389  		exit(1);
390  	}
391  
392  	set_iopl(3);
393  	cmos_read_all(data);
394  	set_iopl(0);
395  
396  	if (fwrite(data, 1, CMOS_SIZE, f) != CMOS_SIZE) {
397  		fprintf(stderr, "%s: Error writing CMOS data to file %s: %s\n",
398  			prog_name, nvramtool_op.param, strerror(errno));
399  		exit(1);
400  	}
401  
402  	fclose(f);
403  }
404  
405  /****************************************************************************
406   * op_read_cmos_dump
407   *
408   * -B INPUT_FILE
409   *
410   * Read binary data from a file and write the data to CMOS memory.
411   ****************************************************************************/
412  static void op_read_cmos_dump(void)
413  {
414  	unsigned char data[CMOS_SIZE];
415  	size_t nr_bytes;
416  	FILE *f;
417  
418  	if ((f = fopen(nvramtool_op.param, "rb")) == NULL) {
419  		fprintf(stderr, "%s: Can not open file %s for reading: %s\n",
420  			prog_name, nvramtool_op.param, strerror(errno));
421  		exit(1);
422  	}
423  
424  	if ((nr_bytes = fread(data, 1, CMOS_SIZE, f)) != CMOS_SIZE) {
425  		fprintf(stderr,
426  			"%s: Error: Only able to read %d bytes of CMOS data "
427  			"from file %s.  CMOS data is unchanged.\n", prog_name,
428  			(int)nr_bytes, nvramtool_op.param);
429  		exit(1);
430  	}
431  
432  	fclose(f);
433  	set_iopl(3);
434  	cmos_write_all(data);
435  	set_iopl(0);
436  }
437  
438  /****************************************************************************
439   * op_show_cmos_hex_dump
440   *
441   * -x
442   *
443   * Write a hex dump of CMOS memory to standard output.
444   ****************************************************************************/
445  static void op_show_cmos_hex_dump(void)
446  {
447  	unsigned char data[CMOS_SIZE];
448  
449  	set_iopl(3);
450  	cmos_read_all(data);
451  	set_iopl(0);
452  	hexdump(data, CMOS_SIZE, 0, stdout, &cmos_dump_format);
453  }
454  
455  /****************************************************************************
456   * op_show_cmos_dumpfile
457   *
458   * -X DUMP_FILE
459   *
460   * Read binary data from a file (presumably a CMOS dump file) and display a
461   * hex dump of the CMOS data from the file.
462   ****************************************************************************/
463  static void op_show_cmos_dumpfile(void)
464  {
465  	unsigned char data[CMOS_SIZE];
466  	size_t nr_bytes;
467  	FILE *f;
468  
469  	if ((f = fopen(nvramtool_op.param, "r")) == NULL) {
470  		fprintf(stderr, "%s: Can not open file %s for reading: %s\n",
471  			prog_name, nvramtool_op.param, strerror(errno));
472  		exit(1);
473  	}
474  
475  	nr_bytes = fread(data, 1, CMOS_SIZE, f);
476  	fclose(f);
477  	hexdump(data, nr_bytes, 0, stdout, &cmos_dump_format);
478  }
479  
480  /****************************************************************************
481   * list_one_param
482   *
483   * Attempt to list one CMOS parameter given by 'name'.  'show_name' is a
484   * boolean value indicating whether the parameter name should be displayed
485   * along with its value.  Return 1 if error was encountered.  Else return OK.
486   ****************************************************************************/
487  static int list_one_param(const char name[], int show_name)
488  {
489  	const cmos_entry_t *e;
490  
491  	if (is_checksum_name(name) || ((e = find_cmos_entry(name)) == NULL)) {
492  		fprintf(stderr, "%s: CMOS parameter %s not found.\n", prog_name,
493  			name);
494  		exit(1);
495  	}
496  
497  	if (e->config == CMOS_ENTRY_RESERVED) {
498  		fprintf(stderr, "%s: Parameter %s is reserved.\n", prog_name,
499  			name);
500  		exit(1);
501  	}
502  
503  	return (list_cmos_entry(e, show_name) != 0);
504  }
505  
506  /****************************************************************************
507   * list_all_params
508   *
509   * Attempt to list all CMOS parameters.  Return 1 if error was encountered.
510   * Else return OK.
511   ****************************************************************************/
512  static int list_all_params(void)
513  {
514  	const cmos_entry_t *e;
515  	int result;
516  
517  	result = OK;
518  
519  	for (e = first_cmos_entry(); e != NULL; e = next_cmos_entry(e)) {
520  		if ((e->config == CMOS_ENTRY_RESERVED)
521  		    || is_checksum_name(e->name))
522  			continue;
523  
524  		if (list_cmos_entry(e, TRUE))
525  			result = 1;
526  	}
527  
528  	return result;
529  }
530  
531  /****************************************************************************
532   * list_param_enums
533   *
534   * List all possible values for CMOS parameter given by 'name'.
535   ****************************************************************************/
536  static void list_param_enums(const char name[])
537  {
538  	const cmos_entry_t *e;
539  	const cmos_enum_t *p;
540  
541  	if (is_checksum_name(name) || (e = find_cmos_entry(name)) == NULL) {
542  		fprintf(stderr, "%s: CMOS parameter %s not found.\n", prog_name,
543  			name);
544  		exit(1);
545  	}
546  
547  	switch (e->config) {
548  	case CMOS_ENTRY_ENUM:
549  		for (p = first_cmos_enum_id(e->config_id);
550  		     p != NULL; p = next_cmos_enum_id(p))
551  			printf("%s\n", p->text);
552  
553  		break;
554  
555  	case CMOS_ENTRY_HEX:
556  		printf("Parameter %s requires a %u-bit unsigned integer.\n",
557  		       name, e->length);
558  		break;
559  
560  	case CMOS_ENTRY_STRING:
561  		printf("Parameter %s requires a %u-byte string.\n", name,
562  		       e->length / 8);
563  		break;
564  
565  	case CMOS_ENTRY_RESERVED:
566  		printf("Parameter %s is reserved.\n", name);
567  		break;
568  
569  	default:
570  		BUG();
571  	}
572  }
573  
574  /****************************************************************************
575   * set_one_param
576   *
577   * Set the CMOS parameter given by 'name' to 'value'.  The 'name' parameter
578   * is case-sensitive.  If we are setting an enum parameter, then 'value' is
579   * interpreted as a case-sensitive string that must match the option name
580   * exactly.  If we are setting a 'hex' parameter, then 'value' is treated as
581   * a string representation of an unsigned integer that may be specified in
582   * decimal, hex, or octal.
583   ****************************************************************************/
584  static void set_one_param(const char name[], const char value[])
585  {
586  	const cmos_entry_t *e;
587  	unsigned long long n;
588  
589  	if (is_checksum_name(name) || (e = find_cmos_entry(name)) == NULL) {
590  		fprintf(stderr, "%s: CMOS parameter %s not found.\n", prog_name,
591  			name);
592  		exit(1);
593  	}
594  
595  	switch (prepare_cmos_write(e, value, &n)) {
596  	case OK:
597  		break;
598  
599  	case CMOS_OP_BAD_ENUM_VALUE:
600  		fprintf(stderr, "%s: Bad value for parameter %s.", prog_name,
601  			name);
602  		goto fail;
603  
604  	case CMOS_OP_NEGATIVE_INT:
605  		fprintf(stderr,
606  			"%s: This program does not support assignment of negative "
607  			"numbers to coreboot parameters.", prog_name);
608  		goto fail;
609  
610  	case CMOS_OP_INVALID_INT:
611  		fprintf(stderr, "%s: %s is not a valid integer.", prog_name,
612  			value);
613  		goto fail;
614  
615  	case CMOS_OP_RESERVED:
616  		fprintf(stderr,
617  			"%s: Can not modify reserved coreboot parameter %s.",
618  			prog_name, name);
619  		goto fail;
620  
621  	case CMOS_OP_VALUE_TOO_WIDE:
622  		fprintf(stderr,
623  			"%s: Can not write value %s to CMOS parameter %s that is "
624  			"only %d bits wide.", prog_name, value, name,
625  			e->length);
626  		goto fail;
627  
628  	case CMOS_OP_NO_MATCHING_ENUM:
629  		fprintf(stderr,
630  			"%s: coreboot parameter %s has no matching enums.",
631  			prog_name, name);
632  		goto fail;
633  
634  	case CMOS_AREA_OUT_OF_RANGE:
635  		fprintf(stderr,
636  			"%s: The CMOS area specified by the layout info for "
637  			"coreboot parameter %s is out of range.", prog_name,
638  			name);
639  		goto fail;
640  
641  	case CMOS_AREA_OVERLAPS_RTC:
642  		fprintf(stderr,
643  			"%s: The CMOS area specified by the layout info for "
644  			"coreboot parameter %s overlaps the realtime clock area.",
645  			prog_name, name);
646  		goto fail;
647  
648  	case CMOS_AREA_TOO_WIDE:
649  		fprintf(stderr,
650  			"%s: The CMOS area specified by the layout info for "
651  			"coreboot parameter %s is too wide.", prog_name, name);
652  		goto fail;
653  
654  	default:
655  		fprintf(stderr,
656  			"%s: Unknown error encountered while attempting to modify "
657  			"coreboot parameter %s.", prog_name, name);
658  		goto fail;
659  	}
660  
661  	/* write the value to nonvolatile RAM */
662  	set_iopl(3);
663  	cmos_write(e, n);
664  	cmos_checksum_write(cmos_checksum_compute());
665  	set_iopl(0);
666  	return;
667  
668        fail:
669  	fprintf(stderr, "  CMOS write not performed.\n");
670  	exit(1);
671  }
672  
673  /****************************************************************************
674   * set_params
675   *
676   * Set coreboot parameters according to the contents of file 'f'.
677   ****************************************************************************/
678  static void set_params(FILE * f)
679  {				/* First process the input file.  Then perform writes only if there were
680  				 * no problems processing the input.  Either all values will be written
681  				 * successfully or no values will be written.
682  				 */
683  	do_cmos_writes(process_input_file(f));
684  }
685  
686  /****************************************************************************
687   * parse_assignment
688   *
689   * Parse the string 'arg' (which supposedly represents an assignment) into a
690   * NAME and a VALUE.  If 'arg' does not conform to the proper assignment
691   * syntax, exit with a usage message.  Otherwise, on return, 'arg' is broken
692   * into substrings representing NAME and VALUE, and *name and *value are set
693   * to point to these two substrings.
694   ****************************************************************************/
695  static void parse_assignment(char arg[], const char **name, const char **value)
696  {
697  	static const size_t N_MATCHES = 4;
698  	regmatch_t match[N_MATCHES];
699  	regex_t assignment;
700  
701  	compile_reg_expr(REG_EXTENDED | REG_NEWLINE, assignment_regex, &assignment);
702  
703  	/* Does 'arg' conform to proper assignment syntax?  If not, exit with a
704  	 * usage message.
705  	 */
706  	if (regexec(&assignment, arg, N_MATCHES, match, 0))
707  		usage(stderr);
708  
709  	/* Ok, we found a valid assignment.  Break it into two strings
710  	 * representing NAME and VALUE.
711  	 */
712  	arg[match[1].rm_eo] = '\0';
713  	arg[match[2].rm_eo] = '\0';
714  	*name = &arg[match[1].rm_so];
715  	*value = &arg[match[2].rm_so];
716  
717  	regfree(&assignment);
718  }
719  
720  /****************************************************************************
721   * list_cmos_entry
722   *
723   * Attempt to list the CMOS entry represented by 'e'.  'show_name' is a
724   * boolean value indicating whether the parameter name should be displayed
725   * along with its value.  On success, return OK.  On error, print an error
726   * message and return 1.
727   ****************************************************************************/
728  static int list_cmos_entry(const cmos_entry_t * e, int show_name)
729  {
730  	const cmos_enum_t *p;
731  	unsigned long long value;
732  	char *w;
733  
734  	/* sanity check CMOS entry */
735  	switch (prepare_cmos_read(e)) {
736  	case OK:
737  		break;
738  
739  	case CMOS_OP_RESERVED:
740  		fprintf(stderr,
741  			"%s: Cannot access reserved CMOS area (for %s).\n",
742  			prog_name, e->name);
743  		return 1;
744  
745  	case CMOS_AREA_OUT_OF_RANGE:
746  		fprintf(stderr,
747  			"%s: Can not read coreboot parameter %s because "
748  			"layout info specifies out of range CMOS area.\n",
749  			prog_name, e->name);
750  		return 1;
751  
752  	case CMOS_AREA_OVERLAPS_RTC:
753  		fprintf(stderr,
754  			"%s: Can not read coreboot parameter %s because "
755  			"layout info specifies CMOS area that overlaps realtime "
756  			"clock area.\n", prog_name, e->name);
757  		return 1;
758  
759  	case CMOS_AREA_TOO_WIDE:
760  		fprintf(stderr,
761  			"%s: Can not read coreboot parameter %s because "
762  			"layout info specifies CMOS area that is too wide.\n",
763  			prog_name, e->name);
764  		return 1;
765  
766  	default:
767  		fprintf(stderr,
768  			"%s: Unknown error encountered while attempting to "
769  			"read coreboot parameter %s\n", prog_name, e->name);
770  		return 1;
771  	}
772  
773  	/* read the value from CMOS */
774  	set_iopl(3);
775  	value = cmos_read(e);
776  	set_iopl(0);
777  
778  	/* display the value */
779  	switch (e->config) {
780  	case CMOS_ENTRY_ENUM:
781  		if ((p = find_cmos_enum(e->config_id, value)) == NULL) {
782  			if (show_name)
783  				printf("# Bad value -> %s = 0x%llx\n", e->name,
784  				       value);
785  			else
786  				printf("Bad value -> 0x%llx\n", value);
787  		} else {
788  			if (show_name)
789  				printf("%s = %s\n", e->name, p->text);
790  			else
791  				printf("%s\n", p->text);
792  		}
793  
794  		break;
795  
796  	case CMOS_ENTRY_HEX:
797  		if (show_name)
798  			printf("%s = 0x%llx\n", e->name, value);
799  		else
800  			printf("0x%llx\n", value);
801  
802  		break;
803  
804  	case CMOS_ENTRY_STRING:
805  		w = (char *)(unsigned long)value;
806  		while (*w) {
807  			if(!isprint((int)(unsigned char)*w)) {
808  				if (show_name)
809  					printf("# Bad value -> %s\n", e->name);
810  				else
811  					printf("Bad value\n");
812  				break;
813  			}
814  			w++;
815  		}
816  
817  		if (!*w) {
818  
819  			if (show_name)
820  				printf("%s = %s\n", e->name,
821  				       (char *)(unsigned long)value);
822  			else
823  				printf("%s\n", (char *)(unsigned long)value);
824  		}
825  
826  		free((void *)(unsigned long)value);
827  
828  		break;
829  
830  	case CMOS_ENTRY_RESERVED:
831  	default:
832  		BUG();
833  	}
834  
835  	return OK;
836  }
837  
838  /****************************************************************************
839   * convert_checksum_value
840   *
841   * 'value' is the string representation of a checksum value that the user
842   * wishes to set using the -c option.  Convert the string to a 16-bit
843   * unsigned integer and return the result.  Exit with an error message if
844   * 'value' is invalid.
845   ****************************************************************************/
846  static uint16_t convert_checksum_value(const char value[])
847  {
848  	unsigned long n;
849  	const char *p;
850  	uint16_t result;
851  	int negative;
852  
853  	for (p = value; isspace((int)(unsigned char)*p); p++) ;
854  
855  	negative = (*p == '-');
856  	n = strtoul(value, (char **)&p, 0);
857  
858  	if (*p) {
859  		fprintf(stderr,
860  			"%s: Checksum value %s is not a valid integer.\n",
861  			prog_name, value);
862  		exit(1);
863  	}
864  
865  	if (negative) {
866  		fprintf(stderr,
867  			"%s: Checksum must be an unsigned integer.\n",
868  			prog_name);
869  		exit(1);
870  	}
871  
872  	result = (uint16_t) n;
873  
874  	if (result != n) {
875  		fprintf(stderr,
876  			"%s: Checksum value must fit within 16 bits.\n",
877  			prog_name);
878  		exit(1);
879  	}
880  
881  	return result;
882  }