indent all of nvramtool to make it fit into coreboot's

coding style

Signed-off-by: Stefan Reinauer <stepan@coresystems.de>
Acked-by: Stefan Reinauer <stepan@coresystems.de>



git-svn-id: svn://svn.coreboot.org/coreboot/trunk@5007 2b7e53f0-3cfb-0310-b3e9-8179ed1497e1

24 files changed, 3584 insertions, 3408 deletions

diff --git a/util/nvramtool/cmos_lowlevel.c b/util/nvramtool/cmos_lowlevel.c
index 570161b..67d561b 100644
--- a/util/nvramtool/cmos_lowlevel.c
+++ b/util/nvramtool/cmos_lowlevel.c
@@ -36,22 +36,21 @@
 #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);
+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
@@ -59,9 +58,11 @@ static void put_bits (unsigned char value, unsigned bit, unsigned nr_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)); }
+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
@@ -71,9 +72,12 @@ static inline unsigned char get_bits (unsigned long long value, unsigned 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; }
+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
@@ -82,43 +86,48 @@ static inline void put_bits (unsigned char value, unsigned bit,
  * 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 = calloc(1, (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;
- }
+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 = calloc(1, (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
@@ -127,34 +136,38 @@ unsigned long long cmos_read (const cmos_entry_t *e)
  * 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));
-       }
-    }
- }
+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
@@ -166,23 +179,23 @@ void cmos_write (const cmos_entry_t *e, unsigned long long value)
  * 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;
+unsigned char cmos_read_byte(unsigned index)
+{
+	unsigned short port_0, port_1;
 
-   assert(!verify_cmos_byte_index(index));
+	assert(!verify_cmos_byte_index(index));
 
-   if (index < 128)
-    { port_0 = 0x70;
-      port_1 = 0x71;
-    }
-   else
-    { port_0 = 0x72;
-      port_1 = 0x73;
-    }
+	if (index < 128) {
+		port_0 = 0x70;
+		port_1 = 0x71;
+	} else {
+		port_0 = 0x72;
+		port_1 = 0x73;
+	}
 
-   OUTB(index, port_0);
-   return INB(port_1);
- }
+	OUTB(index, port_0);
+	return INB(port_1);
+}
 
 /****************************************************************************
  * cmos_write_byte
@@ -194,23 +207,23 @@ unsigned char cmos_read_byte (unsigned index)
  *       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;
+void cmos_write_byte(unsigned index, unsigned char value)
+{
+	unsigned short port_0, port_1;
 
-   assert(!verify_cmos_byte_index(index));
+	assert(!verify_cmos_byte_index(index));
 
-   if (index < 128)
-    { port_0 = 0x70;
-      port_1 = 0x71;
-    }
-   else
-    { port_0 = 0x72;
-      port_1 = 0x73;
-    }
+	if (index < 128) {
+		port_0 = 0x70;
+		port_1 = 0x71;
+	} else {
+		port_0 = 0x72;
+		port_1 = 0x73;
+	}
 
-   OUTB(index, port_0);
-   OUTB(value, port_1);
- }
+	OUTB(index, port_0);
+	OUTB(value, port_1);
+}
 
 /****************************************************************************
  * cmos_read_all
@@ -218,15 +231,16 @@ void cmos_write_byte (unsigned index, unsigned char value)
  * 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;
+void cmos_read_all(unsigned char data[])
+{
+	unsigned i;
 
-   for (i = 0; i < CMOS_RTC_AREA_SIZE; i++)
-      data[i] = 0;
+	for (i = 0; i < CMOS_RTC_AREA_SIZE; i++)
+		data[i] = 0;
 
-   for (; i < CMOS_SIZE; i++)
-      data[i] = cmos_read_byte(i);
- }
+	for (; i < CMOS_SIZE; i++)
+		data[i] = cmos_read_byte(i);
+}
 
 /****************************************************************************
  * cmos_write_all
@@ -235,12 +249,13 @@ void cmos_read_all (unsigned char data[])
  * bytes of 'data' are ignored since this corresponds to the real time clock
  * area.
  ****************************************************************************/
-void cmos_write_all (unsigned char data[])
- { unsigned i;
+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]);
- }
+	for (i = CMOS_RTC_AREA_SIZE; i < CMOS_SIZE; i++)
+		cmos_write_byte(i, data[i]);
+}
 
 /****************************************************************************
  * set_iopl
@@ -251,45 +266,37 @@ void cmos_write_all (unsigned char data[])
  * interrupts while executing in user space.  Messing with the I/O privilege
  * level is therefore somewhat dangerous.
  ****************************************************************************/
-void set_iopl (int level)
- {
+void set_iopl(int level)
+{
 #if defined(__FreeBSD__)
-   static int io_fd = -1;
+	static int io_fd = -1;
 #endif
 
-   assert((level >= 0) && (level <= 3));
+	assert((level >= 0) && (level <= 3));
 
 #if defined(__FreeBSD__)
-   if (level == 0)
-    {
-      if (io_fd != -1)
-       {
-         close(io_fd);
-         io_fd = -1;
-       }
-    }
-   else
-    {
-      if (io_fd == -1)
-       {
-         io_fd = open("/dev/io", O_RDWR);
-         if (io_fd < 0)
-          {
-            perror("/dev/io");
-            exit(1);
-          }
-       }
-    }
+	if (level == 0) {
+		if (io_fd != -1) {
+			close(io_fd);
+			io_fd = -1;
+		}
+	} else {
+		if (io_fd == -1) {
+			io_fd = open("/dev/io", O_RDWR);
+			if (io_fd < 0) {
+				perror("/dev/io");
+				exit(1);
+			}
+		}
+	}
 #else
-   if (iopl(level))
-    { fprintf(stderr,
-              "%s: iopl() system call failed.  You must be root to do "
-              "this.\n",
-              prog_name);
-      exit(1);
-    }
+	if (iopl(level)) {
+		fprintf(stderr, "%s: iopl() system call failed.  "
+			"You must be root to do this.\n", prog_name);
+		exit(1);
+	}
 #endif
- }
+}
 
 /****************************************************************************
  * verify_cmos_op
@@ -300,21 +307,22 @@ void set_iopl (int level)
  * 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;
+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 (bit < (8 * CMOS_RTC_AREA_SIZE))
+		return CMOS_AREA_OVERLAPS_RTC;
 
-   if (config == CMOS_ENTRY_STRING)
-      return OK;
+	if (config == CMOS_ENTRY_STRING)
+		return OK;
 
-   if (length > (8 * sizeof(unsigned long long)))
-      return CMOS_AREA_TOO_WIDE;
+	if (length > (8 * sizeof(unsigned long long)))
+		return CMOS_AREA_TOO_WIDE;
 
-   return OK;
- }
+	return OK;
+}
 
 /****************************************************************************
  * cmos_bit_op_strategy
@@ -322,15 +330,16 @@ int verify_cmos_op (unsigned bit, unsigned length, cmos_entry_config_t config)
  * 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;
+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;
- }
+	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
@@ -338,11 +347,12 @@ static unsigned cmos_bit_op_strategy (unsigned bit, unsigned bits_left,
  * 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));
- }
+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
@@ -350,17 +360,18 @@ static unsigned char cmos_read_bits (const cmos_bit_op_location_t *where,
  * 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);
- }
+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);
+}
diff --git a/util/nvramtool/cmos_lowlevel.h b/util/nvramtool/cmos_lowlevel.h
index d07520b..ebe82a7 100644
--- a/util/nvramtool/cmos_lowlevel.h
+++ b/util/nvramtool/cmos_lowlevel.h
@@ -38,17 +38,17 @@
 #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);
+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 */
+#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
@@ -56,7 +56,9 @@ int verify_cmos_op (unsigned bit, unsigned length, cmos_entry_config_t config);
  * 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); }
+static inline int verify_cmos_byte_index(unsigned index)
+{
+	return (index < CMOS_RTC_AREA_SIZE) || (index >= CMOS_SIZE);
+}
 
-#endif  /* NVRAMTOOL_CMOS_LOWLEVEL_H */
+#endif				/* NVRAMTOOL_CMOS_LOWLEVEL_H */
diff --git a/util/nvramtool/cmos_ops.c b/util/nvramtool/cmos_ops.c
index 738c8ed..73d68e0 100644
--- a/util/nvramtool/cmos_ops.c
+++ b/util/nvramtool/cmos_ops.c
@@ -32,26 +32,27 @@
 #include "cmos_ops.h"
 #include "cmos_lowlevel.h"
 
-static int prepare_cmos_op_common (const cmos_entry_t *e);
+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;
+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 (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;
+	if ((result = verify_cmos_op(e->bit, e->length, e->config)) != OK)
+		return result;
 
-   assert(e->length > 0);
-   return OK;
- }
+	assert(e->length > 0);
+	return OK;
+}
 
 /****************************************************************************
  * prepare_cmos_read
@@ -60,24 +61,25 @@ static int prepare_cmos_op_common (const cmos_entry_t *e)
  * 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;
+int prepare_cmos_read(const cmos_entry_t * e)
+{
+	int result;
 
-   if ((result = prepare_cmos_op_common(e)) != OK)
-      return 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;
+	switch (e->config) {
+	case CMOS_ENTRY_ENUM:
+	case CMOS_ENTRY_HEX:
+	case CMOS_ENTRY_STRING:
+		break;
 
-      default:
-         BUG();
-    }
+	default:
+		BUG();
+	}
 
-   return OK;
- }
+	return OK;
+}
 
 /****************************************************************************
  * prepare_cmos_write
@@ -87,79 +89,78 @@ int prepare_cmos_read (const cmos_entry_t *e)
  * 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;
- }
+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
@@ -167,14 +168,15 @@ int prepare_cmos_write (const cmos_entry_t *e, const char value_str[],
  * Read the checksum for the coreboot parameters stored in CMOS and return
  * this value.
  ****************************************************************************/
-uint16_t cmos_checksum_read (void)
- { uint16_t lo, hi;
+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;
- }
+	/* 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
@@ -182,15 +184,16 @@ uint16_t cmos_checksum_read (void)
  * Set the checksum for the coreboot parameters stored in CMOS to
  * 'checksum'.
  ****************************************************************************/
-void cmos_checksum_write (uint16_t checksum)
- { unsigned char lo, hi;
+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);
- }
+	/* 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
@@ -198,16 +201,17 @@ void cmos_checksum_write (uint16_t checksum)
  * 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;
+uint16_t cmos_checksum_compute(void)
+{
+	unsigned i, sum;
 
-   sum = 0;
+	sum = 0;
 
-   for (i = cmos_checksum_start; i <= cmos_checksum_end; i++)
-      sum += cmos_read_byte(i);
+	for (i = cmos_checksum_start; i <= cmos_checksum_end; i++)
+		sum += cmos_read_byte(i);
 
-   return ~((uint16_t) (sum & 0xffff));
- }
+	return ~((uint16_t) (sum & 0xffff));
+}
 
 /****************************************************************************
  * cmos_checksum_verify
@@ -215,17 +219,18 @@ uint16_t cmos_checksum_compute (void)
  * 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);
-    }
- }
+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);
+	}
+}
diff --git a/util/nvramtool/cmos_ops.h b/util/nvramtool/cmos_ops.h
index 842e90f..3ef5023 100644
--- a/util/nvramtool/cmos_ops.h
+++ b/util/nvramtool/cmos_ops.h
@@ -41,12 +41,12 @@
 #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);
+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 */
+#endif				/* CMOS_OPS_H */
diff --git a/util/nvramtool/common.c b/util/nvramtool/common.c
index bf2158b..c80c2da 100644
--- a/util/nvramtool/common.c
+++ b/util/nvramtool/common.c
@@ -42,27 +42,29 @@ const char prog_version[] = "2.1";
  * 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;
