power: Allow board to take custom action on G3 timer expiration

This patch introduces board_system_is_idle callback function. It's
called when system is in G3. A board can customize its action taken
when system is idle in G3 using battery thresholds, expiration timer,
etc. determined at runtime.

Signed-off-by: Daisuke Nojiri <dnojiri@chromium.org>

BUG=none
BRANCH=nami,strago,coral
TEST=Verify Vayne cut off battery on G3 idle expiration while other
Nami's hibernate.

Change-Id: I6118a074ac7d844b99d9c0f3eb638b72d5894008
Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/platform/ec/+/1515721
Reviewed-by: Daisuke Nojiri <dnojiri@chromium.org>
Commit-Queue: Daisuke Nojiri <dnojiri@chromium.org>
Tested-by: Daisuke Nojiri <dnojiri@chromium.org>

7 files changed, 749 insertions, 23 deletions

diff --git a/board/samus/board.c b/board/samus/board.c
new file mode 100644
index 0000000000..82ebc4f8ca
--- /dev/null
+++ b/board/samus/board.c
@@ -0,0 +1,484 @@
+/* Copyright (c) 2013 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.
+ */
+/* EC for Samus board configuration */
+
+#include "als.h"
+#include "adc.h"
+#include "adc_chip.h"
+#include "backlight.h"
+#include "battery.h"
+#include "capsense.h"
+#include "charger.h"
+#include "charge_state.h"
+#include "common.h"
+#include "console.h"
+#include "driver/accel_kionix.h"
+#include "driver/accel_kxcj9.h"
+#include "driver/accelgyro_lsm6ds0.h"
+#include "driver/als_isl29035.h"
+#include "driver/temp_sensor/tmp006.h"
+#include "extpower.h"
+#include "fan.h"
+#include "gesture.h"
+#include "gpio.h"
+#include "hooks.h"
+#include "host_command.h"
+#include "i2c.h"
+#include "keyboard_scan.h"
+#include "keyboard_8042.h"
+#include "keyboard_8042_sharedlib.h"
+#include "lid_switch.h"
+#include "lightbar.h"
+#include "motion_sense.h"
+#include "motion_lid.h"
+#include "peci.h"
+#include "power.h"
+#include "power_button.h"
+#include "pwm.h"
+#include "pwm_chip.h"
+#include "registers.h"
+#include "switch.h"
+#include "system.h"
+#include "task.h"
+#include "temp_sensor.h"
+#include "temp_sensor_chip.h"
+#include "timer.h"
+#include "thermal.h"
+#include "uart.h"
+#include "util.h"
+
+static void pd_mcu_interrupt(enum gpio_signal signal)
+{
+	/* Exchange status with PD MCU. */
+	host_command_pd_send_status(PD_CHARGE_NO_CHANGE);
+}
+
+#include "gpio_list.h"
+
+/* power signal list.  Must match order of enum power_signal. */
+const struct power_signal_info power_signal_list[] = {
+	{GPIO_PP1050_PGOOD,  POWER_SIGNAL_ACTIVE_HIGH, "PGOOD_PP1050"},
+	{GPIO_PP1200_PGOOD,  POWER_SIGNAL_ACTIVE_HIGH, "PGOOD_PP1200"},
+	{GPIO_PP1800_PGOOD,  POWER_SIGNAL_ACTIVE_HIGH, "PGOOD_PP1800"},
+	{GPIO_VCORE_PGOOD,   POWER_SIGNAL_ACTIVE_HIGH, "PGOOD_VCORE"},
+	{GPIO_PCH_SLP_S0_L,  POWER_SIGNAL_ACTIVE_HIGH, "SLP_S0_DEASSERTED"},
+	{GPIO_PCH_SLP_S3_L,  POWER_SIGNAL_ACTIVE_HIGH, "SLP_S3_DEASSERTED"},
+	{GPIO_PCH_SLP_S5_L,  POWER_SIGNAL_ACTIVE_HIGH, "SLP_S5_DEASSERTED"},
+	{GPIO_PCH_SLP_SUS_L, POWER_SIGNAL_ACTIVE_HIGH, "SLP_SUS_DEASSERTED"},
+	{GPIO_PCH_SUSWARN_L, POWER_SIGNAL_ACTIVE_HIGH, "SUSWARN_DEASSERTED"},
+};
+BUILD_ASSERT(ARRAY_SIZE(power_signal_list) == POWER_SIGNAL_COUNT);
+
+/* ADC channels. Must be in the exactly same order as in enum adc_channel. */
+const struct adc_t adc_channels[] = {
+	/*
+	 * EC internal temperature is calculated by
+	 * 273 + (295 - 450 * ADC_VALUE / ADC_READ_MAX) / 2
+	 * = -225 * ADC_VALUE / ADC_READ_MAX + 420.5
+	 */
+	{"ECTemp", LM4_ADC_SEQ0, -225, ADC_READ_MAX, 420,
+	 LM4_AIN_NONE, 0x0e /* TS0 | IE0 | END0 */, 0, 0},
+	/*
+	 * TODO(crosbug.com/p/23827): We don't know what to expect here, but
+	 * it's an analog input that's pulled high. We're using it as a battery
+	 * presence indicator for now. We'll return just 0 - ADC_READ_MAX for
+	 * now.
+	 */
+	{"BatteryTemp", LM4_ADC_SEQ2, 1, 1, 0,
+	 LM4_AIN(10), 0x06 /* IE0 | END0 */, LM4_GPIO_B, (1<<4)},
+};
+BUILD_ASSERT(ARRAY_SIZE(adc_channels) == ADC_CH_COUNT);
+
+/* PWM channels. Must be in the exactly same order as in enum pwm_channel. */
+const struct pwm_t pwm_channels[] = {
+	{4, 0},
+};
+BUILD_ASSERT(ARRAY_SIZE(pwm_channels) == PWM_CH_COUNT);
+
+/* Physical fans. These are logically separate from pwm_channels. */
+const struct fan_conf fan_conf_0 = {
+	.flags = FAN_USE_RPM_MODE,
+	.ch = 2,	/* Use MFT id to control fan */
+	.pgood_gpio = -1,
+	.enable_gpio = -1,
+};
+
+const struct fan_conf fan_conf_1 = {
+	.flags = FAN_USE_RPM_MODE,
+	.ch = 3,	/* Use MFT id to control fan */
+	.pgood_gpio = -1,
+	.enable_gpio = -1,
+};
+
+const struct fan_rpm fan_rpm_0 = {
+	.rpm_min = 1000,
+	.rpm_start = 1000,
+	.rpm_max = 6350,
+};
+
+struct fan_t fans[] = {
+	{ .conf = &fan_conf_0, .rpm = &fan_rpm_0, },
+	{ .conf = &fan_conf_1, .rpm = &fan_rpm_0, },
+};
+BUILD_ASSERT(ARRAY_SIZE(fans) == CONFIG_FANS);
+
+/* I2C ports */
+const struct i2c_port_t i2c_ports[] = {
+	{"batt_chg", 0, 100, GPIO_I2C0_SCL, GPIO_I2C0_SDA},
+	{"lightbar", 1, 400, GPIO_I2C1_SCL, GPIO_I2C1_SDA},
+	{"thermal",  5, 100, GPIO_I2C5_SCL, GPIO_I2C5_SDA},
+};
+const unsigned int i2c_ports_used = ARRAY_SIZE(i2c_ports);
+
+#define TEMP_U40_REG_ADDR	((0x40 << 1) | I2C_FLAG_BIG_ENDIAN)
+#define TEMP_U41_REG_ADDR	((0x44 << 1) | I2C_FLAG_BIG_ENDIAN)
+#define TEMP_U42_REG_ADDR	((0x41 << 1) | I2C_FLAG_BIG_ENDIAN)
+#define TEMP_U43_REG_ADDR	((0x45 << 1) | I2C_FLAG_BIG_ENDIAN)
+#define TEMP_U115_REG_ADDR	((0x42 << 1) | I2C_FLAG_BIG_ENDIAN)
+#define TEMP_U116_REG_ADDR	((0x43 << 1) | I2C_FLAG_BIG_ENDIAN)
+
+#define TEMP_U40_ADDR TMP006_ADDR(I2C_PORT_THERMAL, TEMP_U40_REG_ADDR)
+#define TEMP_U41_ADDR TMP006_ADDR(I2C_PORT_THERMAL, TEMP_U41_REG_ADDR)
+#define TEMP_U42_ADDR TMP006_ADDR(I2C_PORT_THERMAL, TEMP_U42_REG_ADDR)
+#define TEMP_U43_ADDR TMP006_ADDR(I2C_PORT_THERMAL, TEMP_U43_REG_ADDR)
+#define TEMP_U115_ADDR TMP006_ADDR(I2C_PORT_THERMAL, TEMP_U115_REG_ADDR)
+#define TEMP_U116_ADDR TMP006_ADDR(I2C_PORT_THERMAL, TEMP_U116_REG_ADDR)
+
+const struct tmp006_t tmp006_sensors[TMP006_COUNT] = {
+	{"Charger", TEMP_U40_ADDR},
+	{"CPU", TEMP_U41_ADDR},
+	{"Left C", TEMP_U42_ADDR},
+	{"Right C", TEMP_U43_ADDR},
+	{"Right D", TEMP_U115_ADDR},
+	{"Left D", TEMP_U116_ADDR},
+};
+BUILD_ASSERT(ARRAY_SIZE(tmp006_sensors) == TMP006_COUNT);
+
+/* Temperature sensors data; must be in same order as enum temp_sensor_id. */
+const struct temp_sensor_t temp_sensors[] = {
+	{"PECI", TEMP_SENSOR_TYPE_CPU, peci_temp_sensor_get_val, 0, 2},
+	{"ECInternal", TEMP_SENSOR_TYPE_BOARD, chip_temp_sensor_get_val, 0, 4},
+	{"I2C-Charger-Die", TEMP_SENSOR_TYPE_BOARD, tmp006_get_val, 0, 7},
+	{"I2C-Charger-Object", TEMP_SENSOR_TYPE_CASE, tmp006_get_val, 1, 7},
+	{"I2C-CPU-Die", TEMP_SENSOR_TYPE_BOARD, tmp006_get_val, 2, 7},
+	{"I2C-CPU-Object", TEMP_SENSOR_TYPE_CASE, tmp006_get_val, 3, 7},
+	{"I2C-Left C-Die", TEMP_SENSOR_TYPE_BOARD, tmp006_get_val, 4, 7},
+	{"I2C-Left C-Object", TEMP_SENSOR_TYPE_CASE, tmp006_get_val, 5, 7},
+	{"I2C-Right C-Die", TEMP_SENSOR_TYPE_BOARD, tmp006_get_val, 6, 7},
+	{"I2C-Right C-Object", TEMP_SENSOR_TYPE_CASE, tmp006_get_val, 7, 7},
+	{"I2C-Right D-Die", TEMP_SENSOR_TYPE_BOARD, tmp006_get_val, 8, 7},
+	{"I2C-Right D-Object", TEMP_SENSOR_TYPE_CASE, tmp006_get_val, 9, 7},
+	{"I2C-Left D-Die", TEMP_SENSOR_TYPE_BOARD, tmp006_get_val, 10, 7},
+	{"I2C-Left D-Object", TEMP_SENSOR_TYPE_CASE, tmp006_get_val, 11, 7},
+	{"Battery", TEMP_SENSOR_TYPE_BATTERY, charge_get_battery_temp, 0, 4},
+};
+BUILD_ASSERT(ARRAY_SIZE(temp_sensors) == TEMP_SENSOR_COUNT);
+
+/* ALS instances. Must be in same order as enum als_id. */
+struct als_t als[] = {
+	{"ISL", isl29035_init, isl29035_read_lux, 5},
+};
+BUILD_ASSERT(ARRAY_SIZE(als) == ALS_COUNT);
+
+
+/* Thermal limits for each temp sensor. All temps are in degrees K. Must be in
+ * same order as enum temp_sensor_id. To always ignore any temp, use 0.
+ */
+struct ec_thermal_config thermal_params[] = {
+	/* {Twarn, Thigh, Thalt}, fan_off, fan_max */
+	{{C_TO_K(95), C_TO_K(101), C_TO_K(104)},
+	 {0, 0, 0}, C_TO_K(55), C_TO_K(90)},		/* PECI */
+	{{0, 0, 0}, {0, 0, 0}, 0, 0},			/* EC */
+	{{0, 0, 0}, {0, 0, 0}, C_TO_K(41), C_TO_K(55)},	/* Charger die */
+	{{0, 0, 0}, {0, 0, 0}, 0, 0},
+	{{0, 0, 0}, {0, 0, 0}, C_TO_K(35), C_TO_K(49)},	/* CPU die */
+	{{0, 0, 0}, {0, 0, 0}, 0, 0},
+	{{0, 0, 0}, {0, 0, 0}, 0, 0},			/* Left C die */
+	{{0, 0, 0}, {0, 0, 0}, 0, 0},
+	{{0, 0, 0}, {0, 0, 0}, 0, 0},			/* Right C die */
+	{{0, 0, 0}, {0, 0, 0}, 0, 0},
+	{{0, 0, 0}, {0, 0, 0}, 0, 0},			/* Right D die */
+	{{0, 0, 0}, {0, 0, 0}, 0, 0},
+	{{0, 0, 0}, {0, 0, 0}, C_TO_K(43), C_TO_K(54)},	/* Left D die */
+	{{0, 0, 0}, {0, 0, 0}, 0, 0},
+	{{0, 0, 0}, {0, 0, 0}, 0, 0},			/* Battery */
+};
+BUILD_ASSERT(ARRAY_SIZE(thermal_params) == TEMP_SENSOR_COUNT);
+
+struct keyboard_scan_config keyscan_config = {
+	.output_settle_us = 40,
+	.debounce_down_us = 6 * MSEC,
+	.debounce_up_us = 30 * MSEC,
+	.scan_period_us = 1500,
+	.min_post_scan_delay_us = 1000,
+	.poll_timeout_us = SECOND,
+	.actual_key_mask = {
+		0x14, 0xff, 0xff, 0xff, 0xff, 0xf5, 0xff,
+		0xa4, 0xff, 0xf6, 0x55, 0xfa, 0xc8  /* full set */
+	},
+};
+
+/* Initialize board. */
+static void board_init(void)
+{
+	gpio_enable_interrupt(GPIO_PD_MCU_INT);
+}
+DECLARE_HOOK(HOOK_INIT, board_init, HOOK_PRIO_DEFAULT);
+
+#ifdef CONFIG_BATTERY_PRESENT_CUSTOM
+/**
+ * Physical check of battery presence.
+ */
+enum battery_present battery_is_present(void)
+{
+	/*
+	 * This pin has a pullup, so if it's not completely pegged there's
+	 * something attached. Probably a battery.
+	 */
+	int analog_val = adc_read_channel(ADC_CH_BAT_TEMP);
+	return analog_val < (9 * ADC_READ_MAX / 10) ? BP_YES : BP_NO;
+}
+#endif
+
+static int discharging_on_ac;
+
+/**
+ * Discharge battery when on AC power for factory test.
+ */
+int board_discharge_on_ac(int enable)
+{
+	int rv = charger_discharge_on_ac(enable);
+
+	if (rv == EC_SUCCESS)
+		discharging_on_ac = enable;
+
+	return rv;
+}
+
+/**
+ * Check if we are discharging while connected to AC
+ */
+int board_is_discharging_on_ac(void)
+{
+	return discharging_on_ac;
+}
+
+/**
+ * Reset PD MCU
+ */
+void board_reset_pd_mcu(void)
+{
+	gpio_set_level(GPIO_USB_MCU_RST, 1);
+	usleep(100);
+	gpio_set_level(GPIO_USB_MCU_RST, 0);
+}
+
+void sensor_board_proc_double_tap(void)
+{
+	lightbar_sequence(LIGHTBAR_TAP);
+}
+
+const int usb_port_enable[CONFIG_USB_PORT_POWER_SMART_PORT_COUNT] = {
+	GPIO_USB1_ENABLE,
+	GPIO_USB2_ENABLE,
+};
+
+/* Base Sensor mutex */
+static struct mutex g_base_mutex;
+
+/* Lid Sensor mutex */
+static struct mutex g_lid_mutex;
+
+/* kxcj9 local/private data */
+struct kionix_accel_data g_kxcj9_data;
+
+/* lsm6ds0 local sensor data (per-sensor) */
+struct lsm6ds0_data g_saved_data[2];
+
+/* Four Motion sensors */
+/* Matrix to rotate accelrator into standard reference frame */
+const mat33_fp_t base_standard_ref = {
+	{FLOAT_TO_FP(-1),  0,  0},
+	{ 0, FLOAT_TO_FP(-1),  0},
+	{ 0,  0, FLOAT_TO_FP(-1)}
+};
+
+const mat33_fp_t lid_standard_ref = {
+	{ 0,  FLOAT_TO_FP(1),  0},
+	{FLOAT_TO_FP(-1),  0,  0},
+	{ 0,  0, FLOAT_TO_FP(-1)}
+};
+
+struct motion_sensor_t motion_sensors[] = {
+	/*
+	 * Note: lsm6ds0: supports accelerometer and gyro sensor
+	 * Requirement: accelerometer sensor must init before gyro sensor
+	 * DO NOT change the order of the following table.
+	 */
+	{.name = "Base",
+	 .active_mask = SENSOR_ACTIVE_S0_S3_S5,
+	 .chip = MOTIONSENSE_CHIP_LSM6DS0,
+	 .type = MOTIONSENSE_TYPE_ACCEL,
+	 .location = MOTIONSENSE_LOC_BASE,
+	 .drv = &lsm6ds0_drv,
+	 .mutex = &g_base_mutex,
+	 .drv_data = &g_saved_data[0],
+	 .port = I2C_PORT_ACCEL,
+	 .addr = LSM6DS0_ADDR1,
+	 .rot_standard_ref = &base_standard_ref,
+	 .default_range = 2,  /* g, enough for laptop. */
+	 .min_frequency = LSM6DS0_ACCEL_MIN_FREQ,
+	 .max_frequency = LSM6DS0_ACCEL_MAX_FREQ,
+	 .config = {
+		 /* EC use accel for angle detection */
+		 [SENSOR_CONFIG_EC_S0] = {
+			 .odr = 119000 | ROUND_UP_FLAG,
+			 .ec_rate = 100 * MSEC,
+		 },
+		 /* Used for double tap */
+		 [SENSOR_CONFIG_EC_S3] = {
+			 .odr = TAP_ODR_LSM6DS0 | ROUND_UP_FLAG,
+			 .ec_rate = CONFIG_GESTURE_SAMPLING_INTERVAL_MS * MSEC,
+		 },
+		 [SENSOR_CONFIG_EC_S5] = {
+			 .odr = TAP_ODR_LSM6DS0 | ROUND_UP_FLAG,
+			 .ec_rate = CONFIG_GESTURE_SAMPLING_INTERVAL_MS * MSEC,
+		 },
+	 },
+	},
+
+	{.name = "Lid",
+	 .active_mask = SENSOR_ACTIVE_S0,
+	 .chip = MOTIONSENSE_CHIP_KXCJ9,
+	 .type = MOTIONSENSE_TYPE_ACCEL,
+	 .location = MOTIONSENSE_LOC_LID,
+	 .drv = &kionix_accel_drv,
+	 .mutex = &g_lid_mutex,
+	 .drv_data = &g_kxcj9_data,
+	 .port = I2C_PORT_ACCEL,
+	 .addr = KXCJ9_ADDR0,
+	 .rot_standard_ref = &lid_standard_ref,
+	 .default_range = 2,  /* g, enough for laptop. */
+	 .min_frequency = KXCJ9_ACCEL_MIN_FREQ,
+	 .max_frequency = KXCJ9_ACCEL_MAX_FREQ,
+	 .config = {
+		 /* EC use accel for angle detection */
+		 [SENSOR_CONFIG_EC_S0] = {
+			 .odr = 100000 | ROUND_UP_FLAG,
+			 .ec_rate = 100 * MSEC,
+		 },
+	 },
+	},
+
+	{.name = "Base Gyro",
+	 .active_mask = SENSOR_ACTIVE_S0_S3_S5,
+	 .chip = MOTIONSENSE_CHIP_LSM6DS0,
+	 .type = MOTIONSENSE_TYPE_GYRO,
+	 .location = MOTIONSENSE_LOC_BASE,
+	 .drv = &lsm6ds0_drv,
+	 .mutex = &g_base_mutex,
+	 .drv_data = &g_saved_data[1],
+	 .port = I2C_PORT_ACCEL,
+	 .addr = LSM6DS0_ADDR1,
+	 .rot_standard_ref = NULL,
+	 .default_range = 2000,  /* g, enough for laptop. */
+	 .min_frequency = LSM6DS0_GYRO_MIN_FREQ,
+	 .max_frequency = LSM6DS0_GYRO_MAX_FREQ,
+	},
+
+};
+const unsigned int motion_sensor_count = ARRAY_SIZE(motion_sensors);
+
+#ifdef CONFIG_LOW_POWER_IDLE
+void jtag_interrupt(enum gpio_signal signal)
+{
+	/*
+	 * This interrupt is the first sign someone is trying to use
+	 * the JTAG. Disable slow speed sleep so that the JTAG action
+	 * can take place.
+	 */
+	disable_sleep(SLEEP_MASK_JTAG);
+
+	/*
+	 * Once we get this interrupt, disable it from occurring again
+	 * to avoid repeated interrupts when debugging via JTAG.
+	 */
+	gpio_disable_interrupt(GPIO_JTAG_TCK);
+}
+#endif /* CONFIG_LOW_POWER_IDLE */
+
+
+enum ec_error_list keyboard_scancode_callback(uint16_t *make_code,
+					      int8_t pressed)
+{
+	const uint16_t k = *make_code;
+	static uint8_t s;
+	static const uint16_t a[] = {
+		SCANCODE_UP, SCANCODE_UP, SCANCODE_DOWN, SCANCODE_DOWN,
+		SCANCODE_LEFT, SCANCODE_RIGHT, SCANCODE_LEFT, SCANCODE_RIGHT,
+		SCANCODE_B, SCANCODE_A};
+
+	if (!pressed)
+		return EC_SUCCESS;
+
+	/* Lightbar demo mode: keyboard can fake the battery state */
+	switch (k) {
+	case SCANCODE_UP:
+		demo_battery_level(1);
+		break;
+	case SCANCODE_DOWN:
+		demo_battery_level(-1);
+		break;
+	case SCANCODE_LEFT:
+		demo_is_charging(0);
+		break;
+	case SCANCODE_RIGHT:
+		demo_is_charging(1);
+		break;
+	case SCANCODE_F6:  /* dim */
+		demo_brightness(-1);
+		break;
+	case SCANCODE_F7:  /* bright */
+		demo_brightness(1);
+		break;
+	case SCANCODE_T:
+		demo_tap();
+		break;
+	}
+
+	if (k == a[s])
+		s++;
+	else if (k != a[0])
+		s = 0;
+	else if (s != 2)
+		s = 1;
+
+	if (s == ARRAY_SIZE(a)) {
+		s = 0;
+		lightbar_sequence(LIGHTBAR_KONAMI);
+	}
+	return EC_SUCCESS;
+}
+
+/*
+ * Use to define going in to hibernate early if low on battery.
+ * HIBERNATE_BATT_PCT specifies the low battery threshold
+ * for going into hibernate early, and HIBERNATE_BATT_SEC defines
+ * the minimum amount of time to stay in G3 before checking for low
+ * battery hibernate.
+ */
+#define HIBERNATE_BATT_PCT 10
+#define HIBERNATE_BATT_SEC (3600 * 24)
+
+enum critical_shutdown board_system_is_idle(uint64_t last_shutdown_time,
+					    uint64_t *target, uint64_t now)
+{
+	if (charge_get_percent() <= HIBERNATE_BATT_PCT) {
+		uint64_t t = last_shutdown_time + HIBERNATE_BATT_SEC * SEC_UL;
+		*target = MIN(*target, t);
+	}
+	return now > *target ?
+			CRITICAL_SHUTDOWN_HIBERNATE : CRITICAL_SHUTDOWN_IGNORE;
+}
diff --git a/board/samus/board.h b/board/samus/board.h
new file mode 100644
index 0000000000..362635f0ca
--- /dev/null
+++ b/board/samus/board.h
@@ -0,0 +1,223 @@
+/* Copyright (c) 2013 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.
+ */
+
+/* Configuration for Samus mainboard */
+
+#ifndef __CROS_EC_BOARD_H
+#define __CROS_EC_BOARD_H
+
+/* Debug features */
+#define CONFIG_CONSOLE_CMDHELP
+#define CONFIG_TASK_PROFILING
+
+#undef HEY_USE_BUILTIN_CLKRUN
+
+/* Optional features */
+#define CONFIG_ACCELGYRO_LSM6DS0
+#define CONFIG_ACCEL_KXCJ9
+#define CONFIG_ACCEL_STD_REF_FRAME_OLD
+#define CONFIG_ALS_ISL29035
+#define CONFIG_BOARD_VERSION_GPIO
+#define CONFIG_CMD_ACCELS
+#define CONFIG_CMD_ACCEL_INFO
+#undef  CONFIG_BATTERY_CRITICAL_SHUTDOWN_TIMEOUT
+#define CONFIG_BATTERY_CRITICAL_SHUTDOWN_TIMEOUT 60
+#define CONFIG_BATTERY_CUT_OFF
+#define CONFIG_POWER_COMMON
+#define CONFIG_POWER_SHUTDOWN_PAUSE_IN_S5
+#define CONFIG_CHIPSET_CAN_THROTTLE
+#define CONFIG_I2C
+#define CONFIG_I2C_MASTER
+#define CONFIG_KEYBOARD_BOARD_CONFIG
+#define CONFIG_KEYBOARD_PROTOCOL_8042
+#define CONFIG_KEYBOARD_COL2_INVERTED
+#define CONFIG_KEYBOARD_SCANCODE_CALLBACK
+#define CONFIG_LID_ANGLE
+#define CONFIG_LIGHTBAR_POWER_RAILS
+#define CONFIG_LOW_POWER_IDLE
+#define CONFIG_POWER_BUTTON
+#define CONFIG_POWER_BUTTON_X86
+/* Note: not CONFIG_BACKLIGHT_LID. It's handled specially for Samus. */
+#define CONFIG_BACKLIGHT_REQ_GPIO GPIO_PCH_BL_EN
+/* TODO(crosbug.com/p/29467): remove this workaround when possible. */
+#define CONFIG_BATTERY_REQUESTS_NIL_WHEN_DEAD
+#define CONFIG_CHARGER_PROFILE_OVERRIDE
+#define CONFIG_BATTERY_SMART
+#define CONFIG_BATTERY_REVIVE_DISCONNECT
+#define CONFIG_CHARGER
+#define CONFIG_CHARGER_V2
+#define CONFIG_CHARGER_BQ24773
+#define CONFIG_CHARGER_ILIM_PIN_DISABLED
+#define CONFIG_CHARGER_SENSE_RESISTOR 5
+#define CONFIG_CHARGER_SENSE_RESISTOR_AC 10
+#define CONFIG_CHARGER_INPUT_CURRENT 320
+#define CONFIG_CHARGER_DISCHARGE_ON_AC
+#define CONFIG_CHARGER_DISCHARGE_ON_AC_CUSTOM
+#define CONFIG_CHARGER_MIN_BAT_PCT_FOR_POWER_ON 1
+#define CONFIG_FANS 2
+#define CONFIG_FAN_UPDATE_PERIOD 10
+#define CONFIG_FPU
+#define CONFIG_GESTURE_DETECTION
+#define CONFIG_GESTURE_SW_DETECTION
+#define CONFIG_GESTURE_SAMPLING_INTERVAL_MS 5
+#undef  CONFIG_HIBERNATE_DELAY_SEC
+#define CONFIG_HIBERNATE_DELAY_SEC (3600 * 24 * 7)
+#define CONFIG_HOSTCMD_PD
+#define CONFIG_HOSTCMD_PD_CHG_CTRL
+#define CONFIG_HOSTCMD_PD_PANIC
+#define CONFIG_PECI_TJMAX 105
+#define CONFIG_PWM
+#define CONFIG_PWM_KBLIGHT
+#define CONFIG_TEMP_SENSOR
+#define CONFIG_TEMP_SENSOR_TMP006
+#define CONFIG_TEMP_SENSOR_POWER_GPIO GPIO_PP3300_DSW_GATED_EN
+#define CONFIG_THROTTLE_AP
+#define CONFIG_UART_HOST 2
+#define CONFIG_USB_PORT_POWER_SMART
+#define CONFIG_USB_PORT_POWER_SMART_DEFAULT_MODE USB_CHARGE_MODE_CDP
+#define CONFIG_USB_PORT_POWER_SMART_INVERTED
+#define GPIO_USB1_ILIM_SEL GPIO_USB1_ILIM_SEL_L
+#define GPIO_USB2_ILIM_SEL GPIO_USB2_ILIM_SEL_L
+#define CONFIG_VBOOT_HASH
+#define CONFIG_WIRELESS
+#define CONFIG_WIRELESS_SUSPEND \
+	(EC_WIRELESS_SWITCH_WLAN | EC_WIRELESS_SWITCH_WLAN_POWER)
+/* Do we want EC_WIRELESS_SWITCH_WWAN as well? */
+
+#ifndef __ASSEMBLER__
+
+/* I2C ports */
+#define I2C_PORT_BACKLIGHT 0
+#define I2C_PORT_BATTERY 0
+#define I2C_PORT_CHARGER 0
+#define I2C_PORT_PD_MCU 0
+#define I2C_PORT_ALS 1
+#define I2C_PORT_ACCEL 1
+#define I2C_PORT_LIGHTBAR 1
+#define I2C_PORT_THERMAL 5
+
+/* 13x8 keyboard scanner uses an entire GPIO bank for row inputs */
+#define KB_SCAN_ROW_IRQ  LM4_IRQ_GPIOK
+#define KB_SCAN_ROW_GPIO LM4_GPIO_K
+
+/* Host connects to keyboard controller module via LPC */
+#define HOST_KB_BUS_LPC
+
+/* USB ports managed by the EC */
+#define USB_PORT_COUNT 2
+
+#include "gpio_signal.h"
+
+/* x86 signal definitions */
+enum x86_signal {
+	X86_PGOOD_PP1050 = 0,
+	X86_PGOOD_PP1200,
+	X86_PGOOD_PP1800,
+	X86_PGOOD_VCORE,
+
+	X86_SLP_S0_DEASSERTED,
+	X86_SLP_S3_DEASSERTED,
+	X86_SLP_S5_DEASSERTED,
+	X86_SLP_SUS_DEASSERTED,
+	X86_SUSWARN_DEASSERTED,
+
+	/* Number of X86 signals */
+	POWER_SIGNAL_COUNT
+};
+
+enum adc_channel {
+	/* EC internal die temperature in degrees K. */
+	ADC_CH_EC_TEMP = 0,
+	/* BAT_TEMP */
+	ADC_CH_BAT_TEMP,
+
+	ADC_CH_COUNT
+};
+
+enum pwm_channel {
+	PWM_CH_KBLIGHT,
+
+	/* Number of PWM channels */
+	PWM_CH_COUNT
+};
+
+enum temp_sensor_id {
+	/* CPU die temperature via PECI */
+	TEMP_SENSOR_CPU_PECI,
+	/* EC internal temperature sensor */
+	TEMP_SENSOR_EC_INTERNAL,
+	/* TMP006 U40, die/object temperature near battery charger */
+	TEMP_SENSOR_I2C_U40_DIE,
+	TEMP_SENSOR_I2C_U40_OBJECT,
+	/* TMP006 U41, die/object temperature near CPU */
+	TEMP_SENSOR_I2C_U41_DIE,
+	TEMP_SENSOR_I2C_U41_OBJECT,
+	/* TMP006 U42, die/object temperature left side of C-case */
+	TEMP_SENSOR_I2C_U42_DIE,
+	TEMP_SENSOR_I2C_U42_OBJECT,
+	/* TMP006 U43, die/object temperature right side of C-case */
+	TEMP_SENSOR_I2C_U43_DIE,
+	TEMP_SENSOR_I2C_U43_OBJECT,
+	/* TMP006 U115, die/object temperature right side of D-case */
+	TEMP_SENSOR_I2C_U115_DIE,
+	TEMP_SENSOR_I2C_U115_OBJECT,
+	/* TMP006 U116, die/object temperature left side of D-case */
+	TEMP_SENSOR_I2C_U116_DIE,
+	TEMP_SENSOR_I2C_U116_OBJECT,
+
+	/* Battery temperature sensor */
+	TEMP_SENSOR_BATTERY,
+
+	TEMP_SENSOR_COUNT
+};
+
+/* The number of TMP006 sensor chips on the board. */
+#define TMP006_COUNT 6
+
+/* Light sensors attached to the EC. */
+enum als_id {
+	ALS_ISL29035 = 0,
+
+	ALS_COUNT,
+};
+
+/* Wireless signals */
+#define WIRELESS_GPIO_WLAN GPIO_WLAN_OFF_L
+#define WIRELESS_GPIO_WLAN_POWER GPIO_PP3300_WLAN_EN
+
+/* Discharge battery when on AC power for factory test. */
+int board_is_discharging_on_ac(void);
+
+/* Reset PD MCU */
+void board_reset_pd_mcu(void);
+
+/* Backboost detected interrupt */
+void bkboost_det_interrupt(enum gpio_signal signal);
+
+/* Interrupt handler for JTAG clock */
+void jtag_interrupt(enum gpio_signal signal);
+
+/* Bit masks for turning on PP5000 rail in G3 */
+#define PP5000_IN_G3_AC       (1 << 0)
+#define PP5000_IN_G3_LIGHTBAR (1 << 1)
+
+/* Enable/disable PP5000 rail mask in G3 */
+void set_pp5000_in_g3(int mask, int enable);
+
+/* Define for sensor tasks */
+#define CONFIG_GESTURE_SENSOR_BATTERY_TAP 0
+#define CONFIG_GESTURE_TAP_OUTER_WINDOW_T 200
+#define CONFIG_GESTURE_TAP_INNER_WINDOW_T 30
+#define CONFIG_GESTURE_TAP_MIN_INTERSTICE_T 120
+#define CONFIG_GESTURE_TAP_MAX_INTERSTICE_T 500
+/* event 2 to 9 are reserved for hardware interrupt */
+#define CONFIG_GESTURE_TAP_EVENT          TASK_EVENT_CUSTOM(1024)
+
+#define CONFIG_LID_ANGLE_SENSOR_BASE 0
+#define CONFIG_LID_ANGLE_SENSOR_LID 1
+
+#endif /* !__ASSEMBLER__ */
+
+#endif /* __CROS_EC_BOARD_H */
diff --git a/include/charge_state_v2.h b/include/charge_state_v2.h
index 4eca32e21e..c52fe17ca1 100644
--- a/include/charge_state_v2.h
+++ b/include/charge_state_v2.h
@@ -5,6 +5,7 @@
 
 #include "battery.h"
 #include "charger.h"
