Refactor async console output

This adds a 'ch' command which prints/sets which channels are active

This handles all the async output; the remaining debug commands will
be refactored to use ccprintf() / ccputs() in a followup CL.

Signed-off-by: Randall Spangler <rspangler@chromium.org>

BUG=chrome-os-partner:7464
TEST=manual

ch --> all channels active
ch 0x100 -> just port80 active
powerbtn -> system boots; only port 80 codes shown on console

Change-Id: I9efc43acec919b62b78c2c82c61946d32380adfe

11 files changed, 704 insertions, 571 deletions

diff --git a/common/charge_state.c b/common/charge_state.c
index c17df6e97e..a47bb2f23d 100644
--- a/common/charge_state.c
+++ b/common/charge_state.c
@@ -20,10 +20,13 @@
 #include "smart_battery.h"
 #include "system.h"
 #include "timer.h"
-#include "uart.h"
 #include "util.h"
 #include "x86_power.h"
 
+/* Console output macros */
+#define CPUTS(outstr) cputs(CC_CHARGER, outstr)
+#define CPRINTF(format, args...) cprintf(CC_CHARGER, format, ## args)
+
 /* Stop charge when state of charge reaches this percentage */
 #define STOP_CHARGE_THRESHOLD 100
 
@@ -414,7 +417,7 @@ static enum power_state state_error(struct power_state_context *ctx)
 
 	/* Debug output */
 	if (ctx->curr.error != logged_error) {
-		uart_printf("[Charge error: flag[%08b -> %08b], ac %d, "
+		CPRINTF("[Charge error: flag[%08b -> %08b], ac %d, "
 			" charger %s, battery %s\n",
 			logged_error, ctx->curr.error, ctx->curr.ac,
 			(ctx->curr.error & F_CHARGER_MASK) ?
@@ -439,7 +442,7 @@ static void charging_progress(struct power_state_context *ctx)
 		else
 			battery_time_to_empty(&minutes);
 
-		uart_printf("[Battery %3d%% / %dh:%d]\n",
+		CPRINTF("[Battery %3d%% / %dh:%d]\n",
 			ctx->curr.batt.state_of_charge,
 			minutes / 60, minutes % 60);
 		return;
@@ -455,7 +458,7 @@ static void charging_progress(struct power_state_context *ctx)
 		seconds = (int)(get_time().val -
 				ctx->trickle_charging_time.val) / (int)SECOND;
 		minutes = seconds / 60;
-		uart_printf("[Precharge CHG(%dmV) BATT(%dmV %dmA) "
+		CPRINTF("[Precharge CHG(%dmV) BATT(%dmV %dmA) "
 			"%dh:%d]\n", ctx->curr.charging_voltage,
 			ctx->curr.batt.voltage, ctx->curr.batt.current,
 			minutes / 60, minutes % 60);
@@ -508,15 +511,15 @@ void charge_state_machine_task(void)
 			new_state = state_error(&ctx);
 			break;
 		default:
-			uart_printf("[Undefined charging state %d]\n",
-					ctx.curr.state);
+			CPRINTF("[Undefined charging state %d]\n",
+				ctx.curr.state);
 			ctx.curr.state = PWR_STATE_ERROR;
 			new_state = PWR_STATE_ERROR;
 		}
 
 		if (new_state) {
 			ctx.curr.state = new_state;
-			uart_printf("[Charge state %s -> %s]\n",
+			CPRINTF("[Charge state %s -> %s]\n",
 				state_name[ctx.prev.state],
 				state_name[new_state]);
 		}
diff --git a/common/console.c b/common/console.c
index 29de7ef85a..0eff6e3529 100644
--- a/common/console.c
+++ b/common/console.c
@@ -15,19 +15,74 @@
 
 #define PROMPT "> "
 
+/* Default to all channels active */
+static uint32_t channel_mask = 0xffffffff;
+
+static char input_buf[80];  /* Current console command line */
+
+/* List of channel names; must match enum console_channel. */
+/* TODO: move this to board.c */
+static const char *channel_names[CC_CHANNEL_COUNT] = {
+	"command",
+	"charger",
+	"hostcmd",
+	"i8042",
+	"keyboard",
+	"keyscan",
+	"lightbar",
+	"lpc",
+	"port80",
+	"powerbtn",
+	"system",
+	"task",
+	"usbcharge",
+	"x86power",
+};
 
-void console_has_input(void)
+/*****************************************************************************/
+/* Channel-based console output */
+
+int cputs(enum console_channel channel, const char *outstr)
 {
-	/* Wake up the console task */
-	task_wake(TASK_ID_CONSOLE);
+	/* Filter out inactive channels */
+	if (!((1 << channel) & channel_mask))
+		return EC_SUCCESS;
+
+	return uart_puts(outstr);
+}
+
+
+int cprintf(enum console_channel channel, const char *format, ...)
+{
+	int rv;
+	va_list args;
+
+	/* Filter out inactive channels */
+	if (!((1 << channel) & channel_mask))
+		return EC_SUCCESS;
+
+	va_start(args, format);
+	rv = uart_vprintf(format, args);
+	va_end(args);
+	return rv;
 }
 
 
+void cflush(void)
+{
+	uart_flush_output();
+}
+
+
+
+/*****************************************************************************/
+/* Console input */
+
 /* Splits a line of input into words.  Stores the count of words in
  * <argc>.  Stores pointers to the words in <argv>, which must be at
  * least <max_argc> long.  If more than <max_argc> words are found,
  * discards the excess and returns EC_ERROR_OVERFLOW. */
-int split_words(char *input, int max_argc, int *argc, char **argv)
+static int split_words(char *input, int max_argc, int *argc, char **argv)
 {
 	char *c;
 	int in_word = 0;
@@ -63,7 +118,7 @@ int split_words(char *input, int max_argc, int *argc, char **argv)
 
 /* Finds a command by name.  Returns the command structure, or NULL if
  * no match found. */
-const struct console_command *find_command(char *name)
+static const struct console_command *find_command(char *name)
 {
 	const struct console_command *cmd;
 
@@ -96,15 +151,26 @@ static int handle_command(char *input)
 	if (cmd)
 		return cmd->handler(argc, argv);
 
-	uart_printf("Command '%s' not found.\n", argv[0]);
+	ccprintf("Command '%s' not found.\n", argv[0]);
 	return EC_ERROR_UNKNOWN;
 }
 
 
-static char input_buf[80];
+static int console_init(void)
+{
+	*input_buf = '\0';
+	uart_set_console_mode(1);
+	uart_printf("Console is enabled; type HELP for help.\n");
+	uart_puts(PROMPT);
+
+	/* TODO: restore channel list from EEPROM */
+
+	return EC_SUCCESS;
+}
+
 
 /* handle a console command */
-void console_process(void)
+static void console_process(void)
 {
         int rv;
 
@@ -122,6 +188,14 @@ void console_process(void)
 	}
 }
 
+
+void console_has_input(void)
+{
+	/* Wake up the console task */
+	task_wake(TASK_ID_CONSOLE);
+}
+
+
 void console_task(void)
 {
 	console_init();
@@ -133,6 +207,7 @@ void console_task(void)
 	}
 }
 
+
 /*****************************************************************************/
 /* Console commands */
 
@@ -152,7 +227,7 @@ static int command_help(int argc, char **argv)
 		const char *next = "zzzz";
 
 		if (!(i % 5))
-			uart_puts("\n  ");
+			ccputs("\n  ");
 
 		/* Find the next command */
 		for (cmd = __cmds; cmd < __cmds_end; cmd++) {
@@ -161,27 +236,55 @@ static int command_help(int argc, char **argv)
 				next = cmd->name;
 		}
 
-		uart_printf("%-15s", next);
+		ccprintf("%-15s", next);
 		/* Generates enough output to overflow the buffer */
-		uart_flush_output();
+		cflush();
 
 		prev = next;
 	}
 
-	uart_puts("\n");
+	ccputs("\n");
 	return EC_SUCCESS;
 }
 DECLARE_CONSOLE_COMMAND(help, command_help);
 
-/*****************************************************************************/
-/* Initialization */
 
-int console_init(void)
+/* Set active channels */
+static int command_ch(int argc, char **argv)
 {
-	*input_buf = '\0';
-	uart_set_console_mode(1);
-	uart_printf("Console is enabled; type HELP for help.\n");
-	uart_puts(PROMPT);
+	int m;
+	char *e;
+
+	/* If no args, print the list of channels */
+	if (argc == 1) {
+		int i;
+		ccputs(" # Mask     Enabled Channel\n");
+		for (i = 0; i < CC_CHANNEL_COUNT; i++) {
+			ccprintf("%2d %08x %c       %s\n",
+				 i, 1 << i,
+				 (channel_mask & (1 << i) ? '*' : ' '),
+				 channel_names[i]);
+		}
+		return EC_SUCCESS;
+	}
 
-	return EC_SUCCESS;
-}
+	/* If one arg, set the mask */
+	if (argc == 2) {
+		m = strtoi(argv[1], &e, 0);
+		if (e && *e) {
+			ccputs("Invalid mask\n");
+			return EC_ERROR_INVAL;
+		}
+		/* No disabling the command output channel */
+		channel_mask = m | (1 << CC_COMMAND);
+
+		/* TODO: save channel list to EEPROM */
+
+		return EC_SUCCESS;
+	}
+
+	/* Otherwise, print help */
+	ccputs("Usage: ch [newmask]\n");
+	return EC_ERROR_INVAL;
+};
+DECLARE_CONSOLE_COMMAND(ch, command_ch);
diff --git a/common/host_command.c b/common/host_command.c
index 09bc339e8b..8428edc497 100644
--- a/common/host_command.c
+++ b/common/host_command.c
@@ -13,9 +13,12 @@
 #include "system.h"
 #include "task.h"
 #include "timer.h"
-#include "uart.h"
 #include "util.h"
 
+/* Console output macros */
+#define CPUTS(outstr) cputs(CC_SYSTEM, outstr)
+#define CPRINTF(format, args...) cprintf(CC_SYSTEM, format, ## args)
+
 #define TASK_EVENT_SLOT(n) TASK_EVENT_CUSTOM(1 << n)
 
 static int host_command[2];
@@ -49,7 +52,7 @@ static enum lpc_status host_command_hello(uint8_t *data)
 	struct lpc_response_hello *r = (struct lpc_response_hello *)data;
 	uint32_t d = p->in_data;
 
-	uart_printf("[LPC Hello 0x%08x]\n", d);
+	CPRINTF("[LPC Hello 0x%08x]\n", d);
 
 #ifdef DELAY_HELLO_RESPONSE
 	/* Pretend command takes a long time, so we can see the busy
@@ -60,7 +63,7 @@ static enum lpc_status host_command_hello(uint8_t *data)
 	usleep(1000000);
 #endif
 
-	uart_puts("[LPC sending hello back]\n");
+	CPUTS("[LPC sending hello back]\n");
 
 	r->out_data = d + 0x01020304;
 	return EC_LPC_RESULT_SUCCESS;
@@ -133,7 +136,7 @@ static void command_process(int slot)
 	uint8_t *data = lpc_get_host_range(slot);
 	const struct host_command *cmd = find_host_command(command);
 
-	uart_printf("[hostcmd%d 0x%02x]\n", slot, command);
+	CPRINTF("[hostcmd%d 0x%02x]\n", slot, command);
 
 	if (cmd)
 		lpc_send_host_response(slot, cmd->handler(data));
diff --git a/common/i8042.c b/common/i8042.c
index 5db0c98388..fa5a7bc512 100644
--- a/common/i8042.c
+++ b/common/i8042.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011 The Chromium OS Authors. All rights reserved.
+/* Copyright (c) 2012 The Chromium OS Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  *
@@ -7,16 +7,28 @@
 
 #include "board.h"
 #include "common.h"
+#include "console.h"
 #include "i8042.h"
 #include "keyboard.h"
 #include "task.h"
 #include "timer.h"
-#include "uart.h"
 #include "util.h"
 
 
 #define I8042_DEBUG 1
 
+/* Console output macros */
+#if I8042_DEBUG >= 4
+#define CPRINTF4(format, args...) cprintf(CC_I8042, format, ## args)
+#else
+#define CPRINTF4(format, args...)
+#endif
+#if I8042_DEBUG >= 5
+#define CPRINTF5(format, args...) cprintf(CC_I8042, format, ## args)
+#else
+#define CPRINTF5(format, args...)
+#endif
+
 #define MAX_QUEUED_KEY_PRESS 16
 
 /* Circular buffer to host.
@@ -113,12 +125,9 @@ void i8042_command_task(void)
 			/* if the host still didn't read that away,
 			   try next time. */
 			if (keyboard_has_char()) {
-#if I8042_DEBUG >= 5
-				uart_printf("[%d] i8042_command_task() "
-					    "cannot send to host due to host "
-					    "havn't taken away.\n",
-					    get_time().le.lo);
-#endif
+				CPRINTF5("[%T i8042_command_task() "
+					 "cannot send to host due to host "
+					 "haven't taken away.\n");
 				break;
 			}
 
@@ -129,11 +138,8 @@ void i8042_command_task(void)
 
 			/* Write to host. */
 			keyboard_put_char(chr, i8042_irq_enabled);
-#if I8042_DEBUG >= 4
-			uart_printf("[%d] i8042_command_task() "
-				    "sends to host: 0x%02x\n",
-				    get_time().le.lo, chr);
-#endif
+			CPRINTF4("[%T i8042_command_task() "
+				 "sends to host: 0x%02x\n", chr);
 		}
 	}
 }
