sylas: Add sylas board

BUG=b:155315878
TEST=make -j BOARD=sylas
BRANCH=sylas

Signed-off-by: Ginger Cheng <cheng.ginger@inventec.corp-partner.google.com>
Change-Id: I4122f58d54f7657508e9f08a3a9c2ebbd71ad8ee
Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/platform/ec/+/2203574
Reviewed-by: Raymond Chung <raymondchung@ami.corp-partner.google.com>
Reviewed-by: Henry Sun <henrysun@google.com>
Commit-Queue: Henry Sun <henrysun@google.com>
Tested-by: Raymond Chung <raymondchung@ami.corp-partner.google.com>

8 files changed, 2013 insertions, 0 deletions

diff --git a/board/sylas/battery.c b/board/sylas/battery.c
new file mode 100644
index 0000000000..6c0188a19e
--- /dev/null
+++ b/board/sylas/battery.c
@@ -0,0 +1,445 @@
+/* Copyright 2020 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.
+ *
+ * Placeholder values for temporary battery pack.
+ */
+
+#include "battery.h"
+#include "battery_smart.h"
+#include "board.h"
+#include "charge_state.h"
+#include "console.h"
+#include "ec_commands.h"
+#include "extpower.h"
+#include "gpio.h"
+#include "hooks.h"
+#include "util.h"
+
+#define CPRINTF(format, args...) cprintf(CC_CHARGER, format, ## args)
+#define CPRINTS(format, args...) cprints(CC_CHARGER, format, ## args)
+
+/* Default, Nami, Vayne */
+static const struct battery_info info_0 = {
+	.voltage_max = 8800,
+	.voltage_normal = 7600,
+	.voltage_min = 6000,
+	.precharge_current = 256,
+	.start_charging_min_c = 0,
+	.start_charging_max_c = 50,
+	.charging_min_c = 0,
+	.charging_max_c = 60,
+	.discharging_min_c = -20,
+	.discharging_max_c = 70,
+};
+
+/* Sona */
+static const struct battery_info info_1 = {
+	.voltage_max = 13200,
+	.voltage_normal = 11550,
+	.voltage_min = 9000,
+	.precharge_current = 256,
+	.start_charging_min_c = 0,
+	.start_charging_max_c = 45,
+	.charging_min_c = 0,
+	.charging_max_c = 45,
+	.discharging_min_c = -10,
+	.discharging_max_c = 60,
+};
+
+/* Pantheon */
+static const struct battery_info info_2 = {
+	.voltage_max = 8700,
+	.voltage_normal = 7500,
+	.voltage_min = 6000,
+	.precharge_current = 373,
+	.start_charging_min_c = 0,
+	.start_charging_max_c = 50,
+	.charging_min_c = 0,
+	.charging_max_c = 60,
+	.discharging_min_c = -20,
+	.discharging_max_c = 60,
+};
+
+/* Panasonic AP15O5L (Akali) */
+static const struct battery_info info_3 = {
+	.voltage_max = 13200,
+	.voltage_normal = 11550,
+	.voltage_min = 9000,
+	.precharge_current = 256,
+	.start_charging_min_c = 0,
+	.start_charging_max_c = 50,
+	.charging_min_c = 0,
+	.charging_max_c = 60,
+	.discharging_min_c = 0,
+	.discharging_max_c = 60,
+};
+
+/* Panasonic AP18F4M (Bard/Ekko) */
+static const struct battery_info info_4 = {
+	.voltage_max = 8700,
+	.voltage_normal = 7600,
+	.voltage_min = 5500,
+	.precharge_current = 256,
+	.start_charging_min_c = 0,
+	.start_charging_max_c = 50,
+	.charging_min_c = 0,
+	.charging_max_c = 60,
+	.discharging_min_c = -20,
+	.discharging_max_c = 75,
+};
+
+
+
+
+/* Sylas */
+static const struct battery_info info_5 = {
+	.voltage_max = 13200,
+	.voltage_normal = 11550,
+	.voltage_min = 9000,
+	.precharge_current = 256,
+	.start_charging_min_c = 0,
+	.start_charging_max_c = 45,
+	.charging_min_c = 0,
+	.charging_max_c = 45,
+	.discharging_min_c = -10,
+	.discharging_max_c = 60,
+};
+
+
+enum battery_type {
+	BATTERY_TYPE_AP15 = 0,
+	BATTERY_TYPE_AP18,
+	BATTERY_TYPE_COUNT,
+};
+
+enum gauge_type {
+	GAUGE_TYPE_UNKNOWN = 0,
+	GAUGE_TYPE_TI_BQ40Z50,
+	GAUGE_TYPE_RENESAS_RAJ240,
+	GAUGE_TYPE_AKALI,
+};
+
+static const struct battery_info *info = &info_0;
+static int sb_ship_mode_reg = SB_MANUFACTURER_ACCESS;
+static int sb_shutdown_data = 0x0010;
+static enum gauge_type fuel_gauge;
+
+const struct battery_info *battery_get_info(void)
+{
+	return info;
+}
+
+/*
+ * Read a value from the Manufacturer Access System (MAC).
+ */
+static int sb_get_mac(uint16_t cmd, uint8_t *data, int len)
+{
+	int rv;
+
+	rv = sb_write(SB_MANUFACTURER_ACCESS, cmd);
+	if (rv)
+		return rv;
+
+	return sb_read_string(SB_MANUFACTURER_DATA, data, len);
+}
+
+static enum gauge_type get_gauge_ic(void)
+{
+	uint8_t data[11];
+
+	if (oem == PROJECT_AKALI)
+		return GAUGE_TYPE_AKALI;
+
+	/* 0x0002 is for 'Firmware Version' (p91 in BQ40Z50-R2 TRM).
+	 * We can't use sb_read_mfgacc because the command won't be included
+	 * in the returned block. */
+	if (sb_get_mac(0x0002, data, sizeof(data)))
+		return GAUGE_TYPE_UNKNOWN;
+
+	/* BQ40Z50 returns something while Renesus gauge returns all zeros. */
+	if (data[2] == 0 && data[3] == 0)
+		return GAUGE_TYPE_RENESAS_RAJ240;
+	else
+		return GAUGE_TYPE_TI_BQ40Z50;
+}
+
+static enum battery_type get_akali_battery_type(void)
+{
+	return CBI_SKU_CUSTOM_FIELD(sku);
+}
+
+void board_battery_init(void)
+{
+	/* Only static config because gauge may not be initialized yet */
+	switch (oem) {
+	case PROJECT_AKALI:
+		if (get_akali_battery_type() == BATTERY_TYPE_AP15)
+			info = &info_3;
+		else if (get_akali_battery_type() == BATTERY_TYPE_AP18)
+			info = &info_4;
+		sb_ship_mode_reg = 0x3A;
+		sb_shutdown_data = 0xC574;
+		break;
+	case PROJECT_SONA:
+		info = &info_1;
+		break;
+	case PROJECT_PANTHEON:
+		info = &info_2;
+		break;
+	case PROJECT_SYLAS:
+		info = &info_5;
+		break;
+	default:
+		break;
+	}
+}
+DECLARE_HOOK(HOOK_INIT, board_battery_init, HOOK_PRIO_DEFAULT);
+
+int board_cut_off_battery(void)
+{
+	int rv;
+
+	/* Ship mode command must be sent twice to take effect */
+	rv = sb_write(sb_ship_mode_reg, sb_shutdown_data);
+
+	if (rv != EC_SUCCESS)
+		return rv;
+
+	return sb_write(sb_ship_mode_reg, sb_shutdown_data);
+}
+
+int charger_profile_override(struct charge_state_data *curr)
+{
+	const struct battery_info *batt_info;
+	int bat_temp_c;
+
+	batt_info = battery_get_info();
+
+	if ((curr->batt.flags & BATT_FLAG_BAD_ANY) == BATT_FLAG_BAD_ANY) {
+		curr->requested_current = batt_info->precharge_current;
+		curr->requested_voltage = batt_info->voltage_max;
+		return 1000;
+	}
+
+	/* battery temp in 0.1 deg C */
+	bat_temp_c = curr->batt.temperature - 2731;
+
+	/* Don't charge if outside of allowable temperature range */
+	if (bat_temp_c >= batt_info->charging_max_c * 10 ||
+	    bat_temp_c < batt_info->charging_min_c * 10) {
+		curr->requested_current = 0;
+		curr->requested_voltage = 0;
+		curr->batt.flags &= ~BATT_FLAG_WANT_CHARGE;
+		curr->state = ST_IDLE;
+	}
+	return 0;
+}
+
+/* Customs options controllable by host command. */
+#define PARAM_FASTCHARGE (CS_PARAM_CUSTOM_PROFILE_MIN + 0)
+
+enum ec_status charger_profile_override_get_param(uint32_t param,
+						  uint32_t *value)
+{
+	return EC_RES_INVALID_PARAM;
+}
+
+enum ec_status charger_profile_override_set_param(uint32_t param,
+						  uint32_t value)
+{
+	return EC_RES_INVALID_PARAM;
+}
+
+enum battery_present battery_hw_present(void)
+{
+	/* The GPIO is low when the battery is physically present */
+	return gpio_get_level(GPIO_BATTERY_PRESENT_L) ? BP_NO : BP_YES;
+}
+
+static int battery_init(void)
+{
+	static int batt_status;
+
+	if (batt_status & STATUS_INITIALIZED)
+		return 1;
+
+	return battery_status(&batt_status) ? 0 :
+		!!(batt_status & STATUS_INITIALIZED);
+}
+
+enum battery_disconnect_grace_period {
+	BATTERY_DISCONNECT_GRACE_PERIOD_OFF,
+	BATTERY_DISCONNECT_GRACE_PERIOD_ON,
+	BATTERY_DISCONNECT_GRACE_PERIOD_OVER,
+};
+static enum battery_disconnect_grace_period disconnect_grace_period;
+
+static void battery_disconnect_timer(void)
+{
+	disconnect_grace_period = BATTERY_DISCONNECT_GRACE_PERIOD_OVER;
+}
+DECLARE_DEFERRED(battery_disconnect_timer);
+
+/*
+ * Check for case where both XCHG and XDSG bits are set indicating that even
+ * though the FG can be read from the battery, the battery is not able to be
+ * charged or discharged. This situation will happen if a battery disconnect was
+ * initiated via H1 setting the DISCONN signal to the battery. This will put the
+ * battery pack into a sleep state and when power is reconnected, the FG can be
+ * read, but the battery is still not able to provide power to the system. The
+ * calling function returns batt_pres = BP_NO, which instructs the charging
+ * state machine to prevent powering up the AP on battery alone which could lead
+ * to a brownout event when the battery isn't able yet to provide power to the
+ * system. .
+ */
+static int battery_check_disconnect_ti_bq40z50(void)
+{
+	int rv;
+	uint8_t data[6];
+
+	/* Check if battery charging + discharging is disabled. */
+	rv = sb_read_mfgacc(PARAM_OPERATION_STATUS,
+			    SB_ALT_MANUFACTURER_ACCESS, data, sizeof(data));
+	if (rv)
+		return BATTERY_DISCONNECT_ERROR;
+
+	if ((data[3] & (BATTERY_DISCHARGING_DISABLED |
+			BATTERY_CHARGING_DISABLED)) ==
+	    (BATTERY_DISCHARGING_DISABLED | BATTERY_CHARGING_DISABLED)) {
+		if (oem != PROJECT_SONA)
+			return BATTERY_DISCONNECTED;
+		/*
+		 * For Sona, we need a workaround to wake up a battery from
+		 * cutoff. We return DISCONNECT_ERROR for the 5 seconds after
+		 * the first call BP_NOT_SURE is reported to chgstv2. It will
+		 * supply precharge current and wakes up the battery from
+		 * cutoff. If the battery is good, we won't come back here.
+		 * If not, after 5 seconds, we will return DISCONNECTED to
+		 * stop charging and avoid damaging the battery.
+		 */
+		if (disconnect_grace_period ==
+				BATTERY_DISCONNECT_GRACE_PERIOD_OVER)
+			return BATTERY_DISCONNECTED;
+		if (disconnect_grace_period ==
+				BATTERY_DISCONNECT_GRACE_PERIOD_OFF)
+			hook_call_deferred(&battery_disconnect_timer_data,
+					   5 * SECOND);
+		ccprintf("Battery disconnect grace period\n");
+		disconnect_grace_period = BATTERY_DISCONNECT_GRACE_PERIOD_ON;
+		return BATTERY_DISCONNECT_ERROR;
+	}
+
+	return BATTERY_NOT_DISCONNECTED;
+}
+
+static int battery_check_disconnect_renesas_raj240(void)
+{
+	int data;
+	int rv;
+
+	rv = sb_read(0x41, &data);
+	if (rv)
+		return BATTERY_DISCONNECT_ERROR;
+
+	if (data != 0x1E /* 1E: Power down */)
+		return BATTERY_NOT_DISCONNECTED;
+
+	return BATTERY_DISCONNECTED;
+}
+
+static int battery_check_disconnect_1(void)
+{
+	int batt_discharge_fet;
+
+	if (sb_read(SB_MANUFACTURER_ACCESS, &batt_discharge_fet))
+		return BATTERY_DISCONNECT_ERROR;
+
+	if (get_akali_battery_type() == BATTERY_TYPE_AP15) {
+		/* Bit 15: Discharge FET status (1: On, 0: Off) */
+		if (batt_discharge_fet & 0x4000)
+			return BATTERY_NOT_DISCONNECTED;
+	} else if (get_akali_battery_type() == BATTERY_TYPE_AP18) {
+		/* Bit 13: Discharge FET status (1: Off, 0: On) */
+		if (!(batt_discharge_fet & 0x2000))
+			return BATTERY_NOT_DISCONNECTED;
+	}
+
+	return BATTERY_DISCONNECT_ERROR;
+}
+
+static int battery_check_disconnect(void)
+{
+	if (!battery_init())
+		return BATTERY_DISCONNECT_ERROR;
+
+	if (fuel_gauge == GAUGE_TYPE_UNKNOWN) {
+		fuel_gauge = get_gauge_ic();
+		CPRINTS("fuel_gauge=%d\n", fuel_gauge);
+	}
+
+	switch (fuel_gauge) {
+	case GAUGE_TYPE_AKALI:
+		return battery_check_disconnect_1();
+	case GAUGE_TYPE_TI_BQ40Z50:
+		return battery_check_disconnect_ti_bq40z50();
+	case GAUGE_TYPE_RENESAS_RAJ240:
+		return battery_check_disconnect_renesas_raj240();
+	default:
+		return BATTERY_DISCONNECT_ERROR;
+	}
+}
+
+static enum battery_present batt_pres_prev; /* Default BP_NO (=0) */
+
+static enum battery_present battery_check_present_status(void)
+{
+	enum battery_present batt_pres;
+	int batt_disconnect_status;
+
+	/* Get the physical hardware status */
+	batt_pres = battery_hw_present();
+
+	/*
+	 * If the battery is not physically connected, then no need to perform
+	 * any more checks.
+	 */
+	if (batt_pres != BP_YES)
+		return batt_pres;
+
+	/*
+	 * If the battery is present now and was present last time we checked,
+	 * return early.
+	 */
+	if (batt_pres == batt_pres_prev)
+		return batt_pres;
+
+	/*
+	 * Check battery disconnect status. If we are unable to read battery
+	 * disconnect status, then return BP_NOT_SURE. Battery could be in ship
+	 * mode and might require pre-charge current to wake it up. BP_NO is not
+	 * returned here because charger state machine will not provide
+	 * pre-charge current assuming that battery is not present.
+	 */
+	batt_disconnect_status = battery_check_disconnect();
+	if (batt_disconnect_status == BATTERY_DISCONNECT_ERROR)
+		return BP_NOT_SURE;
+
+	/*
+	 * Ensure that battery is:
+	 * 1. Not in cutoff
+	 * 2. Not disconnected
+	 * 3. Initialized
+	 */
+	if (battery_is_cut_off() != BATTERY_CUTOFF_STATE_NORMAL ||
+	    batt_disconnect_status != BATTERY_NOT_DISCONNECTED)
+		return BP_NO;
+
+	return BP_YES;
+}
+
+enum battery_present battery_is_present(void)
+{
+	batt_pres_prev = battery_check_present_status();
+	return batt_pres_prev;
+}
diff --git a/board/sylas/board.c b/board/sylas/board.c
new file mode 100644
index 0000000000..de7b794e59
--- /dev/null
+++ b/board/sylas/board.c
@@ -0,0 +1,637 @@
+/* Copyright 2020 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.
+ */
+
+/* Poppy board-specific configuration */
+
+#include "adc.h"
+#include "adc_chip.h"
+#include "anx7447.h"
+#include "board_config.h"
+#include "button.h"
+#include "charge_manager.h"
+#include "charge_state.h"
+#include "charge_ramp.h"
+#include "charger.h"
+#include "chipset.h"
+#include "console.h"
+#include "cros_board_info.h"
+#include "driver/pmic_tps650x30.h"
+#include "driver/accelgyro_bmi160.h"
+#include "driver/accel_bma2x2.h"
+#include "driver/accel_kionix.h"
+#include "driver/baro_bmp280.h"
+#include "driver/led/lm3509.h"
+#include "driver/tcpm/ps8xxx.h"
+#include "driver/tcpm/tcpci.h"
+#include "driver/tcpm/tcpm.h"
+#include "driver/temp_sensor/f75303.h"
+#include "extpower.h"
+#include "gpio.h"
+#include "hooks.h"
+#include "host_command.h"
+#include "i2c.h"
+#include "isl923x.h"
+#include "keyboard_8042_sharedlib.h"
+#include "keyboard_backlight.h"
+#include "keyboard_config.h"
+#include "keyboard_raw.h"
+#include "keyboard_scan.h"
+#include "lid_switch.h"
+#include "math_util.h"
+#include "motion_lid.h"
+#include "motion_sense.h"
+#include "pi3usb9281.h"
+#include "power.h"
+#include "power_button.h"
+#include "pwm.h"
+#include "pwm_chip.h"
+#include "spi.h"
+#include "switch.h"
+#include "system.h"
+#include "tablet_mode.h"
+#include "task.h"
+#include "temp_sensor.h"
+#include "timer.h"
+#include "uart.h"
+#include "usb_charge.h"
+#include "usb_mux.h"
+#include "usb_pd.h"
+#include "usb_pd_tcpm.h"
+#include "util.h"
+#include "espi.h"
+#include "fan.h"
+#include "fan_chip.h"
+
+#define CPRINTS(format, args...) cprints(CC_USBCHARGE, format, ## args)
+#define CPRINTF(format, args...) cprintf(CC_USBCHARGE, format, ## args)
+
+#define USB_PD_PORT_PS8751	0
+#define USB_PD_PORT_ANX7447	1
+
+/******************************************************************************/
+/* Physical fans. These are logically separate from pwm_channels. */
+
+const struct fan_conf fan_conf_0 = {
+	.flags = FAN_USE_RPM_MODE,
+	.ch = MFT_CH_0,	/* Use MFT id to control fan */
+	.pgood_gpio = -1,
+	.enable_gpio = -1,
+};
+
+/* Default, Nami, Vayne */
+const struct fan_rpm fan_rpm_0 = {
+	.rpm_min = 3100,
+	.rpm_start = 3100,
+	.rpm_max = 6900,
+};
+
+/* Sona */
+const struct fan_rpm fan_rpm_1 = {
+	.rpm_min = 2700,
+	.rpm_start = 2700,
+	.rpm_max = 6000,
+};
+
+/* Pantheon */
+const struct fan_rpm fan_rpm_2 = {
+	.rpm_min = 2100,
+	.rpm_start = 2300,
+	.rpm_max = 5100,
+};
+
+/* Akali */
+const struct fan_rpm fan_rpm_3 = {
+	.rpm_min = 2700,
+	.rpm_start = 2700,
+	.rpm_max = 5500,
+};
+
+const struct fan_rpm fan_rpm_4 = {
+	.rpm_min = 2400,
+	.rpm_start = 2400,
+	.rpm_max = 4500,
+};
+
+struct fan_t fans[FAN_CH_COUNT] = {
+	[FAN_CH_0] = { .conf = &fan_conf_0, .rpm = &fan_rpm_0, },
+};
+
+/******************************************************************************/
+/* MFT channels. These are logically separate from pwm_channels. */
+const struct mft_t mft_channels[] = {
+	[MFT_CH_0] = {NPCX_MFT_MODULE_2, TCKC_LFCLK, PWM_CH_FAN},
+};
+BUILD_ASSERT(ARRAY_SIZE(mft_channels) == MFT_CH_COUNT);
+
+/* I2C port map */
+const struct i2c_port_t i2c_ports[]  = {
+	{"tcpc0",     NPCX_I2C_PORT0_0, 400, GPIO_I2C0_0_SCL, GPIO_I2C0_0_SDA},
+	{"tcpc1",     NPCX_I2C_PORT0_1, 400, GPIO_I2C0_1_SCL, GPIO_I2C0_1_SDA},
+	{"battery",   NPCX_I2C_PORT1,   100, GPIO_I2C1_SCL,   GPIO_I2C1_SDA},
+	{"charger",   NPCX_I2C_PORT2,   100, GPIO_I2C2_SCL,   GPIO_I2C2_SDA},
+	{"pmic",      NPCX_I2C_PORT2,   400, GPIO_I2C2_SCL,   GPIO_I2C2_SDA},
+	{"accelgyro", NPCX_I2C_PORT3,   400, GPIO_I2C3_SCL,   GPIO_I2C3_SDA},
+};
+const unsigned int i2c_ports_used = ARRAY_SIZE(i2c_ports);
+
+/*
+ * F75303_Remote1 is near CPU, and F75303_Remote2 is near 5V power IC.
+ */
+const struct temp_sensor_t temp_sensors[TEMP_SENSOR_COUNT] = {
+	{"F75303_Local", TEMP_SENSOR_TYPE_BOARD, f75303_get_val,
+		F75303_IDX_LOCAL, 4},
+	{"F75303_Remote1", TEMP_SENSOR_TYPE_CPU, f75303_get_val,
+		F75303_IDX_REMOTE1, 4},
+	{"F75303_Remote2", TEMP_SENSOR_TYPE_BOARD, f75303_get_val,
+		F75303_IDX_REMOTE2, 4},
+};
+
+struct ec_thermal_config thermal_params[TEMP_SENSOR_COUNT];
+
+/* Nami/Vayne Remote 1, 2 */
+const static struct ec_thermal_config thermal_a = {
+	.temp_host = {
+		[EC_TEMP_THRESH_WARN] = 0,
+		[EC_TEMP_THRESH_HIGH] = C_TO_K(75),
+		[EC_TEMP_THRESH_HALT] = C_TO_K(80),
+	},
+	.temp_host_release = {
+		[EC_TEMP_THRESH_WARN] = 0,
+		[EC_TEMP_THRESH_HIGH] = C_TO_K(65),
+		[EC_TEMP_THRESH_HALT] = 0,
+	},
+	.temp_fan_off = C_TO_K(39),
+	.temp_fan_max = C_TO_K(50),
+};
+
+/* Sona Remote 1 */
+const static struct ec_thermal_config thermal_b1 = {
+	.temp_host = {
+		[EC_TEMP_THRESH_WARN] = 0,
+		[EC_TEMP_THRESH_HIGH] = C_TO_K(82),
+		[EC_TEMP_THRESH_HALT] = C_TO_K(89),
+	},
+	.temp_host_release = {
+		[EC_TEMP_THRESH_WARN] = 0,
+		[EC_TEMP_THRESH_HIGH] = C_TO_K(72),
+		[EC_TEMP_THRESH_HALT] = 0,
+	},
+	.temp_fan_off = C_TO_K(38),
+	.temp_fan_max = C_TO_K(58),
+};
+
+/* Sona Remote 2 */
+const static struct ec_thermal_config thermal_b2 = {
+	.temp_host = {
+		[EC_TEMP_THRESH_WARN] = 0,
+		[EC_TEMP_THRESH_HIGH] = C_TO_K(84),
+		[EC_TEMP_THRESH_HALT] = C_TO_K(91),
+	},
+	.temp_host_release = {
+		[EC_TEMP_THRESH_WARN] = 0,
+		[EC_TEMP_THRESH_HIGH] = C_TO_K(74),
+		[EC_TEMP_THRESH_HALT] = 0,
+	},
+	.temp_fan_off = C_TO_K(40),
+	.temp_fan_max = C_TO_K(60),
+};
+
+/* Pantheon Remote 1 */
+const static struct ec_thermal_config thermal_c1 = {
+	.temp_host = {
+		[EC_TEMP_THRESH_WARN] = 0,
+		[EC_TEMP_THRESH_HIGH] = C_TO_K(66),
+		[EC_TEMP_THRESH_HALT] = C_TO_K(80),
+	},
+	.temp_host_release = {
+		[EC_TEMP_THRESH_WARN] = 0,
+		[EC_TEMP_THRESH_HIGH] = C_TO_K(56),
+		[EC_TEMP_THRESH_HALT] = 0,
+	},
+	.temp_fan_off = C_TO_K(38),
+	.temp_fan_max = C_TO_K(61),
+};
+
+/* Pantheon Remote 2 */
+const static struct ec_thermal_config thermal_c2 = {
+	.temp_host = {
+		[EC_TEMP_THRESH_WARN] = 0,
+		[EC_TEMP_THRESH_HIGH] = C_TO_K(74),
+		[EC_TEMP_THRESH_HALT] = C_TO_K(82),
+	},
+	.temp_host_release = {
+		[EC_TEMP_THRESH_WARN] = 0,
+		[EC_TEMP_THRESH_HIGH] = C_TO_K(64),
+		[EC_TEMP_THRESH_HALT] = 0,
+	},
+	.temp_fan_off = C_TO_K(38),
+	.temp_fan_max = C_TO_K(61),
+};
+
+/* Akali Local */
+const static struct ec_thermal_config thermal_d0 = {
+	.temp_host = {
+		[EC_TEMP_THRESH_WARN] = C_TO_K(79),
+		[EC_TEMP_THRESH_HIGH] = 0,
+		[EC_TEMP_THRESH_HALT] = C_TO_K(81),
+	},
+	.temp_host_release = {
+		[EC_TEMP_THRESH_WARN] = C_TO_K(80),
+		[EC_TEMP_THRESH_HIGH] = 0,
+		[EC_TEMP_THRESH_HALT] = C_TO_K(82),
+	},
+	.temp_fan_off = C_TO_K(35),
+	.temp_fan_max = C_TO_K(70),
+};
+
+/* Akali Remote 1 */
+const static struct ec_thermal_config thermal_d1 = {
+	.temp_host = {
+		[EC_TEMP_THRESH_WARN] = C_TO_K(59),
+		[EC_TEMP_THRESH_HIGH] = 0,
+		[EC_TEMP_THRESH_HALT] = 0,
+	},
+	.temp_host_release = {
+		[EC_TEMP_THRESH_WARN] = C_TO_K(60),
+		[EC_TEMP_THRESH_HIGH] = 0,
+		[EC_TEMP_THRESH_HALT] = 0,
+	},
+	.temp_fan_off = 0,
+	.temp_fan_max = 0,
+};
+
+/* Akali Remote 2 */
+const static struct ec_thermal_config thermal_d2 = {
+	.temp_host = {
+		[EC_TEMP_THRESH_WARN] = C_TO_K(59),
+		[EC_TEMP_THRESH_HIGH] = 0,
+		[EC_TEMP_THRESH_HALT] = 0,
+	},
+	.temp_host_release = {
+		[EC_TEMP_THRESH_WARN] = C_TO_K(60),
+		[EC_TEMP_THRESH_HIGH] = 0,
+		[EC_TEMP_THRESH_HALT] = 0,
+	},
+	.temp_fan_off = 0,
+	.temp_fan_max = 0,
+};
+
+
+
+/* Sylas Remote 1 */
+const static struct ec_thermal_config thermal_e1 = {
+	.temp_host = {
+		[EC_TEMP_THRESH_WARN] = 0,
+		[EC_TEMP_THRESH_HIGH] = C_TO_K(82),
+		[EC_TEMP_THRESH_HALT] = C_TO_K(89),
+	},
+	.temp_host_release = {
+		[EC_TEMP_THRESH_WARN] = 0,
+		[EC_TEMP_THRESH_HIGH] = C_TO_K(72),
+		[EC_TEMP_THRESH_HALT] = 0,
+	},
+	.temp_fan_off = C_TO_K(38),
+	.temp_fan_max = C_TO_K(58),
+};
+
+
+
+
+static void setup_fans(void)
+{
+	switch (oem) {
+	case PROJECT_SONA:
+		if (model == MODEL_SYNDRA)
+			fans[FAN_CH_0].rpm = &fan_rpm_4;
+		else
+			fans[FAN_CH_0].rpm = &fan_rpm_1;
+		thermal_params[TEMP_SENSOR_REMOTE1] = thermal_b1;
+		thermal_params[TEMP_SENSOR_REMOTE2] = thermal_b2;
+		break;
+	case PROJECT_PANTHEON:
+		fans[FAN_CH_0].rpm = &fan_rpm_2;
+		thermal_params[TEMP_SENSOR_REMOTE1] = thermal_c1;
+		thermal_params[TEMP_SENSOR_REMOTE2] = thermal_c2;
+		break;
+	case PROJECT_AKALI:
+		fans[FAN_CH_0].rpm = &fan_rpm_3;
+		thermal_params[TEMP_SENSOR_LOCAL] = thermal_d0;
+		thermal_params[TEMP_SENSOR_REMOTE1] = thermal_d1;
+		thermal_params[TEMP_SENSOR_REMOTE2] = thermal_d2;
+		break;
+	case PROJECT_SYLAS:
+		if (model == MODEL_SYNDRA)
+			fans[FAN_CH_0].rpm = &fan_rpm_4;
+		else
+			fans[FAN_CH_0].rpm = &fan_rpm_1;
+		thermal_params[TEMP_SENSOR_REMOTE1] = thermal_e1;
+		break;
+	case PROJECT_NAMI:
+	case PROJECT_VAYNE:
+	default:
+		thermal_params[TEMP_SENSOR_REMOTE1] = thermal_a;
+		thermal_params[TEMP_SENSOR_REMOTE2] = thermal_a;
+	}
+}
+
+void board_reset_pd_mcu(void)
+{
+	if (oem == PROJECT_AKALI && board_version < 0x0200) {
+		if (anx7447_flash_erase(USB_PD_PORT_ANX7447))
+			CPRINTS("Failed to erase OCM flash");
+
+	}
+
+	/* Assert reset */
+	gpio_set_level(GPIO_USB_C0_PD_RST_L, 0);
+	gpio_set_level(GPIO_USB_C1_PD_RST, 1);
+	msleep(1);
+	gpio_set_level(GPIO_USB_C0_PD_RST_L, 1);
+	gpio_set_level(GPIO_USB_C1_PD_RST, 0);
+	/* After TEST_R release, anx7447/3447 needs 2ms to finish eFuse
+	 * loading. */
+	msleep(2);
+}
+
+static int ps8751_tune_mux(const struct usb_mux *mux)
+{
+	/* 0x98 sets lower EQ of DP port (3.6db) */
+	tcpc_write(mux->port_addr, PS8XXX_REG_MUX_DP_EQ_CONFIGURATION, 0x98);
+	return EC_SUCCESS;
+}
+
+void board_tcpc_init(void)
+{
+	int port;
+
+	/* Only reset TCPC if not sysjump */
+	if (!system_jumped_to_this_image())
+		board_reset_pd_mcu();
+
+	/* Enable TCPC interrupts */
+	gpio_enable_interrupt(GPIO_USB_C0_PD_INT_ODL);
+	gpio_enable_interrupt(GPIO_USB_C1_PD_INT_ODL);
+
+	if (oem == PROJECT_SONA && model != MODEL_SYNDRA)
+		usb_muxes[USB_PD_PORT_PS8751].board_init = ps8751_tune_mux;
+
+	/*
+	 * Initialize HPD to low; after sysjump SOC needs to see
+	 * HPD pulse to enable video path
+	 */
+	for (port = 0; port < CONFIG_USB_PD_PORT_COUNT; port++) {
+		const struct usb_mux *mux = &usb_muxes[port];
+		mux->hpd_update(port, 0, 0);
+	}
+}
+DECLARE_HOOK(HOOK_INIT, board_tcpc_init, HOOK_PRIO_INIT_I2C + 2);
+
+static void board_init(void)
+{
+#ifndef TEST_BUILD
+	if (oem == PROJECT_AKALI && model == MODEL_BARD) {
+		/* Search key is moved to col=0,row=3 */
+		keyscan_config.actual_key_mask[0] = 0x1c;
+		keyscan_config.actual_key_mask[1] = 0xfe;
+		/* No need to swap scancode_set2[0][3] and [1][0] because both
+		 * are mapped to search key. */
+	}
+#endif
+}
+DECLARE_HOOK(HOOK_INIT, board_init, HOOK_PRIO_DEFAULT);
+
+void board_set_charge_limit(int port, int supplier, int charge_ma,
+			    int max_ma, int charge_mv)
+{
+	/*
+	 * Limit the input current to 96% negotiated limit,
+	 * to account for the charger chip margin.
+	 */
+	if (oem == PROJECT_AKALI &&
+		(model == MODEL_EKKO || model == MODEL_BARD))
+		charge_ma = charge_ma * 95 / 100;
+	else
+		charge_ma = charge_ma * 96 / 100;
+	charge_set_input_current_limit(
+			MAX(charge_ma, CONFIG_CHARGER_INPUT_CURRENT),
+			charge_mv);
+}
+
+void board_kblight_init(void)
+{
+	if (!(sku & SKU_ID_MASK_KBLIGHT))
+		return;
+
+	switch (oem) {
+	default:
+	case PROJECT_NAMI:
+	case PROJECT_AKALI:
+	case PROJECT_VAYNE:
+	case PROJECT_PANTHEON:
+		kblight_register(&kblight_lm3509);
+		break;
+	case PROJECT_SONA:
+		kblight_register(&kblight_pwm);
+		break;
+	}
+}
+
+int board_is_lid_angle_tablet_mode(void)
+{
+	/* Boards with no GMR sensor use lid angles to detect tablet mode. */
+	return oem != PROJECT_AKALI;
+}
+
+enum critical_shutdown board_critical_shutdown_check(
+		struct charge_state_data *curr)
+{
+	if (oem == PROJECT_VAYNE)
+		return CRITICAL_SHUTDOWN_CUTOFF;
+	else
+		return CRITICAL_SHUTDOWN_HIBERNATE;
+
+}
+
+/* Lid Sensor mutex */
+static struct mutex g_lid_mutex;
+static struct mutex g_base_mutex;
+
+/* Lid accel private data */
+static struct bmi160_drv_data_t g_bmi160_data;
+static struct kionix_accel_data g_kx022_data;
+
+/* BMA255 private data */
+static struct accelgyro_saved_data_t g_bma255_data;
+
+/* Matrix to rotate accelrator into standard reference frame */
+const matrix_3x3_t base_standard_ref = {
+	{ 0, FLOAT_TO_FP(-1), 0},
+	{ FLOAT_TO_FP(1), 0, 0},
+	{ 0, 0, FLOAT_TO_FP(1)}
+};
+
+const matrix_3x3_t lid_standard_ref = {
+	{ FLOAT_TO_FP(1), 0, 0},
+	{ 0, FLOAT_TO_FP(-1), 0},
+	{ 0, 0, FLOAT_TO_FP(-1)}
+};
+
+const matrix_3x3_t rotation_x180_z90 = {
+	{ 0, FLOAT_TO_FP(-1), 0 },
+	{ FLOAT_TO_FP(-1), 0, 0 },
+	{ 0, 0, FLOAT_TO_FP(-1) }
+};
+
+struct motion_sensor_t motion_sensors[] = {
+	[LID_ACCEL] = {
+		.name = "Lid Accel",
+		.active_mask = SENSOR_ACTIVE_S0_S3,
+		.chip = MOTIONSENSE_CHIP_BMA255,
+		.type = MOTIONSENSE_TYPE_ACCEL,
+		.location = MOTIONSENSE_LOC_LID,
+		.drv = &bma2x2_accel_drv,
+		.mutex = &g_lid_mutex,
+		.drv_data = &g_bma255_data,
+		.port = I2C_PORT_ACCEL,
+		.addr = BMA2x2_I2C_ADDR1,
+		.rot_standard_ref = &lid_standard_ref,
+		.min_frequency = BMA255_ACCEL_MIN_FREQ,
+		.max_frequency = BMA255_ACCEL_MAX_FREQ,
+		.default_range = 2, /* g, to support tablet mode */
+		.config = {
+			/* EC use accel for angle detection */
+			[SENSOR_CONFIG_EC_S0] = {
+				.odr = 10000 | ROUND_UP_FLAG,
+				.ec_rate = 0,
+			},
+			/* Sensor on in S3 */
+			[SENSOR_CONFIG_EC_S3] = {
+				.odr = 10000 | ROUND_UP_FLAG,
+				.ec_rate = 0,
+			},
+		},
+	},
+	[BASE_ACCEL] = {
+		.name = "Base Accel",
+		.active_mask = SENSOR_ACTIVE_S0_S3,
+		.chip = MOTIONSENSE_CHIP_BMI160,
+		.type = MOTIONSENSE_TYPE_ACCEL,
+		.location = MOTIONSENSE_LOC_BASE,
+		.drv = &bmi160_drv,
+		.mutex = &g_base_mutex,
+		.drv_data = &g_bmi160_data,
+		.port = I2C_PORT_ACCEL,
+		.addr = BMI160_ADDR0,
+		.rot_standard_ref = &base_standard_ref,
+		.min_frequency = BMI160_ACCEL_MIN_FREQ,
+		.max_frequency = BMI160_ACCEL_MAX_FREQ,
+		.default_range = 2, /* g, to support tablet mode  */
+		.config = {
+			/* EC use accel for angle detection */
+			[SENSOR_CONFIG_EC_S0] = {
+				.odr = 10000 | ROUND_UP_FLAG,
+				.ec_rate = 100 * MSEC,
+			},
+			/* Sensor on in S3 */
+			[SENSOR_CONFIG_EC_S3] = {
+				.odr = 10000 | ROUND_UP_FLAG,
+				.ec_rate = 0,
+			},
+		},
+	},
+	[BASE_GYRO] = {
+		.name = "Base Gyro",
+		.active_mask = SENSOR_ACTIVE_S0_S3,
+		.chip = MOTIONSENSE_CHIP_BMI160,
+		.type = MOTIONSENSE_TYPE_GYRO,
+		.location = MOTIONSENSE_LOC_BASE,
+		.drv = &bmi160_drv,
+		.mutex = &g_base_mutex,
+		.drv_data = &g_bmi160_data,
+		.port = I2C_PORT_ACCEL,
+		.addr = BMI160_ADDR0,
+		.default_range = 1000, /* dps */
+		.rot_standard_ref = &base_standard_ref,
+		.min_frequency = BMI160_GYRO_MIN_FREQ,
+		.max_frequency = BMI160_GYRO_MAX_FREQ,
+	},
+};
+unsigned int motion_sensor_count = ARRAY_SIZE(motion_sensors);
+
+const struct motion_sensor_t lid_accel_1 = {
+	.name = "Lid Accel",
+	.active_mask = SENSOR_ACTIVE_S0_S3,
+	.chip = MOTIONSENSE_CHIP_KX022,
+	.type = MOTIONSENSE_TYPE_ACCEL,
+	.location = MOTIONSENSE_LOC_LID,
+	.drv = &kionix_accel_drv,
+	.mutex = &g_lid_mutex,
+	.drv_data = &g_kx022_data,
+	.port = I2C_PORT_ACCEL,
+	.addr = KX022_ADDR1,
+	.rot_standard_ref = &rotation_x180_z90,
+	.min_frequency = KX022_ACCEL_MIN_FREQ,
+	.max_frequency = KX022_ACCEL_MAX_FREQ,
+	.default_range = 2, /* g, to support tablet mode */
+	.config = {
+		/* EC use accel for angle detection */
+		[SENSOR_CONFIG_EC_S0] = {
+			.odr = 10000 | ROUND_UP_FLAG,
+		},
+		/* Sensor on in S3 */
+		[SENSOR_CONFIG_EC_S3] = {
+			.odr = 10000 | ROUND_UP_FLAG,
+		},
+	},
+};
+
+static void setup_motion_sensors(void)
+{
+	if (sku & SKU_ID_MASK_CONVERTIBLE) {
+		if (oem == PROJECT_AKALI) {
+			/* Rotate axis for Akali 360 */
+			motion_sensors[LID_ACCEL] = lid_accel_1;
+			motion_sensors[BASE_ACCEL].rot_standard_ref = NULL;
+			motion_sensors[BASE_GYRO].rot_standard_ref = NULL;
+		}
+	} else {
+		/* Clamshells have no accel/gyro */
+		motion_sensor_count = 0;
+	}
+}
+
+/*
+ * Read CBI from i2c eeprom and initialize variables for board variants
+ */
+static void cbi_init(void)
+{
+	uint32_t val;
+
+	if (cbi_get_board_version(&val) == EC_SUCCESS && val <= UINT16_MAX)
+		board_version = val;
+	CPRINTS("Board Version: 0x%04x", board_version);
+
+	if (cbi_get_oem_id(&val) == EC_SUCCESS && val < PROJECT_COUNT)
+		oem = val;
+	CPRINTS("OEM: %d", oem);
+
+	if (cbi_get_sku_id(&val) == EC_SUCCESS)
+		sku = val;
+	CPRINTS("SKU: 0x%08x", sku);
+
+	if (cbi_get_model_id(&val) == EC_SUCCESS)
+		model = val;
+	CPRINTS("MODEL: 0x%08x", model);
+
+	if (board_version < 0x300)
+		/* Previous boards have GPIO42 connected to TP_INT_CONN */
+		gpio_set_flags(GPIO_USB2_ID, GPIO_INPUT);
+
+	setup_motion_sensors();
+
+	setup_fans();
+}
+DECLARE_HOOK(HOOK_INIT, cbi_init, HOOK_PRIO_INIT_I2C + 1);
+
diff --git a/board/sylas/board.h b/board/sylas/board.h
new file mode 100644
index 0000000000..3197bdc001
--- /dev/null
+++ b/board/sylas/board.h
@@ -0,0 +1,101 @@
+/* Copyright 2020 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.
+ */
+
+/* Eve board configuration */
+
+#ifndef __CROS_EC_BOARD_H
+#define __CROS_EC_BOARD_H
+
+#include "baseboard.h"
+
+/* EC console commands */
+#define CONFIG_CMD_ACCELS
+#define CONFIG_CMD_ACCEL_INFO
+#define CONFIG_CMD_BUTTON
+
+
+/* Sensor */
+#define CONFIG_TEMP_SENSOR
+#define CONFIG_TEMP_SENSOR_F75303
+
+#define CONFIG_ACCELGYRO_BMI160
+#define CONFIG_ACCELGYRO_BMI160_INT_EVENT TASK_EVENT_CUSTOM(4)
+#define CONFIG_ACCELGYRO_BMI160_INT2_OUTPUT
+#define CONFIG_ACCEL_BMA255
+#define CONFIG_ACCEL_KX022
+#define CONFIG_ACCEL_INTERRUPTS
+
+#ifndef __ASSEMBLER__
+
+enum oem_id {
+	PROJECT_AKALI = 1,
+	PROJECT_VAYNE = 3,
+	PROJECT_SONA,
+	PROJECT_PANTHEON,
+	PROJECT_NAMI,
+	PROJECT_COUNT,
+	PROJECT_SYLAS,
+};
+
+enum model_id {
+	/* Sona variants */
+	MODEL_SYNDRA = 1,
+	/* Akali variants */
+	MODEL_EKKO = 1,
+	MODEL_BARD = 2,
+};
+
+enum temp_sensor_id {
+	TEMP_SENSOR_LOCAL = 0,
+	TEMP_SENSOR_REMOTE1,
+	TEMP_SENSOR_REMOTE2,
+	TEMP_SENSOR_COUNT,
+};
+
+/*
+ * Motion sensors:
+ * When reading through IO memory is set up for sensors (LPC is used),
+ * the first 2 entries must be accelerometers, then gyroscope.
+ * For BMI160, accel, gyro and compass sensors must be next to each other.
+ */
+
+enum sensor_id {
+	LID_ACCEL = 0,
+	BASE_ACCEL,
+	BASE_GYRO,
+	LID_ALS,
+};
+
+enum adc_channel {
+	ADC_BASE_DET,
+	ADC_VBUS,
+	ADC_AMON_BMON,
+	ADC_CH_COUNT,
+};
+
+enum pwm_channel {
+	PWM_CH_LED1,
+	PWM_CH_LED2,
+	PWM_CH_FAN,
+	PWM_CH_KBLIGHT,
+	/* Number of PWM channels */
+	PWM_CH_COUNT,
+};
+
+enum fan_channel {
+	FAN_CH_0 = 0,
+	/* Number of FAN channels */
+	FAN_CH_COUNT,
+};
+
+enum mft_channel {
+	MFT_CH_0 = 0,
+	/* Number of MFT channels */
+	MFT_CH_COUNT,
+};
+
+#endif /* !__ASSEMBLER__ */
+
+#endif /* __CROS_EC_BOARD_H */
diff --git a/board/sylas/build.mk b/board/sylas/build.mk
new file mode 100644
index 0000000000..4e3e6c7fb6
--- /dev/null
+++ b/board/sylas/build.mk
@@ -0,0 +1,15 @@
+# -*- makefile -*-
+# Copyright 2020 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.
+#
+# Board specific files build
+#
+
+CHIP:=npcx
+CHIP_VARIANT:=npcx5m6g
+BASEBOARD:=nami
+
+board-y=board.o
+board-$(CONFIG_BATTERY_SMART)+=battery.o
+board-$(CONFIG_LED_COMMON)+=led.o
diff --git a/board/sylas/dev_key.pem b/board/sylas/dev_key.pem
new file mode 100644
index 0000000000..b72c787613
--- /dev/null
+++ b/board/sylas/dev_key.pem
@@ -0,0 +1,39 @@
+-----BEGIN RSA PRIVATE KEY-----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+-----END RSA PRIVATE KEY-----
diff --git a/board/sylas/ec.tasklist b/board/sylas/ec.tasklist
new file mode 100644
index 0000000000..ce8bf223b0
--- /dev/null
+++ b/board/sylas/ec.tasklist
@@ -0,0 +1,39 @@
+/* Copyright 2020 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.
+ */
+
+/*
+ * List of enabled tasks in the priority order
+ *
+ * The first one has the lowest priority.
+ *
+ * For each task, use the macro TASK_ALWAYS(n, r, d, s) for base tasks and
+ * TASK_NOTEST(n, r, d, s) for tasks that can be excluded in test binaries,
+ * where :
+ * 'n' in the name of the task
+ * 'r' in the main routine of the task
+ * 'd' in an opaque parameter passed to the routine at startup
+ * 's' is the stack size in bytes; must be a multiple of 8
+ *
+ * For USB PD tasks, IDs must be in consecutive order and correspond to
+ * the port which they are for. See TASK_ID_TO_PD_PORT() macro.
+ */
+
+#define CONFIG_TASK_LIST \
+	TASK_ALWAYS(HOOKS, hook_task, NULL, LARGER_TASK_STACK_SIZE) \
+	TASK_ALWAYS(USB_CHG_P0, usb_charger_task, NULL, TASK_STACK_SIZE) \
+	TASK_ALWAYS(USB_CHG_P1, usb_charger_task, NULL, TASK_STACK_SIZE) \
+	TASK_ALWAYS(CHARGER, charger_task, NULL, LARGER_TASK_STACK_SIZE) \
+	TASK_ALWAYS(MOTIONSENSE, motion_sense_task, NULL, VENTI_TASK_STACK_SIZE) \
+	TASK_NOTEST(CHIPSET, chipset_task, NULL, LARGER_TASK_STACK_SIZE) \
+	TASK_NOTEST(KEYPROTO, keyboard_protocol_task, NULL, TASK_STACK_SIZE) \
+	TASK_NOTEST(PDCMD, pd_command_task, NULL, TASK_STACK_SIZE) \
+	TASK_ALWAYS(HOSTCMD, host_command_task, NULL, LARGER_TASK_STACK_SIZE) \
+	TASK_ALWAYS(CONSOLE, console_task, NULL, LARGER_TASK_STACK_SIZE) \
+	TASK_ALWAYS(POWERBTN, power_button_task, NULL, LARGER_TASK_STACK_SIZE) \
+	TASK_NOTEST(KEYSCAN, keyboard_scan_task, NULL, TASK_STACK_SIZE) \
+	TASK_ALWAYS(PD_C0, pd_task, NULL, LARGER_TASK_STACK_SIZE) \
+	TASK_ALWAYS(PD_C1, pd_task, NULL, LARGER_TASK_STACK_SIZE) \
+	TASK_ALWAYS(PD_INT_C0, pd_interrupt_handler_task, 0, TASK_STACK_SIZE) \
+	TASK_ALWAYS(PD_INT_C1, pd_interrupt_handler_task, 1, TASK_STACK_SIZE)
diff --git a/board/sylas/gpio.inc b/board/sylas/gpio.inc
new file mode 100644
index 0000000000..ecd9be499f
--- /dev/null
+++ b/board/sylas/gpio.inc
@@ -0,0 +1,120 @@
+/* -*- mode:c -*-
+ *
+ * Copyright 2020 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.
+ */
+
+/* Declare symbolic names for all the GPIOs that we care about.
+ * Note: Those with interrupt handlers must be declared first. */
+
+/*
+ * ADCs are not configured in this file but listed below for reference.
+ *
+ * PIN(4, 4) ADC1: IADP_AMON_BMON
+ * PIN(4, 3) ADC2: PPVAR_BOOSTIN_SENSE
+ */
+
+GPIO_INT(USB_C0_PD_INT_ODL,	PIN(3, 7), GPIO_INT_FALLING,		tcpc_alert_event)
+GPIO_INT(USB_C1_PD_INT_ODL,	PIN(7, 1), GPIO_INT_FALLING,		tcpc_alert_event)
+#ifdef CONFIG_POWER_S0IX
+GPIO_INT(PCH_SLP_S0_L,		PIN(7, 5), GPIO_INT_BOTH,		power_signal_interrupt)
+#endif
+GPIO_INT(PCH_SLP_SUS_L,		PIN(6, 2), GPIO_INT_BOTH,		power_signal_interrupt)
+GPIO_INT(RSMRST_L_PGOOD,	PIN(B, 0), GPIO_INT_BOTH,		power_signal_interrupt)
+GPIO_INT(PMIC_DPWROK,		PIN(C, 7), GPIO_INT_BOTH,		power_signal_interrupt)
+GPIO_INT(POWER_BUTTON_L,	PIN(0, 3), GPIO_INT_BOTH | GPIO_PULL_UP,power_button_interrupt)
+GPIO_INT(LID_OPEN,		PIN(8, 3), GPIO_INT_BOTH,		lid_interrupt)
+GPIO_INT(VOLUME_DOWN_L,		PIN(7, 3), GPIO_INT_BOTH | GPIO_PULL_UP,button_interrupt)
+GPIO_INT(VOLUME_UP_L,		PIN(8, 6), GPIO_INT_BOTH | GPIO_PULL_UP,button_interrupt)
+GPIO_INT(WP_L,			PIN(9, 3), GPIO_INT_BOTH,		switch_interrupt)
+GPIO_INT(AC_PRESENT,		PIN(C, 1), GPIO_INT_BOTH,		extpower_interrupt)
+GPIO_INT(USB_C0_VBUS_WAKE_L,	PIN(9, 7), GPIO_INT_BOTH | GPIO_PULL_UP,vbus0_evt)
+GPIO_INT(USB_C1_VBUS_WAKE_L,	PIN(C, 5), GPIO_INT_BOTH | GPIO_PULL_UP,vbus1_evt)
+GPIO_INT(USB_C0_BC12_INT_L,	PIN(D, 2), GPIO_INT_FALLING,		usb0_evt)
+GPIO_INT(USB_C1_BC12_INT_L,	PIN(D, 3), GPIO_INT_FALLING,		usb1_evt)
+GPIO_INT(ACCELGYRO3_INT_L,	PIN(3, 6), GPIO_INT_FALLING | GPIO_PULL_UP, bmi160_interrupt)
+GPIO_INT(TABLET_MODE_L,		PIN(7, 2), GPIO_INT_BOTH,		tablet_mode_isr)
+GPIO_INT(CCD_MODE_ODL,		PIN(6, 3), GPIO_INT_FALLING,		ccd_mode_isr)
+
+GPIO(ENABLE_BACKLIGHT_L,		PIN(6, 7), GPIO_OUT_LOW)	/* LCD backlight */
+GPIO(PP3300_DX_WLAN,		PIN(B, 1), GPIO_OUT_LOW)	/* Enable WLAN 3.3V Power */
+GPIO(CPU_PROCHOT,		PIN(8, 1), GPIO_OUT_HIGH)	/* PROCHOT# to SOC */
+GPIO(PCH_ACPRESENT,		PIN(5, 0), GPIO_ODR_LOW)	/* ACOK to SOC */
+GPIO(PCH_WAKE_L,		PIN(A, 3), GPIO_ODR_HIGH)	/* Wake SOC */
+GPIO(PCH_RSMRST_L,		PIN(7, 0), GPIO_OUT_LOW)	/* RSMRST# to SOC */
+GPIO(PCH_PWRBTN_L,		PIN(7, 4), GPIO_ODR_HIGH)	/* Power Button to SOC */
+GPIO(EC_PLATFORM_RST,		PIN(4, 5), GPIO_OUT_LOW)	/* EC Reset to LDO_EN */
+GPIO(SYS_RESET_L,		PIN(6, 1), GPIO_ODR_HIGH)	/* Cold Reset to SOC */
+GPIO(PMIC_SLP_SUS_L,		PIN(8, 5), GPIO_OUT_LOW)	/* SLP_SUS# to PMIC */
+GPIO(BATTERY_PRESENT_L,		PIN(3, 4), GPIO_INPUT)		/* Battery Present */
+GPIO(ENTERING_RW,		PIN(7, 6), GPIO_OUTPUT)		/* EC Entering RW */
+GPIO(PMIC_INT_L,		PIN(6, 0), GPIO_INPUT)		/* PMIC interrupt */
+#ifndef CONFIG_POWER_S0IX
+GPIO(PCH_SLP_S0_L,		PIN(7, 5), GPIO_INPUT)
+#endif
+GPIO(CR50_RESET_ODL,		PIN(0, 2), GPIO_ODR_HIGH)	/* Cr50 Reset. dnojiri: unused. */
+GPIO(GPP_B14,			PIN(C, 2), GPIO_INPUT) /* Used for Intel's experimental uCode/P-unit update */
+/* Will be used to shut down EC on board_hibernate. */
+GPIO(EC_HIBERNATE,		PIN(0, 1), GPIO_OUT_LOW)
+/* GPIO(PCH_RTCRST,		PIN(E, 7), GPIO_INPUT) dnojiri: Revisit */
+
+/* I2C pins - these will be reconfigured for alternate function below */
+GPIO(I2C0_0_SCL,		PIN(B, 5), GPIO_INPUT)		/* EC_I2C0_0_USBC_3V3_SCL */
+GPIO(I2C0_0_SDA,		PIN(B, 4), GPIO_INPUT)		/* EC_I2C0_0_USBC_3V3_SDA */
+GPIO(I2C0_1_SCL,		PIN(B, 3), GPIO_INPUT)		/* EC_I2C0_1_USBC_3V3_SCL */
+GPIO(I2C0_1_SDA,		PIN(B, 2), GPIO_INPUT)		/* EC_I2C0_1_USBC_3V3_SDA */
+GPIO(I2C1_SCL,			PIN(9, 0), GPIO_INPUT)		/* EC_I2C1_3V3_SCL */
+GPIO(I2C1_SDA,			PIN(8, 7), GPIO_INPUT)		/* EC_I2C1_3V3_SDA */
+GPIO(I2C2_SCL,			PIN(9, 2), GPIO_INPUT)		/* EC_I2C2_PMIC_3V3_SCL */
+GPIO(I2C2_SDA,			PIN(9, 1), GPIO_INPUT)		/* EC_I2C2_PMIC_3V3_SDA */
+GPIO(I2C3_SCL,			PIN(D, 1), GPIO_INPUT | GPIO_SEL_1P8V)	/* EC_I2C3_SENSOR_1V8_SCL */
+GPIO(I2C3_SDA,			PIN(D, 0), GPIO_INPUT | GPIO_SEL_1P8V)	/* EC_I2C3_SENSOR_1V8_SDA */
+
+/* rev0: 5V enables: INPUT=1.5A, OUT_LOW=OFF, OUT_HIGH=3A */
+GPIO(USB_C0_5V_EN,		PIN(4, 0), GPIO_OUT_LOW)	/* C0 5V Enable */
+GPIO(USB_C0_3A_EN,		PIN(3, 5), GPIO_OUT_LOW)	/* C0 Enable 3A */
+GPIO(USB_C0_CHARGE_L,		PIN(C, 0), GPIO_OUT_LOW)	/* C0 Charge enable. Active low. */
+GPIO(USB_C1_5V_EN,		PIN(3, 3), GPIO_OUT_LOW)	/* C1 5V Enable */
+GPIO(USB_C1_3A_EN,		PIN(6, 6), GPIO_OUT_LOW)	/* C1 3A Enable */
+GPIO(USB_C1_CHARGE_L,		PIN(C, 3), GPIO_OUT_LOW)	/* C1 Charge enable. Active low. */
+GPIO(USB_C0_PD_RST_L,		PIN(C, 6), GPIO_ODR_HIGH)	/* C0 PD Reset */
+GPIO(USB_C1_PD_RST,		PIN(0, 0), GPIO_OUT_LOW)	/* C1 PD Reset */
+GPIO(USB_C0_DP_HPD,		PIN(9, 4), GPIO_INPUT)		/* C0 DP Hotplug Detect */
+GPIO(USB_C1_DP_HPD,		PIN(A, 5), GPIO_INPUT)		/* C1 DP Hotplug Detect */
+GPIO(USB_PP3300_USB_PD,		PIN(8, 4), GPIO_INPUT)		/* Reserved. Currently, has no effect. */
+GPIO(USB2_ID,			PIN(4, 2), GPIO_OUT_HIGH)	/* USB OTG ID */
+GPIO(USB3_POWER_DOWN_L,		PIN(3, 2), GPIO_OUT_LOW)	/* USB3 Redriver Power control. Only used by Sona. */
+
+/* Sensors */
+
+/* Trackpad */
+GPIO(TP_INT_EN,			PIN(A, 1), GPIO_OUT_LOW)
+
+/* LED */
+GPIO(LED1,			PIN(A, 7), GPIO_OUT_LOW)
+
+/* Alternate functions GPIO definitions */
+ALTERNATE(PIN_MASK(6, 0x30), 1, MODULE_UART, 0)	/* GPIO64-65 UART from EC to Servo */
+ALTERNATE(PIN_MASK(8, 0x80), 1, MODULE_I2C, 0)	/* GPIO87 EC_I2C1_3V3_SDA */
+ALTERNATE(PIN_MASK(9, 0x01), 1, MODULE_I2C, 0)	/* GPIO90 EC_I2C1_3V3_SCL */
+ALTERNATE(PIN_MASK(9, 0x06), 1, MODULE_I2C, 0)	/* GPIO91-92 EC_I2C2_SDA/SCL */
+ALTERNATE(PIN_MASK(B, 0x30), 1, MODULE_I2C, 0)	/* GPIOB4-B5 EC_I2C0_0_SDA/SCL */
+ALTERNATE(PIN_MASK(B, 0x0C), 1, MODULE_I2C, 0)	/* GPOPB2-B3 EC_I2C0_1_SDA/SCL */
+ALTERNATE(PIN_MASK(D, 0x03), 1, MODULE_I2C, 0)	/* GPIOD0-D1 EC_I2C3_SDA/SCL */
+ALTERNATE(PIN_MASK(B, 0x40), 1, MODULE_PWM, 0)	/* GPIOB6 PWM1 Fan control */
+ALTERNATE(PIN_MASK(8, 0x01), 1, MODULE_PWM, 0)	/* GPIO80 PWM3 LED White */
+ALTERNATE(PIN_MASK(B, 0x80), 1, MODULE_PWM, 0)	/* GPIOB7 PWM5 LED Yellow */
+ALTERNATE(PIN_MASK(A, 0x40), 1, MODULE_PWM, 0)	/* GPIOA6 TA2 */
+ALTERNATE(PIN_MASK(C, 0x10), 1, MODULE_PWM, 0)	/* GPIOC4 PWM2 */
+
+/* Keyboard pins */
+#define GPIO_KB_INPUT (GPIO_INPUT | GPIO_PULL_UP)
+#define GPIO_KB_OUTPUT (GPIO_ODR_HIGH)
+ALTERNATE(PIN_MASK(3, 0x03), 0, MODULE_KEYBOARD_SCAN, GPIO_KB_INPUT)
+ALTERNATE(PIN_MASK(2, 0xfc), 0, MODULE_KEYBOARD_SCAN, GPIO_KB_INPUT)
+ALTERNATE(PIN_MASK(2, 0x03), 0, MODULE_KEYBOARD_SCAN, GPIO_KB_OUTPUT)
+ALTERNATE(PIN_MASK(1, 0x7f), 0, MODULE_KEYBOARD_SCAN, GPIO_KB_OUTPUT)
+ALTERNATE(PIN_MASK(0, 0xf0), 0, MODULE_KEYBOARD_SCAN, GPIO_KB_OUTPUT)
+ALTERNATE(PIN_MASK(8, 0x04), 0, MODULE_KEYBOARD_SCAN, GPIO_KB_OUTPUT)
+GPIO(KBD_KSO2,			PIN(1, 7), GPIO_OUT_LOW)
diff --git a/board/sylas/led.c b/board/sylas/led.c
new file mode 100644
index 0000000000..95d5aaa37a
--- /dev/null
+++ b/board/sylas/led.c
@@ -0,0 +1,617 @@
+/* Copyright 2020 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.
+ *
+ * Power and battery LED control for Nami and its variants
+ *
+ * This is an event-driven LED control library. It does not use tasks or
+ * periodical hooks (HOOK_TICK, HOOK_SECOND), thus, it's more resource
+ * efficient.
+ *
+ * The library defines LED states and assigns an LED behavior to each state.
+ * The state space consists of tuple of (charge state, power state).
+ * In each LED state, a color and a pulse interval can be defined.
+ *
+ * Charging states are queried each time there is a state transition, thus, not
+ * stored. We hook power state transitions (e.g. s0->s3) and save the
+ * destination states (e.g. s3) in power_state.
+ *
+ * When system is suspending and AC is unplugged, there will be race condition
+ * between a power state hook and a charge state hook but whichever is called
+ * first or last the result will be the same.
+ *
+ * Currently, it supports two LEDs, called 'battery LED' and 'power LED'.
+ * It assumes the battery LED is connected to a PWM pin and the power LED is
+ * connected to a regular GPIO pin.
+ */
+
+#include "cros_board_info.h"
+#include "charge_state.h"
+#include "chipset.h"
+#include "console.h"
+#include "ec_commands.h"
+#include "gpio.h"
+#include "hooks.h"
+#include "led_common.h"
+#include "power.h"
+#include "pwm.h"
+#include "timer.h"
+#include "util.h"
+
+const enum ec_led_id supported_led_ids[] = {
+		EC_LED_ID_BATTERY_LED, EC_LED_ID_POWER_LED};
+const int supported_led_ids_count = ARRAY_SIZE(supported_led_ids);
+
+enum led_color {
+	LED_OFF = 0,
+	LED_RED,
+	LED_GREEN,
+	LED_AMBER,
+	LED_WHITE,
+	LED_WARM_WHITE,
+	LED_FACTORY,
+	/* Number of colors, not a color itself */
+	LED_COLOR_COUNT
+};
+
+/* Charging states of LED's interests */
+enum led_charge_state {
+	LED_STATE_DISCHARGE = 0,
+	LED_STATE_CHARGE,
+	LED_STATE_FULL,
+	LED_CHARGE_STATE_COUNT,
+};
+
+/* Power states of LED's interests */
+enum led_power_state {
+	LED_STATE_S0 = 0,
+	LED_STATE_S3,
+	LED_STATE_S5,
+	LED_POWER_STATE_COUNT,
+};
+
+/* Defines a LED pattern for a single state */
+struct led_pattern {
+	uint8_t color;
+	/* Bit 0-5: Interval in 100 msec. 0=solid. Max is 3.2 sec.
+	 * Bit 6: 1=alternate (on-off-off-off), 0=regular (on-off-on-off)
+	 * Bit 7: 1=pulse, 0=blink */
+	uint8_t pulse;
+};
+
+#define PULSE_NO		0
+#define PULSE(interval)		(1 << 7 | (interval))
+#define BLINK(interval) 	(interval)
+#define ALTERNATE(interval)	(1 << 6 | (interval))
+#define IS_PULSING(pulse)	((pulse) & 0x80)
+#define IS_ALTERNATE(pulse)	((pulse) & 0x40)
+#define PULSE_INTERVAL(pulse)	(((pulse) & 0x3f) * 100 * MSEC)
+
+/* 40 msec for nice and smooth transition. */
+#define LED_PULSE_TICK_US	(40 * MSEC)
+
+typedef struct led_pattern led_patterns[LED_CHARGE_STATE_COUNT]
+					[LED_POWER_STATE_COUNT];
+
+/*
+ * Nami/Vayne - One dual color LED:
+ * Charging               Amber on (S0/S3/S5)
+ * Charging (full)        White on (S0/S3/S5)
+ * Discharge in S0        White on
+ * Discharge in S3/S0ix   Pulsing (rising for 2 sec , falling for 2 sec)
+ * Discharge in S5        Off
+ * Battery Error          Amber on 1sec off 1sec
+ * Factory mode	          White on 2sec, Amber on 2sec
+ */
+const static led_patterns battery_pattern_0 = {
+	/* discharging: s0, s3, s5 */
+	{{LED_WHITE, PULSE_NO}, {LED_WHITE, PULSE(10)}, {LED_OFF,  PULSE_NO}},
+	/* charging: s0, s3, s5 */
+	{{LED_AMBER, PULSE_NO}, {LED_AMBER, PULSE_NO}, {LED_AMBER, PULSE_NO}},
+	/* full: s0, s3, s5 */
+	{{LED_WHITE, PULSE_NO}, {LED_WHITE, PULSE_NO}, {LED_WHITE, PULSE_NO}},
+};
+
+/*
+ * Sona - Battery LED (dual color)
+ */
+const static led_patterns battery_pattern_1 = {
+	/* discharging: s0, s3, s5 */
+	{{LED_OFF,   PULSE_NO}, {LED_OFF,   PULSE_NO}, {LED_OFF,   PULSE_NO}},
+	/* charging: s0, s3, s5 */
+	{{LED_AMBER, PULSE_NO}, {LED_AMBER, PULSE_NO}, {LED_AMBER, PULSE_NO}},
+	/* full: s0, s3, s5 */
+	{{LED_WHITE, PULSE_NO}, {LED_WHITE, PULSE_NO}, {LED_WHITE, PULSE_NO}},
+};
+
+/*
+ * Pantheon - AC In/Battery LED(dual color):
+ * Connected to AC power / Charged (100%)        White (solid on)
+ * Connected to AC power / Charging(1% -99%)     Amber (solid on)
+ * Not connected to AC power                     Off
+ */
+const static led_patterns battery_pattern_2 = {
+	/* discharging: s0, s3, s5 */
+	{{LED_OFF,   PULSE_NO}, {LED_OFF,   PULSE_NO}, {LED_OFF,   PULSE_NO}},
+	/* charging: s0, s3, s5 */
+	{{LED_AMBER, PULSE_NO}, {LED_AMBER, PULSE_NO}, {LED_AMBER, PULSE_NO}},
+	/* full: s0, s3, s5 */
+	{{LED_WHITE, PULSE_NO}, {LED_WHITE, PULSE_NO}, {LED_WHITE, PULSE_NO}},
+};
+
+/*
+ * Sona - Power LED (single color)
+ */
+const static led_patterns power_pattern_1 = {
+	/* discharging: s0, s3, s5 */
+	{{LED_WHITE, PULSE_NO}, {LED_WHITE, BLINK(10)}, {LED_OFF, PULSE_NO}},
+	/* charging: s0, s3, s5 */
+	{{LED_WHITE, PULSE_NO}, {LED_WHITE, BLINK(10)}, {LED_OFF, PULSE_NO}},
+	/* full: s0, s3, s5 */
+	{{LED_WHITE, PULSE_NO}, {LED_WHITE, BLINK(10)}, {LED_OFF, PULSE_NO}},
+};
+
+/*
+ * Pantheon - Power LED
+ * S0:        White on
+ * S3/S0ix:   White 1 second on, 3 second off
+ * S5:        Off
+ */
+const static led_patterns power_pattern_2 = {
+	/* discharging: s0, s3, s5 */
+	{{LED_WHITE, 0}, {LED_WHITE, ALTERNATE(BLINK(10))}, {LED_OFF, 0}},
+	/* charging: s0, s3, s5 */
+	{{LED_WHITE, 0}, {LED_WHITE, ALTERNATE(BLINK(10))}, {LED_OFF, 0}},
+	/* full: s0, s3, s5 */
+	{{LED_WHITE, 0}, {LED_WHITE, ALTERNATE(BLINK(10))}, {LED_OFF, 0}},
+};
+
+/*
+ * Akali - battery LED
+ * Charge:           Amber on (s0/s3/s5)
+ * Full:             Blue on (s0/s3/s5)
+ * Discharge in S0:  Blue on
+ * Discharge in S3:  Amber on 1 sec off 3 sec
+ * Discharge in S5:  Off
+ * Battery Error:    Amber on 1sec off 1sec
+ * Factory mode :    Blue on 2sec, Amber on 2sec
+ */
+const static led_patterns battery_pattern_3 = {
+	/* discharging: s0, s3, s5 */
+	{{LED_WHITE, 0}, {LED_AMBER, ALTERNATE(BLINK(10))}, {LED_OFF, 0}},
+	/* charging: s0, s3, s5 */
+	{{LED_AMBER, PULSE_NO}, {LED_AMBER, PULSE_NO}, {LED_AMBER,  PULSE_NO}},
+	/* full: s0, s3, s5 */
+	{{LED_WHITE, PULSE_NO}, {LED_WHITE, PULSE_NO}, {LED_WHITE,  PULSE_NO}},
+};
+
+const static led_patterns battery_pattern_4 = {
+	/* discharging: s0, s3, s5 */
+	{{LED_WHITE, PULSE_NO}, {LED_WHITE, BLINK(10)}, {LED_OFF, PULSE_NO}},
+	/* charging: s0, s3, s5 */
+	{{LED_AMBER, PULSE_NO}, {LED_AMBER, PULSE_NO},  {LED_AMBER, PULSE_NO}},
+	/* full: s0, s3, s5 */
+	{{LED_WHITE, PULSE_NO}, {LED_WHITE, PULSE_NO},  {LED_WHITE, PULSE_NO}},
+};
+
+/* Patterns for battery LED and power LED. Initialized at run-time. */
+static led_patterns const *patterns[2];
+/* Pattern for battery error. Only blinking battery LED is supported. */
+static struct led_pattern battery_error = {LED_AMBER, BLINK(10)};
+/* Pattern for low state of charge. Only battery LED is supported. */
+static struct led_pattern low_battery = {LED_WHITE, BLINK(10)};
+/* Pattern for factory mode. Blinking 2-color battery LED. */
+static struct led_pattern battery_factory = {LED_FACTORY, BLINK(20)};
+static int low_battery_soc;
+static void led_charge_hook(void);
+static enum led_power_state power_state;
+
+static void led_init(void)
+{
+	uint32_t oem = PROJECT_NAMI;
+
+	cbi_get_oem_id(&oem);
+
+	switch (oem) {
+	case PROJECT_NAMI:
+	case PROJECT_VAYNE:
+		patterns[0] = &battery_pattern_0;
+		break;
+	case PROJECT_SONA:
+		if (model == MODEL_SYNDRA) {
+			/* Syndra doesn't have power LED */
+			patterns[0] = &battery_pattern_4;
+		} else {
+			patterns[0] = &battery_pattern_1;
+			patterns[1] = &power_pattern_1;
+		}
+		battery_error.pulse = BLINK(5);
+		low_battery_soc = 100;
+		break;
+	case PROJECT_PANTHEON:
+		patterns[0] = &battery_pattern_2;
+		patterns[1] = &power_pattern_2;
+		battery_error.color = LED_OFF;
+		battery_error.pulse = 0;
+		break;
+	case PROJECT_AKALI:
+		patterns[0] = &battery_pattern_3;
+		break;
+	default:
+		break;
+	}
+
+	pwm_enable(PWM_CH_LED1, 1);
+	pwm_enable(PWM_CH_LED2, 1);
+
+	/* After sysjump, power_state is cleared. Thus, we need to actively
+	 * retrieve it. */
+	if (chipset_in_state(CHIPSET_STATE_ANY_OFF))
+		power_state = LED_STATE_S5;
+	else if (chipset_in_state(CHIPSET_STATE_ANY_SUSPEND))
+		power_state = LED_STATE_S3;
+	else
+		power_state = LED_STATE_S0;
+}
+DECLARE_HOOK(HOOK_INIT, led_init, HOOK_PRIO_DEFAULT);
+
+static int set_color_battery(enum led_color color, int duty)
+{
+	int led1 = 0;
+	int led2 = 0;
+
+	if (duty < 0 || 100 < duty)
+		return EC_ERROR_UNKNOWN;
+
+	switch (color) {
+	case LED_OFF:
+		break;
+	case LED_AMBER:
+		led2 = 1;
+		break;
+	case LED_WHITE:
+		led1 = 1;
+		break;
+	case LED_WARM_WHITE:
+		led1 = 1;
+		led2 = 1;
+		break;
+	case LED_FACTORY:
+		break;
+	default:
+		return EC_ERROR_UNKNOWN;
+	}
+
+	if (color != LED_FACTORY) {
+		pwm_set_duty(PWM_CH_LED1, led1 ? duty : 0);
+		pwm_set_duty(PWM_CH_LED2, led2 ? duty : 0);
+	} else {
+		pwm_set_duty(PWM_CH_LED1, duty ? 100 : 0);
+		pwm_set_duty(PWM_CH_LED2, duty ? 0 : 100);
+	}
+
+	return EC_SUCCESS;
+}
+
+static int set_color_power(enum led_color color, int duty)
+{
+	if (color == LED_OFF)
+		duty = 0;
+	gpio_set_level(GPIO_LED1, !duty /* Reversed logic */);
+	return EC_SUCCESS;
+}
+
+static int set_color(enum ec_led_id id, enum led_color color, int duty)
+{
+	switch (id) {
+	case EC_LED_ID_BATTERY_LED:
+		return set_color_battery(color, duty);
+	case EC_LED_ID_POWER_LED:
+		return set_color_power(color, duty);
+	default:
+		return EC_ERROR_UNKNOWN;
+	}
+}
+
+static struct {
+	uint32_t interval;
+	int duty_inc;
+	enum led_color color;
+	int duty;
+	int alternate;
+	uint8_t pulse;
+} tick[2];
+
+static void tick_battery(void);
+DECLARE_DEFERRED(tick_battery);
+static void tick_power(void);
+DECLARE_DEFERRED(tick_power);
+static void cancel_tick(enum ec_led_id id)
+{
+	if (id == EC_LED_ID_BATTERY_LED)
+		hook_call_deferred(&tick_battery_data, -1);
+	else
+		hook_call_deferred(&tick_power_data, -1);
+}
+
+static int config_tick(enum ec_led_id id, const struct led_pattern *pattern)
+{
+	static const struct led_pattern *patterns[2];
+	uint32_t stride;
+
+	if (pattern == patterns[id])
+		/* This pattern was already set */
+		return -1;
+
+	patterns[id] = pattern;
+
+	if (!pattern->pulse) {
+		/* This is a steady pattern. cancel the tick */
+		cancel_tick(id);
+		set_color(id, pattern->color, 100);
+		return 1;
+	}
+
+	stride = PULSE_INTERVAL(pattern->pulse);
+	if (IS_PULSING(pattern->pulse)) {
+		tick[id].interval = LED_PULSE_TICK_US;
+		tick[id].duty_inc = 100 / (stride / LED_PULSE_TICK_US);
+	} else {
+		tick[id].interval = stride;
+		tick[id].duty_inc = 100;
+	}
+	tick[id].color = pattern->color;
+	tick[id].duty = 0;
+	tick[id].alternate = 0;
+	tick[id].pulse = pattern->pulse;
+
+	return 0;
+}
+
+/*
+ * When pulsing, brightness is incremented by <duty_inc> every <interval> usec
+ * from 0 to 100%. Then it's decremented from 100% to 0.
+ */
+static void pulse_led(enum ec_led_id id)
+{
+	if (tick[id].duty + tick[id].duty_inc > 100) {
+		tick[id].duty_inc = tick[id].duty_inc * -1;
+	} else if (tick[id].duty + tick[id].duty_inc < 0) {
+		if (IS_ALTERNATE(tick[id].pulse)) {
+			/* Falling phase landing. Flip the alternate flag. */
+			tick[id].alternate = !tick[id].alternate;
+			if (tick[id].alternate)
+				return;
+		}
+		tick[id].duty_inc = tick[id].duty_inc * -1;
+	}
+	tick[id].duty += tick[id].duty_inc;
+	set_color(id, tick[id].color, tick[id].duty);
+}
+
+static uint32_t tick_led(enum ec_led_id id)
+{
+	uint32_t elapsed;
+	uint32_t start = get_time().le.lo;
+	uint32_t next;
+
+	if (led_auto_control_is_enabled(id))
+		pulse_led(id);
+	if (tick[id].alternate)
+		/* Skip 2 phases (rising & falling) */
+		next = PULSE_INTERVAL(tick[id].pulse) * 2;
+	else
+		next = tick[id].interval;
+	elapsed = get_time().le.lo - start;
+	return next > elapsed ? next - elapsed : 0;
+}
+
+static void tick_battery(void)
+{
+	hook_call_deferred(&tick_battery_data, tick_led(EC_LED_ID_BATTERY_LED));
+}
+
+static void tick_power(void)
+{
+	hook_call_deferred(&tick_power_data, tick_led(EC_LED_ID_POWER_LED));
+}
+
+static void start_tick(enum ec_led_id id, const struct led_pattern *pattern)
+{
+	if (config_tick(id, pattern))
+		/*
+		 * If this pattern is already active, ticking must have started
+		 * already. So, we don't re-start ticking to prevent LED from
+		 * blinking at every SOC change.
+		 *
+		 * If this pattern is static, we skip ticking as well.
+		 */
+		return;
+
+	if (id == EC_LED_ID_BATTERY_LED)
+		tick_battery();
+	else
+		tick_power();
+}
+
+static void led_alert(int enable)
+{
+	if (enable)
+		start_tick(EC_LED_ID_BATTERY_LED, &battery_error);
+	else
+		led_charge_hook();
+}
+
+static void led_factory(int enable)
+{
+	if (enable)
+		start_tick(EC_LED_ID_BATTERY_LED, &battery_factory);
+	else
+		led_charge_hook();
+}
+
+void config_led(enum ec_led_id id, enum led_charge_state charge)
+{
+	const led_patterns *pattern;
+
+	pattern = patterns[id];
+	if (!pattern)
+		return;	/* This LED isn't present */
+
+	start_tick(id, &(*pattern)[charge][power_state]);
+}
+
+void config_leds(enum led_charge_state charge)
+{
+	config_led(EC_LED_ID_BATTERY_LED, charge);
+	config_led(EC_LED_ID_POWER_LED, charge);
+}
+
+static void call_handler(void)
+{
+	int soc;
+	enum charge_state cs;
+
+	if (!led_auto_control_is_enabled(EC_LED_ID_BATTERY_LED))
+		return;
+
+	cs = charge_get_state();
+	soc = charge_get_display_charge();
+	if (soc < 0)
+		cs = PWR_STATE_ERROR;
+
+	switch (cs) {
+	case PWR_STATE_DISCHARGE:
+	case PWR_STATE_DISCHARGE_FULL:
+		if (soc < low_battery_soc)
+			start_tick(EC_LED_ID_BATTERY_LED, &low_battery);
+		else
+			config_led(EC_LED_ID_BATTERY_LED, LED_STATE_DISCHARGE);
+		config_led(EC_LED_ID_POWER_LED, LED_STATE_DISCHARGE);
+		break;
+	case PWR_STATE_CHARGE_NEAR_FULL:
+	case PWR_STATE_CHARGE:
+		if (soc >= 1000)
+			config_leds(LED_STATE_FULL);
+		else
+			config_leds(LED_STATE_CHARGE);
+		break;
+	case PWR_STATE_ERROR:
+		/* It doesn't matter what 'charge' state we pass because power
+		 * LED (if it exists) is orthogonal to battery state. */
+		config_led(EC_LED_ID_POWER_LED, 0);
+		led_alert(1);
+		break;
+	case PWR_STATE_IDLE:
+		/* External power connected in IDLE. This is also used to show
+		 * factory mode when 'ectool chargecontrol idle' is run during
+		 * factory process. */
+		if (charge_get_flags() & CHARGE_FLAG_FORCE_IDLE)
+			led_factory(1);
+		break;
+	default:
+		;
+	}
+}
+
+/* LED state transition handlers */
+static void s0(void)
+{
+	power_state = LED_STATE_S0;
+	call_handler();
+}
+DECLARE_HOOK(HOOK_CHIPSET_RESUME, s0, HOOK_PRIO_DEFAULT);
+DECLARE_HOOK(HOOK_CHIPSET_STARTUP, s0, HOOK_PRIO_DEFAULT);
+
+static void s3(void)
+{
+	power_state = LED_STATE_S3;
+	call_handler();
+}
+DECLARE_HOOK(HOOK_CHIPSET_SUSPEND, s3, HOOK_PRIO_DEFAULT);
+
+static void s5(void)
+{
+	power_state = LED_STATE_S5;
+	call_handler();
+}
+DECLARE_HOOK(HOOK_CHIPSET_SHUTDOWN, s5, HOOK_PRIO_DEFAULT);
+
+static void led_charge_hook(void)
+{
+	call_handler();
+}
+DECLARE_HOOK(HOOK_BATTERY_SOC_CHANGE, led_charge_hook, HOOK_PRIO_DEFAULT);
+
+static void print_config(enum ec_led_id id)
+{
+	ccprintf("ID:%d\n", id);
+	ccprintf("  Color:%d\n", tick[id].color);
+	ccprintf("  Duty:%d\n", tick[id].duty);
+	ccprintf("  Duty Increment:%d\n", tick[id].duty_inc);
+	ccprintf("  Interval:%d\n", tick[id].interval);
+}
+
+static int command_led(int argc, char **argv)
+{
+	enum ec_led_id id = EC_LED_ID_BATTERY_LED;
+	static int alert = 0;
+	static int factory;
+
+	if (argc < 2)
+		return EC_ERROR_PARAM_COUNT;
+
+	if (!strcasecmp(argv[1], "debug")) {
+		led_auto_control(id, !led_auto_control_is_enabled(id));
+		ccprintf("o%s\n", led_auto_control_is_enabled(id) ? "ff" : "n");
+	} else if (!strcasecmp(argv[1], "off")) {
+		set_color(id, LED_OFF, 0);
+	} else if (!strcasecmp(argv[1], "red")) {
+		set_color(id, LED_RED, 100);
+	} else if (!strcasecmp(argv[1], "white")) {
+		set_color(id, LED_WHITE, 100);
+	} else if (!strcasecmp(argv[1], "amber")) {
+		set_color(id, LED_AMBER, 100);
+	} else if (!strcasecmp(argv[1], "alert")) {
+		alert = !alert;
+		led_alert(alert);
+	} else if (!strcasecmp(argv[1], "s0")) {
+		s0();
+	} else if (!strcasecmp(argv[1], "s3")) {
+		s3();
+	} else if (!strcasecmp(argv[1], "s5")) {
+		s5();
+	} else if (!strcasecmp(argv[1], "conf")) {
+		print_config(id);
+	} else if (!strcasecmp(argv[1], "factory")) {
+		factory = !factory;
+		led_factory(factory);
+	} else {
+		return EC_ERROR_PARAM1;
+	}
+	return EC_SUCCESS;
+}
+DECLARE_CONSOLE_COMMAND(led, command_led,
+			"[debug|red|green|amber|off|alert|s0|s3|s5|conf|factory]",
+			"Turn on/off LED.");
+
+void led_get_brightness_range(enum ec_led_id led_id, uint8_t *brightness_range)
+{
+	/*
+	 * We return amber=100, white=100 regardless of OEM ID or led_id. This
+	 * function is for ectool led command, which is used to test LED
+	 * functionality.
+	 */
+	brightness_range[EC_LED_COLOR_AMBER] = 100;
+	brightness_range[EC_LED_COLOR_WHITE] = 100;
+}
+
+int led_set_brightness(enum ec_led_id id, const uint8_t *brightness)
+{
+	if (brightness[EC_LED_COLOR_AMBER])
+		return set_color(id, LED_AMBER, brightness[EC_LED_COLOR_AMBER]);
+	else if (brightness[EC_LED_COLOR_WHITE])
+		return set_color(id, LED_WHITE, brightness[EC_LED_COLOR_WHITE]);
+	else
+		return set_color(id, LED_OFF, 0);
+}