+#include "chipset.h"
 #include "timer.h"
 
 #ifndef __CROS_EC_CHARGE_STATE_V2_H
@@ -77,11 +78,6 @@ int charge_set_input_current_limit(int ma);
  * @param curr Pointer to struct charge_state_data
  * @return Action to take.
  */
-enum critical_shutdown {
-	CRITICAL_SHUTDOWN_IGNORE,
-	CRITICAL_SHUTDOWN_HIBERNATE,
-	CRITICAL_SHUTDOWN_CUTOFF,
-};
 enum critical_shutdown board_critical_shutdown_check(
 		struct charge_state_data *curr);
 
diff --git a/include/chipset.h b/include/chipset.h
index d9faad56cb..29ab52db66 100644
--- a/include/chipset.h
+++ b/include/chipset.h
@@ -35,6 +35,12 @@ enum chipset_state_mask {
 				 CHIPSET_STATE_SOFT_OFF),  /* Any off state */
 };
 
+enum critical_shutdown {
+	CRITICAL_SHUTDOWN_IGNORE,
+	CRITICAL_SHUTDOWN_HIBERNATE,
+	CRITICAL_SHUTDOWN_CUTOFF,
+};
+
 #ifdef HAS_TASK_CHIPSET
 
 /**
@@ -112,4 +118,15 @@ static inline void power_interrupt(enum gpio_signal signal) { }
 
 #endif /* !HAS_TASK_CHIPSET */
 