+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;
- }
+	/* 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);
- }
+void out_of_memory(void)
+{
+	fprintf(stderr, "%s: Out of memory.\n", prog_name);
+	exit(1);
+}
 
 /****************************************************************************
  * usage
@@ -70,36 +72,37 @@ void out_of_memory (void)
  * 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);
- }
+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);
+}
diff --git a/util/nvramtool/common.h b/util/nvramtool/common.h
index 6061e6e..5d6e204 100644
--- a/util/nvramtool/common.h
+++ b/util/nvramtool/common.h
@@ -77,7 +77,7 @@
 #define CMOS_RESULT_START 0x30000
 #define CMOS_OP_RESULT_START 0x40000
 
-#define OK 0  /* 0 is used universally to indicate success. */
+#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)
@@ -88,8 +88,8 @@ 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);
+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 */
+#endif				/* COMMON_H */
diff --git a/util/nvramtool/compute_ip_checksum.c b/util/nvramtool/compute_ip_checksum.c
index 12bed5f..f19e943 100644
--- a/util/nvramtool/compute_ip_checksum.c
+++ b/util/nvramtool/compute_ip_checksum.c
@@ -13,32 +13,32 @@
 
 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;
+	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;
 }
diff --git a/util/nvramtool/coreboot_tables.h b/util/nvramtool/coreboot_tables.h
index afab7bc..d6e1b76 100644
--- a/util/nvramtool/coreboot_tables.h
+++ b/util/nvramtool/coreboot_tables.h
@@ -59,30 +59,27 @@ struct lb_uint64 {
 
 static inline uint64_t unpack_lb64(struct lb_uint64 value)
 {
-        uint64_t result;
-        result = value.hi;
-        result = (result << 32) + value.lo;
-        return result;
+	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_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;
+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
@@ -92,8 +89,8 @@ struct lb_header
  * forward compatibility with records not yet defined.
  */
 struct lb_record {
-        uint32_t tag;                /* tag ID */
-        uint32_t size;                /* size of record (in bytes) */
+	uint32_t tag;		/* tag ID */
+	uint32_t size;		/* size of record (in bytes) */
 };
 
 #define LB_TAG_UNUSED        0x0000
@@ -103,48 +100,48 @@ struct lb_record {
 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 */
+	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];
+	uint32_t tag;
+	uint32_t size;
+	struct lb_memory_range map[0];
 };
 
-#define LB_TAG_HWRPB        0x0002
+#define LB_TAG_HWRPB            0x0002
 struct lb_hwrpb {
-        uint32_t tag;
-        uint32_t size;
-        uint64_t 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];
+	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_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];
+	uint32_t tag;
+	uint32_t size;
+	uint8_t string[0];
 };
 #define LB_TAG_SERIAL		0x000f
 #define LB_TAG_CONSOLE		0x0010
@@ -159,9 +156,9 @@ struct lb_forward {
 #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 */
+	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
@@ -173,31 +170,30 @@ struct cmos_option_table {
 */
 #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 */
+	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 */
+	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 */
+	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 */
+	uint8_t text[CMOS_MAX_TEXT_LENGTH];	/* enum description in ascii, 
+						   variable length int aligned */
 };
 
 /* cmos defaults record
@@ -205,16 +201,16 @@ struct cmos_enums {
 */
 #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 */
+	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 */
+	uint8_t default_set[CMOS_IMAGE_BUFFER_SIZE];	/* default settings */
 };
 
 #define LB_TAG_OPTION_CHECKSUM 204
-struct	cmos_checksum {
+struct cmos_checksum {
 	uint32_t tag;
 	uint32_t size;
 	/* In practice everything is byte aligned, but things are measured
@@ -228,6 +224,4 @@ struct	cmos_checksum {
 #define CHECKSUM_PCBIOS	1
 };
 
-
-
-#endif /* COREBOOT_TABLES_H */
+#endif				/* COREBOOT_TABLES_H */
diff --git a/util/nvramtool/hexdump.c b/util/nvramtool/hexdump.c
index 5df2619..78199eb 100644
--- a/util/nvramtool/hexdump.c
+++ b/util/nvramtool/hexdump.c
@@ -43,11 +43,11 @@
  * 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);
+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
@@ -65,95 +65,98 @@ static void charprint (FILE *outfile, unsigned char byte,
  *     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;
+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;
+	/* 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;
+	is_printable_fn = format->is_printable_fn;
 
-   if (is_printable_fn == NULL)
-      is_printable_fn = default_is_printable_fn;
+	if (is_printable_fn == NULL)
+		is_printable_fn = default_is_printable_fn;
 
-   p = (const unsigned char *) mem;
-   index = 0;
+	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);
+	/* 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++]);
+		/* display the bytes in hex */
+		for (i = 0;;) {
+			hexprint(outfile, p[index++]);
 
-         if (++i >= format->bytes_per_line)
-            break;
+			if (++i >= format->bytes_per_line)
+				break;
 
-         fprintf(outfile, format->sep2);
-       }
+			fprintf(outfile, format->sep2);
+		}
 
-      index -= format->bytes_per_line;
-      fprintf(outfile, format->sep3);
+		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);
+		/* 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");
-    }
+		fprintf(outfile, "\n");
+	}
 
-   if (bytes_left == 0)
-      return;
+	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);
+	/* 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);
-    }
+	/* 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;
+	index -= bytes_left;
 
-   /* pad the rest of the hex byte area with spaces */
-   for (; ; )
-    { fprintf(outfile, "  ");
+	/* pad the rest of the hex byte area with spaces */
+	for (;;) {
+		fprintf(outfile, "  ");
 
-      if (++i >= format->bytes_per_line)
-         break;
+		if (++i >= format->bytes_per_line)
+			break;
 
-      fprintf(outfile, format->sep2);
-    }
+		fprintf(outfile, format->sep2);
+	}
 
-   fprintf(outfile, format->sep3);
+	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);
+	/* 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, " ");
+	/* pad the rest of the character area with spaces */
+	for (; i < format->bytes_per_line; i++)
+		fprintf(outfile, " ");
 
-   fprintf(outfile, "\n");
- }
+	fprintf(outfile, "\n");
+}
 
 /*--------------------------------------------------------------------------
  * default_is_printable_fn
@@ -169,8 +172,10 @@ void hexdump (const void *mem, int bytes, uint64_t addrprint_start,
  * 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); }
+int default_is_printable_fn(unsigned char c)
+{
+	return (c >= 0x20) && (c <= 0x7e);
+}
 
 /*--------------------------------------------------------------------------
  * addrprint
@@ -183,32 +188,33 @@ int default_is_printable_fn (unsigned char c)
  *     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, ":");
-    }
- }
+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
@@ -219,14 +225,15 @@ static void addrprint (FILE *outfile, uint64_t address, int width)
  *     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'
-    };
+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]);
- }
+	fprintf(outfile, "%c%c", tbl[byte >> 4], tbl[byte & 0x0f]);
+}
 
 /*--------------------------------------------------------------------------
  * charprint
@@ -241,7 +248,9 @@ static void hexprint (FILE *outfile, unsigned char byte)
  *     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); }
+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);
+}
diff --git a/util/nvramtool/hexdump.h b/util/nvramtool/hexdump.h
index bd21ed9..a63ec02 100644
--- a/util/nvramtool/hexdump.h
+++ b/util/nvramtool/hexdump.h
@@ -81,17 +81,16 @@ typedef int (*is_printable_fn_t) (unsigned char c);
  *                      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;
+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
@@ -109,8 +108,8 @@ hexdump_format_t;
  *     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);
+void hexdump(const void *mem, int bytes, uint64_t addrprint_start,
+	     FILE * outfile, const hexdump_format_t * format);
 
 /*--------------------------------------------------------------------------
  * default_is_printable_fn
@@ -126,6 +125,6 @@ void hexdump (const void *mem, int bytes, uint64_t addrprint_start,
  * return value:
  *     Return 1 if the input character is printable.  Otherwise return 0.
  *--------------------------------------------------------------------------*/
-int default_is_printable_fn (unsigned char c);
+int default_is_printable_fn(unsigned char c);
 
-#endif  /* _HEXDUMP_H */
+#endif				/* _HEXDUMP_H */
diff --git a/util/nvramtool/input_file.c b/util/nvramtool/input_file.c
index 99b580e..38214d9 100644
--- a/util/nvramtool/input_file.c
+++ b/util/nvramtool/input_file.c
@@ -35,38 +35,35 @@
 #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[]);
+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 */
-   "#.*$)";
+    /* 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:]]*$";
+    /* 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;
 
@@ -77,77 +74,77 @@ static int line_num;
  * 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;
- }
+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
@@ -156,25 +153,26 @@ cmos_write_t * process_input_file (FILE *f)
  * 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);
- }
+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
@@ -183,27 +181,29 @@ void do_cmos_writes (cmos_write_t *list)
  * 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 */
- }
+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
@@ -212,73 +212,83 @@ static int get_input_file_line (FILE *f, char line[], int line_buf_size)
  * 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 */
- }
+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 */
+}
diff --git a/util/nvramtool/input_file.h b/util/nvramtool/input_file.h
index 0912a69..05d14de 100644
--- a/util/nvramtool/input_file.h
+++ b/util/nvramtool/input_file.h
@@ -36,22 +36,22 @@
 
 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.
+/* 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;
- };
+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);
+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 */
+#endif				/* INPUT_FILE_H */
diff --git a/util/nvramtool/ip_checksum.h b/util/nvramtool/ip_checksum.h
index 365bbd1..ebd52ce 100644
--- a/util/nvramtool/ip_checksum.h
+++ b/util/nvramtool/ip_checksum.h
@@ -13,4 +13,4 @@
 
 unsigned long compute_ip_checksum(void *addr, unsigned long length);
 
-#endif /* IP_CHECKSUM_H */
+#endif				/* IP_CHECKSUM_H */
diff --git a/util/nvramtool/layout.c b/util/nvramtool/layout.c
index e210cae..f543d12 100644
--- a/util/nvramtool/layout.c
+++ b/util/nvramtool/layout.c
@@ -34,23 +34,23 @@
 
 typedef struct cmos_entry_item_t cmos_entry_item_t;
 
-struct cmos_entry_item_t
- { cmos_entry_t item;
-   cmos_entry_item_t *next;
- };
+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;
- };
+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);
+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";
 