diff --git a/common/keyboard.c b/common/keyboard.c
index 95d1586600..3764329d91 100644
--- a/common/keyboard.c
+++ b/common/keyboard.c
@@ -25,6 +25,23 @@
 
 #define KEYBOARD_DEBUG 1
 
+/* Console output macros */
+#if KEYBOARD_DEBUG >= 1
+#define CPUTS(outstr) cputs(CC_KEYBOARD, outstr)
+#define CPRINTF(format, args...) cprintf(CC_KEYBOARD, format, ## args)
+#else
+#define CPUTS(outstr)
+#define CPRINTF(format, args...)
+#endif
+
+#if KEYBOARD_DEBUG >= 5
+#define CPUTS5(outstr) cputs(CC_KEYBOARD, outstr)
+#define CPRINTF5(format, args...) cprintf(CC_KEYBOARD, format, ## args)
+#else
+#define CPUTS5(outstr)
+#define CPRINTF5(format, args...)
+#endif
+
 
 /*
  * i8042 global settings.
@@ -34,9 +51,9 @@ static uint8_t resend_command[MAX_SCAN_CODE_LEN];
 static uint8_t resend_command_len = 0;
 static uint8_t controller_ram_address;
 static uint8_t controller_ram[0x20] = {
-  /* the so called "command byte" */
-  I8042_XLATE | I8042_AUX_DIS | I8042_KBD_DIS,
-  /* 0x01 - 0x1f are controller RAM */
+	/* the so called "command byte" */
+	I8042_XLATE | I8042_AUX_DIS | I8042_KBD_DIS,
+	/* 0x01 - 0x1f are controller RAM */
 };
 static int power_button_pressed = 0;
 static void keyboard_special(uint16_t k);
@@ -70,13 +87,13 @@ static int typematic_len = 0;  /* length of typematic_scan_code */
 static uint8_t typematic_scan_code[MAX_SCAN_CODE_LEN];
 
 
-#define KB_SYSJUMP_TAG 0x4b42  // "KB"
+#define KB_SYSJUMP_TAG 0x4b42  /* "KB" */
 #define KB_HOOK_VERSION 1
 /* the previous keyboard state before reboot_ec. */
 struct kb_state {
 	uint8_t codeset;
 	uint8_t ctlram;
-	uint8_t pad[2];  // pad to 4 bytes for system_add_jump_tag().
+	uint8_t pad[2];  /* Pad to 4 bytes for system_add_jump_tag(). */
 };
 
 