+/**
+ * Callback which allows board to take custom action on G3 timer expiration
+ *
+ * @param last_shutdown_time Last shutdown time
+ * @param target             Expiration time. Can be modified by board.
+ * @param now                Current time
+ * @return Action to take
+ */
+enum critical_shutdown board_system_is_idle(uint64_t last_shutdown_time,
+					    uint64_t *target, uint64_t now);
+
 #endif  /* __CROS_EC_CHIPSET_H */
diff --git a/include/config.h b/include/config.h
index 9e59a380c0..99f522c2f4 100644
--- a/include/config.h
+++ b/include/config.h
@@ -988,16 +988,6 @@
 #define CONFIG_HIBERNATE_DELAY_SEC 3600
 
 /*
- * Use to define going in to hibernate early if low on battery.
- * CONFIG_HIBERNATE_BATT_PCT specifies the low battery threshold
- * for going into hibernate early, and CONFIG_HIBERNATE_BATT_SEC defines
- * the minimum amount of time to stay in G3 before checking for low
- * battery hibernate.
- */
-#undef CONFIG_HIBERNATE_BATT_PCT
-#undef CONFIG_HIBERNATE_BATT_SEC
-
-/*
  * Perform a system reset on wake from hibernate. This is the default behavior,
  * and the only chip-supported behavior for certain ECs.
  */