@@ -99,39 +99,41 @@ static cmos_layout_get_fn_t cmos_layout_get_fn = default_cmos_layout_get_fn;
  *
  * 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); }
+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;
+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;
- }
+	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;
+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;
- }
+	offset = (unsigned long)pos;
+	address = ((unsigned long)p) - offset;
+	return (const cmos_enum_item_t *)address;
+}
 
 /****************************************************************************
  * register_cmos_layout_get_fn
@@ -139,16 +141,20 @@ static inline const cmos_enum_item_t * cmos_enum_to_const_item
  * 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; }
+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(); }
+void get_cmos_layout(void)
+{
+	cmos_layout_get_fn();
+}
 
 /****************************************************************************
  * add_cmos_entry
@@ -158,61 +164,63 @@ void get_cmos_layout (void)
  * 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;
- }
+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
@@ -220,16 +228,17 @@ fail:
  * 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;
+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;
-    }
+	for (item = cmos_entry_list; item != NULL; item = item->next) {
+		if (!strcmp(item->item.name, name))
+			return &item->item;
+	}
 
-   return NULL;
- }
+	return NULL;
+}
 
 /****************************************************************************
  * first_cmos_entry
@@ -237,8 +246,10 @@ const cmos_entry_t * find_cmos_entry (const char name[])
  * 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; }
+const cmos_entry_t *first_cmos_entry(void)
+{
+	return (cmos_entry_list == NULL) ? NULL : &cmos_entry_list->item;
+}
 
 /****************************************************************************
  * next_cmos_entry
@@ -246,13 +257,14 @@ const cmos_entry_t * first_cmos_entry (void)
  * 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;
+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;
- }
+	last_item = cmos_entry_to_const_item(last);
+	next_item = last_item->next;
+	return (next_item == NULL) ? NULL : &next_item->item;
+}
 
 /****************************************************************************
  * add_cmos_enum
@@ -260,73 +272,75 @@ const cmos_entry_t * next_cmos_entry (const cmos_entry_t *last)
  * 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;
- }
+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
@@ -334,22 +348,22 @@ int add_cmos_enum (const cmos_enum_t *e)
  * 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;
+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;
+	if ((item = find_first_cmos_enum_id(config_id)) == NULL)
+		return NULL;
 
-   while (item->item.value < value)
-    { item = item->next;
+	while (item->item.value < value) {
+		item = item->next;
 
-      if ((item == NULL) || (item->item.config_id != config_id))
-         return NULL;
-    }
+		if ((item == NULL) || (item->item.config_id != config_id))
+			return NULL;
+	}
 
-   return (item->item.value == value) ? &item->item : NULL;
- }
+	return (item->item.value == value) ? &item->item : NULL;
+}
 
 /****************************************************************************
  * first_cmos_enum
@@ -357,8 +371,10 @@ const cmos_enum_t * find_cmos_enum (unsigned config_id,
  * 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; }
+const cmos_enum_t *first_cmos_enum(void)
+{
+	return (cmos_enum_list == NULL) ? NULL : &cmos_enum_list->item;
+}
 
 /****************************************************************************
  * next_cmos_enum
@@ -366,13 +382,14 @@ const cmos_enum_t * first_cmos_enum (void)
  * 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;
+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;
- }
+	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
@@ -380,12 +397,13 @@ const cmos_enum_t * next_cmos_enum (const cmos_enum_t *last)
  * 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;
+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;
- }
+	item = find_first_cmos_enum_id(config_id);
+	return (item == NULL) ? NULL : &item->item;
+}
 
 /****************************************************************************
  * next_cmos_enum_id
@@ -393,13 +411,14 @@ const cmos_enum_t * first_cmos_enum_id (unsigned config_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;
+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;
- }
+	item = cmos_enum_to_const_item(last)->next;
+	return ((item == NULL) || (item->item.config_id != last->config_id)) ?
+	    NULL : &item->item;
+}
 
 /****************************************************************************
  * is_checksum_name
@@ -407,8 +426,10 @@ const cmos_enum_t * next_cmos_enum_id (const cmos_enum_t *last)
  * 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); }
+int is_checksum_name(const char name[])
+{
+	return !strcmp(name, checksum_param_name);
+}
 
 /****************************************************************************
  * checksum_layout_to_bytes
@@ -418,45 +439,46 @@ int is_checksum_name (const char name[])
  * 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;
+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;
+	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 (start % 8)
+		return LAYOUT_SUMMED_AREA_START_NOT_ALIGNED;
 
-   if ((end % 8) != 7)
-      return LAYOUT_SUMMED_AREA_END_NOT_ALIGNED;
+	if ((end % 8) != 7)
+		return LAYOUT_SUMMED_AREA_END_NOT_ALIGNED;
 
-   if (index % 8)
-      return LAYOUT_CHECKSUM_LOCATION_NOT_ALIGNED;
+	if (index % 8)
+		return LAYOUT_CHECKSUM_LOCATION_NOT_ALIGNED;
 
-   if (end <= start)
-      return LAYOUT_INVALID_SUMMED_AREA;
+	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;
+	/* 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(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;
+	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;
+	/* 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;
- }
+	layout->summed_area_start = start;
+	layout->summed_area_end = end;
+	layout->checksum_at = index;
+	return OK;
+}
 
 /****************************************************************************
  * checksum_layout_to_bits
@@ -464,11 +486,12 @@ int checksum_layout_to_bytes (cmos_checksum_layout_t *layout)
  * 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;
- }
+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
@@ -477,22 +500,25 @@ void checksum_layout_to_bits (cmos_checksum_layout_t *layout)
  * obtaining CMOS layout information was not set before attempting to
  * retrieve layout information.
  ****************************************************************************/
-static void default_cmos_layout_get_fn (void)
- { BUG(); }
+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;
+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));
- }
+	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
@@ -500,13 +526,14 @@ static int areas_overlap (unsigned area_0_start, unsigned area_0_length,
  * 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;
+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);
+	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;
- }
+	return ((item == NULL) || (item->item.config_id > config_id)) ?
+	    NULL : item;
+}
diff --git a/util/nvramtool/layout.h b/util/nvramtool/layout.h
index 0e86aeb..d99275c 100644
--- a/util/nvramtool/layout.h
+++ b/util/nvramtool/layout.h
@@ -45,44 +45,40 @@
 #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;
+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;
+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;
+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.
+/* 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;
+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[];
 
@@ -94,21 +90,20 @@ 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);
+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 */
+#endif				/* LAYOUT_H */
diff --git a/util/nvramtool/layout_file.c b/util/nvramtool/layout_file.c
index 0cdacee..51b332c 100644
--- a/util/nvramtool/layout_file.c
+++ b/util/nvramtool/layout_file.c
@@ -34,42 +34,39 @@
 #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[]);
+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 */
-   "#.*$)";
+    /* 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;
 
@@ -77,12 +74,12 @@ static regex_t blank_or_comment_expr;
  * "entries" section.
  */
 static const char start_entries_regex[] =
-   /* optional whitespace */
-   "^[[:space:]]*"
-   /* followed by "entries" */
-   "entries"
-   /* followed by optional whitespace */
-   "[[:space:]]*$";
+    /* optional whitespace */
+    "^[[:space:]]*"
+    /* followed by "entries" */
+    "entries"
+    /* followed by optional whitespace */
+    "[[:space:]]*$";
 
 static regex_t start_entries_expr;
 
@@ -90,12 +87,12 @@ static regex_t start_entries_expr;
  * "enumerations" section
  */
 static const char start_enums_regex[] =
-   /* optional whitespace */
-   "^[[:space:]]*"
-   /* followed by "enumerations" */
-   "enumerations"
-   /* followed by optional whitespace */
-   "[[:space:]]*$";
+    /* optional whitespace */
+    "^[[:space:]]*"
+    /* followed by "enumerations" */
+    "enumerations"
+    /* followed by optional whitespace */
+    "[[:space:]]*$";
 
 static regex_t start_enums_expr;
 
@@ -103,58 +100,58 @@ static regex_t start_enums_expr;
  * "checksums" section
  */
 static const char start_checksums_regex[] =
-   /* optional whitespace */
-   "^[[:space:]]*"
-   /* followed by "checksums" */
-   "checksums"
-   /* followed by optional whitespace */
-   "[[:space:]]*$";
+    /* 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:]]*$";
+    /* 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:]]*$";
+    /* 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;
 
@@ -162,24 +159,24 @@ static regex_t enums_line_expr;
  * 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:]]*$";
+    /* 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;
 
@@ -194,28 +191,32 @@ static const char *layout_filename = NULL;
  *
  * Set the name of the file we will obtain CMOS layout information from.
  ****************************************************************************/
-void set_layout_filename (const char filename[])
- { layout_filename = filename; }
+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;
+void get_layout_from_file(void)
+{
+	FILE *f;
 
-   assert(layout_filename != NULL);
+	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);
-    }
+	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);
- }
+	process_layout_file(f);
+	fclose(f);
+}
 
 /****************************************************************************
  * write_cmos_layout
@@ -223,35 +224,35 @@ void get_layout_from_file (void)
  * 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);
- }
+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
@@ -259,99 +260,105 @@ void write_cmos_layout (FILE *f)
  * 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);
- }
+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];
+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);
-       }
+	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(&blank_or_comment_expr, line, 0, NULL, 0))
+			continue;
 
-      if (!regexec(&start_entries_expr, line, 0, NULL, 0))
-         break;
+		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);
-    }
+		fprintf(stderr,
+			"%s: Syntax error on line %d of CMOS layout file.  "
+			"\"entries\" line expected.\n", prog_name, line_num);
+		exit(1);
+	}
 
-   line_num++;
- }
+	line_num++;
+}
 
 /****************************************************************************
  * process_entry
@@ -360,56 +367,58 @@ static void skip_past_start (FILE *f)
  * 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;
- }
+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
@@ -418,91 +427,96 @@ static int process_entry (FILE *f, int skip_add)
  * 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;
- }
+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;
-    }
- }
+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
@@ -510,20 +524,21 @@ static void process_checksum_info (FILE *f)
  * 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);
-       }
-    }
- }
+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
@@ -531,54 +546,57 @@ static void skip_remaining_lines (FILE *f)
  * 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);
- }
+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
@@ -586,44 +604,48 @@ bad_config_str:
  * 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);
- }
+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
@@ -631,20 +653,22 @@ static void try_add_layout_file_entry (const cmos_entry_t *cmos_entry)
  * 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);
- }
+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
@@ -652,23 +676,24 @@ static void create_enum (cmos_enum_t *cmos_enum, const char id_str[],
  * 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;
+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;
+	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();
-    }
+	default:
+		BUG();
+	}
 
-   exit(1);
- }
+	exit(1);
+}
 
 /****************************************************************************
  * set_checksum_info
@@ -676,100 +701,111 @@ static void try_add_cmos_enum (const cmos_enum_t *cmos_enum)
  * 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);
- }
+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';
+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_HEX:
+		return 'h';
 
-      case CMOS_ENTRY_RESERVED:
-         return 'r';
+	case CMOS_ENTRY_RESERVED:
+		return 'r';
 
-      case CMOS_ENTRY_STRING:
-         return 's';
+	case CMOS_ENTRY_STRING:
+		return 's';
 
-      default:
-         BUG();
-    }
+	default:
+		BUG();
+	}
 
-   return 0;  /* not reached */
- }
+	return 0;		/* not reached */
+}
 
 /****************************************************************************
  * get_layout_file_line
@@ -778,56 +814,62 @@ static char cmos_entry_char_value (cmos_entry_config_t config)
  * 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 */
