Put the lightbar IC controls and pattern logic into separate files

This puts the code that talks to the lightbar hardware in one file, and the
code that implements the pretty patterns and behavior into another. This
will let us make improvements or changes to the patterns without requiring
detailed knowledge of the controller chips.

BUG=chrome-os-partner:28596
BRANCH=ToT
TEST=make buildall -j

Refactoring only. There is no new functionality.

Change-Id: I4e5fe8943385ddeab26bbd7e66c20e2dccd3dc43
Signed-off-by: Bill Richardson <wfrichar@chromium.org>
Reviewed-on: https://chromium-review.googlesource.com/199882
Reviewed-by: Randall Spangler <rspangler@chromium.org>

4 files changed, 316 insertions, 284 deletions

diff --git a/common/build.mk b/common/build.mk
index 7189a07432..07ea8e2ba9 100644
--- a/common/build.mk
+++ b/common/build.mk
@@ -71,7 +71,7 @@ common-$(HAS_TASK_CONSOLE)+=console.o console_output.o uart_buffering.o
 common-$(HAS_TASK_CONSOLE)+=memory_commands.o
 common-$(HAS_TASK_HOSTCMD)+=acpi.o host_command.o host_event_commands.o
 common-$(HAS_TASK_KEYSCAN)+=keyboard_scan.o
-common-$(HAS_TASK_LIGHTBAR)+=lightbar.o
+common-$(HAS_TASK_LIGHTBAR)+=lb_common.o lightbar.o
 common-$(HAS_TASK_MOTIONSENSE)+=motion_sense.o math_util.o
 common-$(TEST_BUILD)+=test_util.o
 
