scottk/OpenCellular
1
0
Fork 0
mirror of https://github.com/Telecominfraproject/OpenCellular.git synced 2026-01-09 00:51:29 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
e802e4fa37e1506ef19a5e38f86decbaa0ca0121
OpenCellular/common/lightbar.c
Bill Richardson e802e4fa37 Refactor lightbar host command to pass messages the new way. 
We recently changed the way host messages are passed to the EC to make it
work nicer across I2C. When we did, we updated all the internal structs
except those used for lightbar commands. This CL updates the lightbar
commands too.

BUG=chrome-os-partner:11277
BRANCH=all
TEST=manual

This shouldn't change anything, but you can ensure that by poking at the
lightbar manually. On Link, run this from a root shell:

  ectool lightbar seq stop
  ectool lightbar 4 ff 00 ff
  ectool lightbar seq run

With the first command, the lightbar pattern should freeze.
With the second command, it should turn magenta.
With the third command, it should resume pulsing as before.

Change-Id: Ic5dc4c827b3b4459288d7d9bd7d06af8a5176b3c
Signed-off-by: Bill Richardson <wfrichar@chromium.org>
Reviewed-on: https://gerrit.chromium.org/gerrit/33798
Reviewed-by: Randall Spangler <rspangler@chromium.org>
2012-09-21 16:48:53 -07:00

1195 lines
30 KiB
C
Raw Blame History