- }
+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;
- }
+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"); }
+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
@@ -835,20 +877,22 @@ static unsigned long string_to_unsigned_long (const char str[],
  * 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;
- }
+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;
+}
diff --git a/util/nvramtool/layout_file.h b/util/nvramtool/layout_file.h
index 795c793..21997e9 100644
--- a/util/nvramtool/layout_file.h
+++ b/util/nvramtool/layout_file.h
@@ -34,8 +34,8 @@
 #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);
+void set_layout_filename(const char filename[]);
+void get_layout_from_file(void);
+void write_cmos_layout(FILE * f);
 
-#endif  /* LAYOUT_FILE_H */
+#endif				/* LAYOUT_FILE_H */
diff --git a/util/nvramtool/lbtable.c b/util/nvramtool/lbtable.c
index 56e61ff..88d7f9c 100644
--- a/util/nvramtool/lbtable.c
+++ b/util/nvramtool/lbtable.c
@@ -39,115 +39,110 @@
 #include "cmos_lowlevel.h"
 #include "hexdump.h"
 
-typedef void (*lbtable_print_fn_t) (const struct lb_record *rec);
+typedef void (*lbtable_print_fn_t) (const struct lb_record * rec);
 
 /* This structure represents an item in the coreboot table that may be
  * displayed using the -l option.
  */
-typedef struct
- { uint32_t tag;
-   const char *name;
-   const char *description;
-   const char *nofound_msg;
-   lbtable_print_fn_t print_fn;
- }
-lbtable_choice_t;
-
-typedef struct
- { unsigned long start;  /* address of first byte of memory range */
-   unsigned long end;  /* address of last byte of memory range */
- }
-mem_range_t;
-
-static const struct lb_header * lbtable_scan (unsigned long start,
-                                              unsigned long end,
-                                              int *bad_header_count,
-                                              int *bad_table_count);
-static void process_cmos_table (void);
-static void get_cmos_checksum_info (void);
-static void try_convert_checksum_layout (cmos_checksum_layout_t *layout);
-static void try_add_cmos_table_enum (cmos_enum_t *cmos_enum);
-static void try_add_cmos_table_entry (cmos_entry_t *cmos_entry);
-static const struct lb_record * find_lbrec (uint32_t tag);
-static const char * lbrec_tag_to_str (uint32_t tag);
-static const struct cmos_entries * first_cmos_table_entry (void);
-static const struct cmos_entries *
-      next_cmos_table_entry (const struct cmos_entries *last);
-static const struct cmos_enums * first_cmos_table_enum (void);
-static const struct cmos_enums * next_cmos_table_enum
-      (const struct cmos_enums *last);
-static const struct lb_record * first_cmos_rec (uint32_t tag);
-static const struct lb_record * next_cmos_rec (const struct lb_record *last,
-                                               uint32_t tag);
-static void memory_print_fn (const struct lb_record *rec);
-static void mainboard_print_fn (const struct lb_record *rec);
-static void cmos_opt_table_print_fn (const struct lb_record *rec);
-static void print_option_record (const struct cmos_entries *cmos_entry);
-static void print_enum_record (const struct cmos_enums *cmos_enum);
-static void print_defaults_record (const struct cmos_defaults *cmos_defaults);
-static void print_unknown_record (const struct lb_record *cmos_item);
-static void option_checksum_print_fn (const struct lb_record *rec);
-static void string_print_fn (const struct lb_record *rec);
-static void uint64_to_hex_string (char str[], uint64_t n);
+typedef struct {
+	uint32_t tag;
+	const char *name;
+	const char *description;
+	const char *nofound_msg;
+	lbtable_print_fn_t print_fn;
+} lbtable_choice_t;
+
+typedef struct {
+	unsigned long start;	/* address of first byte of memory range */
+	unsigned long end;	/* address of last byte of memory range */
+} mem_range_t;
+
+static const struct lb_header *lbtable_scan(unsigned long start,
+					    unsigned long end,
+					    int *bad_header_count,
+					    int *bad_table_count);
+static 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";
+    "    This shows information about system memory.\n";
 
 static const char mainboard_desc[] =
-"    This shows information about your mainboard.\n";
+    "    This shows information about your mainboard.\n";
 
 static const char version_desc[] =
-"    This shows coreboot version information.\n";
+    "    This shows coreboot version information.\n";
 
 static const char extra_version_desc[] =
-"    This shows extra coreboot version information.\n";
+    "    This shows extra coreboot version information.\n";
 
-static const char build_desc[] =
-"    This shows coreboot build information.\n";
+static const char build_desc[] = "    This shows coreboot build information.\n";
 
 static const char compile_time_desc[] =
-"    This shows when coreboot was compiled.\n";
+    "    This shows when coreboot was compiled.\n";
 
-static const char compile_by_desc[] =
-"    This shows who compiled coreboot.\n";
+static const char compile_by_desc[] = "    This shows who compiled coreboot.\n";
 
 static const char compile_host_desc[] =
-"    This shows the name of the machine that compiled coreboot.\n";
+    "    This shows the name of the machine that compiled coreboot.\n";
 
 static const char compile_domain_desc[] =
-"    This shows the domain name of the machine that compiled coreboot.\n";
+    "    This shows the domain name of the machine that compiled coreboot.\n";
 
 static const char compiler_desc[] =
-"    This shows the name of the compiler used to build coreboot.\n";
+    "    This shows the name of the compiler used to build coreboot.\n";
 
 static const char linker_desc[] =
-"    This shows the name of the linker used to build coreboot.\n";
+    "    This shows the name of the linker used to build coreboot.\n";
 
 static const char assembler_desc[] =
-"    This shows the name of the assembler used to build coreboot.\n";
+    "    This shows the name of the assembler used to build coreboot.\n";
 
 static const char cmos_opt_table_desc[] =
-"    This does a low-level dump of the CMOS option table.  The table "
-"contains\n"
-"    information about the layout of the values that coreboot stores in\n"
-"    nonvolatile RAM.\n";
+    "    This does a low-level dump of the CMOS option table.  The table "
+    "contains\n"
+    "    information about the layout of the values that coreboot stores in\n"
+    "    nonvolatile RAM.\n";
 
 static const char option_checksum_desc[] =
-"    This shows the location of the CMOS checksum and the area over which it "
-"is\n"
-"    calculated.\n";
+    "    This shows the location of the CMOS checksum and the area over which it "
+    "is\n" "    calculated.\n";
 
 static const char generic_nofound_msg[] =
-"%s: Item %s not found in coreboot table.\n";
+    "%s: Item %s not found in coreboot table.\n";
 
 static const char nofound_msg_cmos_opt_table[] =
-"%s: Item %s not found in coreboot table.  Apparently, the "
-"coreboot installed on this system was built without specifying "
-"CONFIG_HAVE_OPTION_TABLE.\n";
+    "%s: Item %s not found in coreboot table.  Apparently, the "
+    "coreboot installed on this system was built without specifying "
+    "CONFIG_HAVE_OPTION_TABLE.\n";
 
 static const char nofound_msg_option_checksum[] =
-"%s: Item %s not found in coreboot table. Apparently, you are "
-"using coreboot v1.\n";
+    "%s: Item %s not found in coreboot table. Apparently, you are "
+    "using coreboot v1.\n";
 
 int fd;
 
@@ -160,63 +155,49 @@ int fd;
  * displayed using the -l option.
  */
 static const lbtable_choice_t lbtable_choices[NUM_LBTABLE_CHOICES] =
- { { LB_TAG_MEMORY,            "memory",
-     memory_desc,              generic_nofound_msg,
-     memory_print_fn
-   },
-   { LB_TAG_MAINBOARD,         "mainboard",
-     mainboard_desc,           generic_nofound_msg,
-     mainboard_print_fn
-   },
-   { LB_TAG_VERSION,           "version",
-     version_desc,             generic_nofound_msg,
-     string_print_fn
-   },
-   { LB_TAG_EXTRA_VERSION,     "extra_version",
-     extra_version_desc,       generic_nofound_msg,
-     string_print_fn
-   },
-   { LB_TAG_BUILD,             "build",
-     build_desc,               generic_nofound_msg,
-     string_print_fn
-   },
-   { LB_TAG_COMPILE_TIME,      "compile_time",
-     compile_time_desc,        generic_nofound_msg,
-     string_print_fn
-   },
-   { LB_TAG_COMPILE_BY,        "compile_by",
-     compile_by_desc,          generic_nofound_msg,
-     string_print_fn
-   },
-   { LB_TAG_COMPILE_HOST,      "compile_host",
-     compile_host_desc,        generic_nofound_msg,
-     string_print_fn
-   },
-   { LB_TAG_COMPILE_DOMAIN,    "compile_domain",
-     compile_domain_desc,      generic_nofound_msg,
-     string_print_fn
-   },
-   { LB_TAG_COMPILER,          "compiler",
-     compiler_desc,            generic_nofound_msg,
-     string_print_fn
-   },
-   { LB_TAG_LINKER,            "linker",
-     linker_desc,              generic_nofound_msg,
-     string_print_fn
-   },
-   { LB_TAG_ASSEMBLER,         "assembler",
-     assembler_desc,           generic_nofound_msg,
-     string_print_fn
-   },
-   { LB_TAG_CMOS_OPTION_TABLE, "cmos_opt_table",
-     cmos_opt_table_desc,      nofound_msg_cmos_opt_table,
-     cmos_opt_table_print_fn
-   },
-   { LB_TAG_OPTION_CHECKSUM, "option_checksum",
-     option_checksum_desc,     nofound_msg_option_checksum,
-     option_checksum_print_fn
-   }
- };
+    { {LB_TAG_MEMORY, "memory",
+       memory_desc, generic_nofound_msg,
+       memory_print_fn},
+{LB_TAG_MAINBOARD, "mainboard",
+ mainboard_desc, generic_nofound_msg,
+ mainboard_print_fn},
+{LB_TAG_VERSION, "version",
+ version_desc, generic_nofound_msg,
+ string_print_fn},
+{LB_TAG_EXTRA_VERSION, "extra_version",
+ extra_version_desc, generic_nofound_msg,
+ string_print_fn},
+{LB_TAG_BUILD, "build",
+ build_desc, generic_nofound_msg,
+ string_print_fn},
+{LB_TAG_COMPILE_TIME, "compile_time",
+ compile_time_desc, generic_nofound_msg,
+ string_print_fn},
+{LB_TAG_COMPILE_BY, "compile_by",
+ compile_by_desc, generic_nofound_msg,
+ string_print_fn},
+{LB_TAG_COMPILE_HOST, "compile_host",
+ compile_host_desc, generic_nofound_msg,
+ string_print_fn},
+{LB_TAG_COMPILE_DOMAIN, "compile_domain",
+ compile_domain_desc, generic_nofound_msg,
+ string_print_fn},
+{LB_TAG_COMPILER, "compiler",
+ compiler_desc, generic_nofound_msg,
+ string_print_fn},
+{LB_TAG_LINKER, "linker",
+ linker_desc, generic_nofound_msg,
+ string_print_fn},
+{LB_TAG_ASSEMBLER, "assembler",
+ assembler_desc, generic_nofound_msg,
+ string_print_fn},
+{LB_TAG_CMOS_OPTION_TABLE, "cmos_opt_table",
+ cmos_opt_table_desc, nofound_msg_cmos_opt_table,
+ cmos_opt_table_print_fn},
+{LB_TAG_OPTION_CHECKSUM, "option_checksum",
+ option_checksum_desc, nofound_msg_option_checksum,
+ option_checksum_print_fn}
+};
 
 /* The coreboot table resides in low physical memory, which we access using
  * /dev/mem.  These are ranges of physical memory that should be scanned for a
@@ -226,9 +207,9 @@ static const lbtable_choice_t lbtable_choices[NUM_LBTABLE_CHOICES] =
 #define NUM_MEM_RANGES 2
 
 static const mem_range_t mem_ranges[NUM_MEM_RANGES] =
- { { 0x00000000, 0x00000fff },
-   { 0x000f0000, 0x000fffff }
- };
+    { {0x00000000, 0x00000fff},
+{0x000f0000, 0x000fffff}
+};
 
 /* This is the number of bytes of physical memory to map, starting at physical
  * address 0.  This value must be large enough to contain all memory ranges
@@ -253,7 +234,7 @@ static const struct lb_header *lbtable = NULL;
 static const struct cmos_option_table *cmos_table = NULL;
 
 static const hexdump_format_t format =
- { 12, 4, "            ", " | ", " ", " | ", '.', NULL };
+    { 12, 4, "            ", " | ", " ", " | ", '.', NULL };
 
 /****************************************************************************
  * vtophys
@@ -282,56 +263,57 @@ static const hexdump_format_t format =
  *
  * Find the coreboot table and set global variable lbtable to point to it.
  ****************************************************************************/