diff --git a/common/lb_common.c b/common/lb_common.c
new file mode 100644
index 0000000000..1cb49cd096
--- /dev/null
+++ b/common/lb_common.c
@@ -0,0 +1,270 @@
+/* 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.
+ *
+ * Lightbar IC interface
+ */
+
+#include "common.h"
+#include "console.h"
+#include "ec_commands.h"
+#include "i2c.h"
+#include "lb_common.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 */
+/******************************************************************************/
+
+/* Since there's absolutely nothing we can do about it if an I2C access
+ * isn't working, we're completely ignoring any failures. */
+
+static const uint8_t i2c_addr[] = { 0x54, 0x56 };
+
+static inline void controller_write(int ctrl_num, uint8_t reg, uint8_t val)
+{
+	ctrl_num = ctrl_num % ARRAY_SIZE(i2c_addr);
+	i2c_write8(I2C_PORT_LIGHTBAR, i2c_addr[ctrl_num], reg, val);
+}
+
+static inline uint8_t controller_read(int ctrl_num, uint8_t reg)
+{
+	int val = 0;
+	ctrl_num = ctrl_num % ARRAY_SIZE(i2c_addr);
+	i2c_read8(I2C_PORT_LIGHTBAR, i2c_addr[ctrl_num], reg, &val);
+	return val;
+}
+
+/******************************************************************************/
+/* Controller details. We have an ADP8861 and and ADP8863, but we can treat
+ * them identically for our purposes */
+/******************************************************************************/
+
+#ifdef BOARD_BDS
+/* We need to limit the total current per ISC to no more than 20mA (5mA per
+ * color LED, but we have four LEDs in parallel on each ISC). Any more than
+ * that runs the risk of damaging the LED component. A value of 0x67 is as high
+ * as we want (assuming Square Law), but the blue LED is the least bright, so
+ * I've lowered the other colors until they all appear approximately equal
+ * brightness when full on. That's still pretty bright and a lot of current
+ * drain on the battery, so we'll probably rarely go that high. */
+#define MAX_RED   0x5c
+#define MAX_GREEN 0x30
+#define MAX_BLUE  0x67
+#endif
+#ifdef BOARD_LINK
+/* Link uses seven segments, not four, but keep the same limits anyway */
+#define MAX_RED   0x5c
+#define MAX_GREEN 0x30
+#define MAX_BLUE  0x67
+#endif
+#ifdef BOARD_SAMUS
+/* Samus uses completely different LEDs, so the numbers are different */
+#define MAX_RED   0x4f
+#define MAX_GREEN 0x55
+#define MAX_BLUE  0x67
+#endif
+
+/* How we'd like to see the driver chips initialized. The controllers have some
+ * auto-cycling capability, but it's not much use for our purposes. For now,
+ * we'll just control all color changes actively. */
+struct initdata_s {
+	uint8_t reg;
+	uint8_t val;
+};
+
+static const struct initdata_s init_vals[] = {
+	{0x04, 0x00},				/* no backlight function */
+	{0x05, 0x3f},				/* xRGBRGB per chip */
+	{0x0f, 0x01},				/* square law looks better */
+	{0x10, 0x3f},				/* enable independent LEDs */
+	{0x11, 0x00},				/* no auto cycling */
+	{0x12, 0x00},				/* no auto cycling */
+	{0x13, 0x00},				/* instant fade in/out */
+	{0x14, 0x00},				/* not using LED 7 */
+	{0x15, 0x00},				/* current for LED 6 (blue) */
+	{0x16, 0x00},				/* current for LED 5 (red) */
+	{0x17, 0x00},				/* current for LED 4 (green) */
+	{0x18, 0x00},				/* current for LED 3 (blue) */
+	{0x19, 0x00},				/* current for LED 2 (red) */
+	{0x1a, 0x00},				/* current for LED 1 (green) */
+};
+
+static void set_from_array(const struct initdata_s *data, int count)
+{
+	int i;
+	for (i = 0; i < count; i++) {
+		controller_write(0, data[i].reg, data[i].val);
+		controller_write(1, data[i].reg, data[i].val);
+	}
+}
+
+/* Controller register lookup tables. */
+static const uint8_t led_to_ctrl[] = { 1, 1, 0, 0 };
+#ifdef BOARD_BDS
+static const uint8_t led_to_isc[] = { 0x18, 0x15, 0x18, 0x15 };
+#endif
+#ifdef BOARD_LINK
+static const uint8_t led_to_isc[] = { 0x18, 0x15, 0x18, 0x15 };
+#endif
+#ifdef BOARD_SAMUS
+static const uint8_t led_to_isc[] = { 0x15, 0x18, 0x15, 0x18 };
+#endif
+
+/* Scale 0-255 into max value */
+static inline uint8_t scale_abs(int val, int max)
+{
+	return (val * max)/255;
+}
+
+/* This is the overall brightness control. */
+static int brightness = 0xc0;
+
+/* So that we can make brightness changes happen instantly, we need to track
+ * the current values. The values in the controllers aren't very helpful. */
+static uint8_t current[NUM_LEDS][3];
+
+/* Scale 0-255 by brightness */
+static inline uint8_t scale(int val, int max)
+{
+	return scale_abs((val * brightness)/255, max);
+}
+
+/* Helper function to set one LED color and remember it for later */
+static void setrgb(int led, int red, int green, int blue)
+{
+	int ctrl, bank;
+	current[led][0] = red;
+	current[led][1] = green;
+	current[led][2] = blue;
+	ctrl = led_to_ctrl[led];
+	bank = led_to_isc[led];
+	controller_write(ctrl, bank, scale(blue, MAX_BLUE));
+	controller_write(ctrl, bank+1, scale(red, MAX_RED));
+	controller_write(ctrl, bank+2, scale(green, MAX_GREEN));
+}
+
+/* LEDs are numbered 0-3, RGB values should be in 0-255.
+ * If you specify too large an LED, it sets them all. */
+void lb_set_rgb(unsigned int led, int red, int green, int blue)
+{
+	int i;
+	if (led >= NUM_LEDS)
+		for (i = 0; i < NUM_LEDS; i++)
+			setrgb(i, red, green, blue);
+	else
+		setrgb(led, red, green, blue);
+}
+
+/* Get current LED values, if the LED number is in range. */
+int lb_get_rgb(unsigned int led, uint8_t *red, uint8_t *green, uint8_t *blue)
+{
+	if (led < 0 || led >= NUM_LEDS)
+		return EC_RES_INVALID_PARAM;
+
+	*red = current[led][0];
+	*green = current[led][1];
+	*blue = current[led][2];
+
+	return EC_RES_SUCCESS;
+}
+
+/* Change current display brightness (0-255) */
+void lb_set_brightness(unsigned int newval)
+{
+	int i;
+	CPRINTF("[%T LB_bright 0x%02x]\n", newval);
+	brightness = newval;
+	for (i = 0; i < NUM_LEDS; i++)
+		setrgb(i, current[i][0], current[i][1], current[i][2]);
+}
+
+/* Get current display brightness (0-255) */
+uint8_t lb_get_brightness(void)
+{
+	return brightness;
+}
+
+/* Initialize the controller ICs after reset */
+void lb_init(void)
+{
+	CPRINTF("[%T LB_init_vals]\n");
+	set_from_array(init_vals, ARRAY_SIZE(init_vals));
+	memset(current, 0, sizeof(current));
+}
+
+/* Just go into standby mode. No register values should change. */
+void lb_off(void)
+{
+	CPRINTF("[%T LB_off]\n");
+	controller_write(0, 0x01, 0x00);
+	controller_write(1, 0x01, 0x00);
+}
+
+/* Come out of standby mode. */
+void lb_on(void)
+{
+	CPRINTF("[%T LB_on]\n");
+	controller_write(0, 0x01, 0x20);
+	controller_write(1, 0x01, 0x20);
+}
+
+/*
+ * This sets up the auto-cycling features of the controllers to make a
+ * semi-random pattern of slowly fading colors. This is interesting only
+ * because it doesn't require any effort from the EC.
+*/
+void lb_start_builtin_cycle(void)
+{
+	int r = scale(255, MAX_RED);
+	int g = scale(255, MAX_BLUE);
+	int b = scale(255, MAX_GREEN);
+	struct initdata_s pulse_vals[] = {
+		{0x11, 0xce},
+		{0x12, 0x67},
+		{0x13, 0xef},
+		{0x15, b},
+		{0x16, r},
+		{0x17, g},
+		{0x18, b},
+		{0x19, r},
+		{0x1a, g},
+	};
+
+	set_from_array(pulse_vals, ARRAY_SIZE(pulse_vals));
+	controller_write(1, 0x13, 0xcd);	/* this one's different */
+}
+
+static const uint8_t dump_reglist[] = {
+	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+	0x08, 0x09, 0x0a,			  0x0f,
+	0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
+	0x18, 0x19, 0x1a
+};
+
+/* Helper for host command to dump controller registers */
+void lb_hc_cmd_dump(struct ec_response_lightbar *out)
+{
+	int i;
+	uint8_t reg;
+
+	BUILD_ASSERT(ARRAY_SIZE(dump_reglist) ==
+		     ARRAY_SIZE(out->dump.vals));
+
+	for (i = 0; i < ARRAY_SIZE(dump_reglist); i++) {
+		reg = dump_reglist[i];
+		out->dump.vals[i].reg = reg;
+		out->dump.vals[i].ic0 = controller_read(0, reg);
+		out->dump.vals[i].ic1 = controller_read(1, reg);
+	}
+}
+
+/* Helper for host command to write controller registers directly */
+void lb_hc_cmd_reg(const struct ec_params_lightbar *in)
+{
+	controller_write(in->reg.ctrl, in->reg.reg, in->reg.value);
+}
diff --git a/common/lightbar.c b/common/lightbar.c
index 873263fe4e..6508d897fb 100644
--- a/common/lightbar.c
+++ b/common/lightbar.c
@@ -1,4 +1,5 @@
-/* Copyright (c) 2012 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.
  *
@@ -9,10 +10,10 @@
 #include "charge_state.h"
 #include "common.h"
 #include "console.h"
-#include "gpio.h"
+#include "ec_commands.h"
 #include "hooks.h"
 #include "host_command.h"
-#include "i2c.h"
+#include "lb_common.h"
 #include "lightbar.h"
 #include "pwm.h"
 #include "system.h"
@@ -20,11 +21,10 @@
 #include "timer.h"
 #include "util.h"
 
-
 /*
- * The Link lightbar had no version command, so defaulted to zero. If we make
- * any incompatible changes, update the version. Indicate any new features in
- * the current version with flags bits.
+ * The Link lightbar had no version command, so defaulted to zero. We have
+ * added a couple of new commands, so we've updated the version. Any
+ * optional features in the current version should be marked with flags.
  */
 #define LIGHTBAR_IMPLEMENTATION_VERSION 1
 #define LIGHTBAR_IMPLEMENTATION_FLAGS   0