/* 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.
*
* LED controls.
*/
#include "battery.h"
#include "battery_pack.h"
#include "charge_state.h"
#include "common.h"
#include "console.h"
#include "gpio.h"
#include "hooks.h"
#include "host_command.h"
#include "i2c.h"
#include "lightbar.h"
#include "system.h"
#include "task.h"
#include "timer.h"
#include "util.h"
/* Console output macros */
#define CPUTS(outstr) cputs(CC_LIGHTBAR, outstr)
#define CPRINTF(format, args...) cprintf(CC_LIGHTBAR, format, ## args)
#define CONSOLE_COMMAND_LIGHTBAR_HELP
/******************************************************************************/
/* 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 */
/******************************************************************************/
/* 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
/* How many 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[] = { 0, 0, 1, 1 };
static const uint8_t led_to_isc[] = { 0x15, 0x18, 0x15, 0x18 };
/* Scale 0-255 into max value */
static inline uint8_t scale_abs(int val, int max)
{
return (val * max)/255 + max/256;
}
/* It will often be simpler to provide an overall brightness control. */
static int brightness = 0x80;
/* 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);
}
static void lightbar_init_vals(void)
{
CPRINTF("[%T LB_init_vals]\n");
set_from_array(init_vals, ARRAY_SIZE(init_vals));
memset(current, 0, sizeof(current));
}
/* Helper function. */
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));
}
/******************************************************************************/
/* Basic LED control functions. */
/******************************************************************************/
static void lightbar_off(void)
{
CPRINTF("[%T LB_off]\n");
/* Just go into standby mode. No register values should change. */
controller_write(0, 0x01, 0x00);
controller_write(1, 0x01, 0x00);
}
static void lightbar_on(void)
{
CPRINTF("[%T LB_on]\n");
/* Come out of standby mode. */
controller_write(0, 0x01, 0x20);
controller_write(1, 0x01, 0x20);
}
/* 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 lightbar_setrgb(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);
}
static void lightbar_brightness(int newval)
{
int i;
CPRINTF("[%T LB_bright 0x%02x]\n", newval);
brightness = newval;
for (i = 0; i < NUM_LEDS; i++)
lightbar_setrgb(i, current[i][0],
current[i][1], current[i][2]);
}
/******************************************************************************/
/* Major colors */
static const struct {
uint8_t r, g, b;
} testy[] = {
{0xff, 0x00, 0x00},
{0x00, 0xff, 0x00},
{0x00, 0x00, 0xff},
{0xff, 0xff, 0x00}, /* The first four are Google colors */
{0x00, 0xff, 0xff},
{0xff, 0x00, 0xff},
{0xff, 0xff, 0xff},
};
/******************************************************************************/
/* Now for the pretty patterns */
/******************************************************************************/
/* 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. FIXME: This doesn't quite stop the problems. */
static struct {
/* What patterns are we showing? */
enum lightbar_sequence cur_seq;
enum lightbar_sequence prev_seq;
/* Quantized battery charge level: 0=low 1=med 2=high 3=full. */
int battery_level;
/* We'll pulse slightly faster when charging */
int battery_is_charging;
} st;
#define LB_SYSJUMP_TAG 0x4c42 /* "LB" */
static int lb_preserve_state(void)
{
system_add_jump_tag(LB_SYSJUMP_TAG, 0, sizeof(st), &st);
return EC_SUCCESS;
}
DECLARE_HOOK(HOOK_SYSJUMP, lb_preserve_state, HOOK_PRIO_DEFAULT);
static void lb_restore_state(void)
{
const uint8_t *old_state = 0;
int size;
old_state = system_get_jump_tag(LB_SYSJUMP_TAG, 0, &size);
if (old_state && size == sizeof(st)) {
memcpy(&st, old_state, size);
} else {
st.cur_seq = st.prev_seq = LIGHTBAR_S5;
st.battery_level = 2;
}
CPRINTF("[%T LB state: %d %d - %d/%d]\n",
st.cur_seq, st.prev_seq,
st.battery_is_charging, st.battery_level);
}
/* Here's where we keep messages waiting to be delivered to lightbar task. If
* more than one is sent before the task responds, we only want to deliver the
* latest one. */
static uint32_t pending_msg;
/* And here's the task event that we use to trigger delivery. */
#define PENDING_MSG 1
/* Interruptible delay */
#define WAIT_OR_RET(A) do { \
uint32_t msg = task_wait_event(A); \
if (TASK_EVENT_CUSTOM(msg) == PENDING_MSG) \
return PENDING_MSG; } while (0)
/****************************************************************************/
/* Demo sequence */
struct rgb_s {
uint8_t r, g, b;
};
enum {
COLOR_LOW, COLOR_MEDIUM, COLOR_HIGH, COLOR_FULL, COLOR_BLACK,
};
static const struct rgb_s colors[] = {
{0xff, 0x00, 0x00}, /* low = red */
{0xff, 0xff, 0x00}, /* med = yellow */
{0x00, 0x00, 0xff}, /* high = blue */
{0x00, 0xff, 0x00}, /* full = green */
{0x00, 0x00, 0x00}, /* black */
};
static int demo_mode;
void demo_battery_level(int inc)
{
if ((!demo_mode) ||
(st.battery_level == COLOR_LOW && inc < 0) ||
(st.battery_level == COLOR_FULL && inc > 0))
return;
st.battery_level += inc;
CPRINTF("[%T LB demo: battery_level=%d]\n", st.battery_level);
}
void demo_is_charging(int ischarge)
{
if (!demo_mode)
return;
st.battery_is_charging = ischarge;
CPRINTF("[%T LB demo: battery_is_charging=%d]\n",
st.battery_is_charging);
}
void demo_brightness(int inc)
{
int b;
if (!demo_mode)
return;
b = brightness + (inc * 16);
if (b > 0xff)
b = 0xff;
else if (b < 0)
b = 0;
lightbar_brightness(b);
}
static int last_battery_is_charging;
static int last_battery_level;
static void get_battery_level(void)
{
int pct = 0;
if (demo_mode)
return;
#ifdef CONFIG_TASK_POWERSTATE
pct = charge_get_percent();
st.battery_is_charging = (PWR_STATE_DISCHARGE != charge_get_state());
#endif
if (pct > LIGHTBAR_POWER_THRESHOLD_FULL)
st.battery_level = COLOR_FULL;
else if (pct > LIGHTBAR_POWER_THRESHOLD_HIGH)
st.battery_level = COLOR_HIGH;
else if (pct > LIGHTBAR_POWER_THRESHOLD_MEDIUM)
st.battery_level = COLOR_MEDIUM;
else
st.battery_level = COLOR_LOW;
}
static struct {
timestamp_t start_time;
timestamp_t end_time;
struct rgb_s prev;
struct rgb_s next;
} led_state[NUM_LEDS];
#define MSECS(a) (a * 1000)
#define SEC(a) (a * 1000000)
static const uint64_t transition_time = SEC(3);
static const uint64_t transition_stagger[NUM_LEDS] = {
MSECS(0), MSECS(200), MSECS(733), MSECS(450),
};
static const int pulse_period[2] = { SEC(20), /* discharging */
SEC(10) }; /* charging */
static const int pulse_stagger[2][NUM_LEDS] = {
{ MSECS(0), MSECS(4800), MSECS(16000), MSECS(11000) }, /* discharging */
{ MSECS(0), MSECS(2400), MSECS(8000), MSECS(5500) } /* charging */
};
static struct rgb_s tmp_color;
static int tmp_percent;
static void interpolate(timestamp_t now, int i)
{
int range, sofar;
if (now.val <= led_state[i].start_time.val) {
tmp_color = led_state[i].prev;
tmp_percent = 0;
return;
}
if (now.val >= led_state[i].end_time.val) {
tmp_percent = 100;
tmp_color = led_state[i].next;
return;
}
range = (int)(led_state[i].end_time.val - led_state[i].start_time.val);
sofar = (int)(now.val - led_state[i].start_time.val);
tmp_percent = (sofar * 100) / range;
tmp_color.r = ((100 - tmp_percent) * led_state[i].prev.r) / 100 +
(tmp_percent * led_state[i].next.r) / 100;
tmp_color.g = ((100 - tmp_percent) * led_state[i].prev.g) / 100 +
(tmp_percent * led_state[i].next.g) / 100;
tmp_color.b = ((100 - tmp_percent) * led_state[i].prev.b) / 100 +
(tmp_percent * led_state[i].next.b) / 100;
}
/* 8-bit fixed-point sin(x). domain 0-PI == 0-127, range 0-1 == 0-255.
* This is just the first half cycle. */
const uint8_t sin_table[] = {
0, 6, 13, 19, 25, 31, 37, 44, 50, 56, 62, 68, 74, 80, 86, 92, 98,
103, 109, 115, 120, 126, 131, 136, 142, 147, 152, 157, 162, 167,
171, 176, 180, 185, 189, 193, 197, 201, 205, 208, 212, 215, 219,
222, 225, 228, 231, 233, 236, 238, 240, 242, 244, 246, 247, 249,
250, 251, 252, 253, 254, 254, 255, 255, 255, 255, 255, 254, 254,
253, 252, 251, 250, 249, 247, 246, 244, 242, 240, 238, 236, 233,
231, 228, 225, 222, 219, 215, 212, 208, 205, 201, 197, 193, 189,
185, 180, 176, 171, 167, 162, 157, 152, 147, 142, 136, 131, 126,
120, 115, 109, 103, 98, 92, 86, 80, 74, 68, 62, 56, 50, 44, 37, 31,
25, 19, 13, 6
};
/* This provides the other half. */
int sini(uint8_t i)
{
if (i < 128)
return sin_table[i];
return -sin_table[i-128];
}
static void pulse(timestamp_t now, int period_offset)
{
int t;
uint8_t i;
int j;
/* Bound time to one cycle */
t = (now.le.lo + period_offset) % pulse_period[st.battery_is_charging];
/* Convert phase to 0-255 */
i = ((t >> 8) / (pulse_period[st.battery_is_charging] >> 16));
/* Compute sinusoidal for phase, as [-255:255] */
j = sini(i);
j = j * sini((int)i * 3 / 2) / 255;
j = j * sini((int)i * 16 / 10) / 255;
/* Cut it down a bit if we're plugged in. */
j = j / (1 + st.battery_is_charging);
/* Luminize current color using sinusoidal */
t = j + tmp_color.r;
if (t > 255)
tmp_color.r = 255;
else if (t < 0)
tmp_color.r = 0;
else
tmp_color.r = t;
t = j + tmp_color.g;
if (t > 255)
tmp_color.g = 255;
else if (t < 0)
tmp_color.g = 0;
else
tmp_color.g = t;
t = j + tmp_color.b;
if (t > 255)
tmp_color.b = 255;
else if (t < 0)
tmp_color.b = 0;
else
tmp_color.b = t;
}
/* CPU is fully on */
static uint32_t sequence_S0(void)
{
int i, tick, last_tick;
timestamp_t start, now;
start = get_time();
tick = last_tick = 0;
lightbar_on();
/* start black, we'll fade in first thing */
lightbar_setrgb(NUM_LEDS, 0, 0, 0);
for (i = 0; i < NUM_LEDS; i++)
led_state[i].prev = colors[COLOR_BLACK];
last_battery_is_charging = !st.battery_is_charging; /* force update */
while (1) {
now = get_time();
/* Only check the battery state every so often. The battery
* charging task doesn't update as quickly as we do, and isn't
* always valid for a bit after jumping from RO->RW. */
tick = (now.le.lo - start.le.lo) / SEC(1);
if (tick % 4 == 3 && tick != last_tick) {
get_battery_level();
last_tick = tick;
}
/* Has something changed? */
if (st.battery_is_charging != last_battery_is_charging ||
st.battery_level != last_battery_level) {
/* yes */
for (i = 0; i < NUM_LEDS; i++) {
led_state[i].start_time.val = now.val +
transition_stagger[i];
led_state[i].end_time.val =
led_state[i]. start_time.val +
transition_time;
led_state[i].prev = led_state[i].next;
led_state[i].next = colors[st.battery_level];
}
last_battery_is_charging = st.battery_is_charging;
last_battery_level = st.battery_level;
}
/* Figure out what colors to show now */
for (i = 0; i < NUM_LEDS; i++) {
/* Compute transition between prev and next colors. */
interpolate(now, i);
/* Pulse sinusoidally */
pulse(now, pulse_stagger[st.battery_is_charging][i]);
/* Show it */
lightbar_setrgb(i, tmp_color.r, tmp_color.g,
tmp_color.b);
}
WAIT_OR_RET(MSECS(15));
}
return 0;
}
/* CPU is off */
static uint32_t sequence_S5(void)
{
/* Just wait forever. */
lightbar_off();
WAIT_OR_RET(-1);
return 0;
}
/* CPU is powering up. The lightbar loses power when the CPU is in S5, so this
* might not be useful. */
static uint32_t sequence_S5S3(void)
{
/* The controllers need 100us after power is applied before they'll
* respond. Don't return early, because we still want to initialize the
* lightbar even if another message comes along while we're waiting. */
usleep(100);
lightbar_init_vals();
/* For now, do something to indicate this transition.
* We might see it. */
lightbar_on();
lightbar_setrgb(NUM_LEDS, 0, 0, 0);
WAIT_OR_RET(500000);
return 0;
}
/* CPU is going to sleep */
static uint32_t sequence_S0S3(void)
{
int i;
lightbar_on();
for (i = 0; i < NUM_LEDS; i++) {
lightbar_setrgb(i, 0, 0, 0);
WAIT_OR_RET(200000);
}
return 0;
}
/* CPU is sleeping */
static uint32_t sequence_S3(void)
{
int r, g, b;
int i;
lightbar_off();
lightbar_init_vals();
lightbar_setrgb(NUM_LEDS, 0, 0, 0);
while (1) {
WAIT_OR_RET(SEC(15));
get_battery_level();
lightbar_on();
r = colors[st.battery_level].r;
g = colors[st.battery_level].g;
b = colors[st.battery_level].b;
for (i = 0; i < 255; i += 5) {
lightbar_setrgb(NUM_LEDS,
(r * i) / 255,
(g * i) / 255,
(b * i) / 255);
WAIT_OR_RET(15000);
}
for (i = 255; i > 0; i -= 5) {
lightbar_setrgb(NUM_LEDS,
(r * i) / 255,
(g * i) / 255,
(b * i) / 255);
WAIT_OR_RET(15000);
}
lightbar_setrgb(NUM_LEDS, 0, 0, 0);
lightbar_off();
}
return 0;
}
/* CPU is waking from sleep */
static uint32_t sequence_S3S0(void)
{
int i;
lightbar_init_vals();
lightbar_on();
for (i = 0; i < NUM_LEDS; i++) {
lightbar_setrgb(i, testy[i].r, testy[i].g, testy[i].b);
WAIT_OR_RET(200000);
}
return 0;
}
/* Sleep to off. */
static uint32_t sequence_S3S5(void)
{
/* For now, do something to indicate this transition.
* We might see it. */
lightbar_off();
WAIT_OR_RET(500000);
return 0;
}
/* Used by factory. */
static uint32_t sequence_TEST_inner(void)
{
int i, j, k, r, g, b;
int kmax = 254;
int kstep = 8;
lightbar_init_vals();
lightbar_on();
for (i = 0; i < ARRAY_SIZE(testy); i++) {
for (k = 0; k <= kmax; k += kstep) {
for (j = 0; j < NUM_LEDS; j++) {
r = testy[i].r ? k : 0;
g = testy[i].g ? k : 0;
b = testy[i].b ? k : 0;
lightbar_setrgb(j, r, g, b);
}
WAIT_OR_RET(10000);
}
for (k = kmax; k >= 0; k -= kstep) {
for (j = 0; j < NUM_LEDS; j++) {
r = testy[i].r ? k : 0;
g = testy[i].g ? k : 0;
b = testy[i].b ? k : 0;
lightbar_setrgb(j, r, g, b);
}
WAIT_OR_RET(10000);
}
}
return 0;
}
static uint32_t sequence_TEST(void)
{
int tmp;
uint32_t r;
tmp = brightness;
brightness = 255;
r = sequence_TEST_inner();
brightness = tmp;
return r;
}
/* This uses 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 uint32_t sequence_PULSE(void)
{
uint32_t msg;
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},
};
lightbar_init_vals();
lightbar_on();
set_from_array(pulse_vals, ARRAY_SIZE(pulse_vals));
controller_write(1, 0x13, 0xcd); /* this one's different */
/* Not using WAIT_OR_RET() here, because we want to clean up when we're
* done. The only way out is to get a message. */
msg = task_wait_event(-1);
lightbar_init_vals();
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. */
static uint32_t sequence_STOP(void)
{
uint32_t msg;
do {
msg = TASK_EVENT_CUSTOM(task_wait_event(-1));
CPRINTF("[%T LB_stop got pending_msg %d]\n", pending_msg);
} while (msg != PENDING_MSG || pending_msg != LIGHTBAR_RUN);
/* FIXME: What should we do if the host shuts down? */
CPRINTF("[%T LB_stop->running]\n");
return 0;
}
/* Telling us to run when we're already running should do nothing. */
static uint32_t sequence_RUN(void)
{
return 0;
}
/* We shouldn't come here, but if we do it shouldn't hurt anything */
static uint32_t sequence_ERROR(void)
{
lightbar_init_vals();
lightbar_on();
lightbar_setrgb(0, 255, 255, 255);
lightbar_setrgb(1, 255, 0, 255);
lightbar_setrgb(2, 0, 255, 255);
lightbar_setrgb(3, 255, 255, 255);
WAIT_OR_RET(10000000);
return 0;
}
static const struct {
uint8_t led;
uint8_t r, g, b;
unsigned int delay;
} konami[] = {
{1, 0xff, 0xff, 0x00, 0},
{2, 0xff, 0xff, 0x00, 100000},
{1, 0x00, 0x00, 0x00, 0},
{2, 0x00, 0x00, 0x00, 100000},
{1, 0xff, 0xff, 0x00, 0},
{2, 0xff, 0xff, 0x00, 100000},
{1, 0x00, 0x00, 0x00, 0},
{2, 0x00, 0x00, 0x00, 100000},
{0, 0x00, 0x00, 0xff, 0},
{3, 0x00, 0x00, 0xff, 100000},
{0, 0x00, 0x00, 0x00, 0},
{3, 0x00, 0x00, 0x00, 100000},
{0, 0x00, 0x00, 0xff, 0},
{3, 0x00, 0x00, 0xff, 100000},
{0, 0x00, 0x00, 0x00, 0},
{3, 0x00, 0x00, 0x00, 100000},
{0, 0xff, 0x00, 0x00, 0},
{1, 0xff, 0x00, 0x00, 100000},
{0, 0x00, 0x00, 0x00, 0},
{1, 0x00, 0x00, 0x00, 100000},
{2, 0x00, 0xff, 0x00, 0},
{3, 0x00, 0xff, 0x00, 100000},
{2, 0x00, 0x00, 0x00, 0},
{3, 0x00, 0x00, 0x00, 100000},
{0, 0xff, 0x00, 0x00, 0},
{1, 0xff, 0x00, 0x00, 100000},
{0, 0x00, 0x00, 0x00, 0},
{1, 0x00, 0x00, 0x00, 100000},
{2, 0x00, 0xff, 0x00, 0},
{3, 0x00, 0xff, 0x00, 100000},
{2, 0x00, 0x00, 0x00, 0},
{3, 0x00, 0x00, 0x00, 100000},
{0, 0x00, 0xff, 0xff, 0},
{2, 0x00, 0xff, 0xff, 100000},
{0, 0x00, 0x00, 0x00, 0},
{2, 0x00, 0x00, 0x00, 150000},
{1, 0xff, 0x00, 0xff, 0},
{3, 0xff, 0x00, 0xff, 100000},
{1, 0x00, 0x00, 0x00, 0},
{3, 0x00, 0x00, 0x00, 250000},
{4, 0xff, 0xff, 0xff, 100000},
{4, 0x00, 0x00, 0x00, 100000},
{4, 0xff, 0xff, 0xff, 100000},
{4, 0x00, 0x00, 0x00, 100000},
{4, 0xff, 0xff, 0xff, 100000},
{4, 0x00, 0x00, 0x00, 100000},
{4, 0xff, 0xff, 0xff, 100000},
{4, 0x00, 0x00, 0x00, 100000},
{4, 0xff, 0xff, 0xff, 100000},
{4, 0x00, 0x00, 0x00, 100000},
{4, 0xff, 0xff, 0xff, 100000},
{4, 0x00, 0x00, 0x00, 100000},
};
static uint32_t sequence_KONAMI(void)
{
int i;
int tmp;
lightbar_init_vals();
lightbar_on();
tmp = brightness;
brightness = 255;
for (i = 0; i < ARRAY_SIZE(konami); i++) {
lightbar_setrgb(konami[i].led,
konami[i].r, konami[i].g, konami[i].b);
if (konami[i].delay)
usleep(konami[i].delay);
}
brightness = tmp;
return 0;
}
/****************************************************************************/
/* The main lightbar task. It just cycles between various pretty patterns. */
/****************************************************************************/
/* Link each sequence with a command to invoke it. */
struct lightbar_cmd_t {
const char * const string;
uint32_t (*sequence)(void);
};
#define LBMSG(state) { #state, sequence_##state }
#include "lightbar_msg_list.h"
static struct lightbar_cmd_t lightbar_cmds[] = {
LIGHTBAR_MSG_LIST
};
#undef LBMSG
void lightbar_task(void)
{
uint32_t msg;
CPRINTF("[%T LB task starting]\n");
lb_restore_state();
while (1) {
CPRINTF("[%T LB task %d = %s]\n",
st.cur_seq, lightbar_cmds[st.cur_seq].string);
msg = lightbar_cmds[st.cur_seq].sequence();
if (TASK_EVENT_CUSTOM(msg) == PENDING_MSG) {
CPRINTF("[%T LB msg %d = %s]\n", pending_msg,
lightbar_cmds[pending_msg].string);
st.prev_seq = st.cur_seq;
st.cur_seq = pending_msg;
} else {
CPRINTF("[%T LB msg 0x%x]\n", msg);
switch (st.cur_seq) {
case LIGHTBAR_S5S3:
st.cur_seq = LIGHTBAR_S3;
break;
case LIGHTBAR_S3S0:
st.cur_seq = LIGHTBAR_S0;
break;
case LIGHTBAR_S0S3:
st.cur_seq = LIGHTBAR_S3;
break;
case LIGHTBAR_S3S5:
st.cur_seq = LIGHTBAR_S5;
break;
case LIGHTBAR_TEST:
case LIGHTBAR_STOP:
case LIGHTBAR_RUN:
case LIGHTBAR_ERROR:
case LIGHTBAR_KONAMI:
st.cur_seq = st.prev_seq;
default:
break;
}
}
}
}
/* Function to request a preset sequence from the lightbar task. */
void lightbar_sequence(enum lightbar_sequence num)
{
if (num > 0 && num < LIGHTBAR_NUM_SEQUENCES) {
CPRINTF("[%T LB_seq %d = %s]\n", num,
lightbar_cmds[num].string);
pending_msg = num;
task_set_event(TASK_ID_LIGHTBAR,
TASK_EVENT_WAKE | TASK_EVENT_CUSTOM(PENDING_MSG),
0);
} else
CPRINTF("[%T LB_seq %d - ignored]\n", num);
}
/****************************************************************************/
/* Get notifications from other parts of the system */
static int lightbar_startup(void)
{
lightbar_sequence(LIGHTBAR_S5S3);
return EC_SUCCESS;
}
DECLARE_HOOK(HOOK_CHIPSET_STARTUP, lightbar_startup, HOOK_PRIO_DEFAULT);
static int lightbar_resume(void)
{
lightbar_sequence(LIGHTBAR_S3S0);
return EC_SUCCESS;
}
DECLARE_HOOK(HOOK_CHIPSET_RESUME, lightbar_resume, HOOK_PRIO_DEFAULT);
static int lightbar_suspend(void)
{
lightbar_sequence(LIGHTBAR_S0S3);
return EC_SUCCESS;
}
DECLARE_HOOK(HOOK_CHIPSET_SUSPEND, lightbar_suspend, HOOK_PRIO_DEFAULT);
static int lightbar_shutdown(void)
{
lightbar_sequence(LIGHTBAR_S3S5);
return EC_SUCCESS;
}
DECLARE_HOOK(HOOK_CHIPSET_SHUTDOWN, lightbar_shutdown, HOOK_PRIO_DEFAULT);
/****************************************************************************/
/* Generic command-handling (should work the same for both console & LPC) */
/****************************************************************************/
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
};
static void do_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);
}
}
static void do_cmd_rgb(uint8_t led,
uint8_t red, uint8_t green, uint8_t blue)
{
int i;
if (led >= NUM_LEDS)
for (i = 0; i < NUM_LEDS; i++)
lightbar_setrgb(i, red, green, blue);
else
lightbar_setrgb(led, red, green, blue);
}
/****************************************************************************/
/* Host commands via LPC bus */
/****************************************************************************/
static int lpc_cmd_lightbar(struct host_cmd_handler_args *args)
{
const struct ec_params_lightbar *in = args->params;
struct ec_response_lightbar *out = args->response;
switch (in->cmd) {
case LIGHTBAR_CMD_DUMP:
do_cmd_dump(out);
args->response_size = sizeof(out->dump);
break;
case LIGHTBAR_CMD_OFF:
lightbar_off();
break;
case LIGHTBAR_CMD_ON:
lightbar_on();
break;
case LIGHTBAR_CMD_INIT:
lightbar_init_vals();
break;
case LIGHTBAR_CMD_BRIGHTNESS:
lightbar_brightness(in->brightness.num);
break;
case LIGHTBAR_CMD_SEQ:
lightbar_sequence(in->seq.num);
break;
case LIGHTBAR_CMD_REG:
controller_write(in->reg.ctrl,
in->reg.reg,
in->reg.value);
break;
case LIGHTBAR_CMD_RGB:
do_cmd_rgb(in->rgb.led,
in->rgb.red,
in->rgb.green,
in->rgb.blue);
break;
case LIGHTBAR_CMD_GET_SEQ:
out->get_seq.num = st.cur_seq;
args->response_size = sizeof(out->get_seq);
break;
case LIGHTBAR_CMD_DEMO:
demo_mode = in->demo.num ? 1 : 0;
CPRINTF("[%T LB_demo %d]\n", demo_mode);
break;
default:
CPRINTF("[%T LB bad cmd 0x%x]\n", in->cmd);
return EC_RES_INVALID_PARAM;
}
return EC_RES_SUCCESS;
}
DECLARE_HOST_COMMAND(EC_CMD_LIGHTBAR_CMD,
lpc_cmd_lightbar,
EC_VER_MASK(0));
/****************************************************************************/
/* EC console commands */
/****************************************************************************/
#ifdef CONSOLE_COMMAND_LIGHTBAR_HELP
static int help(const char *cmd)
{
ccprintf("Usage:\n");
ccprintf(" %s - dump all regs\n", cmd);
ccprintf(" %s off - enter standby\n", cmd);
ccprintf(" %s on - leave standby\n", cmd);
ccprintf(" %s init - load default vals\n", cmd);
ccprintf(" %s brightness NUM - set intensity (0-ff)\n", cmd);
ccprintf(" %s seq [NUM|SEQUENCE] - run given pattern"
" (no arg for list)\n", cmd);
ccprintf(" %s CTRL REG VAL - set LED controller regs\n", cmd);
ccprintf(" %s LED RED GREEN BLUE - set color manually"
" (LED=4 for all)\n", cmd);
ccprintf(" %s demo [0|1] - turn demo mode on & off\n", cmd);
return EC_SUCCESS;
}
#endif
static uint8_t find_msg_by_name(const char *str)
{
uint8_t i;
for (i = 0; i < LIGHTBAR_NUM_SEQUENCES; i++)
if (!strcasecmp(str, lightbar_cmds[i].string))
return i;
return LIGHTBAR_NUM_SEQUENCES;
}
static void show_msg_names(void)
{
int i;
ccprintf("Sequences:");
for (i = 0; i < LIGHTBAR_NUM_SEQUENCES; i++)
ccprintf(" %s", lightbar_cmds[i].string);
ccprintf("\nCurrent = 0x%x %s\n", st.cur_seq,
lightbar_cmds[st.cur_seq].string);
}
static int command_lightbar(int argc, char **argv)
{
int i;
uint8_t num;
struct ec_response_lightbar out;
if (1 == argc) { /* no args = dump 'em all */
do_cmd_dump(&out);
for (i = 0; i < ARRAY_SIZE(dump_reglist); i++)
ccprintf(" %02x %02x %02x\n",
out.dump.vals[i].reg,
out.dump.vals[i].ic0,
out.dump.vals[i].ic1);
return EC_SUCCESS;
}
if (argc == 2 && !strcasecmp(argv[1], "init")) {
lightbar_init_vals();
return EC_SUCCESS;
}
if (argc == 2 && !strcasecmp(argv[1], "off")) {
lightbar_off();
return EC_SUCCESS;
}
if (argc == 2 && !strcasecmp(argv[1], "on")) {
lightbar_on();
return EC_SUCCESS;
}
if (argc == 3 && !strcasecmp(argv[1], "brightness")) {
char *e;
num = 0xff & strtoi(argv[2], &e, 16);
lightbar_brightness(num);
return EC_SUCCESS;
}
if (argc == 3 && !strcasecmp(argv[1], "demo")) {
if (!strcasecmp(argv[2], "on") || argv[2][0] == '1')
demo_mode = 1;
else if (!strcasecmp(argv[2], "off") || argv[2][0] == '0')
demo_mode = 0;
else
return EC_ERROR_PARAM1;
ccprintf("demo mode is %s\n", demo_mode ? "on" : "off");
return EC_SUCCESS;
}
if (argc >= 2 && !strcasecmp(argv[1], "seq")) {
char *e;
uint8_t num;
if (argc == 2) {
show_msg_names();
return 0;
}
num = 0xff & strtoi(argv[2], &e, 16);
if (*e)
num = find_msg_by_name(argv[2]);
if (num >= LIGHTBAR_NUM_SEQUENCES)
return EC_ERROR_PARAM2;
lightbar_sequence(num);
return EC_SUCCESS;
}
if (argc == 4) {
char *e;
uint8_t ctrl, reg, val;
ctrl = 0xff & strtoi(argv[1], &e, 16);
reg = 0xff & strtoi(argv[2], &e, 16);
val = 0xff & strtoi(argv[3], &e, 16);
controller_write(ctrl, reg, val);
return EC_SUCCESS;
}
if (argc == 5) {
char *e;
uint8_t led, r, g, b;
led = strtoi(argv[1], &e, 16);
r = strtoi(argv[2], &e, 16);
g = strtoi(argv[3], &e, 16);
b = strtoi(argv[4], &e, 16);
do_cmd_rgb(led, r, g, b);
return EC_SUCCESS;
}
#ifdef CONSOLE_COMMAND_LIGHTBAR_HELP
help(argv[0]);
#endif
return EC_ERROR_INVAL;
}
DECLARE_CONSOLE_COMMAND(lightbar, command_lightbar,
"[on | off | init | brightness | seq] | [ctrl reg val]",
"Get/set lightbar state",
NULL);
Reference in New Issue View Git Blame Copy Permalink