-void get_lbtable (void)
- { int i, bad_header_count, bad_table_count, bad_headers, bad_tables;
-
-   if (lbtable != NULL)
-      return;
-
-   /* The coreboot table is located in low physical memory, which may be
-    * conveniently accessed by calling mmap() on /dev/mem.
-    */
-
-   if ((fd = open("/dev/mem", O_RDONLY, 0)) < 0)
-    { fprintf(stderr, "%s: Can not open /dev/mem for reading: %s\n",
-              prog_name, strerror(errno));
-      exit(1);
-    }
-
-   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);
- }
+void get_lbtable(void)
+{
+	int i, bad_header_count, bad_table_count, bad_headers, bad_tables;
+
+	if (lbtable != NULL)
+		return;
+
+	/* The coreboot table is located in low physical memory, which may be
+	 * conveniently accessed by calling mmap() on /dev/mem.
+	 */
+
+	if ((fd = open("/dev/mem", O_RDONLY, 0)) < 0) {
+		fprintf(stderr, "%s: Can not open /dev/mem for reading: %s\n",
+			prog_name, strerror(errno));
+		exit(1);
+	}
+
+	if ((low_phys_mem =
+	     mmap(NULL, BYTES_TO_MAP, PROT_READ, MAP_SHARED, fd, 0))
+	    == MAP_FAILED) {
+		fprintf(stderr, "%s: Failed to mmap /dev/mem: %s\n", prog_name,
+			strerror(errno));
+		exit(1);
+	}
+
+	bad_header_count = 0;
+	bad_table_count = 0;
+
+	for (i = 0; i < NUM_MEM_RANGES; i++) {
+		lbtable = lbtable_scan(phystov(mem_ranges[i].start),
+				       phystov(mem_ranges[i].end),
+				       &bad_headers, &bad_tables);
+
+		if (lbtable != NULL)
+			return;	/* success: we found it! */
+
+		bad_header_count += bad_headers;
+		bad_table_count += bad_tables;
+	}
+
+	fprintf(stderr,
+		"%s: coreboot table not found.  coreboot does not appear to\n"
+		"        be installed on this system.  Scanning for the table "
+		"produced the\n"
+		"        following results:\n\n"
+		"            %d valid signatures were found with bad header "
+		"checksums.\n"
+		"            %d valid headers were found with bad table "
+		"checksums.\n", prog_name, bad_header_count, bad_table_count);
+	exit(1);
+}
 
 /****************************************************************************
  * get_layout_from_cmos_table
@@ -339,84 +321,87 @@ void get_lbtable (void)
  * 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 CONFIG_HAVE_OPTION_TABLE.\n",
-              prog_name);
-      exit(1);
-    }
-
-   process_cmos_table();
-   get_cmos_checksum_info();
- }
+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 CONFIG_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");
-    }
- }
+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
@@ -424,48 +409,50 @@ void dump_lbtable (void)
  * List names and informational blurbs for items from the coreboot table
  * that may be displayed using the -l option.
  ****************************************************************************/
-void list_lbtable_choices (void)
- { int i;
+void list_lbtable_choices(void)
+{
+	int i;
 
-   for (i = 0; ; )
-    { printf("%s:\n%s",
-             lbtable_choices[i].name, lbtable_choices[i].description);
+	for (i = 0;;) {
+		printf("%s:\n%s",
+		       lbtable_choices[i].name, lbtable_choices[i].description);
 
-      if (++i >= NUM_LBTABLE_CHOICES)
-         break;
+		if (++i >= NUM_LBTABLE_CHOICES)
+			break;
 
-      printf("\n");
-    }
- }
+		printf("\n");
+	}
+}
 
 /****************************************************************************
  * list_lbtable_item
  *
  * Show the coreboot table item specified by 'item'.
  ****************************************************************************/
-void list_lbtable_item (const char item[])
- { int i;
-   const struct lb_record *rec;
-
-   for (i = 0; i < NUM_LBTABLE_CHOICES; i++)
-    { if (strcmp(item, lbtable_choices[i].name) == 0)
-         break;
-    }
-
-   if (i == NUM_LBTABLE_CHOICES)
-    { fprintf(stderr, "%s: Invalid coreboot table item %s.\n", prog_name,
-              item);
-      exit(1);
-    }
-
-   if ((rec = find_lbrec(lbtable_choices[i].tag)) == NULL)
-    { fprintf(stderr, lbtable_choices[i].nofound_msg, prog_name,
-              lbtable_choices[i].name);
-      exit(1);
-    }
-
-   lbtable_choices[i].print_fn(rec);
- }
+void list_lbtable_item(const char item[])
+{
+	int i;
+	const struct lb_record *rec;
+
+	for (i = 0; i < NUM_LBTABLE_CHOICES; i++) {
+		if (strcmp(item, lbtable_choices[i].name) == 0)
+			break;
+	}
+
+	if (i == NUM_LBTABLE_CHOICES) {
+		fprintf(stderr, "%s: Invalid coreboot table item %s.\n",
+			prog_name, item);
+		exit(1);
+	}
+
+	if ((rec = find_lbrec(lbtable_choices[i].tag)) == NULL) {
+		fprintf(stderr, lbtable_choices[i].nofound_msg, prog_name,
+			lbtable_choices[i].name);
+		exit(1);
+	}
+
+	lbtable_choices[i].print_fn(rec);
+}
 
 /****************************************************************************
  * lbtable_scan
@@ -491,77 +478,83 @@ void list_lbtable_item (const char item[])
  *         Indicates the number of times in which a header with a valid
  *         checksum was found but the table checksum was invalid.
  ****************************************************************************/
-static const struct lb_header * lbtable_scan (unsigned long start,
-                                              unsigned long end,
-                                              int *bad_header_count,
-                                              int *bad_table_count)
- { static const char signature[] = { 'L', 'B', 'I', 'O' };
-   const struct lb_header *table;
-   const struct lb_forward *forward;
-   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! */
-      /* But it may just be a forwarding table, so look if there's a forwarder */
-      lbtable = table;
-      forward = (struct lb_forward *)find_lbrec(LB_TAG_FORWARD);
-      lbtable = NULL;
-
-      if (forward) {
-        uint64_t new_phys = forward->forward;
-
-	new_phys &= ~(getpagesize()-1);
-	
-        munmap((void *)low_phys_mem, BYTES_TO_MAP);
-        if ((low_phys_mem = mmap(NULL, BYTES_TO_MAP, PROT_READ, MAP_SHARED, fd, (off_t)new_phys)) == MAP_FAILED)
-        { fprintf(stderr, "%s: Failed to mmap /dev/mem: %s\n", prog_name,
-              strerror(errno));
-          exit(1);
-        }
-	low_phys_base = new_phys;
-	table = lbtable_scan(phystov(low_phys_base), phystov(low_phys_base + BYTES_TO_MAP), bad_header_count, bad_table_count);
-      }
-      return table;
-    }
-
-   return NULL;
- }
+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 struct lb_forward *forward;
+	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! */
+		/* But it may just be a forwarding table, so look if there's a forwarder */
+		lbtable = table;
+		forward = (struct lb_forward *)find_lbrec(LB_TAG_FORWARD);
+		lbtable = NULL;
+
+		if (forward) {
+			uint64_t new_phys = forward->forward;
+
+			new_phys &= ~(getpagesize() - 1);
+
+			munmap((void *)low_phys_mem, BYTES_TO_MAP);
+			if ((low_phys_mem =
+			     mmap(NULL, BYTES_TO_MAP, PROT_READ, MAP_SHARED, fd,
+				  (off_t) new_phys)) == MAP_FAILED) {
+				fprintf(stderr,
+					"%s: Failed to mmap /dev/mem: %s\n",
+					prog_name, strerror(errno));
+				exit(1);
+			}
+			low_phys_base = new_phys;
+			table =
+			    lbtable_scan(phystov(low_phys_base),
+					 phystov(low_phys_base + BYTES_TO_MAP),
+					 bad_header_count, bad_table_count);
+		}
+		return table;
+	}
+
+	return NULL;
+}
 
 /****************************************************************************
  * process_cmos_table
@@ -569,119 +562,126 @@ static const struct lb_header * lbtable_scan (unsigned long start,
  * 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);
-    }
- }
+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;
- }
+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
@@ -690,60 +690,59 @@ static void get_cmos_checksum_info (void)
  * 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);
- }
+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
@@ -751,22 +750,23 @@ static void try_convert_checksum_layout (cmos_checksum_layout_t *layout)
  * 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;
+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;
+	case LAYOUT_DUPLICATE_ENUM:
+		fprintf(stderr, "%s: Duplicate enum %s found in CMOS option "
+			"table.\n", prog_name, cmos_enum->text);
+		break;
 
-      default:
-         BUG();
-    }
+	default:
+		BUG();
+	}
 
-   exit(1);
- }
+	exit(1);
+}
 
 /****************************************************************************
  * try_add_cmos_table_entry
@@ -774,44 +774,46 @@ static void try_add_cmos_table_enum (cmos_enum_t *cmos_enum)
  * Attempt to add a CMOS entry to our internal repository.  Exit with an
  * error message on failure.
  ****************************************************************************/