@@ -34,267 +34,6 @@
 #define CPRINTF(format, args...) cprintf(CC_LIGHTBAR, format, ## args)
 
 /******************************************************************************/
-/* How to talk to the controller */
-/******************************************************************************/
-
-/* Since there's absolutely nothing we can do about it if an I2C access
- * isn't working, we're completely ignoring any failures. */
-
-static const uint8_t i2c_addr[] = { 0x54, 0x56 };
-
-static inline void controller_write(int ctrl_num, uint8_t reg, uint8_t val)
-{
-	ctrl_num = ctrl_num % ARRAY_SIZE(i2c_addr);
-	i2c_write8(I2C_PORT_LIGHTBAR, i2c_addr[ctrl_num], reg, val);
-}
-
-static inline uint8_t controller_read(int ctrl_num, uint8_t reg)
-{
-	int val = 0;
-	ctrl_num = ctrl_num % ARRAY_SIZE(i2c_addr);
-	i2c_read8(I2C_PORT_LIGHTBAR, i2c_addr[ctrl_num], reg, &val);
-	return val;
-}
-
-/******************************************************************************/
-/* Controller details. We have an ADP8861 and and ADP8863, but we can treat
- * them identically for our purposes */
-/******************************************************************************/
-
-#ifdef BOARD_BDS
-/* We need to limit the total current per ISC to no more than 20mA (5mA per
- * color LED, but we have four LEDs in parallel on each ISC). Any more than
- * that runs the risk of damaging the LED component. A value of 0x67 is as high
- * as we want (assuming Square Law), but the blue LED is the least bright, so
- * I've lowered the other colors until they all appear approximately equal
- * brightness when full on. That's still pretty bright and a lot of current
- * drain on the battery, so we'll probably rarely go that high. */
-#define MAX_RED   0x5c
-#define MAX_GREEN 0x30
-#define MAX_BLUE  0x67
-#endif
-#ifdef BOARD_LINK
-/* Link uses seven segments, not four, but keep the same limits anyway */
-#define MAX_RED   0x5c
-#define MAX_GREEN 0x30
-#define MAX_BLUE  0x67
-#endif
-#ifdef BOARD_SAMUS
-/* Samus uses completely different LEDs, so the numbers are different */
-#define MAX_RED   0x4f
-#define MAX_GREEN 0x55
-#define MAX_BLUE  0x67
-#endif
-
-/* How many (logical) LEDs do we have? */
-#define NUM_LEDS 4
-
-/* How we'd like to see the driver chips initialized. The controllers have some
- * auto-cycling capability, but it's not much use for our purposes. For now,
- * we'll just control all color changes actively. */
-struct initdata_s {
-	uint8_t reg;
-	uint8_t val;
-};
-
-static const struct initdata_s init_vals[] = {
-	{0x04, 0x00},				/* no backlight function */
-	{0x05, 0x3f},				/* xRGBRGB per chip */
-	{0x0f, 0x01},				/* square law looks better */
-	{0x10, 0x3f},				/* enable independent LEDs */
-	{0x11, 0x00},				/* no auto cycling */
-	{0x12, 0x00},				/* no auto cycling */
-	{0x13, 0x00},				/* instant fade in/out */
-	{0x14, 0x00},				/* not using LED 7 */
-	{0x15, 0x00},				/* current for LED 6 (blue) */
-	{0x16, 0x00},				/* current for LED 5 (red) */
-	{0x17, 0x00},				/* current for LED 4 (green) */
-	{0x18, 0x00},				/* current for LED 3 (blue) */
-	{0x19, 0x00},				/* current for LED 2 (red) */
-	{0x1a, 0x00},				/* current for LED 1 (green) */
-};
-
-static void set_from_array(const struct initdata_s *data, int count)
-{
-	int i;
-	for (i = 0; i < count; i++) {
-		controller_write(0, data[i].reg, data[i].val);
-		controller_write(1, data[i].reg, data[i].val);
-	}
-}
-
-/* Controller register lookup tables. */
-static const uint8_t led_to_ctrl[] = { 1, 1, 0, 0 };
-#ifdef BOARD_BDS
-static const uint8_t led_to_isc[] = { 0x18, 0x15, 0x18, 0x15 };
-#endif
-#ifdef BOARD_LINK
-static const uint8_t led_to_isc[] = { 0x18, 0x15, 0x18, 0x15 };
-#endif
-#ifdef BOARD_SAMUS
-static const uint8_t led_to_isc[] = { 0x15, 0x18, 0x15, 0x18 };
-#endif
-
-/* Scale 0-255 into max value */
-static inline uint8_t scale_abs(int val, int max)
-{
-	return (val * max)/255;
-}
-
-/* This is the overall brightness control. */
-static int brightness = 0xc0;
-
-/* So that we can make brightness changes happen instantly, we need to track
- * the current values. The values in the controllers aren't very helpful. */
-static uint8_t current[NUM_LEDS][3];
-
-/* Scale 0-255 by brightness */
-static inline uint8_t scale(int val, int max)
-{
-	return scale_abs((val * brightness)/255, max);
-}
-
-/* Helper function to set one LED color and remember it for later */
-static void setrgb(int led, int red, int green, int blue)
-{
-	int ctrl, bank;
-	current[led][0] = red;
-	current[led][1] = green;
-	current[led][2] = blue;
-	ctrl = led_to_ctrl[led];
-	bank = led_to_isc[led];
-	controller_write(ctrl, bank, scale(blue, MAX_BLUE));
-	controller_write(ctrl, bank+1, scale(red, MAX_RED));
-	controller_write(ctrl, bank+2, scale(green, MAX_GREEN));
-}
-
-/* LEDs are numbered 0-3, RGB values should be in 0-255.
- * If you specify too large an LED, it sets them all. */
-static void lb_set_rgb(unsigned int led, int red, int green, int blue)
-{
-	int i;
-	if (led >= NUM_LEDS)
-		for (i = 0; i < NUM_LEDS; i++)
-			setrgb(i, red, green, blue);
-	else
-		setrgb(led, red, green, blue);
-}
-
-/* Get current LED values, if the LED number is in range. */
-static int lb_get_rgb(unsigned int led,
-		      uint8_t *red, uint8_t *green, uint8_t *blue)
-{
-	if (led < 0 || led >= NUM_LEDS)
-		return EC_RES_INVALID_PARAM;
-
-	*red = current[led][0];
-	*green = current[led][1];
-	*blue = current[led][2];
-
-	return EC_RES_SUCCESS;
-}
-
-/* Change current display brightness (0-255) */
-static void lb_set_brightness(unsigned int newval)
-{
-	int i;
-	CPRINTF("[%T LB_bright 0x%02x]\n", newval);
-	brightness = newval;
-	for (i = 0; i < NUM_LEDS; i++)
-		setrgb(i, current[i][0], current[i][1], current[i][2]);
-}
-
-/* Get current display brightness (0-255) */
-static uint8_t lb_get_brightness(void)
-{
-	return brightness;
-}
-
-/* Initialize the controller ICs after reset */
-static void lb_init(void)
-{
-	CPRINTF("[%T LB_init_vals]\n");
-	set_from_array(init_vals, ARRAY_SIZE(init_vals));
-	memset(current, 0, sizeof(current));
-}
-
-/* Just go into standby mode. No register values should change. */
-static void lb_off(void)
-{
-	CPRINTF("[%T LB_off]\n");
-	controller_write(0, 0x01, 0x00);
-	controller_write(1, 0x01, 0x00);
-}
-
-/* Come out of standby mode. */
-static void lb_on(void)
-{
-	CPRINTF("[%T LB_on]\n");
-	controller_write(0, 0x01, 0x20);
-	controller_write(1, 0x01, 0x20);
-}
-
-
-/*
- * This sets up the auto-cycling features of the controllers to make a
- * semi-random pattern of slowly fading colors. This is interesting only
- * because it doesn't require any effort from the EC.
-*/
-static void lb_start_builtin_cycle(void)
-{
-	int r = scale(255, MAX_RED);
-	int g = scale(255, MAX_BLUE);
-	int b = scale(255, MAX_GREEN);
-	struct initdata_s pulse_vals[] = {
-		{0x11, 0xce},
-		{0x12, 0x67},
-		{0x13, 0xef},
-		{0x15, b},
-		{0x16, r},
-		{0x17, g},
-		{0x18, b},
-		{0x19, r},
-		{0x1a, g},
-	};
-
-	set_from_array(pulse_vals, ARRAY_SIZE(pulse_vals));
-	controller_write(1, 0x13, 0xcd);	/* this one's different */
-}
-
-
-static const uint8_t dump_reglist[] = {
-	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
-	0x08, 0x09, 0x0a,			  0x0f,
-	0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
-	0x18, 0x19, 0x1a
-};
-
-/* Helper for host command to dump controller registers */
-static void lb_hc_cmd_dump(struct ec_response_lightbar *out)
-{
-	int i;
-	uint8_t reg;
-
-	BUILD_ASSERT(ARRAY_SIZE(dump_reglist) ==
-		     ARRAY_SIZE(out->dump.vals));
-
-	for (i = 0; i < ARRAY_SIZE(dump_reglist); i++) {
-		reg = dump_reglist[i];
-		out->dump.vals[i].reg = reg;
-		out->dump.vals[i].ic0 = controller_read(0, reg);
-		out->dump.vals[i].ic1 = controller_read(1, reg);
-	}
-}
-
-/* Helper for host command to write controller registers directly */
-static void lb_hc_cmd_reg(const struct ec_params_lightbar *in)
-{
-	controller_write(in->reg.ctrl, in->reg.reg, in->reg.value);
-}
-
-
-
-/******************************************************************************/
 /* Here's some state that we might want to maintain across sysjumps, just to
  * prevent the lightbar from flashing during normal boot as the EC jumps from
  * RO to RW. */