diff --git a/include/timer.h b/include/timer.h
index cd75614dc6..1574b01d87 100644
--- a/include/timer.h
+++ b/include/timer.h
@@ -14,6 +14,7 @@
 /* Time units in microseconds */
 #define MSEC         1000
 #define SECOND    1000000
+#define SEC_UL    1000000ul
 #define MINUTE   60000000
 #define HOUR   3600000000ull  /* Too big to fit in a signed int */
 
diff --git a/power/common.c b/power/common.c
index bdb40f3522..28547292a6 100644
--- a/power/common.c
+++ b/power/common.c
@@ -5,6 +5,7 @@
 
 /* Common functionality across all chipsets */
 
+#include "battery.h"
 #include "charge_state.h"
 #include "chipset.h"
 #include "common.h"
@@ -142,6 +143,14 @@ void power_set_state(enum power_state new_state)
 		want_g3_exit = 0;
 }
 
+__attribute__((weak))
+enum critical_shutdown board_system_is_idle(uint64_t last_shutdown_time,
+					    uint64_t *target, uint64_t now)
+{
+	return now > *target ?
+			CRITICAL_SHUTDOWN_HIBERNATE : CRITICAL_SHUTDOWN_IGNORE;
+}
+
 /**
  * Common handler for steady states
  *
@@ -161,26 +170,32 @@ static enum power_state power_common_state(enum power_state state)
 #ifdef CONFIG_HIBERNATE
 		{
 			uint64_t target, now, wait;
-			uint32_t delay = hibernate_delay;
 			if (extpower_is_present()) {
 				task_wait_event(-1);
 				break;
 			}
 
 			now = get_time().val;
-#ifdef CONFIG_HIBERNATE_BATT_PCT
-			if (charge_get_percent() <= CONFIG_HIBERNATE_BATT_PCT
-			    && CONFIG_HIBERNATE_BATT_SEC < delay)
-				delay = CONFIG_HIBERNATE_BATT_SEC;
-#endif
-			target = last_shutdown_time + delay * SECOND;
-			if (now > target) {
+			target = last_shutdown_time + hibernate_delay * SECOND;
+			switch (board_system_is_idle(last_shutdown_time,
+						     &target, now)) {
+			case CRITICAL_SHUTDOWN_HIBERNATE:
 #ifdef CONFIG_LOW_POWER_PSEUDO_G3
 				enter_pseudo_g3();
 #else
 				CPRINTS("hibernating");
 				system_hibernate(0, 0);
 #endif
+				break;
+#ifdef CONFIG_BATTERY_CUT_OFF
+			case CRITICAL_SHUTDOWN_CUTOFF:
+				CPRINTS("Cutoff due to G3 idle");
+				board_cut_off_battery();
+				break;
+#endif
+			case CRITICAL_SHUTDOWN_IGNORE:
+			default:
+				break;
 			}
 
 			wait = MIN(target - now, TASK_MAX_WAIT_US);