-static void try_add_cmos_table_entry (cmos_entry_t *cmos_entry)
- { const cmos_entry_t *conflict;
-
-   switch (add_cmos_entry(cmos_entry, &conflict))
-    { case OK:
-         return;
-
-      case CMOS_AREA_OUT_OF_RANGE:
-         fprintf(stderr,
-                 "%s: Bad CMOS option layout in CMOS option table entry "
-                 "%s.\n", prog_name, cmos_entry->name);
-         break;
-
-      case CMOS_AREA_TOO_WIDE:
-         fprintf(stderr,
-                 "%s: Area too wide for CMOS option table entry %s.\n",
-                 prog_name, cmos_entry->name);
-         break;
-
-      case LAYOUT_ENTRY_OVERLAP:
-         fprintf(stderr,
-                 "%s: CMOS option table entries %s and %s have overlapping "
-                 "layouts.\n", prog_name, cmos_entry->name, conflict->name);
-         break;
-
-      case LAYOUT_ENTRY_BAD_LENGTH:
-         /* Silently ignore entries with zero length.  Although this should
-          * never happen in practice, we should handle the case in a
-          * reasonable manner just to be safe.
-          */
-         return;
-
-      default:
-         BUG();
-    }
-
-   exit(1);
- }
+static 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
@@ -819,24 +821,25 @@ static void try_add_cmos_table_entry (cmos_entry_t *cmos_entry)
  * Find the record in the coreboot table that matches 'tag'.  Return pointer
  * to record on success or NULL if record not found.
  ****************************************************************************/
-static const struct lb_record * find_lbrec (uint32_t tag)
- { const char *p;
-   uint32_t bytes_processed;
-   const struct lb_record *lbrec;
+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;
+	p = ((const char *)lbtable) + lbtable->header_bytes;
 
-   for (bytes_processed = 0;
-        bytes_processed < lbtable->table_bytes;
-        bytes_processed += lbrec->size)
-    { lbrec = (const struct lb_record *) &p[bytes_processed];
+	for (bytes_processed = 0;
+	     bytes_processed < lbtable->table_bytes;
+	     bytes_processed += lbrec->size) {
+		lbrec = (const struct lb_record *)&p[bytes_processed];
 
-      if (lbrec->tag == tag)
-         return lbrec;
-    }
+		if (lbrec->tag == tag)
+			return lbrec;
+	}
 
-   return NULL;
- }
+	return NULL;
+}
 
 /****************************************************************************
  * lbrec_tag_to_str
@@ -844,71 +847,72 @@ static const struct lb_record * find_lbrec (uint32_t tag)
  * Return a pointer to the string representation of the given coreboot table
  * tag.
  ****************************************************************************/
-static const char * lbrec_tag_to_str (uint32_t tag)
- { switch (tag)
-    { case LB_TAG_UNUSED:
-         return "UNUSED";
+static const char *lbrec_tag_to_str(uint32_t tag)
+{
+	switch (tag) {
+	case LB_TAG_UNUSED:
+		return "UNUSED";
 
-      case LB_TAG_MEMORY:
-         return "MEMORY";
+	case LB_TAG_MEMORY:
+		return "MEMORY";
 
-      case LB_TAG_HWRPB:
-         return "HWRPB";
+	case LB_TAG_HWRPB:
+		return "HWRPB";
 
-      case LB_TAG_MAINBOARD:
-         return "MAINBOARD";
+	case LB_TAG_MAINBOARD:
+		return "MAINBOARD";
 
-      case LB_TAG_VERSION:
-         return "VERSION";
+	case LB_TAG_VERSION:
+		return "VERSION";
 
-      case LB_TAG_EXTRA_VERSION:
-         return "EXTRA_VERSION";
+	case LB_TAG_EXTRA_VERSION:
+		return "EXTRA_VERSION";
 
-      case LB_TAG_BUILD:
-         return "BUILD";
+	case LB_TAG_BUILD:
+		return "BUILD";
 
-      case LB_TAG_COMPILE_TIME:
-         return "COMPILE_TIME";
+	case LB_TAG_COMPILE_TIME:
+		return "COMPILE_TIME";
 
-      case LB_TAG_COMPILE_BY:
-         return "COMPILE_BY";
+	case LB_TAG_COMPILE_BY:
+		return "COMPILE_BY";
 
-      case LB_TAG_COMPILE_HOST:
-         return "COMPILE_HOST";
+	case LB_TAG_COMPILE_HOST:
+		return "COMPILE_HOST";
 
-      case LB_TAG_COMPILE_DOMAIN:
-         return "COMPILE_DOMAIN";
+	case LB_TAG_COMPILE_DOMAIN:
+		return "COMPILE_DOMAIN";
 
-      case LB_TAG_COMPILER:
-         return "COMPILER";
+	case LB_TAG_COMPILER:
+		return "COMPILER";
 
-      case LB_TAG_LINKER:
-         return "LINKER";
+	case LB_TAG_LINKER:
+		return "LINKER";
 
-      case LB_TAG_ASSEMBLER:
-         return "ASSEMBLER";
+	case LB_TAG_ASSEMBLER:
+		return "ASSEMBLER";
 
-      case LB_TAG_SERIAL:
-         return "SERIAL";
+	case LB_TAG_SERIAL:
+		return "SERIAL";
 
-      case LB_TAG_CONSOLE:
-	 return "CONSOLE";
+	case LB_TAG_CONSOLE:
+		return "CONSOLE";
 
-      case LB_TAG_FORWARD:
-	 return "FORWARD";
+	case LB_TAG_FORWARD:
+		return "FORWARD";
 
-      case LB_TAG_CMOS_OPTION_TABLE:
-         return "CMOS_OPTION_TABLE";
+	case LB_TAG_CMOS_OPTION_TABLE:
+		return "CMOS_OPTION_TABLE";
 
-      case LB_TAG_OPTION_CHECKSUM:
-         return "OPTION_CHECKSUM";
+	case LB_TAG_OPTION_CHECKSUM:
+		return "OPTION_CHECKSUM";
 
-      default:
-         break;
-    }
+	default:
+		break;
+	}
 
-   return "UNKNOWN";
- }
+	return "UNKNOWN";
+}
 
 /****************************************************************************
  * first_cmos_table_entry
@@ -916,8 +920,10 @@ static const char * lbrec_tag_to_str (uint32_t tag)
  * 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); }
+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
@@ -925,11 +931,12 @@ static const struct cmos_entries * first_cmos_table_entry (void)
  * 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);
- }
+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
@@ -938,8 +945,10 @@ static const struct cmos_entries *
  * 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); }
+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
@@ -948,11 +957,11 @@ static const struct cmos_enums * first_cmos_table_enum (void)
  * 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);
- }
+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
@@ -970,25 +979,26 @@ static const struct cmos_enums * next_cmos_table_enum
  * 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;
+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;
+	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];
+	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;
-    }
+		if (lbrec->tag == tag)
+			return lbrec;
+	}
 
-   return NULL;
- }
+	return NULL;
+}
 
 /****************************************************************************
  * next_cmos_rec
@@ -997,279 +1007,290 @@ static const struct lb_record * first_cmos_rec (uint32_t tag)
  * 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;
+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;
+	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];
+	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;
-    }
+		if (lbrec->tag == tag)
+			return lbrec;
+	}
 
-   return NULL;
- }
+	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");
-    }
- }
+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;
+static void mainboard_print_fn(const struct lb_record *rec)
+{
+	const struct lb_mainboard *p;
 
-   p = (const struct lb_mainboard *) rec;
-   printf("Vendor:      %s\n"
-          "Part number: %s\n",
-          &p->strings[p->vendor_idx],
-          &p->strings[p->part_number_idx]);
- }
+	p = (const struct lb_mainboard *)rec;
+	printf("Vendor:      %s\n"
+	       "Part number: %s\n",
+	       &p->strings[p->vendor_idx], &p->strings[p->part_number_idx]);
+}
 
 /****************************************************************************
  * cmos_opt_table_print_fn
  *
  * Display function for 'cmos_opt_table' item of coreboot table.
  ****************************************************************************/
-static void cmos_opt_table_print_fn (const struct lb_record *rec)
- {
-   const struct cmos_option_table *p;
-   const struct lb_record *cmos_item;
-   uint32_t bytes_processed, bytes_for_entries;
-   const char *q;
-
-   p = (const struct cmos_option_table *) rec;
-   q = ((const char *) p) + p->header_length;
-   bytes_for_entries = p->size - p->header_length;
-
-   printf("CMOS option table at physical address 0x%lx:\n"
-          "    tag:           0x%x (decimal: %d)\n"
-          "    size:          0x%x (decimal: %d)\n"
-          "    header_length: 0x%x (decimal: %d)\n\n",
-          vtophys(p), p->tag, p->tag, p->size, p->size, p->header_length,
-          p->header_length);
-
-   if (p->header_length > p->size)
-    { printf("Header length for CMOS option table is greater than the size "
-             "of the entire table including header!!!\n");
-      return;
-    }
-
-   if (bytes_for_entries == 0)
-    { printf("The CMOS option table is empty!!!\n");
-      return;
-    }
-
-   for (bytes_processed = 0; ; )
-    { cmos_item = (const struct lb_record *) &q[bytes_processed];
-
-      switch (cmos_item->tag)
-       { case LB_TAG_OPTION:
-            print_option_record((const struct cmos_entries *) cmos_item);
-            break;
-
-         case LB_TAG_OPTION_ENUM:
-            print_enum_record((const struct cmos_enums *) cmos_item);
-            break;
-
-         case LB_TAG_OPTION_DEFAULTS:
-            print_defaults_record((const struct cmos_defaults *) cmos_item);
-            break;
-
-         default:
-            print_unknown_record(cmos_item);
-            break;
-       }
-
-      bytes_processed += cmos_item->size;
-
-      if (bytes_processed >= bytes_for_entries)
-         break;
-
-      printf("\n");
-    }
- }
+static void cmos_opt_table_print_fn(const struct lb_record *rec)
+{
+	const struct cmos_option_table *p;
+	const struct lb_record *cmos_item;
+	uint32_t bytes_processed, bytes_for_entries;
+	const char *q;
+
+	p = (const struct cmos_option_table *)rec;
+	q = ((const char *)p) + p->header_length;
+	bytes_for_entries = p->size - p->header_length;
+
+	printf("CMOS option table at physical address 0x%lx:\n"
+	       "    tag:           0x%x (decimal: %d)\n"
+	       "    size:          0x%x (decimal: %d)\n"
+	       "    header_length: 0x%x (decimal: %d)\n\n",
+	       vtophys(p), p->tag, p->tag, p->size, p->size, p->header_length,
+	       p->header_length);
+
+	if (p->header_length > p->size) {
+		printf
+		    ("Header length for CMOS option table is greater than the size "
+		     "of the entire table including header!!!\n");
+		return;
+	}
+
+	if (bytes_for_entries == 0) {
+		printf("The CMOS option table is empty!!!\n");
+		return;
+	}
+
+	for (bytes_processed = 0;;) {
+		cmos_item = (const struct lb_record *)&q[bytes_processed];
+
+		switch (cmos_item->tag) {
+		case LB_TAG_OPTION:
+			print_option_record((const struct cmos_entries *)
+					    cmos_item);
+			break;
+
+		case LB_TAG_OPTION_ENUM:
+			print_enum_record((const struct cmos_enums *)cmos_item);
+			break;
+
+		case LB_TAG_OPTION_DEFAULTS:
+			print_defaults_record((const struct cmos_defaults *)
+					      cmos_item);
+			break;
+
+		default:
+			print_unknown_record(cmos_item);
+			break;
+		}
+
+		bytes_processed += cmos_item->size;
+
+		if (bytes_processed >= bytes_for_entries)
+			break;
+
+		printf("\n");
+	}
+}
 
 /****************************************************************************
  * print_option_record
  *
  * Display "option" record from CMOS option table.
  ****************************************************************************/