@@ -416,7 +155,6 @@ static void get_battery_level(void)
 	st.battery_is_charging = (PWR_STATE_DISCHARGE != charge_get_state());
 #endif
 
-
 	/* Find the new battery level */
 	bl = 0;
 	for (i = 0; i < LB_BATTERY_LEVELS - 1; i++)
@@ -431,7 +169,6 @@ static void get_battery_level(void)
 		 pct <= (st.p.battery_threshold[bl] - 1))
 		st.battery_level = bl;
 
-
 #ifdef CONFIG_PWM_KBLIGHT
 	/*
 	 * With nothing else to go on, use the keyboard backlight level to *
@@ -459,7 +196,6 @@ static void get_battery_level(void)
 #endif
 }
 
-
 /* Forcing functions for demo mode, called by the keyboard task. */
 
 /* Up/Down keys */
@@ -504,13 +240,6 @@ void demo_brightness(int inc)
 	lb_set_brightness(b);
 }
 
-
-/******************************************************************************/
-/* Basic LED control functions. Use these to implement the pretty patterns. */
-/******************************************************************************/
-
-
-
 /******************************************************************************/
 /* Helper functions and data. */
 /******************************************************************************/
@@ -898,8 +627,6 @@ static uint32_t sequence_PULSE(void)
 	return TASK_EVENT_CUSTOM(msg);
 }
 
