/**
* Update backlight state.
*/
static void update_backlight(void)
{
/*
* Enable backlight if lid is open; this is AND'd with the request from
* the AP in hardware.
*/
gpio_set_level(GPIO_ENABLE_BACKLIGHT, lid_is_open());
if (lid_is_open())
hook_call_deferred(&lp8555_enable_pwm_mode_data, 0);
}
/**
* Update backlight state.
*/
static void update_backlight(void)
{
#ifdef CONFIG_BACKLIGHT_REQ_GPIO
/* Enable the backlight if lid is open AND requested by AP */
gpio_set_level(GPIO_ENABLE_BACKLIGHT, lid_is_open() &&
gpio_get_level(CONFIG_BACKLIGHT_REQ_GPIO));
#else
/*
* Enable backlight if lid is open; this is AND'd with the request from
* the AP in hardware.
*/
gpio_set_level(GPIO_ENABLE_BACKLIGHT, lid_is_open());
#endif
}
/**
* Update status of non-debounced switches.
*
* Note that deferred functions are called in the same context as lid and
* power button changes, so we don't need a mutex.
*/
static void switch_update(void)
{
static uint8_t prev;
/* Make sure this is safe to call before power_button_init() */
if (!memmap_switches)
return;
prev = *memmap_switches;
if (power_button_is_pressed())
*memmap_switches |= EC_SWITCH_POWER_BUTTON_PRESSED;
else
*memmap_switches &= ~EC_SWITCH_POWER_BUTTON_PRESSED;
if (lid_is_open())
*memmap_switches |= EC_SWITCH_LID_OPEN;
else
*memmap_switches &= ~EC_SWITCH_LID_OPEN;
if ((flash_get_protect() & EC_FLASH_PROTECT_GPIO_ASSERTED) == 0)
*memmap_switches |= EC_SWITCH_WRITE_PROTECT_DISABLED;
else
*memmap_switches &= ~EC_SWITCH_WRITE_PROTECT_DISABLED;
#ifdef CONFIG_SWITCH_DEDICATED_RECOVERY
if (gpio_get_level(GPIO_RECOVERY_L) == 0)
*memmap_switches |= EC_SWITCH_DEDICATED_RECOVERY;
else
*memmap_switches &= ~EC_SWITCH_DEDICATED_RECOVERY;
#endif
if (prev != *memmap_switches)
CPRINTS("SW 0x%02x", *memmap_switches);
}
static void fake_hibernate_lid_hook(void)
{
if (fake_hibernate && lid_is_open()) {
ccprints("%s() resets EC", __func__);
cflush();
system_reset(SYSTEM_RESET_HARD);
}
}
static void rockchip_lid_event(void)
{
/* Power task only cares about lid-open events */
if (!lid_is_open())
return;
lid_opened = 1;
task_wake(TASK_ID_CHIPSET);
}
void gesture_calc(uint32_t *event)
{
/* Only check for gesture if lid is closed and tap detection is on */
if (!tap_detection || lid_is_open())
return;
if (gesture_tap_for_battery())
*event |= CONFIG_GESTURE_TAP_EVENT;
}
static void hang_detect_lid(void)
{
if (lid_is_open()) {
if (hdparams.flags & EC_HANG_START_ON_LID_OPEN)
hang_detect_start("lid open");
} else {
if (hdparams.flags & EC_HANG_START_ON_LID_CLOSE)
hang_detect_start("lid close");
}
}
static void update_touchscreen(void)
{
/*
* If the lid is closed; put the touchscreen in reset to save power.
* If the lid is open, take it out of reset so it can wake the
* processor (although just opening the lid should do that anyway, so
* we don't have to worry about it staying on while the AP is off).
*/
gpio_set_level(GPIO_TOUCHSCREEN_RESET_L, lid_is_open());
}
void gesture_calc(void)
{
/* Only check for gesture if lid is closed and tap detection is on */
if (!tap_detection || lid_is_open())
return;
if (gesture_tap_for_battery()) {
CPRINTS("Double Tap!");
lightbar_sequence(LIGHTBAR_TAP);
/* Don't need to run motion sense task for a while */
task_wait_event(500 * MSEC);
}
}
static int pwr_led_set_color(enum led_color color)
{
switch (color) {
case LED_OFF:
gpio_set_level(GPIO_POWER_LED, POWER_LED_OFF);
break;
case LED_WHITE:
gpio_set_level(GPIO_POWER_LED,
lid_is_open() ? POWER_LED_ON : POWER_LED_OFF);
break;
default:
return EC_ERROR_UNKNOWN;
}
return EC_SUCCESS;
}
/**
* Get raw power button signal state.
*
* @return 1 if power button is pressed, 0 if not pressed.
*/
static int raw_power_button_pressed(void)
{
if (simulate_power_pressed)
return 1;
#ifndef CONFIG_POWER_BUTTON_IGNORE_LID
/*
* Always indicate power button released if the lid is closed.
* This prevents waking the system if the device is squashed enough to
* press the power button through the closed lid.
*/
if (!lid_is_open())
return 0;
#endif
return power_button_signal_asserted();
}
/**
* Setup backlight controller and turn it on.
*/
static void lp8555_enable_pwm_mode(void)
{
int reg;
int rv;
/*
* If not in S0, then PCH backlight enable will not be on, and if
* lid is closed EC backlight enable will not be on. Since these
* two signals are AND'ed together, no point in trying to talk to
* the lp8555 if either one of them is not true.
*/
if (!chipset_in_state(CHIPSET_STATE_ON) || !lid_is_open())
return;
/* Enable PWM mode. */
rv = lp8555_read_with_retry(LP8555_REG_CONFIG, ®);
if (rv != EC_SUCCESS)
return;
reg &= ~LP8555_REG_CONFIG_MODE_MASK;
reg |= LP8555_REG_CONFIG_MODE_PWM;
rv = lp8555_write_with_retry(LP8555_REG_CONFIG, reg);
if (rv != EC_SUCCESS)
return;
/* Set max LED current to 23mA. */
rv = lp8555_write_with_retry(LP8555_REG_CURRENT,
LP8555_REG_CURRENT_MAXCURR_23MA);
if (rv != EC_SUCCESS)
return;
/* Set the rate of brightness change. */
rv = lp8555_write_with_retry(LP8555_REG_STEP,
LP8555_REG_STEP_STEP_200MS |
LP8555_REG_STEP_PWM_IN_HYST_8LSB |
LP8555_REG_STEP_SMOOTH_HEAVY);
if (rv != EC_SUCCESS)
return;
/* Power on. */
rv = lp8555_read_with_retry(LP8555_REG_COMMAND, ®);
if (rv != EC_SUCCESS)
return;
reg |= LP8555_REG_COMMAND_ON;
rv = lp8555_write_with_retry(LP8555_REG_COMMAND, reg);
}
/* Console commands */
static int command_tap_info(int argc, char **argv)
{
int val;
ccprintf("tap: %s\n", (tap_detection && !lid_is_open()) ?
"on" : "off");
if (argc > 1) {
if (!parse_bool(argv[1], &val))
return EC_ERROR_PARAM1;
tap_debug = val;
}
ccprintf("debug: %s\n", tap_debug ? "on" : "off");
ccprintf("odr: %d\n", sensor->drv->get_data_rate(sensor));
return EC_SUCCESS;
}
int main()
{
init_timer();
init_ATX_power();
init_serial();
init_stdio();
init_safety_switches();
init_i2c();
init_laser_power();
init_heaters();
init_main_laser();
sei();
enable_ATX_power();
uint32_t b = millisecond_time();
while (!ATX_power_state()) {
enable_ATX_power();
continue;
}
uint32_t a = millisecond_time();
printf("ATX power: %ld msec\n", a - b);
enable_heater_1(); // aka water pump
delay_milliseconds(2000);
enable_heater_0(); // aka high voltage supply
set_laser_power(4095 / 3); // 1/3rd power
printf("Main Laser! Danger!\n");
while (true) {
if (getchar() == '\r') {
if (e_is_stopped())
printf("Emergency Stop. No fire.\n");
else if (lid_is_open())
printf("Lid is open. No fire.\n");
else {
printf("Fire!\n");
enable_main_laser();
delay_milliseconds(PULSE_MS);
disable_main_laser();
}
}
}
}
/**
* Update backlight state.
*/
static void update_backlight(void)
{
int pch_value;
pch_value = gpio_get_level(GPIO_PCH_BKLTEN);
/* Immediately disable the backlight when the lid is closed or the PCH
* is instructing the backlight to be disabled. */
if (!lid_is_open() || !pch_value) {
/* If there was a scheduled callback pending make sure it picks
* up the disabled value. */
backlight_deferred_value = 0;
gpio_set_level(GPIO_ENABLE_BACKLIGHT, 0);
/* Cancel pending hook */
hook_call_deferred(&set_backlight_value, -1);
return;
}
/* Handle a 0->1 transition by calling a deferred hook. */
if (pch_value && !backlight_deferred_value) {
backlight_deferred_value = 1;
hook_call_deferred(&set_backlight_value, BL_ENABLE_DELAY_US);
}
}
enum power_state power_handle_state(enum power_state state)
{
int value;
static int boot_from_g3;
switch (state) {
case POWER_G3:
boot_from_g3 = check_for_power_on_event();
if (boot_from_g3)
return POWER_G3S5;
break;
case POWER_G3S5:
return POWER_S5;
case POWER_S5:
if (boot_from_g3) {
value = boot_from_g3;
boot_from_g3 = 0;
} else {
value = check_for_power_on_event();
}
if (value) {
CPRINTS("power on %d", value);
return POWER_S5S3;
}
return state;
case POWER_S5S3:
hook_notify(HOOK_CHIPSET_PRE_INIT);
power_on();
disable_sleep(SLEEP_MASK_AP_RUN);
powerled_set_state(POWERLED_STATE_ON);
if (power_wait_signals(IN_POWER_GOOD) == EC_SUCCESS) {
CPRINTS("POWER_GOOD seen");
if (power_button_wait_for_release(
DELAY_SHUTDOWN_ON_POWER_HOLD) ==
EC_SUCCESS) {
power_button_was_pressed = 0;
set_pmic_pwron(0);
/* setup misc gpio for S3/S0 functionality */
gpio_set_flags(GPIO_SUSPEND_L, GPIO_INPUT
| GPIO_INT_BOTH | GPIO_PULL_DOWN);
gpio_set_flags(GPIO_EC_INT_L, GPIO_OUTPUT
| GPIO_OUT_HIGH);
/* Call hooks now that AP is running */
hook_notify(HOOK_CHIPSET_STARTUP);
return POWER_S3;
} else {
CPRINTS("long-press button, shutdown");
power_off();
/*
* Since the AP may be up already, return S0S3
* state to go through the suspend hook.
*/
return POWER_S0S3;
}
} else {
CPRINTS("POWER_GOOD not seen in time");
}
chipset_turn_off_power_rails();
return POWER_S5;
case POWER_S3:
if (!(power_get_signals() & IN_POWER_GOOD))
return POWER_S3S5;
else if (!(power_get_signals() & IN_SUSPEND))
return POWER_S3S0;
return state;
case POWER_S3S0:
powerled_set_state(POWERLED_STATE_ON);
hook_notify(HOOK_CHIPSET_RESUME);
return POWER_S0;
case POWER_S0:
value = check_for_power_off_event();
if (value) {
CPRINTS("power off %d", value);
power_off();
return POWER_S0S3;
} else if (power_get_signals() & IN_SUSPEND)
return POWER_S0S3;
return state;
case POWER_S0S3:
if (lid_is_open())
powerled_set_state(POWERLED_STATE_SUSPEND);
else
powerled_set_state(POWERLED_STATE_OFF);
/* Call hooks here since we don't know it prior to AP suspend */
hook_notify(HOOK_CHIPSET_SUSPEND);
return POWER_S3;
case POWER_S3S5:
power_button_wait_for_release(-1);
power_button_was_pressed = 0;
return POWER_S5;
case POWER_S5G3:
return POWER_G3;
}
return state;
}
/**
* Initialize backlight module.
*/
static void backlight_init(void)
{
gpio_enable_interrupt(GPIO_PCH_BL_EN);
gpio_set_level(GPIO_ENABLE_BACKLIGHT, lid_is_open());
}
static void inductive_charging_deferred_update(void)
{
int lid_open = lid_is_open();
gpio_set_level(GPIO_BASE_CHG_VDD_EN, !lid_open);
inductive_charging_interrupt(GPIO_LID_OPEN);
}
/**
* Handle switch changes based on lid event.
*/
static void powerbtn_x86_lid_change(void)
{
/* If chipset is off, pulse the power button on lid open to wake it. */
if (lid_is_open() && chipset_in_state(CHIPSET_STATE_ANY_OFF))
power_button_pch_pulse();
}
static void pwm_kblight_lid_change(void)
{
pwm_enable(PWM_CH_KBLIGHT, lid_is_open());
}
static void wait_for_lid_debounce(void)
{
while (lid_is_open() != gpio_get_level(GPIO_LID_OPEN))
msleep(20);
}