-static void print_option_record (const struct cmos_entries *cmos_entry)
- { static const size_t S_BUFSIZE = 80;
-   char s[S_BUFSIZE];
-
-   switch (cmos_entry->config)
-    { case 'e':
-         strcpy(s, "ENUM");
-         break;
-
-      case 'h':
-         strcpy(s, "HEX");
-         break;
-
-      case 'r':
-         strcpy(s, "RESERVED");
-         break;
-
-      default:
-         snprintf(s, S_BUFSIZE, "UNKNOWN: value is 0x%x (decimal: %d)",
-                  cmos_entry->config, cmos_entry->config);
-         break;
-    }
-
-   printf("    OPTION record at physical address 0x%lx:\n"
-          "        tag:       0x%x (decimal: %d)\n"
-          "        size:      0x%x (decimal: %d)\n"
-          "        bit:       0x%x (decimal: %d)\n"
-          "        length:    0x%x (decimal: %d)\n"
-          "        config:    %s\n"
-          "        config_id: 0x%x (decimal: %d)\n"
-          "        name:      %s\n",
-          vtophys(cmos_entry), cmos_entry->tag, cmos_entry->tag,
-          cmos_entry->size, cmos_entry->size, cmos_entry->bit,
-          cmos_entry->bit, cmos_entry->length, cmos_entry->length, s,
-          cmos_entry->config_id, cmos_entry->config_id, cmos_entry->name);
- }
+static void print_option_record(const struct cmos_entries *cmos_entry)
+{
+	static const size_t S_BUFSIZE = 80;
+	char s[S_BUFSIZE];
+
+	switch (cmos_entry->config) {
+	case 'e':
+		strcpy(s, "ENUM");
+		break;
+
+	case 'h':
+		strcpy(s, "HEX");
+		break;
+
+	case 'r':
+		strcpy(s, "RESERVED");
+		break;
+
+	default:
+		snprintf(s, S_BUFSIZE, "UNKNOWN: value is 0x%x (decimal: %d)",
+			 cmos_entry->config, cmos_entry->config);
+		break;
+	}
+
+	printf("    OPTION record at physical address 0x%lx:\n"
+	       "        tag:       0x%x (decimal: %d)\n"
+	       "        size:      0x%x (decimal: %d)\n"
+	       "        bit:       0x%x (decimal: %d)\n"
+	       "        length:    0x%x (decimal: %d)\n"
+	       "        config:    %s\n"
+	       "        config_id: 0x%x (decimal: %d)\n"
+	       "        name:      %s\n",
+	       vtophys(cmos_entry), cmos_entry->tag, cmos_entry->tag,
+	       cmos_entry->size, cmos_entry->size, cmos_entry->bit,
+	       cmos_entry->bit, cmos_entry->length, cmos_entry->length, s,
+	       cmos_entry->config_id, cmos_entry->config_id, cmos_entry->name);
+}
 
 /****************************************************************************
  * print_enum_record
  *
  * Display "enum" record from CMOS option table.
  ****************************************************************************/
-static void print_enum_record (const struct cmos_enums *cmos_enum)
- { printf("    ENUM record at physical address 0x%lx:\n"
-          "        tag:       0x%x (decimal: %d)\n"
-          "        size:      0x%x (decimal: %d)\n"
-          "        config_id: 0x%x (decimal: %d)\n"
-          "        value:     0x%x (decimal: %d)\n"
-          "        text:      %s\n",
-          vtophys(cmos_enum), cmos_enum->tag, cmos_enum->tag, cmos_enum->size,
-          cmos_enum->size, cmos_enum->config_id, cmos_enum->config_id,
-          cmos_enum->value, cmos_enum->value, cmos_enum->text);
- }
+static void print_enum_record(const struct cmos_enums *cmos_enum)
+{
+	printf("    ENUM record at physical address 0x%lx:\n"
+	       "        tag:       0x%x (decimal: %d)\n"
+	       "        size:      0x%x (decimal: %d)\n"
+	       "        config_id: 0x%x (decimal: %d)\n"
+	       "        value:     0x%x (decimal: %d)\n"
+	       "        text:      %s\n",
+	       vtophys(cmos_enum), cmos_enum->tag, cmos_enum->tag,
+	       cmos_enum->size, cmos_enum->size, cmos_enum->config_id,
+	       cmos_enum->config_id, cmos_enum->value, cmos_enum->value,
+	       cmos_enum->text);
+}
 
 /****************************************************************************
  * print_defaults_record
  *
  * Display "defaults" record from CMOS option table.
  ****************************************************************************/
-static void print_defaults_record (const struct cmos_defaults *cmos_defaults)
- { printf("    DEFAULTS record at physical address 0x%lx:\n"
-          "        tag:         0x%x (decimal: %d)\n"
-          "        size:        0x%x (decimal: %d)\n"
-          "        name_length: 0x%x (decimal: %d)\n"
-          "        name:        %s\n"
-          "        default_set:\n",
-          vtophys(cmos_defaults), cmos_defaults->tag, cmos_defaults->tag,
-          cmos_defaults->size, cmos_defaults->size,
-          cmos_defaults->name_length, cmos_defaults->name_length,
-          cmos_defaults->name);
-   hexdump(cmos_defaults->default_set, CMOS_IMAGE_BUFFER_SIZE,
-           vtophys(cmos_defaults->default_set), stdout, &format);
- }
+static void print_defaults_record(const struct cmos_defaults *cmos_defaults)
+{
+	printf("    DEFAULTS record at physical address 0x%lx:\n"
+	       "        tag:         0x%x (decimal: %d)\n"
+	       "        size:        0x%x (decimal: %d)\n"
+	       "        name_length: 0x%x (decimal: %d)\n"
+	       "        name:        %s\n"
+	       "        default_set:\n",
+	       vtophys(cmos_defaults), cmos_defaults->tag, cmos_defaults->tag,
+	       cmos_defaults->size, cmos_defaults->size,
+	       cmos_defaults->name_length, cmos_defaults->name_length,
+	       cmos_defaults->name);
+	hexdump(cmos_defaults->default_set, CMOS_IMAGE_BUFFER_SIZE,
+		vtophys(cmos_defaults->default_set), stdout, &format);
+}
 
 /****************************************************************************
  * print_unknown_record
  *
  * Display record of unknown type from CMOS option table.
  ****************************************************************************/
-static void print_unknown_record (const struct lb_record *cmos_item)
- { const char *data;
-
-   printf("    UNKNOWN record at physical address 0x%lx:\n"
-          "        tag:  0x%x (decimal: %d)\n"
-          "        size: 0x%x (decimal: %d)\n"
-          "        data:\n",
-          vtophys(cmos_item), cmos_item->tag, cmos_item->tag,
-          cmos_item->size, cmos_item->size);
-   data = ((const char *) cmos_item) + sizeof(*cmos_item);
-   hexdump(data, cmos_item->size - sizeof(*cmos_item), vtophys(data), stdout,
-           &format);
- }
+static void print_unknown_record(const struct lb_record *cmos_item)
+{
+	const char *data;
+
+	printf("    UNKNOWN record at physical address 0x%lx:\n"
+	       "        tag:  0x%x (decimal: %d)\n"
+	       "        size: 0x%x (decimal: %d)\n"
+	       "        data:\n",
+	       vtophys(cmos_item), cmos_item->tag, cmos_item->tag,
+	       cmos_item->size, cmos_item->size);
+	data = ((const char *)cmos_item) + sizeof(*cmos_item);
+	hexdump(data, cmos_item->size - sizeof(*cmos_item), vtophys(data),
+		stdout, &format);
+}
 
 /****************************************************************************
  * option_checksum_print_fn
  *
  * Display function for 'option_checksum' item of coreboot table.
  ****************************************************************************/
-static void option_checksum_print_fn (const struct lb_record *rec)
- { struct cmos_checksum *p;
+static void option_checksum_print_fn(const struct lb_record *rec)
+{
+	struct cmos_checksum *p;
 
-   p = (struct cmos_checksum *) rec;
-   printf("CMOS checksum from bit %d to bit %d\n"
-          "at position %d is type %s.\n",
-          p->range_start, p->range_end, p->location,
-          (p->type == CHECKSUM_PCBIOS) ? "PC BIOS" : "NONE");
- }
+	p = (struct cmos_checksum *)rec;
+	printf("CMOS checksum from bit %d to bit %d\n"
+	       "at position %d is type %s.\n",
+	       p->range_start, p->range_end, p->location,
+	       (p->type == CHECKSUM_PCBIOS) ? "PC BIOS" : "NONE");
+}
 
 /****************************************************************************
  * string_print_fn
@@ -1277,12 +1298,13 @@ static void option_checksum_print_fn (const struct lb_record *rec)
  * Display function for a generic item of coreboot table that simply
  * consists of a string.
  ****************************************************************************/
-static void string_print_fn (const struct lb_record *rec)
- { const struct lb_string *p;
+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);
- }
+	p = (const struct lb_string *)rec;
+	printf("%s\n", p->string);
+}
 
 /****************************************************************************
  * uint64_to_hex_string
@@ -1293,14 +1315,15 @@ static void string_print_fn (const struct lb_record *rec)
  * 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);
- }
+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);
+}
diff --git a/util/nvramtool/lbtable.h b/util/nvramtool/lbtable.h
index b803263..5587bd8 100644
--- a/util/nvramtool/lbtable.h
+++ b/util/nvramtool/lbtable.h
@@ -33,10 +33,10 @@
 
 #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[]);
+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 */
+#endif				/* LBTABLE_H */
diff --git a/util/nvramtool/nvramtool.c b/util/nvramtool/nvramtool.c
index 86ada99..f26ca97 100644
--- a/util/nvramtool/nvramtool.c
+++ b/util/nvramtool/nvramtool.c
@@ -41,74 +41,72 @@
 
 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 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 };
