diff options
Diffstat (limited to 'common/lightbar.c')
| -rw-r--r-- | common/lightbar.c | 2068 |
1 files changed, 0 insertions, 2068 deletions
diff --git a/common/lightbar.c b/common/lightbar.c deleted file mode 100644 index f80287941d..0000000000 --- a/common/lightbar.c +++ /dev/null @@ -1,2068 +0,0 @@ -/* - * Copyright 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. - */ - -#ifdef LIGHTBAR_SIMULATION -#include "simulation.h" -#else -#include "battery.h" -#include "charge_state.h" -#include "common.h" -#include "console.h" -#include "ec_commands.h" -#include "hooks.h" -#include "host_command.h" -#include "lb_common.h" -#include "lightbar.h" -#include "lid_switch.h" -#include "motion_sense.h" -#include "pwm.h" -#include "system.h" -#include "task.h" -#include "timer.h" -#include "util.h" -#endif - -/* - * 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 - -/* Console output macros */ -#define CPUTS(outstr) cputs(CC_LIGHTBAR, outstr) -#define CPRINTS(format, args...) cprints(CC_LIGHTBAR, format, ## args) - -#define FP_SCALE 10000 - -/******************************************************************************/ -/* 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. */ -static struct p_state { - /* 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; - int battery_percent; - - /* It's either charging or discharging. */ - int battery_is_charging; - - /* Is power-on prevented due to battery level? */ - int battery_is_power_on_prevented; - - /* Pattern variables for state S0. */ - uint16_t w0; /* primary phase */ - uint8_t ramp; /* ramp-in for S3->S0 */ - - uint8_t _pad0; /* next item is __packed */ - - /* Tweakable parameters. */ - union { - struct lightbar_params_v1 p; - struct { - struct lightbar_params_v2_timing timing; - struct lightbar_params_v2_tap tap; - struct lightbar_params_v2_oscillation osc; - struct lightbar_params_v2_brightness bright; - struct lightbar_params_v2_thresholds thlds; - struct lightbar_params_v2_colors colors; - } p_v2; - }; -} st; - -/* Each of the parameters must be less than 120 bytes - * (crbug.com/467716) - */ -#define MAX_PARAM_SIZE 120 -BUILD_ASSERT(sizeof(struct lightbar_params_v2_timing) <= MAX_PARAM_SIZE); -BUILD_ASSERT(sizeof(struct lightbar_params_v2_tap) <= MAX_PARAM_SIZE); -BUILD_ASSERT(sizeof(struct lightbar_params_v2_oscillation) <= MAX_PARAM_SIZE); -BUILD_ASSERT(sizeof(struct lightbar_params_v2_brightness) <= MAX_PARAM_SIZE); -BUILD_ASSERT(sizeof(struct lightbar_params_v2_thresholds) <= MAX_PARAM_SIZE); -BUILD_ASSERT(sizeof(struct lightbar_params_v2_colors) <= MAX_PARAM_SIZE); -#undef MAX_PARAM_SIZE - -#define PRIMARY_BLUE 4 -#define PRIMARY_RED 5 -#define PRIMARY_YELLOW 6 -#define PRIMARY_GREEN 7 - -static const struct lightbar_params_v1 default_params = { - .google_ramp_up = 2500, - .google_ramp_down = 10000, - .s3s0_ramp_up = 2000, - .s0_tick_delay = { 45000, 30000 }, /* battery, AC */ - .s0a_tick_delay = { 5000, 3000 }, /* battery, AC */ - .s0s3_ramp_down = 2000, - .s3_sleep_for = 5 * SECOND, /* between checks */ - .s3_ramp_up = 2500, - .s3_ramp_down = 10000, - .s5_ramp_up = 2500, - .s5_ramp_down = 10000, - .tap_tick_delay = 5000, /* oscillation step time */ - .tap_gate_delay = 200 * MSEC, /* segment gating delay */ - .tap_display_time = 3 * SECOND, /* total sequence time */ - - /* TODO (crosbug.com/p/36996): remove unused tap_pct_red */ - .tap_pct_red = 14, /* below this is red */ - .tap_pct_green = 94, /* above this is green */ - .tap_seg_min_on = 35, /* min intensity (%) for "on" */ - .tap_seg_max_on = 100, /* max intensity (%) for "on" */ - .tap_seg_osc = 50, /* amplitude for charging osc */ - .tap_idx = {PRIMARY_RED, PRIMARY_YELLOW, PRIMARY_GREEN}, /* color */ - - .osc_min = { 0x60, 0x60 }, /* battery, AC */ - .osc_max = { 0xd0, 0xd0 }, /* battery, AC */ - .w_ofs = {24, 24}, /* phase offset, 256 == 2*PI */ - - .bright_bl_off_fixed = {0xcc, 0xff}, /* backlight off: battery, AC */ - .bright_bl_on_min = {0xcc, 0xff}, /* backlight on: battery, AC */ - .bright_bl_on_max = {0xcc, 0xff}, /* backlight on: battery, AC */ - - .battery_threshold = { 14, 40, 99 }, /* percent, lowest to highest */ - .s0_idx = { - /* battery: 0 = red, other = blue */ - { PRIMARY_RED, PRIMARY_BLUE, PRIMARY_BLUE, PRIMARY_BLUE }, - /* AC: always blue */ - { PRIMARY_BLUE, PRIMARY_BLUE, PRIMARY_BLUE, PRIMARY_BLUE } - }, - .s3_idx = { - /* battery: 0 = red, else off */ - { PRIMARY_RED, 0xff, 0xff, 0xff }, - /* AC: do nothing */ - { 0xff, 0xff, 0xff, 0xff } - }, - .s5_idx = PRIMARY_RED, /* flash red */ - .color = { - /* - * These values have been optically calibrated for the - * Samus LEDs to best match the official colors, described at - * https://sites.google.com/a/google.com/brandsite/the-colours - * See crosbug.com/p/33017 before making any changes. - */ - {0x34, 0x70, 0xb4}, /* 0: Google blue */ - {0xbc, 0x50, 0x2c}, /* 1: Google red */ - {0xd0, 0xe0, 0x00}, /* 2: Google yellow */ - {0x50, 0xa0, 0x40}, /* 3: Google green */ - /* These are primary colors */ - {0x00, 0x00, 0xff}, /* 4: full blue */ - {0xff, 0x00, 0x00}, /* 5: full red */ - {0xff, 0xff, 0x00}, /* 6: full yellow */ - {0x00, 0xff, 0x00}, /* 7: full green */ - }, -}; - -#define LB_SYSJUMP_TAG 0x4c42 /* "LB" */ -static void lightbar_preserve_state(void) -{ - system_add_jump_tag(LB_SYSJUMP_TAG, 0, sizeof(st), &st); -} -DECLARE_HOOK(HOOK_SYSJUMP, lightbar_preserve_state, HOOK_PRIO_DEFAULT); - -static void lightbar_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); - CPRINTS("LB state restored: %d %d - %d %d/%d", - st.cur_seq, st.prev_seq, - st.battery_is_charging, - st.battery_percent, - st.battery_level); - } else { - st.cur_seq = st.prev_seq = LIGHTBAR_S5; - st.battery_percent = 100; - st.battery_level = LB_BATTERY_LEVELS - 1; - st.w0 = 0; - st.ramp = 0; - memcpy(&st.p, &default_params, sizeof(st.p)); - CPRINTS("LB state initialized"); - } -} - -/******************************************************************************/ -/* The patterns are generally dependent on the current battery level and AC - * state. These functions obtain that information, generally by querying the - * power manager task. In demo mode, the keyboard task forces changes to the - * state by calling the demo_* functions directly. */ -/******************************************************************************/ - -#ifdef CONFIG_PWM_KBLIGHT -static int last_backlight_level; -#endif -#ifdef CONFIG_ALS_LIGHTBAR_DIMMING -test_export_static int google_color_id; -#endif - -static int demo_mode = DEMO_MODE_DEFAULT; - -static int quantize_battery_level(int pct) -{ - int i, bl = 0; - for (i = 0; i < LB_BATTERY_LEVELS - 1; i++) - if (pct >= st.p.battery_threshold[i]) - bl++; - return bl; -} - -#ifdef CONFIG_ALS_LIGHTBAR_DIMMING -test_export_static int lux_level_to_google_color(const int lux) -{ - int i; - - if (!lid_is_open()) { - /* The lid shades the light sensor, use full brightness. */ - if (google_color_id != 0) { - google_color_id = 0; - return 1; - } else { - return 0; - } - } - - /* See if we need to decrease brightness */ - for (i = google_color_id; i < lb_brightness_levels_count ; i++) - if (lux >= lb_brightness_levels[i].lux_down) - break; - if (i > google_color_id) { - google_color_id = i; - return 1; - } - /* See if we need to increase brightness */ - for (i = google_color_id; i > 0; i--) - if (lux < lb_brightness_levels[i - 1].lux_up) - break; - if (i < google_color_id) { - google_color_id = i; - return 1; - } - return 0; -} -#endif - -/* - * Update the known state. - * Return 1 if something changes. - */ -static int get_battery_level(void) -{ - int pct = 0; - int bl, change = 0; - - if (demo_mode) - return 0; - -#ifdef HAS_TASK_CHARGER - st.battery_percent = pct = charge_get_percent(); - st.battery_is_charging = (PWR_STATE_DISCHARGE != charge_get_state()); - st.battery_is_power_on_prevented = charge_prevent_power_on(0); -#endif - - /* Find the new battery level */ - bl = quantize_battery_level(pct); - - /* Use some hysteresis to avoid flickering */ - if (bl < st.battery_level || - (bl > st.battery_level - && pct >= (st.p.battery_threshold[st.battery_level] + 1))) { - st.battery_level = bl; - change = 1; - } - -#ifdef CONFIG_PWM_KBLIGHT - /* - * With nothing else to go on, use the keyboard backlight level to * - * set the brightness. In general, if the keyboard backlight - * is OFF (which it is when ambient is bright), use max brightness for - * lightbar. If keyboard backlight is ON, use keyboard backlight - * brightness. That fails if the keyboard backlight is off because - * someone's watching a movie in the dark, of course. Ideally we should - * just let the AP control it directly. - */ - if (pwm_get_enabled(PWM_CH_KBLIGHT)) { - pct = pwm_get_duty(PWM_CH_KBLIGHT); - pct = (255 * pct) / 100; /* 00 - FF */ - if (pct > st.p.bright_bl_on_max[st.battery_is_charging]) - pct = st.p.bright_bl_on_max[st.battery_is_charging]; - else if (pct < st.p.bright_bl_on_min[st.battery_is_charging]) - pct = st.p.bright_bl_on_min[st.battery_is_charging]; - } else - pct = st.p.bright_bl_off_fixed[st.battery_is_charging]; - - if (pct != last_backlight_level) { - last_backlight_level = pct; - lb_set_brightness(pct); - change = 1; - } -#endif -#ifdef CONFIG_ALS_LIGHTBAR_DIMMING - /* Read last value (in lux) collected by the motion sensor. */ - /* Convert lux into brightness percentage */ - if (lux_level_to_google_color(MOTION_SENSE_LUX)) { - memcpy(st.p.color, lb_brightness_levels[google_color_id].color, - sizeof(lb_brightness_levels[google_color_id].color)); - change = 1; - } -#endif - return change; -} - -/* Forcing functions for demo mode, called by the keyboard task. */ - -/* Up/Down keys */ -#define DEMO_CHARGE_STEP 1 -void demo_battery_level(int inc) -{ - if (!demo_mode) - return; - - st.battery_percent += DEMO_CHARGE_STEP * inc; - - if (st.battery_percent > 100) - st.battery_percent = 100; - else if (st.battery_percent < 0) - st.battery_percent = 0; - - st.battery_level = quantize_battery_level(st.battery_percent); - - CPRINTS("LB demo: battery_percent = %d%%, battery_level=%d", - st.battery_percent, st.battery_level); -} - -/* Left/Right keys */ - -void demo_is_charging(int ischarge) -{ - if (!demo_mode) - return; - - st.battery_is_charging = ischarge; - CPRINTS("LB demo: battery_is_charging=%d", - st.battery_is_charging); -} - -/* Bright/Dim keys */ -void demo_brightness(int inc) -{ - int b; - - if (!demo_mode) - return; - - b = lb_get_brightness() + (inc * 16); - if (b > 0xff) - b = 0xff; - else if (b < 0) - b = 0; - lb_set_brightness(b); -} - -/* T key */ -void demo_tap(void) -{ - if (!demo_mode) - return; - lightbar_sequence(LIGHTBAR_TAP); -} - -/******************************************************************************/ -/* Helper functions and data. */ -/******************************************************************************/ - -#define F(x) (x * FP_SCALE) -static const uint16_t _ramp_table[] = { - F(0.000000), F(0.002408), F(0.009607), F(0.021530), F(0.038060), - F(0.059039), F(0.084265), F(0.113495), F(0.146447), F(0.182803), - F(0.222215), F(0.264302), F(0.308658), F(0.354858), F(0.402455), - F(0.450991), F(0.500000), F(0.549009), F(0.597545), F(0.645142), - F(0.691342), F(0.735698), F(0.777785), F(0.817197), F(0.853553), - F(0.886505), F(0.915735), F(0.940961), F(0.961940), F(0.978470), - F(0.990393), F(0.997592), F(1.000000), -}; -#undef F - -/* This function provides a smooth ramp up from 0.0 to 1.0 and back to 0.0, - * for input from 0x00 to 0xff. */ -static inline int cycle_010(uint8_t i) -{ - uint8_t bucket, index; - - if (i == 128) - return FP_SCALE; - else if (i > 128) - i = 256 - i; - - bucket = i >> 2; - index = i & 0x3; - - return _ramp_table[bucket] + - ((_ramp_table[bucket + 1] - _ramp_table[bucket]) * index >> 2); -} - -/******************************************************************************/ -/* Here's where we keep messages waiting to be delivered to the 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 TASK_EVENT_CUSTOM_BIT(0) - -/* Interruptible delay. */ -#define WAIT_OR_RET(A) \ - do { \ - uint32_t msg = task_wait_event(A); \ - uint32_t p_msg = pending_msg; \ - if (msg & PENDING_MSG && p_msg != st.cur_seq) \ - return p_msg; \ - } while (0) - -/******************************************************************************/ -/* Here are the preprogrammed sequences. */ -/******************************************************************************/ - -/* Pulse google colors once, off to on to off. */ -static uint32_t pulse_google_colors(void) -{ - int w, i, r, g, b; - int f; - - for (w = 0; w < 128; w += 2) { - f = cycle_010(w); - for (i = 0; i < NUM_LEDS; i++) { - r = st.p.color[i].r * f / FP_SCALE; - g = st.p.color[i].g * f / FP_SCALE; - b = st.p.color[i].b * f / FP_SCALE; - lb_set_rgb(i, r, g, b); - } - WAIT_OR_RET(st.p.google_ramp_up); - } - for (w = 128; w <= 256; w++) { - f = cycle_010(w); - for (i = 0; i < NUM_LEDS; i++) { - r = st.p.color[i].r * f / FP_SCALE; - g = st.p.color[i].g * f / FP_SCALE; - b = st.p.color[i].b * f / FP_SCALE; - lb_set_rgb(i, r, g, b); - } - WAIT_OR_RET(st.p.google_ramp_down); - } - - return 0; -} - -/* CPU is waking from sleep. */ -static uint32_t sequence_S3S0(void) -{ - int w, r, g, b; - int f, fmin; - int ci; - uint32_t res; - - lb_init(1); - lb_on(); - get_battery_level(); - - res = pulse_google_colors(); - if (res) - return res; - -#ifndef BLUE_PULSING - /* next sequence */ - return LIGHTBAR_S0; -#endif - - /* Ramp up to starting brightness, using S0 colors */ - ci = st.p.s0_idx[st.battery_is_charging][st.battery_level]; - if (ci >= ARRAY_SIZE(st.p.color)) - ci = 0; - - fmin = st.p.osc_min[st.battery_is_charging] * FP_SCALE / 255; - - for (w = 0; w <= 128; w++) { - f = cycle_010(w) * fmin / FP_SCALE; - r = st.p.color[ci].r * f / FP_SCALE; - g = st.p.color[ci].g * f / FP_SCALE; - b = st.p.color[ci].b * f / FP_SCALE; - lb_set_rgb(NUM_LEDS, r, g, b); - WAIT_OR_RET(st.p.s3s0_ramp_up); - } - - /* Initial conditions */ - st.w0 = -256; /* start cycle_npn() quietly */ - st.ramp = 0; - - /* Ready for S0 */ - return LIGHTBAR_S0; -} - -#ifdef BLUE_PULSING - -/* This function provides a pulsing oscillation between -0.5 and +0.5. */ -static inline int cycle_npn(uint16_t i) -{ - if ((i / 256) % 4) - return -FP_SCALE / 2; - return cycle_010(i) - FP_SCALE / 2; -} - -/* CPU is fully on */ -static uint32_t sequence_S0(void) -{ - int tick, last_tick; - timestamp_t start, now; - uint8_t r, g, b; - int i, ci; - uint8_t w_ofs; - uint16_t w; - int f, fmin, fmax, base_s0, osc_s0, f_ramp; - - start = get_time(); - tick = last_tick = 0; - - lb_set_rgb(NUM_LEDS, 0, 0, 0); - lb_on(); - - while (1) { - now = get_time(); - - /* Only check the battery state every few seconds. 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) / SECOND; - if (tick % 4 == 3 && tick != last_tick) { - get_battery_level(); - last_tick = tick; - } - - /* Calculate the colors */ - ci = st.p.s0_idx[st.battery_is_charging][st.battery_level]; - if (ci >= ARRAY_SIZE(st.p.color)) - ci = 0; - w_ofs = st.p.w_ofs[st.battery_is_charging]; - fmin = st.p.osc_min[st.battery_is_charging] * FP_SCALE / 255; - fmax = st.p.osc_max[st.battery_is_charging] * FP_SCALE / 255; - base_s0 = (fmax + fmin) / 2; - osc_s0 = fmax - fmin; - f_ramp = st.ramp * FP_SCALE / 255; - - for (i = 0; i < NUM_LEDS; i++) { - w = st.w0 - i * w_ofs * f_ramp / FP_SCALE; - f = base_s0 + osc_s0 * cycle_npn(w) / FP_SCALE; - r = st.p.color[ci].r * f / FP_SCALE; - g = st.p.color[ci].g * f / FP_SCALE; - b = st.p.color[ci].b * f / FP_SCALE; - lb_set_rgb(i, r, g, b); - } - - /* Increment the phase */ - if (st.battery_is_charging) - st.w0--; - else - st.w0++; - - /* Continue ramping in if needed */ - if (st.ramp < 0xff) - st.ramp++; - - i = st.p.s0a_tick_delay[st.battery_is_charging]; - WAIT_OR_RET(i); - } - return 0; -} - -#else /* just simple google colors */ - -static uint32_t sequence_S0(void) -{ - int w, i, r, g, b; - int f, change; - - lb_set_rgb(NUM_LEDS, 0, 0, 0); - lb_on(); - - /* Ramp up */ - for (w = 0; w < 128; w += 2) { - f = cycle_010(w); - for (i = 0; i < NUM_LEDS; i++) { - r = st.p.color[i].r * f / FP_SCALE; - g = st.p.color[i].g * f / FP_SCALE; - b = st.p.color[i].b * f / FP_SCALE; - lb_set_rgb(i, r, g, b); - } - WAIT_OR_RET(st.p.google_ramp_up); - } - - while (1) { - change = get_battery_level(); - - if (change) { - /* Not really low use google colors */ - if (st.battery_level) { - for (i = 0; i < NUM_LEDS; i++) { - r = st.p.color[i].r; - g = st.p.color[i].g; - b = st.p.color[i].b; - lb_set_rgb(i, r, g, b); - } - } else { - r = st.p.color[PRIMARY_RED].r; - g = st.p.color[PRIMARY_RED].g; - b = st.p.color[PRIMARY_RED].b; - lb_set_rgb(4, r, g, b); - } - } - - WAIT_OR_RET(1 * SECOND); - } - return 0; -} - -#endif - -/* CPU is going to sleep. */ -static uint32_t sequence_S0S3(void) -{ - int w, i, r, g, b; - int f; - uint8_t drop[NUM_LEDS][3]; - uint32_t res; - - /* Grab current colors */ - for (i = 0; i < NUM_LEDS; i++) - lb_get_rgb(i, &drop[i][0], &drop[i][1], &drop[i][2]); - - /* Fade down to black */ - for (w = 128; w <= 256; w++) { - f = cycle_010(w); - for (i = 0; i < NUM_LEDS; i++) { - r = drop[i][0] * f / FP_SCALE; - g = drop[i][1] * f / FP_SCALE; - b = drop[i][2] * f / FP_SCALE; - lb_set_rgb(i, r, g, b); - } - WAIT_OR_RET(st.p.s0s3_ramp_down); - } - - /* pulse once and done */ - res = pulse_google_colors(); - if (res) - return res; - - /* next sequence */ - return LIGHTBAR_S3; -} - -/* CPU is sleeping */ -static uint32_t sequence_S3(void) -{ - int r, g, b; - int w; - int f; - int ci; - - lb_off(); - lb_init(1); - lb_set_rgb(NUM_LEDS, 0, 0, 0); - get_battery_level(); - while (1) { - WAIT_OR_RET(st.p.s3_sleep_for); - - /* only pulse if we've been given a valid color index */ - ci = st.p.s3_idx[st.battery_is_charging][st.battery_level]; - if (ci >= ARRAY_SIZE(st.p.color)) - continue; - - /* pulse once */ - lb_on(); - - for (w = 0; w < 128; w += 2) { - f = cycle_010(w); - r = st.p.color[ci].r * f / FP_SCALE; - g = st.p.color[ci].g * f / FP_SCALE; - b = st.p.color[ci].b * f / FP_SCALE; - lb_set_rgb(NUM_LEDS, r, g, b); - WAIT_OR_RET(st.p.s3_ramp_up); - } - for (w = 128; w <= 256; w++) { - f = cycle_010(w); - r = st.p.color[ci].r * f / FP_SCALE; - g = st.p.color[ci].g * f / FP_SCALE; - b = st.p.color[ci].b * f / FP_SCALE; - lb_set_rgb(NUM_LEDS, r, g, b); - WAIT_OR_RET(st.p.s3_ramp_down); - } - - lb_set_rgb(NUM_LEDS, 0, 0, 0); - lb_off(); - } - return 0; -} - - -/* CPU is powering up. We generally boot fast enough that we don't have time - * to do anything interesting in the S3 state, but go straight on to S0. */ -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); - lb_init(1); - lb_set_rgb(NUM_LEDS, 0, 0, 0); - lb_on(); - /* next sequence */ - return LIGHTBAR_S3; -} - -/* Sleep to off. The S3->S5 transition takes about 10msec, so just wait. */ -static uint32_t sequence_S3S5(void) -{ - lb_off(); - /* next sequence */ - return LIGHTBAR_S5; -} - -/* Pulse S5 color to indicate that the battery is so critically low that it - * must charge first before the system can power on. */ -static uint32_t pulse_s5_color(void) -{ - int r, g, b; - int f; - int w; - struct rgb_s *color = &st.p.color[st.p.s5_idx]; - - for (w = 0; w < 128; w += 2) { - f = cycle_010(w); - r = color->r * f / FP_SCALE; - g = color->g * f / FP_SCALE; - b = color->b * f / FP_SCALE; - lb_set_rgb(NUM_LEDS, r, g, b); - WAIT_OR_RET(st.p.s5_ramp_up); - } - for (w = 128; w <= 256; w++) { - f = cycle_010(w); - r = color->r * f / FP_SCALE; - g = color->g * f / FP_SCALE; - b = color->b * f / FP_SCALE; - lb_set_rgb(NUM_LEDS, r, g, b); - WAIT_OR_RET(st.p.s5_ramp_down); - } - - return 0; -} - -/* CPU is off. Pulse the lightbar if a charger is attached and the battery is - * so low that the system cannot power on. Otherwise, the lightbar loses power - * when the CPU is in S5, so there's nothing to do. We'll just wait here until - * the state changes. */ -static uint32_t sequence_S5(void) -{ - int initialized = 0; - uint32_t res = 0; - - get_battery_level(); - while (1) { - if (!st.battery_is_power_on_prevented || - !st.battery_is_charging) - break; - - if (!initialized) { -#ifdef CONFIG_LIGHTBAR_POWER_RAILS - /* Request that lightbar power rails be turned on. */ - if (lb_power(1)) { - lb_set_rgb(NUM_LEDS, 0, 0, 0); - } -#endif - lb_on(); - initialized = 1; - } - - res = pulse_s5_color(); - if (res) - break; - } - -#ifdef CONFIG_LIGHTBAR_POWER_RAILS - if (initialized) - /* Suggest that the lightbar power rails can be shut down. */ - lb_power(0); -#endif - lb_off(); - if (!res) - WAIT_OR_RET(-1); - return res; -} - -/* The AP 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 (or until we think the AP is shutting down). - */ -static uint32_t sequence_STOP(void) -{ - uint32_t msg; - - do { - msg = task_wait_event(-1); - CPRINTS("LB %s() got pending_msg %d", __func__, pending_msg); - } while (msg != PENDING_MSG || ( - pending_msg != LIGHTBAR_RUN && - pending_msg != LIGHTBAR_S0S3 && - pending_msg != LIGHTBAR_S3 && - pending_msg != LIGHTBAR_S3S5 && - pending_msg != LIGHTBAR_S5)); - 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. This - * sequence is to indicate an internal error in the lightbar logic, not an - * error with the Chromebook itself. - */ -static uint32_t sequence_ERROR(void) -{ - lb_init(1); - lb_on(); - - lb_set_rgb(0, 255, 255, 255); - lb_set_rgb(1, 255, 0, 255); - lb_set_rgb(2, 0, 255, 255); - lb_set_rgb(3, 255, 255, 255); - - WAIT_OR_RET(10 * SECOND); - 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_inner(void) -{ - int i; - - for (i = 0; i < ARRAY_SIZE(konami); i++) { - lb_set_rgb(konami[i].led, - konami[i].r, konami[i].g, konami[i].b); - if (konami[i].delay) - WAIT_OR_RET(konami[i].delay); - } - - return 0; -} - -static uint32_t sequence_KONAMI(void) -{ - int tmp; - uint32_t r; - - /* First clear all segments */ - lb_set_rgb(NUM_LEDS, 0, 0, 0); - - /* Force brightness to max, then restore it */ - tmp = lb_get_brightness(); - lb_set_brightness(255); - r = sequence_KONAMI_inner(); - lb_set_brightness(tmp); - return r; -} - -#ifdef CONFIG_LIGHTBAR_TAP_DIM_LAST_SEGMENT -/* Returns 0.0 to 1.0 for val in [min, min + ofs] */ -static int range(int val, int min, int ofs) -{ - if (val <= min) - return 0; - if (val >= min+ofs) - return FP_SCALE; - return (val - min) * FP_SCALE / ofs; -} -#endif - -/* Handy constant */ -#define CUT (100 / NUM_LEDS) - -static uint32_t sequence_TAP_inner(int dir) -{ - enum { RED, YELLOW, GREEN } base_color; - timestamp_t start, now; - uint32_t elapsed_time = 0; - int i, l, ci, max_led; - int f_osc, f_mult; - int gi, gr, gate[NUM_LEDS] = {0, 0, 0, 0}; - uint8_t w = 0; -#ifdef CONFIG_LIGHTBAR_TAP_DIM_LAST_SEGMENT - int f_min, f_delta, f_power; - - f_min = st.p.tap_seg_min_on * FP_SCALE / 100; - f_delta = (st.p.tap_seg_max_on - st.p.tap_seg_min_on) * FP_SCALE / 100; -#endif - f_osc = st.p.tap_seg_osc * FP_SCALE / 100; - - get_battery_level(); - - if (st.battery_level == 0) - base_color = RED; - else if (st.battery_percent > st.p.tap_pct_green) - base_color = GREEN; - else - base_color = YELLOW; - - ci = st.p.tap_idx[base_color]; - max_led = st.battery_percent / CUT; - - start = get_time(); - while (1) { - /* Enable the segments gradually */ - gi = elapsed_time / st.p.tap_gate_delay; - gr = elapsed_time % st.p.tap_gate_delay; - if (gi < NUM_LEDS) - gate[gi] = FP_SCALE * gr / st.p.tap_gate_delay; - if (gi && gi <= NUM_LEDS) - gate[gi - 1] = FP_SCALE; - - for (i = 0; i < NUM_LEDS; i++) { - -#ifdef CONFIG_LIGHTBAR_TAP_DIM_LAST_SEGMENT - if (max_led > i) { - f_mult = FP_SCALE; - } else if (max_led < i) { - f_mult = 0; - } else { - switch (base_color) { - case RED: - f_power = range(st.battery_percent, 0, - st.p.battery_threshold[0] - 1); - break; - case YELLOW: - f_power = range(st.battery_percent, - i * CUT, CUT - 1); - break; - case GREEN: - /* green is always full on */ - f_power = FP_SCALE; - } - f_mult = f_min + f_power * f_delta / FP_SCALE; - } -#else - if (max_led >= i) - f_mult = FP_SCALE; - else if (max_led < i) - f_mult = 0; -#endif - - f_mult = f_mult * gate[i] / FP_SCALE; - - /* Pulse when charging and not yet full */ - if (st.battery_is_charging && - st.battery_percent <= st.p.tap_pct_green) { - int scale = (FP_SCALE - - f_osc * cycle_010(w++) / FP_SCALE); - f_mult = f_mult * scale / FP_SCALE; - } - - l = dir ? i : NUM_LEDS - 1 - i; - lb_set_rgb(l, f_mult * st.p.color[ci].r / FP_SCALE, - f_mult * st.p.color[ci].g / FP_SCALE, - f_mult * st.p.color[ci].b / FP_SCALE); - } - - WAIT_OR_RET(st.p.tap_tick_delay); - - /* Return after some time has elapsed */ - now = get_time(); - elapsed_time = now.le.lo - start.le.lo; - if (elapsed_time > st.p.tap_display_time) - break; - } - return 0; -} - -/* Override the tap direction for testing. -1 means ask the PD MCU. */ -static int force_dir = -1; - -/* Return 0 (left or none) or 1 (right) */ -static int get_tap_direction(void) -{ - static int last_dir; - int dir = 0; - - if (force_dir >= 0) - dir = force_dir; -#ifdef HAS_TASK_PDCMD - else - dir = pd_get_active_charge_port(); -#endif - if (dir < 0) - dir = last_dir; - else if (dir != 1) - dir = 0; - - CPRINTS("LB tap direction %d", dir); - last_dir = dir; - return dir; -} - -static uint32_t sequence_TAP(void) -{ - int i; - uint32_t r; - uint8_t br, save[NUM_LEDS][3]; - int dir; - - /* - * There's a lot of unavoidable glitchiness on the AC_PRESENT interrupt - * each time the EC boots, resulting in fights between the TAP sequence - * and the S5S3->S3->S3S0->S0 sequences. This delay prevents the lights - * from flickering without reducing the responsiveness to manual taps. - */ - WAIT_OR_RET(100 * MSEC); - - /* Which direction should the power meter go? */ - dir = get_tap_direction(); - -#ifdef CONFIG_LIGHTBAR_POWER_RAILS - /* Request that the lightbar power rails be turned on. */ - if (lb_power(1)) { - lb_set_rgb(NUM_LEDS, 0, 0, 0); - } -#endif - /* First clear all segments */ - lb_set_rgb(NUM_LEDS, 0, 0, 0); - - lb_on(); - - for (i = 0; i < NUM_LEDS; i++) - lb_get_rgb(i, &save[i][0], &save[i][1], &save[i][2]); - br = lb_get_brightness(); - lb_set_brightness(255); - - r = sequence_TAP_inner(dir); - - lb_set_brightness(br); - for (i = 0; i < NUM_LEDS; i++) - lb_set_rgb(i, save[i][0], save[i][1], save[i][2]); - -#ifdef CONFIG_LIGHTBAR_POWER_RAILS - /* Suggest that the lightbar power rails can be shut down again. */ - lb_power(0); -#endif - return r; -} - -/****************************************************************************/ -/* Lightbar bytecode interpreter: Lightbyte. */ -/****************************************************************************/ - -/* When a program halts, return this. */ -#define PROGRAM_FINISHED 2 - -static struct lightbar_program cur_prog; -static struct lightbar_program next_prog; -static uint8_t pc; - -static uint8_t led_desc[NUM_LEDS][LB_CONT_MAX][3]; -static uint32_t lb_wait_delay; -static uint32_t lb_ramp_delay; -/* Get one byte of data pointed to by the pc and advance - * the pc forward. - */ -static inline uint32_t decode_8(uint8_t *dest) -{ - if (pc >= cur_prog.size) { - CPRINTS("pc 0x%02x out of bounds", pc); - return EC_RES_INVALID_PARAM; - } - *dest = cur_prog.data[pc++]; - return EC_SUCCESS; -} - -/* Get four bytes of data pointed to by the pc and advance - * the pc forward that amount. - */ -static inline uint32_t decode_32(uint32_t *dest) -{ - if (pc >= cur_prog.size - 3) { - CPRINTS("pc 0x%02x near or out of bounds", pc); - return EC_RES_INVALID_PARAM; - } - *dest = cur_prog.data[pc++] << 24; - *dest |= cur_prog.data[pc++] << 16; - *dest |= cur_prog.data[pc++] << 8; - *dest |= cur_prog.data[pc++]; - return EC_SUCCESS; -} - -/* ON - turn on lightbar */ -static uint32_t lightbyte_ON(void) -{ - lb_on(); - return EC_SUCCESS; -} - -/* OFF - turn off lightbar */ -static uint32_t lightbyte_OFF(void) -{ - lb_off(); - return EC_SUCCESS; -} - -/* JUMP xx - jump to immediate location - * Changes the pc to the one-byte immediate argument. - */ -static uint32_t lightbyte_JUMP(void) -{ - return decode_8(&pc); -} - -/* JUMP_BATTERY aa bb - switch on battery level - * If the battery is low, changes pc to aa. - * If the battery is high, changes pc to bb. - * Otherwise, continues execution as normal. - */ -static uint32_t lightbyte_JUMP_BATTERY(void) -{ - uint8_t low_pc, high_pc; - if (decode_8(&low_pc) != EC_SUCCESS) - return EC_RES_INVALID_PARAM; - if (decode_8(&high_pc) != EC_SUCCESS) - return EC_RES_INVALID_PARAM; - - get_battery_level(); - if (st.battery_level == 0) - pc = low_pc; - else if (st.battery_level == 3) - pc = high_pc; - - return EC_SUCCESS; -} - -/* JUMP_IF_CHARGING xx - conditional jump to location - * Changes the pc to xx if the device is charging. - */ -static uint32_t lightbyte_JUMP_IF_CHARGING(void) -{ - uint8_t charge_pc; - if (decode_8(&charge_pc) != EC_SUCCESS) - return EC_RES_INVALID_PARAM; - - if (st.battery_is_charging) - pc = charge_pc; - - return EC_SUCCESS; -} - -/* SET_WAIT_DELAY xx xx xx xx - set up to yield processor - * Sets the wait delay to the given four-byte immediate, in - * microseconds. Future WAIT instructions will wait for this - * much time. - */ -static uint32_t lightbyte_SET_WAIT_DELAY(void) -{ - return decode_32(&lb_wait_delay); -} - -/* SET_RAMP_DELAY xx xx xx xx - change ramp speed - * This sets the length of time between ramp/cycle steps to - * the four-byte immediate argument, which represents a duration - * in milliseconds. - */ -static uint32_t lightbyte_SET_RAMP_DELAY(void) -{ - return decode_32(&lb_ramp_delay); -} - -/* WAIT - yield processor for some time - * Yields the processor for some amount of time set by the most - * recent SET_WAIT_DELAY instruction. - */ -static uint32_t lightbyte_WAIT(void) -{ - if (lb_wait_delay != 0) - WAIT_OR_RET(lb_wait_delay); - - return EC_SUCCESS; -} - -/* SET_BRIGHTNESS xx - * Sets the current brightness to the given one-byte - * immediate argument. - */ -static uint32_t lightbyte_SET_BRIGHTNESS(void) -{ - uint8_t val; - if (decode_8(&val) != EC_SUCCESS) - return EC_RES_INVALID_PARAM; - - lb_set_brightness(val); - return EC_SUCCESS; -} - -/* SET_COLOR_SINGLE cc xx - * SET_COLOR_RGB cc rr gg bb - * Stores a color value in the led_desc structure. - * cc is a bit-packed location to perform the action on. - * - * The high four bits are a bitset for which LEDs to operate on. - * LED 0 is the lowest of the four bits. - * - * The next two bits are the control bits. This should be a value - * in lb_control that is not LB_CONT_MAX, and the corresponding - * color will be the one the action is performed on. - * - * The last two bits are the color bits if this instruction is - * SET_COLOR_SINGLE. They correspond to a LB_COL value for the - * channel to set the color for using the next immediate byte. - * In SET_COLOR_RGB, these bits are don't-cares, as there should - * always be three bytes that follow, which correspond to a - * complete RGB specification. - */ -static uint32_t lightbyte_SET_COLOR_SINGLE(void) -{ - - uint8_t packed_loc, led, control, color, value; - int i; - if (decode_8(&packed_loc) != EC_SUCCESS) - return EC_RES_INVALID_PARAM; - if (decode_8(&value) != EC_SUCCESS) - return EC_RES_INVALID_PARAM; - - led = packed_loc >> 4; - control = (packed_loc >> 2) & 0x3; - color = packed_loc & 0x3; - - if (control >= LB_CONT_MAX) - return EC_RES_INVALID_PARAM; - - for (i = 0; i < NUM_LEDS; i++) - if (led & BIT(i)) - led_desc[i][control][color] = value; - - return EC_SUCCESS; -} - -static uint32_t lightbyte_SET_COLOR_RGB(void) -{ - uint8_t packed_loc, r, g, b, led, control; - int i; - - /* gross */ - if (decode_8(&packed_loc) != EC_SUCCESS) - return EC_RES_INVALID_PARAM; - if (decode_8(&r) != EC_SUCCESS) - return EC_RES_INVALID_PARAM; - if (decode_8(&g) != EC_SUCCESS) - return EC_RES_INVALID_PARAM; - if (decode_8(&b) != EC_SUCCESS) - return EC_RES_INVALID_PARAM; - - led = packed_loc >> 4; - control = (packed_loc >> 2) & 0x3; - - if (control >= LB_CONT_MAX) - return EC_RES_INVALID_PARAM; - - for (i = 0; i < NUM_LEDS; i++) - if (led & BIT(i)) { - led_desc[i][control][LB_COL_RED] = r; - led_desc[i][control][LB_COL_GREEN] = g; - led_desc[i][control][LB_COL_BLUE] = b; - } - - return EC_SUCCESS; -} - -/* GET_COLORS - take current colors and push them to the state - * Gets the current state of the LEDs and puts them in COLOR0. - * Good for the beginning of a program if you need to fade in. - */ -static uint32_t lightbyte_GET_COLORS(void) -{ - int i; - for (i = 0; i < NUM_LEDS; i++) - lb_get_rgb(i, &led_desc[i][LB_CONT_COLOR0][LB_COL_RED], - &led_desc[i][LB_CONT_COLOR0][LB_COL_GREEN], - &led_desc[i][LB_CONT_COLOR0][LB_COL_BLUE]); - - return EC_SUCCESS; -} - -/* SWAP_COLORS - swaps beginning and end colors in state - * Exchanges COLOR0 and COLOR1 on all LEDs. - */ -static uint32_t lightbyte_SWAP_COLORS(void) -{ - int i, j, tmp; - for (i = 0; i < NUM_LEDS; i++) - for (j = 0; j < 3; j++) { - tmp = led_desc[i][LB_CONT_COLOR0][j]; - led_desc[i][LB_CONT_COLOR0][j] = - led_desc[i][LB_CONT_COLOR1][j]; - led_desc[i][LB_CONT_COLOR1][j] = tmp; - } - - return EC_SUCCESS; -} - -static inline int get_interp_value(int led, int color, int interp) -{ - int base = led_desc[led][LB_CONT_COLOR0][color]; - int delta = led_desc[led][LB_CONT_COLOR1][color] - base; - return base + (delta * interp / FP_SCALE); -} - -static void set_all_leds(int color) -{ - int i, r, g, b; - for (i = 0; i < NUM_LEDS; i++) { - r = led_desc[i][color][LB_COL_RED]; - g = led_desc[i][color][LB_COL_GREEN]; - b = led_desc[i][color][LB_COL_BLUE]; - lb_set_rgb(i, r, g, b); - } -} - -static uint32_t ramp_all_leds(int stop_at) -{ - int w, i, r, g, b, f; - for (w = 0; w < stop_at; w++) { - f = cycle_010(w); - for (i = 0; i < NUM_LEDS; i++) { - r = get_interp_value(i, LB_COL_RED, f); - g = get_interp_value(i, LB_COL_GREEN, f); - b = get_interp_value(i, LB_COL_BLUE, f); - lb_set_rgb(i, r, g, b); - } - WAIT_OR_RET(lb_ramp_delay); - } - return EC_SUCCESS; -} - -/* RAMP_ONCE - simple gradient or color set - * If the ramp delay is set to zero, then this sets the color of - * all LEDs to their respective COLOR1. - * If the ramp delay is nonzero, then this sets their color to - * their respective COLOR0, and takes them via interpolation to - * COLOR1, with the delay time passing in between each step. - */ -static uint32_t lightbyte_RAMP_ONCE(void) -{ - /* special case for instantaneous set */ - if (lb_ramp_delay == 0) { - set_all_leds(LB_CONT_COLOR1); - return EC_SUCCESS; - } - - return ramp_all_leds(128); -} - -/* CYCLE_ONCE - simple cycle or color set - * If the ramp delay is zero, then this sets the color of all LEDs - * to their respective COLOR0. - * If the ramp delay is nonzero, this sets the color of all LEDs - * to COLOR0, then performs a ramp (as in RAMP_ONCE) to COLOR1, - * and finally back to COLOR0. - */ -static uint32_t lightbyte_CYCLE_ONCE(void) -{ - /* special case for instantaneous set */ - if (lb_ramp_delay == 0) { - set_all_leds(LB_CONT_COLOR0); - return EC_SUCCESS; - } - - return ramp_all_leds(256); -} - -/* CYCLE - repeating cycle - * Indefinitely ramps from COLOR0 to COLOR1, taking into - * account the PHASE of each component of each color when - * interpolating. (Different LEDs and different color channels - * on a single LED can start at different places in the cycle, - * though they will advance at the same rate.) - * - * If the ramp delay is zero, this instruction will error out. - */ -static uint32_t lightbyte_CYCLE(void) -{ - int w, i, r, g, b; - - /* what does it mean to cycle indefinitely with 0 delay? */ - if (lb_ramp_delay == 0) - return EC_RES_INVALID_PARAM; - - for (w = 0;; w++) { - for (i = 0; i < NUM_LEDS; i++) { - r = get_interp_value(i, LB_COL_RED, - cycle_010((w & 0xff) + - led_desc[i][LB_CONT_PHASE][LB_COL_RED])); - g = get_interp_value(i, LB_COL_GREEN, - cycle_010((w & 0xff) + - led_desc[i][LB_CONT_PHASE][LB_COL_GREEN])); - b = get_interp_value(i, LB_COL_BLUE, - cycle_010((w & 0xff) + - led_desc[i][LB_CONT_PHASE][LB_COL_BLUE])); - lb_set_rgb(i, r, g, b); - } - WAIT_OR_RET(lb_ramp_delay); - } - return EC_SUCCESS; -} - -/* HALT - return with success - * Show's over. Go back to what you were doing before. - */ -static uint32_t lightbyte_HALT(void) -{ - return PROGRAM_FINISHED; -} - -#undef GET_INTERP_VALUE - -#define OP(NAME, BYTES, MNEMONIC) NAME, -#include "lightbar_opcode_list.h" -enum lightbyte_opcode { - LIGHTBAR_OPCODE_TABLE - MAX_OPCODE -}; -#undef OP - -#define OP(NAME, BYTES, MNEMONIC) lightbyte_ ## NAME, -#include "lightbar_opcode_list.h" -static uint32_t (*lightbyte_dispatch[])(void) = { - LIGHTBAR_OPCODE_TABLE -}; -#undef OP - -#define OP(NAME, BYTES, MNEMONIC) MNEMONIC, -#include "lightbar_opcode_list.h" -static const char * const lightbyte_names[] = { - LIGHTBAR_OPCODE_TABLE -}; -#undef OP - -static uint32_t sequence_PROGRAM(void) -{ - uint8_t saved_brightness; - uint8_t next_inst; - uint32_t rc; - uint8_t old_pc; - - /* load next program */ - memcpy(&cur_prog, &next_prog, sizeof(struct lightbar_program)); - - /* reset program state */ - saved_brightness = lb_get_brightness(); - pc = 0; - memset(led_desc, 0, sizeof(led_desc)); - lb_wait_delay = 0; - lb_ramp_delay = 0; - - lb_on(); - lb_set_brightness(255); - - /* decode-execute loop */ - for (;;) { - old_pc = pc; - if (decode_8(&next_inst) != EC_SUCCESS) - return EC_RES_INVALID_PARAM; - - if (next_inst >= MAX_OPCODE) { - CPRINTS("LB PROGRAM pc: 0x%02x, " - "found invalid opcode 0x%02x", - old_pc, next_inst); - lb_set_brightness(saved_brightness); - return EC_RES_INVALID_PARAM; - } else { - CPRINTS("LB PROGRAM pc: 0x%02x, opcode 0x%02x -> %s", - old_pc, next_inst, lightbyte_names[next_inst]); - rc = lightbyte_dispatch[next_inst](); - if (rc) { - lb_set_brightness(saved_brightness); - return rc; - } - } - - /* yield processor in case we are stuck in a tight loop */ - WAIT_OR_RET(100); - } -} - -/****************************************************************************/ -/* The main lightbar task. It just cycles between various pretty patterns. */ -/****************************************************************************/ - -/* Distinguish "normal" sequences from one-shot sequences */ -static inline int is_normal_sequence(enum lightbar_sequence seq) -{ - return (seq >= LIGHTBAR_S5 && seq <= LIGHTBAR_S3S5); -} - -/* 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 next_seq; - - CPRINTS("LB task starting"); - - lightbar_restore_state(); - - while (1) { - CPRINTS("LB running cur_seq %d %s. prev_seq %d %s", - st.cur_seq, lightbar_cmds[st.cur_seq].string, - st.prev_seq, lightbar_cmds[st.prev_seq].string); - next_seq = lightbar_cmds[st.cur_seq].sequence(); - if (next_seq) { - CPRINTS("LB cur_seq %d %s returned pending msg %d %s", - st.cur_seq, lightbar_cmds[st.cur_seq].string, - next_seq, lightbar_cmds[next_seq].string); - if (st.cur_seq != next_seq) { - if (is_normal_sequence(st.cur_seq)) - st.prev_seq = st.cur_seq; - st.cur_seq = next_seq; - } - } else { - CPRINTS("LB cur_seq %d %s returned value 0", - st.cur_seq, lightbar_cmds[st.cur_seq].string); - 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_STOP: - case LIGHTBAR_RUN: - case LIGHTBAR_ERROR: - case LIGHTBAR_KONAMI: - case LIGHTBAR_TAP: - case LIGHTBAR_PROGRAM: - st.cur_seq = st.prev_seq; - default: - break; - } - } - } -} - -/* Function to request a preset sequence from the lightbar task. */ -void lightbar_sequence_f(enum lightbar_sequence num, const char *f) -{ - if (num > 0 && num < LIGHTBAR_NUM_SEQUENCES) { - CPRINTS("LB %s() requests %d %s", f, num, - lightbar_cmds[num].string); - pending_msg = num; - task_set_event(TASK_ID_LIGHTBAR, PENDING_MSG); - } else - CPRINTS("LB %s() requests %d - ignored", f, num); -} - -/****************************************************************************/ -/* Get notifications from other parts of the system */ - -static uint8_t manual_suspend_control; - -static void lightbar_startup(void) -{ - manual_suspend_control = 0; - lightbar_sequence(LIGHTBAR_S5S3); -} -DECLARE_HOOK(HOOK_CHIPSET_STARTUP, lightbar_startup, HOOK_PRIO_DEFAULT); - -static void lightbar_resume(void) -{ - if (!manual_suspend_control) - lightbar_sequence(LIGHTBAR_S3S0); -} -DECLARE_HOOK(HOOK_CHIPSET_RESUME, lightbar_resume, HOOK_PRIO_DEFAULT); - -static void lightbar_suspend(void) -{ - if (!manual_suspend_control) - lightbar_sequence(LIGHTBAR_S0S3); -} -DECLARE_HOOK(HOOK_CHIPSET_SUSPEND, lightbar_suspend, HOOK_PRIO_DEFAULT); - -static void lightbar_shutdown(void) -{ - lightbar_sequence(LIGHTBAR_S3S5); -} -DECLARE_HOOK(HOOK_CHIPSET_SHUTDOWN, lightbar_shutdown, HOOK_PRIO_DEFAULT); - -/****************************************************************************/ -/* Host commands via LPC bus */ -/****************************************************************************/ - -static enum ec_status lpc_cmd_lightbar(struct host_cmd_handler_args *args) -{ - const struct ec_params_lightbar *in = args->params; - struct ec_response_lightbar *out = args->response; - int rv; - - switch (in->cmd) { - case LIGHTBAR_CMD_DUMP: - lb_hc_cmd_dump(out); - args->response_size = sizeof(out->dump); - break; - case LIGHTBAR_CMD_OFF: - lb_off(); - break; - case LIGHTBAR_CMD_ON: - lb_on(); - break; - case LIGHTBAR_CMD_INIT: - lb_init(1); - break; - case LIGHTBAR_CMD_SET_BRIGHTNESS: - lb_set_brightness(in->set_brightness.num); - break; - case LIGHTBAR_CMD_GET_BRIGHTNESS: - out->get_brightness.num = lb_get_brightness(); - args->response_size = sizeof(out->get_brightness); - break; - case LIGHTBAR_CMD_SEQ: - lightbar_sequence(in->seq.num); - break; - case LIGHTBAR_CMD_REG: - lb_hc_cmd_reg(in); - break; - case LIGHTBAR_CMD_SET_RGB: - lb_set_rgb(in->set_rgb.led, - in->set_rgb.red, - in->set_rgb.green, - in->set_rgb.blue); - break; - case LIGHTBAR_CMD_GET_RGB: - rv = lb_get_rgb(in->get_rgb.led, - &out->get_rgb.red, - &out->get_rgb.green, - &out->get_rgb.blue); - if (rv == EC_RES_SUCCESS) - args->response_size = sizeof(out->get_rgb); - return rv; - 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; - CPRINTS("LB_demo %d", demo_mode); - break; - case LIGHTBAR_CMD_GET_DEMO: - out->get_demo.num = demo_mode; - args->response_size = sizeof(out->get_demo); - break; - case LIGHTBAR_CMD_GET_PARAMS_V0: - CPRINTS("LB_get_params_v0 not supported"); - return EC_RES_INVALID_VERSION; - break; - case LIGHTBAR_CMD_SET_PARAMS_V0: - CPRINTS("LB_set_params_v0 not supported"); - return EC_RES_INVALID_VERSION; - break; - case LIGHTBAR_CMD_GET_PARAMS_V1: - CPRINTS("LB_get_params_v1"); - memcpy(&out->get_params_v1, &st.p, sizeof(st.p)); - args->response_size = sizeof(out->get_params_v1); - break; - case LIGHTBAR_CMD_SET_PARAMS_V1: - CPRINTS("LB_set_params_v1"); - memcpy(&st.p, &in->set_params_v1, sizeof(st.p)); - break; - case LIGHTBAR_CMD_SET_PROGRAM: - CPRINTS("LB_set_program"); - memcpy(&next_prog, - &in->set_program, - sizeof(struct lightbar_program)); - break; - case LIGHTBAR_CMD_VERSION: - CPRINTS("LB_version"); - out->version.num = LIGHTBAR_IMPLEMENTATION_VERSION; - out->version.flags = LIGHTBAR_IMPLEMENTATION_FLAGS; - args->response_size = sizeof(out->version); - break; - case LIGHTBAR_CMD_MANUAL_SUSPEND_CTRL: - CPRINTS("LB_manual_suspend_ctrl"); - manual_suspend_control = in->manual_suspend_ctrl.enable; - break; - case LIGHTBAR_CMD_SUSPEND: - CPRINTS("LB_suspend"); - lightbar_sequence(LIGHTBAR_S0S3); - break; - case LIGHTBAR_CMD_RESUME: - CPRINTS("LB_resume"); - lightbar_sequence(LIGHTBAR_S3S0); - break; - case LIGHTBAR_CMD_GET_PARAMS_V2_TIMING: - CPRINTS("LB_get_params_v2_timing"); - memcpy(&out->get_params_v2_timing, - &st.p_v2.timing, - sizeof(st.p_v2.timing)); - args->response_size = sizeof(out->get_params_v2_timing); - break; - case LIGHTBAR_CMD_SET_PARAMS_V2_TIMING: - CPRINTS("LB_set_params_v2_timing"); - memcpy(&st.p_v2.timing, - &in->set_v2par_timing, - sizeof(struct lightbar_params_v2_timing)); - break; - case LIGHTBAR_CMD_GET_PARAMS_V2_TAP: - CPRINTS("LB_get_params_v2_tap"); - memcpy(&out->get_params_v2_tap, - &st.p_v2.tap, - sizeof(struct lightbar_params_v2_tap)); - args->response_size = sizeof(out->get_params_v2_tap); - break; - case LIGHTBAR_CMD_SET_PARAMS_V2_TAP: - CPRINTS("LB_set_params_v2_tap"); - memcpy(&st.p_v2.tap, - &in->set_v2par_tap, - sizeof(struct lightbar_params_v2_tap)); - break; - case LIGHTBAR_CMD_GET_PARAMS_V2_OSCILLATION: - CPRINTS("LB_get_params_v2_oscillation"); - memcpy(&out->get_params_v2_osc, &st.p_v2.osc, - sizeof(struct lightbar_params_v2_oscillation)); - args->response_size = sizeof(out->get_params_v2_osc); - break; - case LIGHTBAR_CMD_SET_PARAMS_V2_OSCILLATION: - CPRINTS("LB_set_params_v2_oscillation"); - memcpy(&st.p_v2.osc, - &in->set_v2par_osc, - sizeof(struct lightbar_params_v2_oscillation)); - break; - case LIGHTBAR_CMD_GET_PARAMS_V2_BRIGHTNESS: - CPRINTS("LB_get_params_v2_brightness"); - memcpy(&out->get_params_v2_bright, - &st.p_v2.bright, - sizeof(struct lightbar_params_v2_brightness)); - args->response_size = sizeof(out->get_params_v2_bright); - break; - case LIGHTBAR_CMD_SET_PARAMS_V2_BRIGHTNESS: - CPRINTS("LB_set_params_v2_brightness"); - memcpy(&st.p_v2.bright, - &in->set_v2par_bright, - sizeof(struct lightbar_params_v2_brightness)); - break; - case LIGHTBAR_CMD_GET_PARAMS_V2_THRESHOLDS: - CPRINTS("LB_get_params_v2_thlds"); - memcpy(&out->get_params_v2_thlds, - &st.p_v2.thlds, - sizeof(struct lightbar_params_v2_thresholds)); - args->response_size = sizeof(out->get_params_v2_thlds); - break; - case LIGHTBAR_CMD_SET_PARAMS_V2_THRESHOLDS: - CPRINTS("LB_set_params_v2_thlds"); - memcpy(&st.p_v2.thlds, - &in->set_v2par_thlds, - sizeof(struct lightbar_params_v2_thresholds)); - break; - case LIGHTBAR_CMD_GET_PARAMS_V2_COLORS: - CPRINTS("LB_get_params_v2_colors"); - memcpy(&out->get_params_v2_colors, - &st.p_v2.colors, - sizeof(struct lightbar_params_v2_colors)); - args->response_size = sizeof(out->get_params_v2_colors); - break; - case LIGHTBAR_CMD_SET_PARAMS_V2_COLORS: - CPRINTS("LB_set_params_v2_colors"); - memcpy(&st.p_v2.colors, - &in->set_v2par_colors, - sizeof(struct lightbar_params_v2_colors)); - break; - default: - CPRINTS("LB bad cmd 0x%x", 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 CONFIG_CONSOLE_CMDHELP -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=%d for all)\n", cmd, NUM_LEDS); - ccprintf(" %s LED - get current LED color\n", cmd); - ccprintf(" %s demo [0|1] - turn demo mode on & off\n", cmd); -#ifdef LIGHTBAR_SIMULATION - ccprintf(" %s program filename - load lightbyte program\n", cmd); -#endif - ccprintf(" %s version - show current version\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, led, r = 0, g = 0, b = 0; - struct ec_response_lightbar out; - char *e; - - if (argc == 1) { /* no args = dump 'em all */ - lb_hc_cmd_dump(&out); - for (i = 0; i < ARRAY_SIZE(out.dump.vals); 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 (!strcasecmp(argv[1], "init")) { - lb_init(1); - return EC_SUCCESS; - } - - if (!strcasecmp(argv[1], "off")) { - lb_off(); - return EC_SUCCESS; - } - - if (!strcasecmp(argv[1], "on")) { - lb_on(); - return EC_SUCCESS; - } - - if (!strcasecmp(argv[1], "version")) { - ccprintf("version %d flags 0x%x\n", - LIGHTBAR_IMPLEMENTATION_VERSION, - LIGHTBAR_IMPLEMENTATION_FLAGS); - return EC_SUCCESS; - } - - if (!strcasecmp(argv[1], "brightness")) { - if (argc > 2) { - num = 0xff & strtoi(argv[2], &e, 16); - lb_set_brightness(num); - } - ccprintf("brightness is %02x\n", lb_get_brightness()); - return EC_SUCCESS; - } - - if (!strcasecmp(argv[1], "demo")) { - if (argc > 2) { - 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 (!strcasecmp(argv[1], "seq")) { - 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; - if (argc > 3) /* for testing TAP direction */ - force_dir = strtoi(argv[3], 0, 0); - lightbar_sequence(num); - return EC_SUCCESS; - } - -#ifdef LIGHTBAR_SIMULATION - /* Load a program. */ - if (argc >= 3 && !strcasecmp(argv[1], "program")) { - return lb_load_program(argv[2], &next_prog); - } -#endif - - if (argc == 4) { - struct ec_params_lightbar in; - in.reg.ctrl = strtoi(argv[1], &e, 16); - in.reg.reg = strtoi(argv[2], &e, 16); - in.reg.value = strtoi(argv[3], &e, 16); - lb_hc_cmd_reg(&in); - return EC_SUCCESS; - } - - if (argc == 5) { - led = strtoi(argv[1], &e, 16); - r = strtoi(argv[2], &e, 16); - g = strtoi(argv[3], &e, 16); - b = strtoi(argv[4], &e, 16); - lb_set_rgb(led, r, g, b); - return EC_SUCCESS; - } - - /* Only thing left is to try to read an LED value */ - num = strtoi(argv[1], &e, 16); - if (!(e && *e)) { - if (num >= NUM_LEDS) { - for (i = 0; i < NUM_LEDS; i++) { - lb_get_rgb(i, &r, &g, &b); - ccprintf("%x: %02x %02x %02x\n", i, r, g, b); - } - } else { - lb_get_rgb(num, &r, &g, &b); - ccprintf("%02x %02x %02x\n", r, g, b); - } - return EC_SUCCESS; - } - - -#ifdef CONFIG_CONSOLE_CMDHELP - help(argv[0]); -#endif - - return EC_ERROR_INVAL; -} -DECLARE_CONSOLE_COMMAND(lightbar, command_lightbar, - "[help | COMMAND [ARGS]]", - "Get/set lightbar state"); |