-
-
 /* The host CPU (or someone) is going to poke at the lightbar directly, so we
  * don't want the EC messing with it. We'll just sit here and ignore all
  * other messages until we're told to continue. */
@@ -940,7 +667,6 @@ static uint32_t sequence_ERROR(void)
 	return 0;
 }
 
-
 static const struct {
 	uint8_t led;
 	uint8_t r, g, b;
@@ -1014,7 +740,6 @@ static const struct {
 
 	{4, 0xff, 0xff, 0xff, 100000},
 	{4, 0x00, 0x00, 0x00, 100000},
-
 };
 
 static uint32_t sequence_KONAMI(void)
@@ -1233,7 +958,6 @@ DECLARE_HOST_COMMAND(EC_CMD_LIGHTBAR_CMD,
 		     lpc_cmd_lightbar,
 		     EC_VER_MASK(0));
 
-
 /****************************************************************************/
 /* EC console commands */
 /****************************************************************************/
diff --git a/include/lb_common.h b/include/lb_common.h
new file mode 100644
index 0000000000..f2f53aae35
--- /dev/null
+++ b/include/lb_common.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2014 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.
+ */
+
+/* Lightbar IC interface */
+
+#ifndef __CROS_EC_LB_COMMON_H
+#define __CROS_EC_LB_COMMON_H
+
+#include "ec_commands.h"
+
+/* How many (logical) LEDs do we have? */
+#define NUM_LEDS 4
+
+/* Set the color of one LED (or all if the LED number is too large) */
+void lb_set_rgb(unsigned int led, int red, int green, int blue);
+/* Get the current color of one LED. Fails if the LED number is too large. */
+int lb_get_rgb(unsigned int led, uint8_t *red, uint8_t *green, uint8_t *blue);
+/* Set the overall brightness level. */
+void lb_set_brightness(unsigned int newval);
+/* Get the overall brighness level. */
+uint8_t lb_get_brightness(void);
+/* Initialize the IC controller registers to sane values. */
+void lb_init(void);
+/* Disable the LED current off (the IC stays on). */
+void lb_off(void);
+/* Enable the LED current. */
+void lb_on(void);
+/* Instruct the IC to run a built-in sequence of color changes. */
+void lb_start_builtin_cycle(void);
+/* Fill in the response fields for the LIGHTBAR_CMD_DUMP command. */
+void lb_hc_cmd_dump(struct ec_response_lightbar *out);
+/* Write the IC controller register given by the LIGHTBAR_CMD_REG command. */
+void lb_hc_cmd_reg(const struct ec_params_lightbar *in);
+
+#endif  /* __CROS_EC_LB_COMMON_H */