@@ -84,41 +101,41 @@ struct kb_state {
 #define CROS_ROW_NUM 8  /* TODO: +1 for power button. */
 #define CROS_COL_NUM 13
 static uint16_t scancode_set1[CROS_ROW_NUM][CROS_COL_NUM] = {
-  {0x0000, 0xe05b, 0x003b, 0x0030, 0x0044, 0x0073, 0x0031, 0x0000, 0x000d,
-                                           0x0000, 0xe038, 0x0000, 0x0000},
-  {0x0000, 0x0001, 0x003e, 0x0022, 0x0041, 0x0000, 0x0023, 0x0000, 0x0028,
-                                           0x0043, 0x0000, 0x000e, 0x0078},
-  {0x001d, 0x000f, 0x003d, 0x0014, 0x0040, 0x001b, 0x0015, 0x0056, 0x001a,
-                                           0x0042, 0x0073, 0x0000, 0x0000},
-  {0x0000, 0x0029, 0x003c, 0x0006, 0x003f, 0x0000, 0x0007, 0x0000, 0x000c,
-                                           0x0000, 0x0000, 0x002b, 0x0079},
-  {0xe01d, 0x001e, 0x0020, 0x0021, 0x001f, 0x0025, 0x0024, 0x0000, 0x0027,
-                                           0x0026, 0x002b, 0x001c, 0x0000},
-  {0x0000, 0x002c, 0x002e, 0x002f, 0x002d, 0x0033, 0x0032, 0x002a, 0x0035,
-                                           0x0034, 0x0000, 0x0039, 0x0000},
-  {0x0000, 0x0002, 0x0004, 0x0005, 0x0003, 0x0009, 0x0008, 0x0000, 0x000b,
-                                           0x000a, 0x0038, 0xe050, 0xe04d},
-  {0x0000, 0x0010, 0x0012, 0x0013, 0x0011, 0x0017, 0x0016, 0x0036, 0x0019,
-                                           0x0018, 0x0000, 0xe048, 0xe04b},
+	{0x0000, 0xe05b, 0x003b, 0x0030, 0x0044, 0x0073, 0x0031, 0x0000, 0x000d,
+	 0x0000, 0xe038, 0x0000, 0x0000},
+	{0x0000, 0x0001, 0x003e, 0x0022, 0x0041, 0x0000, 0x0023, 0x0000, 0x0028,
+	 0x0043, 0x0000, 0x000e, 0x0078},
+	{0x001d, 0x000f, 0x003d, 0x0014, 0x0040, 0x001b, 0x0015, 0x0056, 0x001a,
+	 0x0042, 0x0073, 0x0000, 0x0000},
+	{0x0000, 0x0029, 0x003c, 0x0006, 0x003f, 0x0000, 0x0007, 0x0000, 0x000c,
+	 0x0000, 0x0000, 0x002b, 0x0079},
+	{0xe01d, 0x001e, 0x0020, 0x0021, 0x001f, 0x0025, 0x0024, 0x0000, 0x0027,
+	 0x0026, 0x002b, 0x001c, 0x0000},
+	{0x0000, 0x002c, 0x002e, 0x002f, 0x002d, 0x0033, 0x0032, 0x002a, 0x0035,
+	 0x0034, 0x0000, 0x0039, 0x0000},
+	{0x0000, 0x0002, 0x0004, 0x0005, 0x0003, 0x0009, 0x0008, 0x0000, 0x000b,
+	 0x000a, 0x0038, 0xe050, 0xe04d},
+	{0x0000, 0x0010, 0x0012, 0x0013, 0x0011, 0x0017, 0x0016, 0x0036, 0x0019,
+	 0x0018, 0x0000, 0xe048, 0xe04b},
 };
 
 static uint16_t scancode_set2[CROS_ROW_NUM][CROS_COL_NUM] = {
-  {0x0000, 0xe01f, 0x0005, 0x0032, 0x0009, 0x0051, 0x0031, 0x0000, 0x0055,
-                                           0x0000, 0xe011, 0x0000, 0x0000},
-  {0x0000, 0x0076, 0x000c, 0x0034, 0x0083, 0x0000, 0x0033, 0x0000, 0x0052,
-                                           0x0001, 0x0000, 0x0066, 0x0067},
-  {0x0014, 0x000d, 0x0004, 0x002c, 0x000b, 0x005b, 0x0035, 0x0061, 0x0054,
-                                           0x000a, 0x0051, 0x0000, 0x0000},
-  {0x0000, 0x000e, 0x0006, 0x002e, 0x0003, 0x0000, 0x0036, 0x0000, 0x004e,
-                                           0x0000, 0x0000, 0x005d, 0x0064},
-  {0xe014, 0x001c, 0x0023, 0x002b, 0x001b, 0x0042, 0x003b, 0x0000, 0x004c,
-                                           0x004b, 0x005d, 0x005a, 0x0000},
-  {0x0000, 0x001a, 0x0021, 0x002a, 0x0022, 0x0041, 0x003a, 0x0012, 0x004a,
-                                           0x0049, 0x0000, 0x0029, 0x0000},
-  {0x0000, 0x0016, 0x0026, 0x0025, 0x001e, 0x003e, 0x003d, 0x0000, 0x0045,
-                                           0x0046, 0x0011, 0xe072, 0xe074},
-  {0x0000, 0x0015, 0x0024, 0x002d, 0x001d, 0x0043, 0x003c, 0x0059, 0x004d,
-                                           0x0044, 0x0000, 0xe075, 0xe06b},
+	{0x0000, 0xe01f, 0x0005, 0x0032, 0x0009, 0x0051, 0x0031, 0x0000, 0x0055,
+	 0x0000, 0xe011, 0x0000, 0x0000},
+	{0x0000, 0x0076, 0x000c, 0x0034, 0x0083, 0x0000, 0x0033, 0x0000, 0x0052,
+	 0x0001, 0x0000, 0x0066, 0x0067},
+	{0x0014, 0x000d, 0x0004, 0x002c, 0x000b, 0x005b, 0x0035, 0x0061, 0x0054,
+	 0x000a, 0x0051, 0x0000, 0x0000},
+	{0x0000, 0x000e, 0x0006, 0x002e, 0x0003, 0x0000, 0x0036, 0x0000, 0x004e,
+	 0x0000, 0x0000, 0x005d, 0x0064},
+	{0xe014, 0x001c, 0x0023, 0x002b, 0x001b, 0x0042, 0x003b, 0x0000, 0x004c,
+	 0x004b, 0x005d, 0x005a, 0x0000},
+	{0x0000, 0x001a, 0x0021, 0x002a, 0x0022, 0x0041, 0x003a, 0x0012, 0x004a,
+	 0x0049, 0x0000, 0x0029, 0x0000},
+	{0x0000, 0x0016, 0x0026, 0x0025, 0x001e, 0x003e, 0x003d, 0x0000, 0x0045,
+	 0x0046, 0x0011, 0xe072, 0xe074},
+	{0x0000, 0x0015, 0x0024, 0x002d, 0x001d, 0x0043, 0x003c, 0x0059, 0x004d,
+	 0x0044, 0x0000, 0xe075, 0xe06b},
 };
 
 
@@ -126,59 +143,56 @@ static uint16_t scancode_set2[CROS_ROW_NUM][CROS_COL_NUM] = {
 static uint8_t simulated_key[CROS_COL_NUM];
 
 
-/* change to set 1 if the I8042_XLATE flag is set. */
-static enum scancode_set_list acting_code_set(enum scancode_set_list set) {
-  if (controller_ram[0] & I8042_XLATE) {
-    /* If the keyboard translation is enabled,
-     * then always generates set 1. */
-    return SCANCODE_SET_1;
-  }
-  return set;
+/* Change to set 1 if the I8042_XLATE flag is set. */
+static enum scancode_set_list acting_code_set(enum scancode_set_list set)
+{
+	if (controller_ram[0] & I8042_XLATE) {
+		/* If the keyboard translation is enabled, then always
+		 * generates set 1. */
+		return SCANCODE_SET_1;
+	}
+	return set;
 }
 
 
-static enum ec_error_list matrix_callback(
-    int8_t row, int8_t col, int8_t pressed,
-    enum scancode_set_list code_set, uint8_t *scan_code, int32_t* len) {
+static enum ec_error_list matrix_callback(int8_t row, int8_t col,
+					  int8_t pressed,
+					  enum scancode_set_list code_set,
+					  uint8_t *scan_code, int32_t* len)
+{
+	uint16_t make_code;
 
-  uint16_t make_code;
+	ASSERT(scan_code);
+	ASSERT(len);
 
-  ASSERT(scan_code);
-  ASSERT(len);
+	if (row > CROS_ROW_NUM || col > CROS_COL_NUM)
+		return EC_ERROR_INVAL;
 
-  if (row > CROS_ROW_NUM ||
-      col > CROS_COL_NUM) {
-    return EC_ERROR_INVAL;
-  }
+	if (pressed)
+		keyboard_special(scancode_set1[row][col]);
 
-  if (pressed)
-    keyboard_special(scancode_set1[row][col]);
+	*len = 0;
 
-  *len = 0;
+	code_set = acting_code_set(code_set);
 
-  code_set = acting_code_set(code_set);
+	switch (code_set) {
+	case SCANCODE_SET_1:
+		make_code = scancode_set1[row][col];
+		break;
 
-  switch (code_set) {
-  case SCANCODE_SET_1:
-    make_code = scancode_set1[row][col];
-    break;
+	case SCANCODE_SET_2:
+		make_code = scancode_set2[row][col];
+		break;
 
-  case SCANCODE_SET_2:
-    make_code = scancode_set2[row][col];
-    break;
+	default:
+		CPRINTF("[Not supported scan code set: %d]\n", code_set);
+		return EC_ERROR_UNIMPLEMENTED;
+	}
 
-  default:
-#if KEYBOARD_DEBUG >= 1
-    uart_printf("[Not supported scan code set: %d]\n", code_set);
-#endif
-    return EC_ERROR_UNIMPLEMENTED;
-  }
-  if (!make_code) {
-#if KEYBOARD_DEBUG >= 1
-    uart_printf("[No scancode for (row:col)=(%d:%d)]\n", row, col);
-#endif
-    return EC_ERROR_UNIMPLEMENTED;
-  }
+	if (!make_code) {
+		CPRINTF("[No scancode for (row:col)=(%d:%d)]\n", row, col);
+		return EC_ERROR_UNIMPLEMENTED;
+	}
 
   /* Output the make code (from table) */
   if (make_code >= 0x0100) {
@@ -217,15 +231,17 @@ static enum ec_error_list matrix_callback(
 }
 
 
-static void reset_rate_and_delay(void) {
-  typematic_value_from_host = DEFAULT_TYPEMATIC_VALUE;
-  refill_first_delay = DEFAULT_FIRST_DELAY;
-  refill_inter_delay = DEFAULT_INTER_DELAY;
+static void reset_rate_and_delay(void)
+{
+	typematic_value_from_host = DEFAULT_TYPEMATIC_VALUE;
+	refill_first_delay = DEFAULT_FIRST_DELAY;
+	refill_inter_delay = DEFAULT_INTER_DELAY;
 }
 
 
-static void clean_underlying_buffer(void) {
-  i8042_init();
+static void clean_underlying_buffer(void)
+{
+	i8042_init();
 }
 
 
@@ -235,380 +251,357 @@ static void clean_underlying_buffer(void) {
  *         daisy(variants): no CONFIG_LPC and no CONFIG_TASK_X86POWER
  *       crosbug.com/p/8523
  */
-static void keyboard_wakeup(void) {
+static void keyboard_wakeup(void)
+{
 #ifdef CONFIG_LPC
-  lpc_set_host_events(EC_LPC_HOST_EVENT_MASK(EC_LPC_HOST_EVENT_KEY_PRESSED));
+	lpc_set_host_events(
+		EC_LPC_HOST_EVENT_MASK(EC_LPC_HOST_EVENT_KEY_PRESSED));
 #endif
 }
 
 
-void keyboard_state_changed(int row, int col, int is_pressed) {
-  uint8_t scan_code[MAX_SCAN_CODE_LEN];
-  int32_t len;
-  enum ec_error_list ret;
-
-#if KEYBOARD_DEBUG >= 5
-  uart_printf("[File %s:%s(): row=%d col=%d is_pressed=%d]\n",
-      __FILE__, __FUNCTION__, row, col, is_pressed);
-#endif
+void keyboard_state_changed(int row, int col, int is_pressed)
+{
+	uint8_t scan_code[MAX_SCAN_CODE_LEN];
+	int32_t len;
+	enum ec_error_list ret;
 
-  ret = matrix_callback(row, col, is_pressed, scancode_set, scan_code, &len);
-  if (ret == EC_SUCCESS) {
-    ASSERT(len > 0);
+	CPRINTF5("[%s(): row=%d col=%d is_pressed=%d]\n",
+		 __func__, row, col, is_pressed);
 
-    i8042_send_to_host(len, scan_code);
-  }
+	ret = matrix_callback(row, col, is_pressed, scancode_set, scan_code,
+			      &len);
+	if (ret == EC_SUCCESS) {
+		ASSERT(len > 0);
+		i8042_send_to_host(len, scan_code);
+	}
 
-  if (is_pressed) {
-    keyboard_wakeup();
+	if (is_pressed) {
+		keyboard_wakeup();
 
-    typematic_delay = refill_first_delay * 1000;
-    memcpy(typematic_scan_code, scan_code, len);
-    typematic_len = len;
-    task_wake(TASK_ID_TYPEMATIC);
-  } else {
-    typematic_len = 0;
-  }
+		typematic_delay = refill_first_delay * 1000;
+		memcpy(typematic_scan_code, scan_code, len);
+		typematic_len = len;
+		task_wake(TASK_ID_TYPEMATIC);
+	} else {
+		typematic_len = 0;
+	}
 }
 
 
-void keyboard_enable(int enable) {
-  if (!keyboard_enabled && enable) {
-    /* enable */
-  } else if (keyboard_enabled && !enable) {
-    /* disable */
-    reset_rate_and_delay();
-    clean_underlying_buffer();
-  }
-  keyboard_enabled = enable;
+void keyboard_enable(int enable)
+{
+	if (!keyboard_enabled && enable) {
+		/* enable */
+	} else if (keyboard_enabled && !enable) {
+		/* disable */
+		reset_rate_and_delay();
+		clean_underlying_buffer();
+	}
+	keyboard_enabled = enable;
 }
 
 
-uint8_t read_ctl_ram(uint8_t addr) {
-  if (addr < 0x20)  // Controller RAM is only 32 bytes.
-    return controller_ram[addr];
-  else
-    return 0;
+uint8_t read_ctl_ram(uint8_t addr)
+{
+	if (addr < 0x20)  /* Controller RAM is only 32 bytes. */
+		return controller_ram[addr];
+	else
+		return 0;
 }
 
 
-/* Manipulates the controller_ram[]. Some bits change may trigger internal
- * state change.
- */
-void update_ctl_ram(uint8_t addr, uint8_t data) {
-  uint8_t orig;
+/* Manipulate the controller_ram[]. Some bits change may trigger internal
+ * state change. */
+void update_ctl_ram(uint8_t addr, uint8_t data)
+{
+	uint8_t orig;
 
-  if (addr >= 0x20);  // Controller RAM is only 32 bytes.
-    return;
+	if (addr >= 0x20)  /* Controller RAM is only 32 bytes. */
+		return;
 
-  orig = controller_ram[addr];
-  controller_ram[addr] = data;
-#if KEYBOARD_DEBUG >= 5
-  uart_printf("[Set CTR_RAM(0x%02x)=0x%02x (old:0x%02x)]\n",
-              addr, data, orig);
-#endif
+	orig = controller_ram[addr];
+	controller_ram[addr] = data;
+	CPRINTF5("[Set CTR_RAM(0x%02x)=0x%02x (old:0x%02x)]\n",
+		 addr, data, orig);
 
-  if (addr == 0x00) {  /* the controller RAM */
-    /* Handle the I8042_KBD_DIS bit */
-    keyboard_enable(!(data & I8042_KBD_DIS));
+	if (addr == 0x00) {  /* the controller RAM */
+		/* Handle the I8042_KBD_DIS bit */
+		keyboard_enable(!(data & I8042_KBD_DIS));
 
-    /* Handle the I8042_ENIRQ1 bit */
-    if (!(orig & I8042_ENIRQ1) && (data & I8042_ENIRQ1)) {
-      i8042_enable_keyboard_irq();
-    } else if ((orig & I8042_ENIRQ1) && !(data & I8042_ENIRQ1)) {
-      i8042_disable_keyboard_irq();
-    }
-  }
+		/* Handle the I8042_ENIRQ1 bit */
+		if (!(orig & I8042_ENIRQ1) && (data & I8042_ENIRQ1))
+			i8042_enable_keyboard_irq();
+		else if ((orig & I8042_ENIRQ1) && !(data & I8042_ENIRQ1))
+			i8042_disable_keyboard_irq();
+	}
 }
 
 
 enum {
-  STATE_NORMAL = 0,
-  STATE_SCANCODE,
-  STATE_SETLEDS,
-  STATE_EX_SETLEDS_1,  /* expect 2-byte parameter coming */
-  STATE_EX_SETLEDS_2,
-  STATE_WRITE_CMD_BYTE,
-  STATE_ECHO_MOUSE,
-  STATE_SETREP,
-  STATE_SEND_TO_MOUSE,
+	STATE_NORMAL = 0,
+	STATE_SCANCODE,
+	STATE_SETLEDS,
+	STATE_EX_SETLEDS_1,  /* expect 2-byte parameter coming */
+	STATE_EX_SETLEDS_2,
+	STATE_WRITE_CMD_BYTE,
+	STATE_ECHO_MOUSE,
+	STATE_SETREP,
+	STATE_SEND_TO_MOUSE,
 } data_port_state = STATE_NORMAL;
 
 
-int handle_keyboard_data(uint8_t data, uint8_t *output) {
-  int out_len = 0;
-  int save_for_resend = 1;
-  int i;
+int handle_keyboard_data(uint8_t data, uint8_t *output)
+{
+	int out_len = 0;
+	int save_for_resend = 1;
+	int i;
+
+	CPRINTF5("[KB recv data: 0x%02x]\n", data);
+
+	switch (data_port_state) {
+	case STATE_SCANCODE:
+		CPRINTF5("[Eaten by STATE_SCANCODE: 0x%02x]\n", data);
+		if (data == SCANCODE_GET_SET) {
+			output[out_len++] = I8042_RET_ACK;
+			output[out_len++] = scancode_set;
+		} else {
+			scancode_set = data;
+			CPRINTF("[Scancode set to %d]\n", scancode_set);
+			output[out_len++] = I8042_RET_ACK;
+		}
+		data_port_state = STATE_NORMAL;
+		break;
+
+	case STATE_SETLEDS:
+		CPUTS5("[Eaten by STATE_SETLEDS]\n");
+		output[out_len++] = I8042_RET_ACK;
+		data_port_state = STATE_NORMAL;
+		break;
+
+	case STATE_EX_SETLEDS_1:
+		CPUTS5("[Eaten by STATE_EX_SETLEDS_1]\n");
+		output[out_len++] = I8042_RET_ACK;
+		data_port_state = STATE_EX_SETLEDS_2;
+		break;
+
+	case STATE_EX_SETLEDS_2:
+		CPUTS5("[Eaten by STATE_EX_SETLEDS_2]\n");
+		output[out_len++] = I8042_RET_ACK;
+		data_port_state = STATE_NORMAL;
+		break;
+
+	case STATE_WRITE_CMD_BYTE:
+		CPRINTF5("[Eaten by STATE_WRITE_CMD_BYTE: 0x%02x]\n", data);
+		update_ctl_ram(controller_ram_address, data);
+		output[out_len++] = I8042_RET_ACK;
+		data_port_state = STATE_NORMAL;
+		break;
+
+	case STATE_ECHO_MOUSE:
+		CPRINTF5("[Eaten by STATE_ECHO_MOUSE: 0x%02x]\n", data);
+		output[out_len++] = I8042_RET_ACK;
+		output[out_len++] = data;
+		data_port_state = STATE_NORMAL;
+		break;
+
+	case STATE_SETREP:
+		CPRINTF5("[Eaten by STATE_SETREP: 0x%02x]\n", data);
+		typematic_value_from_host = data;
+		refill_first_delay =
+			(((typematic_value_from_host & 0x60) >> 5) + 1) * 250;
+		refill_inter_delay = 1000 *  /* ms */
+			(1 << ((typematic_value_from_host & 0x18) >> 3)) *
+			((typematic_value_from_host & 0x7) + 8) /
+			240;
+
+		output[out_len++] = I8042_RET_ACK;
+		data_port_state = STATE_NORMAL;
+		break;
+
+	case STATE_SEND_TO_MOUSE:
+		CPRINTF5("[Eaten by STATE_SEND_TO_MOUSE: 0x%02x]\n", data);
+		data_port_state = STATE_NORMAL;
+		break;
+
+	default:  /* STATE_NORMAL */
+		switch (data) {
+		case I8042_CMD_GSCANSET:  /* also I8042_CMD_SSCANSET */
+			output[out_len++] = I8042_RET_ACK;
+			data_port_state = STATE_SCANCODE;
+			break;
 
-#if KEYBOARD_DEBUG >= 5
-  uart_printf("[KB recv data: 0x%02x]\n", data);
-#endif
+		case I8042_CMD_SETLEDS:
+			/* We use screen indicator. Do nothing in keyboard
+			 * controller. */
+			output[out_len++] = I8042_RET_ACK;
+			data_port_state = STATE_SETLEDS;
+			break;
 
-  switch (data_port_state) {
-  case STATE_SCANCODE:
-#if KEYBOARD_DEBUG >= 5
-    uart_printf("[Eaten by STATE_SCANCODE: 0x%02x]\n", data);
-#endif
-    if (data == SCANCODE_GET_SET) {
-      output[out_len++] = I8042_RET_ACK;
-      output[out_len++] = scancode_set;
-    } else {
-      scancode_set = data;
-#if KEYBOARD_DEBUG >= 1
-      uart_printf("[Scancode set to %d]\n", scancode_set);
-#endif
-      output[out_len++] = I8042_RET_ACK;
-    }
-    data_port_state = STATE_NORMAL;
-    break;
+		case I8042_CMD_EX_SETLEDS:
+			output[out_len++] = I8042_RET_ACK;
+			data_port_state = STATE_EX_SETLEDS_1;
+			break;
 
-  case STATE_SETLEDS:
-#if KEYBOARD_DEBUG >= 5
-    uart_printf("[Eaten by STATE_SETLEDS]\n");
-#endif
-    output[out_len++] = I8042_RET_ACK;
-    data_port_state = STATE_NORMAL;
-    break;
+		case I8042_CMD_DIAG_ECHO:
+			output[out_len++] = I8042_RET_ACK;
+			output[out_len++] = I8042_CMD_DIAG_ECHO;
+			break;
 
-  case STATE_EX_SETLEDS_1:
-#if KEYBOARD_DEBUG >= 5
-    uart_printf("[Eaten by STATE_EX_SETLEDS_1]\n");
-#endif
-    output[out_len++] = I8042_RET_ACK;
-    data_port_state = STATE_EX_SETLEDS_2;
-    break;
+		case I8042_CMD_GETID:    /* fall-thru */
+		case I8042_CMD_OK_GETID:
+			output[out_len++] = I8042_RET_ACK;
+			output[out_len++] = 0xab;  /* Regular keyboards */
+			output[out_len++] = 0x83;
+			break;
 
-  case STATE_EX_SETLEDS_2:
-#if KEYBOARD_DEBUG >= 5
-    uart_printf("[Eaten by STATE_EX_SETLEDS_2]\n");
-#endif
-    output[out_len++] = I8042_RET_ACK;
-    data_port_state = STATE_NORMAL;
-    break;
+		case I8042_CMD_SETREP:
+			output[out_len++] = I8042_RET_ACK;
+			data_port_state = STATE_SETREP;
+			break;
 
-  case STATE_WRITE_CMD_BYTE:
-#if KEYBOARD_DEBUG >= 5
-    uart_printf("[Eaten by STATE_WRITE_CMD_BYTE: 0x%02x]\n", data);
-#endif
-    update_ctl_ram(controller_ram_address, data);
-    output[out_len++] = I8042_RET_ACK;
-    data_port_state = STATE_NORMAL;
-    break;
+		case I8042_CMD_ENABLE:
+			output[out_len++] = I8042_RET_ACK;
+			keyboard_enable(1);
+			break;
 
-  case STATE_ECHO_MOUSE:
-#if KEYBOARD_DEBUG >= 5
-    uart_printf("[Eaten by STATE_ECHO_MOUSE: 0x%02x]\n", data);
-#endif
-    output[out_len++] = I8042_RET_ACK;
-    output[out_len++] = data;
-    data_port_state = STATE_NORMAL;
-    break;
+		case I8042_CMD_RESET_DIS:
+			output[out_len++] = I8042_RET_ACK;
+			keyboard_enable(0);
+			reset_rate_and_delay();
+			clean_underlying_buffer();
+			break;
 
-  case STATE_SETREP:
-#if KEYBOARD_DEBUG >= 5
-    uart_printf("[Eaten by STATE_SETREP: 0x%02x]\n", data);
-#endif
-    typematic_value_from_host = data;
-    refill_first_delay = (((typematic_value_from_host & 0x60) >> 5) + 1) * 250;
-    refill_inter_delay = 1000 *  /* ms */
-                         (1 << ((typematic_value_from_host & 0x18) >> 3)) *
-                         ((typematic_value_from_host & 0x7) + 8) /
-                         240;
-
-    output[out_len++] = I8042_RET_ACK;
-    data_port_state = STATE_NORMAL;
-    break;
+		case I8042_CMD_RESET_DEF:
+			output[out_len++] = I8042_RET_ACK;
+			reset_rate_and_delay();
+			clean_underlying_buffer();
+			break;
 
-  case STATE_SEND_TO_MOUSE:
-#if KEYBOARD_DEBUG >= 5
-    uart_printf("[Eaten by STATE_SEND_TO_MOUSE: 0x%02x]\n", data);
-#endif
-    data_port_state = STATE_NORMAL;
-    break;
+		case I8042_CMD_RESET_BAT:
+			output[out_len++] = I8042_RET_ACK;
+			keyboard_enable(0);
+			output[out_len++] = I8042_RET_BAT;
+			output[out_len++] = I8042_RET_BAT;
+			break;
 
-  default:  /* STATE_NORMAL */
-    switch (data) {
-      case I8042_CMD_GSCANSET:  /* also I8042_CMD_SSCANSET */
-        output[out_len++] = I8042_RET_ACK;
-        data_port_state = STATE_SCANCODE;
-        break;
-
-      case I8042_CMD_SETLEDS:
-        /* We use screen indicator. Do nothing in keyboard controller. */
-        output[out_len++] = I8042_RET_ACK;
-        data_port_state = STATE_SETLEDS;
-        break;
-
-      case I8042_CMD_EX_SETLEDS:
-        output[out_len++] = I8042_RET_ACK;
-        data_port_state = STATE_EX_SETLEDS_1;
-        break;
-
-      case I8042_CMD_DIAG_ECHO:
-        output[out_len++] = I8042_RET_ACK;
-        output[out_len++] = I8042_CMD_DIAG_ECHO;
-        break;
-
-      case I8042_CMD_GETID:    /* fall-thru */
-      case I8042_CMD_OK_GETID:
-        output[out_len++] = I8042_RET_ACK;
-        output[out_len++] = 0xab;  /* Regular keyboards */
-        output[out_len++] = 0x83;
-        break;
-
-      case I8042_CMD_SETREP:
-        output[out_len++] = I8042_RET_ACK;
-        data_port_state = STATE_SETREP;
-        break;
-
-      case I8042_CMD_ENABLE:
-        output[out_len++] = I8042_RET_ACK;
-        keyboard_enable(1);
-        break;
-
-      case I8042_CMD_RESET_DIS:
-        output[out_len++] = I8042_RET_ACK;
-        keyboard_enable(0);
-        reset_rate_and_delay();
-        clean_underlying_buffer();
-        break;
-
-      case I8042_CMD_RESET_DEF:
-        output[out_len++] = I8042_RET_ACK;
-        reset_rate_and_delay();
-        clean_underlying_buffer();
-        break;
-
-      case I8042_CMD_RESET_BAT:
-        output[out_len++] = I8042_RET_ACK;
-        keyboard_enable(0);
-        output[out_len++] = I8042_RET_BAT;
-        output[out_len++] = I8042_RET_BAT;
-        break;
-
-      case I8042_CMD_RESEND:
-        output[out_len++] = I8042_RET_ACK;
-        save_for_resend = 0;
-        for (i = 0; i < resend_command_len; ++i) {
-          output[out_len++] = resend_command[i];
-        }
-        break;
-
-      /* u-boot hack */
-      case 0x60:  /* see CONFIG_USE_CPCIDVI in */
-      case 0x45:  /* third_party/u-boot/files/drivers/input/i8042.c */
-        /* just ignore, don't reply anything. */
-        break;
-
-      case I8042_CMD_SETALL_MB:  /* fall-thru below */
-      case I8042_CMD_SETALL_MBR:
-      case I8042_CMD_EX_ENABLE:
-      default:
-        output[out_len++] = I8042_RET_NAK;
-#if KEYBOARD_DEBUG >= 1
-        uart_printf("[Unsupported i8042 data 0x%02x]\n", data);
-#endif
-        break;
-    }
-  }
+		case I8042_CMD_RESEND:
+			output[out_len++] = I8042_RET_ACK;
+			save_for_resend = 0;
+			for (i = 0; i < resend_command_len; ++i)
+				output[out_len++] = resend_command[i];
+			break;
 
-  /* For resend, keep output before leaving. */
-  if (out_len && save_for_resend) {
-    ASSERT(out_len <= MAX_SCAN_CODE_LEN);
-    for (i = 0; i < out_len; ++i) {
-      resend_command[i] = output[i];
-    }
-    resend_command_len = out_len;
-  }
+		/* u-boot hack */
+		case 0x60:  /* see CONFIG_USE_CPCIDVI in */
+		case 0x45:  /* third_party/u-boot/files/drivers/input/i8042.c */
+			/* just ignore, don't reply anything. */
+			break;
 
-  ASSERT(out_len <= MAX_SCAN_CODE_LEN);
-  return out_len;
+		case I8042_CMD_SETALL_MB:  /* fall-thru below */
+		case I8042_CMD_SETALL_MBR:
+		case I8042_CMD_EX_ENABLE:
+		default:
+			output[out_len++] = I8042_RET_NAK;
+			CPRINTF("[Unsupported i8042 data 0x%02x]\n", data);
+			break;
+		}
+	}
+
+	/* For resend, keep output before leaving. */
+	if (out_len && save_for_resend) {
+		ASSERT(out_len <= MAX_SCAN_CODE_LEN);
+		for (i = 0; i < out_len; ++i)
+			resend_command[i] = output[i];
+		resend_command_len = out_len;
+	}
+
+	ASSERT(out_len <= MAX_SCAN_CODE_LEN);
+	return out_len;
 }
 
 
-int handle_keyboard_command(uint8_t command, uint8_t *output) {
-  int out_len = 0;
+int handle_keyboard_command(uint8_t command, uint8_t *output)
+{
+	int out_len = 0;
 
-#if KEYBOARD_DEBUG >= 5
-  uart_printf("[KB recv cmd: 0x%02x]\n", command);
-#endif
-  switch (command) {
-  case I8042_READ_CMD_BYTE:
-    output[out_len++] = read_ctl_ram(0);
-    break;
+	CPRINTF5("[KB recv cmd: 0x%02x]\n", command);
+	switch (command) {
+	case I8042_READ_CMD_BYTE:
+		output[out_len++] = read_ctl_ram(0);
+		break;
 
-  case I8042_WRITE_CMD_BYTE:
-    data_port_state = STATE_WRITE_CMD_BYTE;
-    controller_ram_address = command - 0x60;
-    break;
+	case I8042_WRITE_CMD_BYTE:
+		data_port_state = STATE_WRITE_CMD_BYTE;
+		controller_ram_address = command - 0x60;
+		break;
 
-  case I8042_DIS_KB:
-    keyboard_enable(0);
-    break;
+	case I8042_DIS_KB:
+		keyboard_enable(0);
+		break;
 
-  case I8042_ENA_KB:
-    keyboard_enable(1);
-    break;
+	case I8042_ENA_KB:
+		keyboard_enable(1);
+		break;
 
-  case I8042_RESET_SELF_TEST:
-    output[out_len++] = 0x55;  // Self test success.
-    break;
+	case I8042_RESET_SELF_TEST:
+		output[out_len++] = 0x55;  /* Self test success */
+		break;
 
-  case I8042_DIS_MOUSE:
-    update_ctl_ram(0, read_ctl_ram(0) | I8042_AUX_DIS);
-    break;
+	case I8042_DIS_MOUSE:
+		update_ctl_ram(0, read_ctl_ram(0) | I8042_AUX_DIS);
+		break;
 
-  case I8042_ENA_MOUSE:
-    update_ctl_ram(0, read_ctl_ram(0) & ~I8042_AUX_DIS);
-    break;
+	case I8042_ENA_MOUSE:
+		update_ctl_ram(0, read_ctl_ram(0) & ~I8042_AUX_DIS);
+		break;
 
-  case I8042_TEST_MOUSE:
-    output[out_len++] = 0;  // no error detected
-    break;
+	case I8042_TEST_MOUSE:
+		output[out_len++] = 0;  /* No error detected */
+		break;
 
-  case I8042_ECHO_MOUSE:
-    data_port_state = STATE_ECHO_MOUSE;
-    break;
+	case I8042_ECHO_MOUSE:
+		data_port_state = STATE_ECHO_MOUSE;
+		break;
 
-  case I8042_SEND_TO_MOUSE:
-    data_port_state = STATE_SEND_TO_MOUSE;
-    break;
+	case I8042_SEND_TO_MOUSE:
+		data_port_state = STATE_SEND_TO_MOUSE;
+		break;
 
 #ifdef CONFIG_TASK_X86POWER
-  case I8042_SYSTEM_RESET:
-	  /* Trigger a cold reset, since that also resets the TPM.  If we just
-	   * trigger a warm reset, that doesn't assert PLTRST# and the TPM is
-	   * not reset.  See crosbug.com/p/8379. */
-	  x86_power_reset(1);
-	  break;
+	case I8042_SYSTEM_RESET:
+		/* Trigger a cold reset, since that also resets the TPM.  If we
+		 * just trigger a warm reset, that doesn't assert PLTRST# and
+		 * the TPM is not reset.  See crosbug.com/p/8379. */
+		x86_power_reset(1);
+		break;
 #endif
 
-  default:
-    if (command >= I8042_READ_CTL_RAM &&
-        command <= I8042_READ_CTL_RAM_END) {
-      output[out_len++] = read_ctl_ram(command - 0x20);
-    } else if (command >= I8042_WRITE_CTL_RAM &&
-               command <= I8042_WRITE_CTL_RAM_END) {
-      data_port_state = STATE_WRITE_CMD_BYTE;
-      controller_ram_address = command - 0x60;
-    } else if (command >= I8042_PULSE_START &&
-               command <= I8042_PULSE_END) {
-      /* Pulse Output Bit. Not implemented. Ignore it. */
-    } else {
-#if KEYBOARD_DEBUG >= 1
-      uart_printf("[Unsupported cmd: 0x%02x]\n", command);
-#endif
-      reset_rate_and_delay();
-      clean_underlying_buffer();
-      output[out_len++] = I8042_RET_NAK;
-      data_port_state = STATE_NORMAL;
-    }
-    break;
-  }
+	default:
+		if (command >= I8042_READ_CTL_RAM &&
+		    command <= I8042_READ_CTL_RAM_END) {
+			output[out_len++] = read_ctl_ram(command - 0x20);
+		} else if (command >= I8042_WRITE_CTL_RAM &&
+			   command <= I8042_WRITE_CTL_RAM_END) {
+			data_port_state = STATE_WRITE_CMD_BYTE;
+			controller_ram_address = command - 0x60;
+		} else if (command >= I8042_PULSE_START &&
+			   command <= I8042_PULSE_END) {
+			/* Pulse Output Bit. Not implemented. Ignore it. */
+		} else {
+			CPRINTF("[Unsupported cmd: 0x%02x]\n", command);
+			reset_rate_and_delay();
+			clean_underlying_buffer();
+			output[out_len++] = I8042_RET_NAK;
+			data_port_state = STATE_NORMAL;
+		}
+		break;
+	}
 
-  return out_len;
+	return out_len;
 }
 
+
 /* U U D D L R L R b a */
 static void keyboard_special(uint16_t k)
 {
@@ -621,6 +614,7 @@ static void keyboard_special(uint16_t k)
 		s = 0;
 	else if (s != 2)
 		s = 1;
+
 	if (s == ARRAY_SIZE(a)) {
 		s = 0;
 #ifdef CONFIG_TASK_LIGHTBAR
@@ -629,6 +623,7 @@ static void keyboard_special(uint16_t k)
 	}
 }
 
+
 void keyboard_set_power_button(int pressed)
 {
 	enum scancode_set_list code_set;
@@ -657,23 +652,23 @@ void keyboard_set_power_button(int pressed)
 }
 
 
-
 void keyboard_typematic_task(void)
 {
-  while (1) {
-    task_wait_event(-1);
-
-    while (typematic_len) {
-      usleep(TYPEMATIC_DELAY_UNIT);
-      typematic_delay -= TYPEMATIC_DELAY_UNIT;
-
-      if (typematic_delay <= 0) {
-        /* re-send to host */
-        i8042_send_to_host(typematic_len, typematic_scan_code);
-        typematic_delay = refill_inter_delay * 1000;
-      }
-    }
-  }
+	while (1) {
+		task_wait_event(-1);
+
+		while (typematic_len) {
+			usleep(TYPEMATIC_DELAY_UNIT);
+			typematic_delay -= TYPEMATIC_DELAY_UNIT;
+
+			if (typematic_delay <= 0) {
+				/* re-send to host */
+				i8042_send_to_host(typematic_len,
+						   typematic_scan_code);
+				typematic_delay = refill_inter_delay * 1000;
+			}
+		}
+	}
 }
 
 
@@ -682,30 +677,30 @@ static int command_typematic(int argc, char **argv)
 	if (argc == 1) {
 		int i;
 
-		uart_printf("Value set from host: 0x%02x\n",
+		ccprintf("Value set from host: 0x%02x\n",
 		            typematic_value_from_host);
-		uart_printf("Refill first delay : %d (ms)\n",
+		ccprintf("Refill first delay : %d (ms)\n",
 		            refill_first_delay);
-		uart_printf("       inter delay : %d (ms)\n",
+		ccprintf("       inter delay : %d (ms)\n",
 		            refill_inter_delay);
-		uart_printf("Current delay      : %d (us)\n",
+		ccprintf("Current delay      : %d (us)\n",
 		            typematic_delay);
 
-		uart_puts("Repeat scan code   : ");
+		ccputs("Repeat scan code   : ");
 		for (i = 0; i < typematic_len; ++i) {
-			uart_printf("0x%02x ", typematic_scan_code[i]);
+			ccprintf("0x%02x ", typematic_scan_code[i]);
 		}
-		uart_puts("\n");
+		ccputs("\n");
 	} else if (argc == 3) {
 		refill_first_delay = strtoi(argv[1], NULL, 0);
 		refill_inter_delay = strtoi(argv[2], NULL, 0);
-		uart_puts("New typematic delays:\n");
-		uart_printf("    Refill first delay : %d (ms)\n",
+		ccputs("New typematic delays:\n");
+		ccprintf("    Refill first delay : %d (ms)\n",
 		            refill_first_delay);
-		uart_printf("    Refill inter delay : %d (ms)\n",
+		ccprintf("    Refill inter delay : %d (ms)\n",
 		            refill_inter_delay);
 	} else {
-		uart_puts("Usage: typematic [<first> <inter>]\n");
+		ccputs("Usage: typematic [<first> <inter>]\n");
 		return EC_ERROR_UNKNOWN;
 	}
 
@@ -719,8 +714,8 @@ static int command_codeset(int argc, char **argv)
 	int set;
 
 	if (argc == 1) {
-		uart_printf("Current scancode set: %d\n", scancode_set);
-		uart_printf("I8042_XLATE: %d\n",
+		ccprintf("Current scancode set: %d\n", scancode_set);
+		ccprintf("I8042_XLATE: %d\n",
 		            controller_ram[0] & I8042_XLATE ? 1 : 0);
 	} else if (argc == 2) {
 		set = strtoi(argv[1], NULL, 0);
@@ -728,15 +723,15 @@ static int command_codeset(int argc, char **argv)
 		case SCANCODE_SET_1:  /* fall-thru */
 		case SCANCODE_SET_2:  /* fall-thru */
 			scancode_set = set;
-			uart_printf("Set scancode set to %d\n", scancode_set);
+			ccprintf("Set scancode set to %d\n", scancode_set);
 			break;
 		default:
-			uart_printf("Scancode %d is NOT supported.\n", set);
+			ccprintf("Scancode %d is NOT supported.\n", set);
 			return EC_ERROR_UNKNOWN;
 			break;
 		}
 	} else {
-		uart_puts("Usage: codeset [<set>]\n");
+		ccputs("Usage: codeset [<set>]\n");
 		return EC_ERROR_UNKNOWN;
 	}
 
@@ -753,23 +748,23 @@ static int command_controller_ram(int argc, char **argv)
 
 	if (argc >= 2) {
 		index = strtoi(argv[1], NULL, 0);
-		uart_printf("Controller RAM index = %d\n", index);
+		ccprintf("Controller RAM index = %d\n", index);
 		if (index >= 0x20) {
-			uart_printf("Index is out of range (0x00-0x1f).\n");
+			ccprintf("Index is out of range (0x00-0x1f).\n");
 			return EC_ERROR_UNKNOWN;
 		}
 
 		if (argc >= 3) {
 			update_ctl_ram(index, strtoi(argv[2], NULL, 0));
-			uart_printf("Write ctlram[%d] as 0x%02x.\n",
+			ccprintf("Write ctlram[%d] as 0x%02x.\n",
 			            index, controller_ram[index]);
 		} else {
-			uart_printf("ctlram[%d] is 0x%02x.\n",
+			ccprintf("ctlram[%d] is 0x%02x.\n",
 			            index, controller_ram[index]);
 		}
 	} else {
-		uart_puts("Usage: ctrlram <index> [<write_value>]\n");
-		uart_puts("\nGet/set controller RAM.\n\n");
+		ccputs("Usage: ctrlram <index> [<write_value>]\n");
+		ccputs("\nGet/set controller RAM.\n\n");
 		return EC_ERROR_UNKNOWN;
 	}
 
@@ -786,30 +781,30 @@ static int command_keyboard_press(int argc, char **argv)
 	int r, c, p;
 	char *e;
 	if (argc == 1) {
-		uart_puts("Simulated key:\n");
+		ccputs("Simulated key:\n");
 		for (i = 0; i < CROS_COL_NUM; ++i) {
 			if (simulated_key[i] == 0)
 				continue;
 			for (j = 0; j < CROS_ROW_NUM; ++j)
 				if (simulated_key[i] & (1 << j))
-					uart_printf("\t%d %d\n", i, j);
+					ccprintf("\t%d %d\n", i, j);
 		}
 	} else if (argc == 4) {
 		c = strtoi(argv[1], &e, 0);
 		if ((e && *e) || c < 0 || c >= CROS_COL_NUM) {
-			uart_puts("Bad column.\n");
+			ccputs("Bad column.\n");
 			return EC_ERROR_UNKNOWN;
 		}
 
 		r = strtoi(argv[2], &e, 0);
 		if ((e && *e) || r < 0 || r >= CROS_ROW_NUM) {
-			uart_puts("Bad row.\n");
+			ccputs("Bad row.\n");
 			return EC_ERROR_UNKNOWN;
 		}
 
 		p = strtoi(argv[3], &e, 0);
 		if ((e && *e) || p < 0 || p > 1) {
-			uart_puts("Bad pressed flag.\n");
+			ccputs("Bad pressed flag.\n");
 			return EC_ERROR_UNKNOWN;
 		}
 
@@ -820,7 +815,7 @@ static int command_keyboard_press(int argc, char **argv)
 
 		keyboard_state_changed(r, c, p);
 	} else {
-		uart_puts("Usage: kbpress [<col> <row> <pressed>]\n");
+		ccputs("Usage: kbpress [<col> <row> <pressed>]\n");
 		return EC_ERROR_UNKNOWN;
 	}
 
@@ -862,7 +857,7 @@ static int keyboard_restore_state(void)
 	prev = (const struct kb_state *)system_get_jump_tag(KB_SYSJUMP_TAG,
 	                                                    &version, &size);
 	if (prev && version == KB_HOOK_VERSION && size == sizeof(*prev)) {
-		// Coming back from a sysjump, so restore settings.
+		/* Coming back from a sysjump, so restore settings. */
 		scancode_set = prev->codeset;
 		update_ctl_ram(0, prev->ctlram);
 	}
diff --git a/common/lightbar.c b/common/lightbar.c
index f2e95e3a74..c2d8ccbab3 100644
--- a/common/lightbar.c
+++ b/common/lightbar.c
@@ -13,9 +13,12 @@
 #include "lightbar.h"
 #include "task.h"
 #include "timer.h"
-#include "uart.h"
 #include "util.h"
 
+/* Console output macros */
+#define CPUTS(outstr) cputs(CC_LIGHTBAR, outstr)
+#define CPRINTF(format, args...) cprintf(CC_LIGHTBAR, format, ## args)
+
 /******************************************************************************/
 /* How to talk to the controller */
 /******************************************************************************/
@@ -92,7 +95,7 @@ static void set_from_array(const struct initdata_s *data, int count)
 
 static void lightbar_init_vals(void)
 {
-	uart_printf("[%s()]\n", __func__);
+	CPRINTF("[%s()]\n", __func__);
 	set_from_array(init_vals, ARRAY_SIZE(init_vals));
 }
 
@@ -141,7 +144,7 @@ static void setrgb(int led, int red, int green, int blue)
 
 static void lightbar_off(void)
 {
-	uart_printf("[%s()]\n", __func__);
+	CPRINTF("[%s()]\n", __func__);
 	/* Just go into standby mode. No register values should change. */
 	controller_write(0, 0x01, 0x00);
 	controller_write(1, 0x01, 0x00);
@@ -149,7 +152,7 @@ static void lightbar_off(void)
 
 static void lightbar_on(void)
 {
-	uart_printf("[%s()]\n", __func__);
+	CPRINTF("[%s()]\n", __func__);
 	/* Come out of standby mode. */
 	controller_write(0, 0x01, 0x20);
 	controller_write(1, 0x01, 0x20);
@@ -171,7 +174,7 @@ static void lightbar_setrgb(int led, int red, int green, int blue)
 static inline void lightbar_brightness(int newval)
 {
 	int i;
-	uart_printf("%s[(%d)]\n", __func__, newval);
+	CPRINTF("%s[(%d)]\n", __func__, newval);
 	brightness = newval;
 	for (i = 0; i < NUM_LEDS; i++)
 		lightbar_setrgb(i, current[i][0],
@@ -208,7 +211,7 @@ static const struct {
 static uint32_t sequence_s5(void)
 {
 	int i;
-	uart_printf("[%s()]\n", __func__);
+	CPRINTF("[%s()]\n", __func__);
 
 	/* For now, do something to indicate S5. We might see it. */
 	lightbar_on();
@@ -226,7 +229,7 @@ static uint32_t sequence_s5s3(void)
 {
 	int i;
 
-	uart_printf("[%s()]\n", __func__);
+	CPRINTF("[%s()]\n", __func__);
 	/* The controllers need 100us after power is applied before they'll
 	 * respond. */
 	usleep(100);
@@ -248,7 +251,7 @@ static uint32_t sequence_s0(void)
 	int l = 0;
 	int n = 0;
 
-	uart_printf("[%s()]\n", __func__);
+	CPRINTF("[%s()]\n", __func__);
 	lightbar_on();
 
 	while (1) {
@@ -270,7 +273,7 @@ static uint32_t sequence_s0(void)
 /* CPU is going to sleep */
 static uint32_t sequence_s0s3(void)
 {
-	uart_printf("[%s()]\n", __func__);
+	CPRINTF("[%s()]\n", __func__);
 	lightbar_on();
 	lightbar_setrgb(0, 0, 0, 255);
 	lightbar_setrgb(1, 255, 0, 0);
@@ -291,7 +294,7 @@ static uint32_t sequence_s0s3(void)
 static uint32_t sequence_s3(void)
 {
 	int i = 0;
-	uart_printf("[%s()]\n", __func__);
+	CPRINTF("[%s()]\n", __func__);
 	lightbar_off();
 	lightbar_init_vals();
 	lightbar_setrgb(0, 0, 0, 0);
@@ -316,7 +319,7 @@ static uint32_t sequence_s3(void)
 /* CPU is waking from sleep */
 static uint32_t sequence_s3s0(void)
 {
-	uart_printf("[%s()]\n", __func__);
+	CPRINTF("[%s()]\n", __func__);
 	lightbar_init_vals();
 	lightbar_on();
 	lightbar_setrgb(0, 0, 0, 255);
@@ -335,7 +338,7 @@ static uint32_t sequence_s3s5(void)
 {
 	int i;
 
-	uart_printf("[%s()]\n", __func__);
+	CPRINTF("[%s()]\n", __func__);
 
 	/* For now, do something to indicate this transition.
 	 * We might see it. */
@@ -354,7 +357,7 @@ static uint32_t sequence_test(void)
 	int kmax = 254;
 	int kstep = 8;
 
-	uart_printf("[%s()]\n", __func__);
+	CPRINTF("[%s()]\n", __func__);
 
 	lightbar_init_vals();
 	lightbar_on();
@@ -403,7 +406,7 @@ static uint32_t sequence_pulse(void)
 		{0x1a, g},
 	};
 
-	uart_printf("[%s()]\n", __func__);
+	CPRINTF("[%s()]\n", __func__);
 
 	lightbar_init_vals();
 	lightbar_on();
@@ -427,15 +430,15 @@ static uint32_t sequence_ec_stop(void)
 {
 	uint32_t msg;
 
-	uart_printf("[%s()]\n", __func__);
+	CPRINTF("[%s()]\n", __func__);
 
 	do {
 		msg = TASK_EVENT_CUSTOM(task_wait_event(-1));
-		uart_printf("[%s - got msg %x]\n", __func__, msg);
+		CPRINTF("[%s - got msg %x]\n", __func__, msg);
 	} while (msg != LIGHTBAR_EC_RUN);
 	/* FIXME: What should we do if the host shuts down? */
 
-	uart_printf("[%s() - leaving]\n", __func__);
+	CPRINTF("[%s() - leaving]\n", __func__);
 
 	return 0;
 }
@@ -443,7 +446,7 @@ static uint32_t sequence_ec_stop(void)
 /* We shouldn't come here, but if we do it shouldn't hurt anything */
 static uint32_t sequence_error(void)
 {
-	uart_printf("[%s()]\n", __func__);
+	CPRINTF("[%s()]\n", __func__);
 
 	lightbar_init_vals();
 	lightbar_on();
@@ -540,7 +543,7 @@ static uint32_t sequence_konami(void)
 	int i;
 	int tmp;
 
-	uart_printf("[%s()]\n", __func__);
+	CPRINTF("[%s()]\n", __func__);
 	lightbar_init_vals();
 	lightbar_on();
 
@@ -599,7 +602,7 @@ void lightbar_task(void)
 
 	while (1) {
 		msg = sequence[state]();
-		uart_printf("[%s(%d)]\n", __func__, msg);
+		CPRINTF("[%s(%d)]\n", __func__, msg);
 		msg = TASK_EVENT_CUSTOM(msg);
 		if (msg && msg < LIGHTBAR_NUM_SEQUENCES) {
 			previous_state = state;
@@ -635,7 +638,7 @@ void lightbar_task(void)
 /* Function to request a preset sequence from the lightbar task. */
 void lightbar_sequence(enum lightbar_sequence num)
 {
-	uart_printf("[%s(%d)]\n", __func__, num);
+	CPRINTF("[%s(%d)]\n", __func__, num);
 	if (num && num < LIGHTBAR_NUM_SEQUENCES)
 		task_set_event(TASK_ID_LIGHTBAR,
 			       TASK_EVENT_WAKE | TASK_EVENT_CUSTOM(num), 0);
@@ -669,14 +672,14 @@ DECLARE_HOST_COMMAND(EC_LPC_COMMAND_LIGHTBAR_TEST, lpc_cmd_test);
 
 static int help(const char *cmd)
 {
-	uart_printf("Usage:  %s\n", cmd);
-	uart_printf("        %s off\n", cmd);
-	uart_printf("        %s init\n", cmd);
-	uart_printf("        %s on\n", cmd);
-	uart_printf("        %s msg NUM\n", cmd);
-	uart_printf("        %s brightness NUM\n", cmd);
-	uart_printf("        %s CTRL REG VAL\n", cmd);
-	uart_printf("        %s LED RED GREEN BLUE\n", cmd);
+	ccprintf("Usage:  %s\n", cmd);
+	ccprintf("        %s off\n", cmd);
+	ccprintf("        %s init\n", cmd);
+	ccprintf("        %s on\n", cmd);
+	ccprintf("        %s msg NUM\n", cmd);
+	ccprintf("        %s brightness NUM\n", cmd);
+	ccprintf("        %s CTRL REG VAL\n", cmd);
+	ccprintf("        %s LED RED GREEN BLUE\n", cmd);
 	return EC_ERROR_UNKNOWN;
 }
 
@@ -691,7 +694,7 @@ static void dump_regs(void)
 		reg = reglist[i];
 		d1 = controller_read(0, reg);
 		d2 = controller_read(1, reg);
-		uart_printf(" %02x     %02x     %02x\n", reg, d1, d2);
+		ccprintf(" %02x     %02x     %02x\n", reg, d1, d2);
 	}
 }
 
diff --git a/common/port80.c b/common/port80.c
index 77ff6fa471..f048a54884 100644
--- a/common/port80.c
+++ b/common/port80.c
@@ -8,9 +8,10 @@
 #include "board.h"
 #include "console.h"
 #include "port80.h"
-#include "uart.h"
 #include "util.h"
 
+#define CPRINTF(format, args...) cprintf(CC_PORT80, format, ## args)
+
 #define HISTORY_LEN 16
 
 static uint8_t history[HISTORY_LEN];
@@ -24,7 +25,7 @@ void port_80_write(int data)
 	 * itself.  Probably not worth the system overhead to buffer the data
 	 * and print it from a task, because we're printing a small amount of
 	 * data and uart_printf() doesn't block. */
-	uart_printf("%c[%T Port 80: 0x%02x]", scroll ? '\n' : '\r', data);
+	CPRINTF("%c[%T Port 80: 0x%02x]", scroll ? '\n' : '\r', data);
 
 	history[head] = data;
 	head = (head + 1) & (HISTORY_LEN - 1);
@@ -42,7 +43,7 @@ static int command_port80(int argc, char **argv)
 	 * (scrolling) or CR (non-scrolling). */
 	if (argc > 1 && !strcasecmp(argv[1], "scroll")) {
 		scroll = !scroll;
-		uart_printf("port80 scrolling %sabled\n",
+		ccprintf("port80 scrolling %sabled\n",
 			    scroll ? "en" : "dis");
 		return EC_SUCCESS;
 	}
@@ -50,10 +51,10 @@ static int command_port80(int argc, char **argv)
 	/* Technically, if a port 80 write comes in while we're
 	 * printing this, we could print an incorrect history.
 	 * Probably not worth the complexity to work around that. */
-	uart_puts("Last port 80 writes:");
+	ccputs("Last port 80 writes:");
 	for (i = 0; i < HISTORY_LEN; i++)
-		uart_printf(" %02x", history[(h + i) & (HISTORY_LEN - 1)]);
-	uart_puts(" <--newest\n");
+		ccprintf(" %02x", history[(h + i) & (HISTORY_LEN - 1)]);
+	ccputs(" <--newest\n");
 	return EC_SUCCESS;
 }
 DECLARE_CONSOLE_COMMAND(port80, command_port80);
diff --git a/common/system_common.c b/common/system_common.c
index 0d1805b2ca..f1b5473eb7 100644
--- a/common/system_common.c
+++ b/common/system_common.c
@@ -16,6 +16,9 @@
 #include "util.h"
 #include "version.h"
 
+/* Console output macros */
+#define CPUTS(outstr) cputs(CC_SYSTEM, outstr)
+#define CPRINTF(format, args...) cprintf(CC_SYSTEM, format, ## args)
 
 struct jump_tag {
 	uint16_t tag;
@@ -330,12 +333,12 @@ int system_common_pre_init(void)
 
 static int command_sysinfo(int argc, char **argv)
 {
-	uart_printf("Reset cause: %d (%s)\n",
+	ccprintf("Reset cause: %d (%s)\n",
 		    system_get_reset_cause(),
 		    system_get_reset_cause_string());
-	uart_printf("Scratchpad: 0x%08x\n", system_get_scratchpad());
-	uart_printf("Firmware copy: %s\n", system_get_image_copy_string());
-	uart_printf("Jumped to this copy: %s\n",
+	ccprintf("Scratchpad: 0x%08x\n", system_get_scratchpad());
+	ccprintf("Firmware copy: %s\n", system_get_image_copy_string());
+	ccprintf("Jumped to this copy: %s\n",
 		    system_jumped_to_this_image() ? "yes" : "no");
 	return EC_SUCCESS;
 }
@@ -344,9 +347,9 @@ DECLARE_CONSOLE_COMMAND(sysinfo, command_sysinfo);
 
 static int command_chipinfo(int argc, char **argv)
 {
-	uart_printf("Chip vendor:   %s\n", system_get_chip_vendor());
-	uart_printf("Chip name:     %s\n", system_get_chip_name());
-	uart_printf("Chip revision: %s\n", system_get_chip_revision());
+	ccprintf("Chip vendor:   %s\n", system_get_chip_vendor());
+	ccprintf("Chip name:     %s\n", system_get_chip_name());
+	ccprintf("Chip revision: %s\n", system_get_chip_revision());
 	return EC_SUCCESS;
 }
 DECLARE_CONSOLE_COMMAND(chipinfo, command_chipinfo);
@@ -358,16 +361,16 @@ static int command_set_scratchpad(int argc, char **argv)
 	char *e;
 
 	if (argc < 2) {
-		uart_puts("Usage: scratchpad <value>\n");
+		ccputs("Usage: scratchpad <value>\n");
 		return EC_ERROR_UNKNOWN;
 	}
 
 	s = strtoi(argv[1], &e, 0);
 	if (*e) {
-		uart_puts("Invalid scratchpad value\n");
+		ccputs("Invalid scratchpad value\n");
 		return EC_ERROR_UNKNOWN;
 	}
-	uart_printf("Setting scratchpad to 0x%08x\n", s);
+	ccprintf("Setting scratchpad to 0x%08x\n", s);
 	return  system_set_scratchpad(s);
 }
 DECLARE_CONSOLE_COMMAND(setscratchpad, command_set_scratchpad);
@@ -379,15 +382,15 @@ static int command_hibernate(int argc, char **argv)
 	int microseconds = 0;
 
 	if (argc < 2) {
-		uart_puts("Usage: hibernate <seconds> [<microseconds>]\n");
+		ccputs("Usage: hibernate <seconds> [<microseconds>]\n");
 		return EC_ERROR_UNKNOWN;
 	}
 	seconds = strtoi(argv[1], NULL, 0);
 	if (argc >= 3)
 		microseconds = strtoi(argv[2], NULL, 0);
 
-	uart_printf("Hibernating for %d.%06d s ...\n", seconds, microseconds);
-	uart_flush_output();
+	ccprintf("Hibernating for %d.%06d s ...\n", seconds, microseconds);
+	cflush();
 
 	system_hibernate(seconds, microseconds);
 
@@ -398,13 +401,13 @@ DECLARE_CONSOLE_COMMAND(hibernate, command_hibernate);
 
 static int command_version(int argc, char **argv)
 {
-	uart_printf("RO version:   %s\n",
+	ccprintf("RO version:   %s\n",
 		    system_get_version(SYSTEM_IMAGE_RO));
-	uart_printf("RW-A version: %s\n",
+	ccprintf("RW-A version: %s\n",
 		    system_get_version(SYSTEM_IMAGE_RW_A));
-	uart_printf("RW-B version: %s\n",
+	ccprintf("RW-B version: %s\n",
 		    system_get_version(SYSTEM_IMAGE_RW_B));
-	uart_printf("Current build: %s\n", system_get_build_info());
+	ccprintf("Current build: %s\n", system_get_build_info());
 	return EC_SUCCESS;
 }
 DECLARE_CONSOLE_COMMAND(version, command_version);
@@ -419,30 +422,30 @@ static int command_sysjump(int argc, char **argv)
 	 * be disabled. */
 
 	if (argc < 2) {
-		uart_puts("Usage: sysjump <RO | A | B | addr>\n");
+		ccputs("Usage: sysjump <RO | A | B | addr>\n");
 		return EC_ERROR_INVAL;
 	}
 
 	/* Handle named images */
 	if (!strcasecmp(argv[1], "RO")) {
-		uart_puts("Jumping directly to RO image...\n");
+		ccputs("Jumping directly to RO image...\n");
 		return system_run_image_copy(SYSTEM_IMAGE_RO);
 	} else if (!strcasecmp(argv[1], "A")) {
-		uart_puts("Jumping directly to image A...\n");
+		ccputs("Jumping directly to image A...\n");
 		return system_run_image_copy(SYSTEM_IMAGE_RW_A);
 	} else if (!strcasecmp(argv[1], "B")) {
-		uart_puts("Jumping directly to image B...\n");
+		ccputs("Jumping directly to image B...\n");
 		return system_run_image_copy(SYSTEM_IMAGE_RW_B);
 	}
 
 	/* Check for arbitrary address */
 	addr = strtoi(argv[1], &e, 0);
 	if (e && *e) {
-		uart_puts("Invalid image address\n");
+		ccputs("Invalid image address\n");
 		return EC_ERROR_INVAL;
 	}
-	uart_printf("Jumping directly to 0x%08x...\n", addr);
-	uart_flush_output();
+	ccprintf("Jumping directly to 0x%08x...\n", addr);
+	cflush();
 	jump_to_image(addr);
 	return EC_SUCCESS;
 }
@@ -451,8 +454,8 @@ DECLARE_CONSOLE_COMMAND(sysjump, command_sysjump);
 
 static int command_reboot(int argc, char **argv)
 {
-	uart_puts("Rebooting!\n\n\n");
-	uart_flush_output();
+	ccputs("Rebooting!\n\n\n");
+	cflush();
 	system_reset(1);
 	return EC_SUCCESS;
 }
@@ -538,17 +541,17 @@ enum lpc_status host_command_reboot(uint8_t *data)
 
 	switch (p->target) {
 	case EC_LPC_IMAGE_RO:
-		uart_puts("[Rebooting to image RO!\n]");
+		CPUTS("[Rebooting to image RO!\n]");
 		clean_busy_bits();
 		system_run_image_copy(SYSTEM_IMAGE_RO);
 		break;
 	case EC_LPC_IMAGE_RW_A:
-		uart_puts("[Rebooting to image A!]\n");
+		CPUTS("[Rebooting to image A!]\n");
 		clean_busy_bits();
 		system_run_image_copy(SYSTEM_IMAGE_RW_A);
 		break;
 	case EC_LPC_IMAGE_RW_B:
-		uart_puts("[Rebooting to image B!]\n");
+		CPUTS("[Rebooting to image B!]\n");
 		clean_busy_bits();
 		system_run_image_copy(SYSTEM_IMAGE_RW_B);
 		break;
diff --git a/common/uart_buffering.c b/common/uart_buffering.c
index 6d08dbb9af..d83b34ea40 100644
--- a/common/uart_buffering.c
+++ b/common/uart_buffering.c
@@ -357,6 +357,7 @@ void uart_process(void)
 		uart_tx_stop();
 }
 
+
 void uart_set_console_mode(int enable)
 {
 	console_mode = enable;
@@ -382,7 +383,7 @@ int uart_puts(const char *outstr)
 }
 
 
-int uart_printf(const char *format, ...)
+int uart_vprintf(const char *format, va_list args)
 {
 	static const char int_chars[] = "0123456789abcdef";
 	static const char error_str[] = "ERROR";
@@ -394,12 +395,9 @@ int uart_printf(const char *format, ...)
 	int is_left;
 	int pad_zero;
 	int pad_width;
-	va_list args;
 	char *vstr;
 	int vlen;
 
-	va_start(args, format);
-
 	while (*format && !dropped_chars) {
 		int c = *format++;
 
@@ -532,7 +530,6 @@ int uart_printf(const char *format, ...)
 			vlen++;
 		}
 	}
-	va_end(args);
 
 	if (uart_tx_stopped())
 		uart_tx_start();
@@ -541,6 +538,19 @@ int uart_printf(const char *format, ...)
 	return dropped_chars ? EC_ERROR_OVERFLOW : EC_SUCCESS;
 }
 
+
+int uart_printf(const char *format, ...)
+{
+	int rv;
+	va_list args;
+
+	va_start(args, format);
+	rv = uart_vprintf(format, args);
+	va_end(args);
+	return rv;
+}
+
+
 void uart_flush_output(void)
 {
 	/* Wait for buffer to empty */
diff --git a/common/usb_charge_commands.c b/common/usb_charge_commands.c
index 006ef97ea8..a8a855841a 100644
--- a/common/usb_charge_commands.c
+++ b/common/usb_charge_commands.c
@@ -8,9 +8,12 @@
 #include "console.h"
 #include "usb_charge.h"
 #include "host_command.h"
-#include "uart.h"
 #include "util.h"
 
+/* Console output macros */
+#define CPUTS(outstr) cputs(CC_USBCHARGE, outstr)
+#define CPRINTF(format, args...) cprintf(CC_USBCHARGE, format, ## args)
+
 
 enum lpc_status usb_charge_command_set_mode(uint8_t *data)
 {
@@ -18,8 +21,8 @@ enum lpc_status usb_charge_command_set_mode(uint8_t *data)
 			(struct lpc_params_usb_charge_set_mode *)data;
 	int rv;
 
-	uart_printf("[Setting USB port %d to mode %d]\n",
-		    p->usb_port_id, p->mode);
+	CPRINTF("[Setting USB port %d to mode %d]\n",
+		p->usb_port_id, p->mode);
 	rv = usb_charge_set_mode(p->usb_port_id, p->mode);
 
 	if (rv != EC_SUCCESS)
diff --git a/common/x86_power.c b/common/x86_power.c
index 8cb1daaa55..de6a5cfe5d 100644
--- a/common/x86_power.c
+++ b/common/x86_power.c
@@ -16,10 +16,13 @@
 #include "system.h"
 #include "task.h"
 #include "timer.h"
-#include "uart.h"
 #include "util.h"
 #include "x86_power.h"
 
+/* Console output macros */
+#define CPUTS(outstr) cputs(CC_X86POWER, outstr)
+#define CPRINTF(format, args...) cprintf(CC_X86POWER, format, ## args)
+
 /* Default timeout in us; if we've been waiting this long for an input
  * transition, just jump to the next state. */
 #define DEFAULT_TIMEOUT 1000000
@@ -145,9 +148,9 @@ static int wait_in_signals(uint32_t want)
 	while ((in_signals & in_want) != in_want) {
 		if (task_wait_event(DEFAULT_TIMEOUT) == TASK_EVENT_TIMER) {
 			update_in_signals();
-			uart_printf("[x86 power timeout on input; "
-				    "wanted 0x%04x, got 0x%04x]\n",
-				    in_want, in_signals & in_want);
+			CPRINTF("[x86 power timeout on input; "
+				"wanted 0x%04x, got 0x%04x]\n",
+				in_want, in_signals & in_want);
 			return EC_ERROR_TIMEOUT;
 		}
 		/* TODO: should really shrink the remaining timeout if we woke
@@ -240,7 +243,7 @@ void x86_power_interrupt(enum gpio_signal signal)
 /*****************************************************************************/
 /* Initialization */
 
-int x86_power_init(void)
+static int x86_power_init(void)
 {
 	/* Default to G3 state unless proven otherwise */
 	state = X86_G3;
@@ -254,11 +257,11 @@ int x86_power_init(void)
 	 * through G3. */
 	if (system_jumped_to_this_image()) {
 		if ((in_signals & IN_ALL_S0) == IN_ALL_S0) {
-			uart_puts("[x86 already in S0]\n");
+			CPUTS("[x86 already in S0]\n");
 			state = X86_S0;
 		} else {
 			/* Force all signals to their G3 states */
-			uart_puts("[x86 forcing G3]\n");
+			CPUTS("[x86 forcing G3]\n");
 			gpio_set_level(GPIO_PCH_PWROK, 0);
 			gpio_set_level(GPIO_ENABLE_VCORE, 0);
 			gpio_set_level(GPIO_PCH_RCINn, 0);
@@ -300,8 +303,8 @@ void x86_power_task(void)
 	x86_power_init();
 
 	while (1) {
-		uart_printf("[%T x86 power state %d = %s, in 0x%04x]\n",
-			    state, state_names[state], in_signals);
+		CPRINTF("[%T x86 power state %d = %s, in 0x%04x]\n",
+			state, state_names[state], in_signals);
 
 		switch (state) {
 		case X86_G3:
@@ -460,11 +463,11 @@ void x86_power_task(void)
 static int command_x86power(int argc, char **argv)
 {
 	/* Print current state */
-	uart_printf("Current X86 state: %d (%s)\n", state, state_names[state]);
+	ccprintf("Current X86 state: %d (%s)\n", state, state_names[state]);
 
 	/* Forcing a power state from EC is deprecated */
 	if (argc > 1)
-		uart_puts("Use 'powerbtn' instead of 'x86power s0'.\n");
+		ccputs("Use 'powerbtn' instead of 'x86power s0'.\n");
 
 	return EC_SUCCESS;
 }
@@ -481,7 +484,7 @@ static int command_x86reset(int argc, char **argv)
 		is_cold = 0;
 
 	/* Force the x86 to reset */
-	uart_printf("Issuing x86 %s reset...\n", is_cold ? "cold" : "warm");
+	ccprintf("Issuing x86 %s reset...\n", is_cold ? "cold" : "warm");
 	x86_power_reset(is_cold);
 	return EC_SUCCESS;
 }