+    { 16, 2, "", " | ", " ", " | ", '.', NULL };
 
 /****************************************************************************
  * main
  ****************************************************************************/
-int main (int argc, char *argv[])
- { cmos_layout_get_fn_t fn;
+int main(int argc, char *argv[])
+{
+	cmos_layout_get_fn_t fn;
 
-   parse_nvramtool_args(argc, argv);
+	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;
+	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;
- }
+	register_cmos_layout_get_fn(fn);
+	op_fns[nvramtool_op.op] ();
+	return 0;
+}
 
 /****************************************************************************
  * op_show_version
@@ -117,8 +115,10 @@ int main (int argc, char *argv[])
  *
  * Show version information for this program.
  ****************************************************************************/
-static void op_show_version (void)
- { printf("This is %s version %s.\n", prog_name, prog_version); }
+static void op_show_version(void)
+{
+	printf("This is %s version %s.\n", prog_name, prog_version);
+}
 
 /****************************************************************************
  * op_show_usage
@@ -127,8 +127,10 @@ static void op_show_version (void)
  *
  * Show a usage message for this program.
  ****************************************************************************/
-static void op_show_usage (void)
- { usage(stdout); }
+static void op_show_usage(void)
+{
+	usage(stdout);
+}
 
 /****************************************************************************
  * op_lbtable_show_info
@@ -138,14 +140,15 @@ static void op_show_usage (void)
  * 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);
-    }
- }
+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
@@ -154,10 +157,11 @@ static void op_lbtable_show_info (void)
  *
  * Do low-level dump of coreboot table.
  ****************************************************************************/
-static void op_lbtable_dump (void)
- { get_lbtable();
-   dump_lbtable();
- }
+static void op_lbtable_dump(void)
+{
+	get_lbtable();
+	dump_lbtable();
+}
 
 /****************************************************************************
  * op_show_param_values
@@ -166,10 +170,11 @@ static void op_lbtable_dump (void)
  *
  * Show all possible values for parameter NAME.
  ****************************************************************************/
-static void op_show_param_values (void)
- { get_cmos_layout();
-   list_param_enums(nvramtool_op.param);
- }
+static void op_show_param_values(void)
+{
+	get_cmos_layout();
+	list_param_enums(nvramtool_op.param);
+}
 
 /****************************************************************************
  * op_cmos_show_one_param
@@ -179,17 +184,19 @@ static void op_show_param_values (void)
  * 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;
+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();
+	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);
- }
+	if (result)
+		exit(1);
+}
 
 /****************************************************************************
  * op_cmos_show_all_params
@@ -198,16 +205,17 @@ static void op_cmos_show_one_param (void)
  *
  * Show names and values for all parameters.
  ****************************************************************************/
-static void op_cmos_show_all_params (void)
- { int result;
+static void op_cmos_show_all_params(void)
+{
+	int result;
 
-   get_cmos_layout();
-   result = list_all_params();
-   cmos_checksum_verify();
+	get_cmos_layout();
+	result = list_all_params();
+	cmos_checksum_verify();
 
-   if (result)
-      exit(1);
- }
+	if (result)
+		exit(1);
+}
 
 /****************************************************************************
  * op_cmos_set_one_param
@@ -216,18 +224,19 @@ static void op_cmos_show_all_params (void)
  *
  * Set parameter NAME to VALUE.
  ****************************************************************************/
-static void op_cmos_set_one_param (void)
- { const char *name, *value;
+static void op_cmos_set_one_param(void)
+{
+	const char *name, *value;
 
-   get_cmos_layout();
+	get_cmos_layout();
 
-   /* Separate 'NAME=VALUE' syntax into two strings representing NAME and
-    * VALUE.
-    */
-   parse_assignment(nvramtool_op.param, &name, &value);
+	/* Separate 'NAME=VALUE' syntax into two strings representing NAME and
+	 * VALUE.
+	 */
+	parse_assignment(nvramtool_op.param, &name, &value);
 
-   set_one_param(name, value);
- }
+	set_one_param(name, value);
+}
 
 /****************************************************************************
  * op_cmos_set_params_stdin
@@ -236,10 +245,11 @@ static void op_cmos_set_one_param (void)
  *
  * Set parameters according to standard input.
  ****************************************************************************/
-static void op_cmos_set_params_stdin (void)
- { get_cmos_layout();
-   set_params(stdin);
- }
+static void op_cmos_set_params_stdin(void)
+{
+	get_cmos_layout();
+	set_params(stdin);
+}
 
 /****************************************************************************
  * op_cmos_set_params_file
@@ -248,19 +258,20 @@ static void op_cmos_set_params_stdin (void)
  *
  * Set parameters according to INPUT_FILE.
  ****************************************************************************/
-static void op_cmos_set_params_file (void)
- { FILE *f;
+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);
-    }
+	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);
- }
+	get_cmos_layout();
+	set_params(f);
+	fclose(f);
+}
 
 /****************************************************************************
  * op_cmos_checksum
@@ -270,24 +281,24 @@ static void op_cmos_set_params_file (void)
  * 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);
-    }
- }
+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
@@ -296,10 +307,11 @@ static void op_cmos_checksum (void)
  *
  * Write CMOS layout information to standard output.
  ****************************************************************************/
-static void op_show_layout (void)
- { get_cmos_layout();
-   write_cmos_layout(stdout);
- }
+static void op_show_layout(void)
+{
+	get_cmos_layout();
+	write_cmos_layout(stdout);
+}
 
 /****************************************************************************
  * op_write_cmos_dump
@@ -308,28 +320,29 @@ static void op_show_layout (void)
  *
  * 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);
- }
+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
@@ -338,29 +351,31 @@ static void op_write_cmos_dump (void)
  *
  * 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);
- }
+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
@@ -369,14 +384,15 @@ static void op_read_cmos_dump (void)
  *
  * Write a hex dump of CMOS memory to standard output.
  ****************************************************************************/
-static void op_show_cmos_hex_dump (void)
- { unsigned char data[CMOS_SIZE];
+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);
- }
+	set_iopl(3);
+	cmos_read_all(data);
+	set_iopl(0);
+	hexdump(data, CMOS_SIZE, 0, stdout, &cmos_dump_format);
+}
 
 /****************************************************************************
  * op_show_cmos_dumpfile
@@ -386,21 +402,22 @@ static void op_show_cmos_hex_dump (void)
  * 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);
- }
+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
@@ -409,21 +426,24 @@ static void op_show_cmos_dumpfile (void)
  * 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;
+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 (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);
-    }
+	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);
- }
+	return (list_cmos_entry(e, show_name) != 0);
+}
 
 /****************************************************************************
  * list_all_params
@@ -431,64 +451,67 @@ static int list_one_param (const char name[], int show_name)
  * 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;
+static int list_all_params(void)
+{
+	const cmos_entry_t *e;
+	int result;
 
-   result = OK;
+	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;
+	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;
-    }
+		if (list_cmos_entry(e, TRUE))
+			result = 1;
+	}
 
-   return result;
- }
+	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();
-    }
- }
+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
@@ -500,102 +523,107 @@ static void list_param_enums (const char name[])
  * 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);
- }
+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));
- }
+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
@@ -606,31 +634,31 @@ static void set_params (FILE *f)
  * 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);
- }
+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
@@ -640,90 +668,96 @@ static void parse_assignment (char arg[], const char **name,
  * 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;
- }
+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
@@ -733,36 +767,40 @@ static int list_cmos_entry (const cmos_entry_t *e, int show_name)
  * 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;
- }
+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;
+}
diff --git a/util/nvramtool/opts.c b/util/nvramtool/opts.c
index 4ebe1e4..44a19c9 100644
--- a/util/nvramtool/opts.c
+++ b/util/nvramtool/opts.c
@@ -35,11 +35,11 @@ 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 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";
 
@@ -48,143 +48,158 @@ static const char getopt_string[] = "-ab:B:c::de:hil::np:r:tvw:xX:y:Y";
  *
  * 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();
- }
+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;
+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 (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;
+	if ((argv[optind] == NULL) || (argv[optind][0] == '-'))
+		return NULL;
 
-   arg = argv[optind];  /* optional arg is present */
+	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);
+	/* This call to getopt yields the optional arg we just found,
+	 * which we want to skip.
+	 */
+	getopt(argc, argv, getopt_string);
 
-   return arg;
- }
+	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);
+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;
- }
+	*op_found = TRUE;
+	nvramtool_op.op = op;
+	nvramtool_op.param = op_param;
+}
 
 /****************************************************************************
  * register_op_modifier
@@ -192,15 +207,16 @@ static void register_op (int *op_found, nvramtool_op_t op, char op_param[])
  * 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;
+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;
- }
+	mod_info = &nvramtool_op_modifiers[mod];
+	mod_info->found = TRUE;
+	mod_info->found_seq = ++found_seq;
+	mod_info->param = mod_param;
+}
 
 /****************************************************************************
  * resolve_op_modifiers
@@ -208,24 +224,28 @@ static void register_op_modifier (nvramtool_op_modifier_t mod, char mod_param[])
  * 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;
-    }
- }
+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);
- }
+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);
+}
diff --git a/util/nvramtool/opts.h b/util/nvramtool/opts.h
index a1ad230..659b3d8 100644
--- a/util/nvramtool/opts.h
+++ b/util/nvramtool/opts.h
@@ -33,51 +33,45 @@
 
 #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 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 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 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;
+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[]);
+void parse_nvramtool_args(int argc, char *argv[]);
 
-#endif  /* OPTS_H */
+#endif				/* OPTS_H */
diff --git a/util/nvramtool/reg_expr.c b/util/nvramtool/reg_expr.c
index 0f9ff46..e737504 100644
--- a/util/nvramtool/reg_expr.c
+++ b/util/nvramtool/reg_expr.c
@@ -37,44 +37,46 @@
  *
  * 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;
+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);
+	va_start(ap, num_exprs);
 
-   for (i = 0; i < num_exprs; i++)
-    { expr = va_arg(ap, const char *);
-      reg  = va_arg(ap, regex_t *);
+	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);
-       }
-    }
+		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);
- }
+	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;
+void free_reg_exprs(int num_exprs, /* regex_t *reg1, */ ...)
+{
+	va_list ap;
+	int i;
 
-   va_start(ap, num_exprs);
+	va_start(ap, num_exprs);
 
-   for (i = 0; i < num_exprs; i++)
-      regfree(va_arg(ap, regex_t *));
+	for (i = 0; i < num_exprs; i++)
+		regfree(va_arg(ap, regex_t *));
 
-   va_end(ap);
- }
+	va_end(ap);
+}
diff --git a/util/nvramtool/reg_expr.h b/util/nvramtool/reg_expr.h
index 925137b..1b1657f 100644
--- a/util/nvramtool/reg_expr.h
+++ b/util/nvramtool/reg_expr.h
@@ -34,8 +34,8 @@
 #include <regex.h>
 #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, */ ...);
+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 */
+#endif				/* REG_EXPR_H */