/* Copyright 2017 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. */ /* * Microchip Evaluation Board(EVB) with * MEC1701H 144-pin processor card. * EVB connected to Intel SKL RVP3 configured * for eSPI with Kabylake silicon. */ #include "adc.h" #include "adc_chip.h" #include "als.h" #include "bd99992gw.h" #include "button.h" #include "charge_manager.h" #include "charge_state.h" #include "charger.h" #include "chipset.h" #include "console.h" #include "driver/als_opt3001.h" #include "driver/accel_kionix.h" #include "driver/accel_kx022.h" #include "driver/accelgyro_bmi160.h" #include "driver/tcpm/tcpci.h" #include "extpower.h" #include "gpio_chip.h" #include "gpio.h" #include "hooks.h" #include "host_command.h" #include "i2c.h" #include "espi.h" #include "lpc_chip.h" #include "keyboard_scan.h" #include "lid_switch.h" #include "math_util.h" #include "motion_sense.h" #include "motion_lid.h" #include "pi3usb9281.h" #include "power.h" #include "power_button.h" #include "spi.h" #include "spi_chip.h" #include "switch.h" #include "system.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 "battery_smart.h" /* Console output macros */ #define CPUTS(outstr) cputs(CC_LPC, outstr) #define CPRINTS(format, args...) cprints(CC_USBCHARGE, format, ## args) #define CPRINTF(format, args...) cprintf(CC_USBCHARGE, format, ## args) /* NOTE: MEC17xx EVB + SKL RVP3 does not use BD99992 PMIC. * RVP3 PMIC controlled by RVP3 logic. */ #define I2C_ADDR_BD99992 0x60 /* * Maxim DS1624 I2C temperature sensor used for testing I2C. * DS1624 contains one internal temperature sensor * and EEPROM. It has no external temperature inputs. */ #define DS1624_I2C_ADDR 0x90 /* 7-bit address is 0x48 */ #define DS1624_IDX_LOCAL 0 #define DS1624_READ_TEMP16 0xAA /* read 16-bit temperature */ #define DS1624_ACCESS_CFG 0xAC /* read/write 8-bit config */ #define DS1624_CMD_START 0xEE #define DS1624_CMD_STOP 0x22 /* * static global and routine to return smart battery * temperature when we do not build with charger task. */ static int smart_batt_temp; static int ds1624_temp; static int sb_temp(int idx, int *temp_ptr); static int ds1624_get_val(int idx, int *temp_ptr); #ifdef HAS_TASK_MOTIONSENSE static void board_spi_enable(void); static void board_spi_disable(void); #endif #ifdef CONFIG_BOARD_PRE_INIT /* * Used to enable JTAG debug during development. * NOTE: If ARM Serial Wire Viewer not used then SWV pin can be * be disabled and used for another purpose. Change mode to * MCHP_JTAG_MODE_SWD. * For low power idle testing enable GPIO060 as function 2(48MHZ_OUT) * to check PLL is turning off in heavy sleep. Note, do not put GPIO060 * in gpio.inc * GPIO060 is port 1 bit[16]. */ void board_config_pre_init(void) { smart_batt_temp = 0; ds1624_temp = 0; #ifdef CONFIG_CHIPSET_DEBUG MCHP_EC_JTAG_EN = MCHP_JTAG_ENABLE + MCHP_JTAG_MODE_SWD_SWV; #endif #if defined(CONFIG_LOW_POWER_IDLE) && defined(CONFIG_MCHP_48MHZ_OUT) gpio_set_alternate_function(1, 0x10000, 2); #endif } #endif /* #ifdef CONFIG_BOARD_PRE_INIT */ /* * Use EC to handle ALL_SYS_PWRGD signal. * MEC17xx connected to SKL/KBL RVP3 reference board * is required to monitor ALL_SYS_PWRGD and drive SYS_RESET_L * after a 10 to 100 ms delay. */ #ifdef CONFIG_BOARD_EC_HANDLES_ALL_SYS_PWRGD static void board_all_sys_pwrgd(void) { int allsys_in = gpio_get_level(GPIO_ALL_SYS_PWRGD); int allsys_out = gpio_get_level(GPIO_SYS_RESET_L); if (allsys_in == allsys_out) return; CPRINTS("ALL_SYS_PWRGD=%d SYS_RESET_L=%d", allsys_in, allsys_out); trace2(0, BRD, 0, "ALL_SYS_PWRGD=%d SYS_RESET_L=%d", allsys_in, allsys_out); /* * Wait at least 10 ms between power signals going high */ if (allsys_in) msleep(100); if (!allsys_out) { /* CPRINTS("Set SYS_RESET_L = %d", allsys_in); */ trace1(0, BRD, 0, "Set SYS_RESET_L=%d", allsys_in); gpio_set_level(GPIO_SYS_RESET_L, allsys_in); /* Force fan on for kabylake RVP */ gpio_set_level(GPIO_EC_FAN1_PWM, 1); } } DECLARE_DEFERRED(board_all_sys_pwrgd); void all_sys_pwrgd_interrupt(enum gpio_signal signal) { trace0(0, ISR, 0, "ALL_SYS_PWRGD Edge"); hook_call_deferred(&board_all_sys_pwrgd_data, 0); } #endif /* #ifdef CONFIG_BOARD_HAS_ALL_SYS_PWRGD */ #ifdef HAS_TASK_PDCMD /* Exchange status with PD MCU. */ static void pd_mcu_interrupt(enum gpio_signal signal) { /* Exchange status with PD MCU to determine interrupt cause */ host_command_pd_send_status(0); } #endif #ifdef CONFIG_USB_POWER_DELIVERY void vbus0_evt(enum gpio_signal signal) { /* VBUS present GPIO is inverted */ usb_charger_vbus_change(0, !gpio_get_level(signal)); task_wake(TASK_ID_PD_C0); } void vbus1_evt(enum gpio_signal signal) { /* VBUS present GPIO is inverted */ usb_charger_vbus_change(1, !gpio_get_level(signal)); task_wake(TASK_ID_PD_C1); } void usb0_evt(enum gpio_signal signal) { task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0); } void usb1_evt(enum gpio_signal signal) { task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12, 0); } #endif /* * enable_input_devices() is called by the tablet_mode ISR, but changes the * state of GPIOs, so its definition must reside after including gpio_list. */ static void enable_input_devices(void); DECLARE_DEFERRED(enable_input_devices); void tablet_mode_interrupt(enum gpio_signal signal) { hook_call_deferred(&enable_input_devices_data, 0); } #include "gpio_list.h" /* power signal list. Must match order of enum power_signal. */ const struct power_signal_info power_signal_list[] = { {GPIO_RSMRST_L_PGOOD, POWER_SIGNAL_ACTIVE_HIGH, "RSMRST_N_PWRGD"}, {VW_SLP_S3_L, POWER_SIGNAL_ACTIVE_HIGH, "SLP_S3_DEASSERTED"}, {VW_SLP_S4_L, POWER_SIGNAL_ACTIVE_HIGH, "SLP_S4_DEASSERTED"}, {GPIO_PCH_SLP_SUS_L, POWER_SIGNAL_ACTIVE_HIGH, "SLP_SUS_DEASSERTED"}, {GPIO_PMIC_DPWROK, POWER_SIGNAL_ACTIVE_HIGH, "PMIC_DPWROK"}, {GPIO_ALL_SYS_PWRGD, POWER_SIGNAL_ACTIVE_HIGH, "ALL_SYS_PWRGD"} }; BUILD_ASSERT(ARRAY_SIZE(power_signal_list) == POWER_SIGNAL_COUNT); /* ADC channels * name, factor multiplier, factor divider, shift, channel */ const struct adc_t adc_channels[] = { /* Vbus sensing. Converted to mV, full ADC is equivalent to 30V. */ [ADC_VBUS] = {"VBUS", 30000, 1024, 0, 1}, /* Adapter current output or battery discharging current */ [ADC_AMON_BMON] = {"AMON_BMON", 25000, 3072, 0, 3}, /* System current consumption */ [ADC_PSYS] = {"PSYS", 1, 1, 0, 4}, [ADC_CASE] = {"CASE", 1, 1, 0, 7}, }; BUILD_ASSERT(ARRAY_SIZE(adc_channels) == ADC_CH_COUNT); /* * MCHP EVB connected to KBL RVP3 */ const struct i2c_port_t i2c_ports[] = { {"sensors", MCHP_I2C_PORT4, 100, GPIO_SMB04_SCL, GPIO_SMB04_SDA}, {"batt", MCHP_I2C_PORT5, 100, GPIO_SMB05_SCL, GPIO_SMB05_SDA}, }; const unsigned int i2c_ports_used = ARRAY_SIZE(i2c_ports); /* * Map ports to controller. * Ports may map to the same controller. */ const uint16_t i2c_port_to_ctrl[I2C_PORT_COUNT] = { (MCHP_I2C_CTRL0 << 8) + MCHP_I2C_PORT4, (MCHP_I2C_CTRL1 << 8) + MCHP_I2C_PORT5 }; /* * default to I2C0 because callers may not check * return value if we returned an error code. */ int board_i2c_p2c(int port) { int i; for (i = 0; i < I2C_PORT_COUNT; i++) if ((i2c_port_to_ctrl[i] & 0xFF) == port) return (int)(i2c_port_to_ctrl[i] >> 8); return -1; } #ifdef CONFIG_USB_POWER_DELIVERY const struct tcpc_config_t tcpc_config[CONFIG_USB_PD_PORT_COUNT] = { {I2C_PORT_TCPC, CONFIG_TCPC_I2C_BASE_ADDR, &tcpci_tcpm_drv}, {I2C_PORT_TCPC, CONFIG_TCPC_I2C_BASE_ADDR + 2, &tcpci_tcpm_drv}, }; #endif const uint32_t i2c_ctrl_slave_addrs[I2C_CONTROLLER_COUNT] = { #ifdef CONFIG_BOARD_MCHP_I2C0_SLAVE_ADDRS (MCHP_I2C_CTRL0 + (CONFIG_BOARD_MCHP_I2C0_SLAVE_ADDRS << 16)), #else (MCHP_I2C_CTRL0 + (CONFIG_MCHP_I2C0_SLAVE_ADDRS << 16)), #endif #ifdef CONFIG_BOARD_MCHP_I2C1_SLAVE_ADDRS (MCHP_I2C_CTRL1 + (CONFIG_BOARD_MCHP_I2C1_SLAVE_ADDRS << 16)), #else (MCHP_I2C_CTRL1 + (CONFIG_MCHP_I2C1_SLAVE_ADDRS << 16)), #endif }; /* Return the two slave addresses the specified * controller will respond to when controller * is acting as a slave. * b[6:0] = b[7:1] of I2C address 1 * b[14:8] = b[7:1] of I2C address 2 * When not using I2C controllers as slaves we can use * the same value for all controllers. The address should * not be 0x00 as this is the general call address. */ uint16_t board_i2c_slave_addrs(int controller) { int i; for (i = 0; i < I2C_CONTROLLER_COUNT; i++) if ((i2c_ctrl_slave_addrs[i] & 0xffff) == controller) return (i2c_ctrl_slave_addrs[i] >> 16); return CONFIG_MCHP_I2C0_SLAVE_ADDRS; } /* SPI devices */ const struct spi_device_t spi_devices[] = { { QMSPI0_PORT, 4, GPIO_QMSPI_CS0}, #if defined(CONFIG_SPI_ACCEL_PORT) { GPSPI0_PORT, 2, GPIO_SPI0_CS0 }, #endif }; const unsigned int spi_devices_used = ARRAY_SIZE(spi_devices); const enum gpio_signal hibernate_wake_pins[] = { GPIO_AC_PRESENT, GPIO_LID_OPEN, GPIO_POWER_BUTTON_L, }; const int hibernate_wake_pins_used = ARRAY_SIZE(hibernate_wake_pins); /* * Deep sleep support, called by chip level. */ #if defined(CONFIG_LOW_POWER_IDLE) && defined(CONFIG_BOARD_DEEP_SLEEP) /* * Perform any board level prepare for sleep actions. * For example, disabling pin/pads to further reduce * current during sleep. */ void board_prepare_for_deep_sleep(void) { #if defined(CONFIG_GPIO_POWER_DOWN) && \ defined(CONFIG_MCHP_DEEP_SLP_GPIO_PWR_DOWN) gpio_power_down_module(MODULE_SPI_FLASH); gpio_power_down_module(MODULE_SPI_MASTER); gpio_power_down_module(MODULE_I2C); /* powering down keyscan is causing an issue with keyscan task * probably due to spurious interrupts on keyscan pins. * gpio_config_module(MODULE_KEYBOARD_SCAN, 0); */ #ifndef CONFIG_POWER_S0IX gpio_power_down_module(MODULE_LPC); #endif #endif } /* * Perform any board level resume from sleep actions. * For example, re-enabling pins powered off in * board_prepare_for_deep_sleep(). */ void board_resume_from_deep_sleep(void) { #if defined(CONFIG_GPIO_POWER_DOWN) && \ defined(CONFIG_MCHP_DEEP_SLP_GPIO_PWR_DOWN) #ifndef CONFIG_POWER_S0IX gpio_config_module(MODULE_LPC, 1); #endif /* gpio_config_module(MODULE_KEYBOARD_SCAN, 1); */ gpio_config_module(MODULE_SPI_FLASH, 1); gpio_config_module(MODULE_SPI_MASTER, 1); gpio_config_module(MODULE_I2C, 1); #endif } #endif #ifdef CONFIG_USB_MUX_PI3USB30532 struct pi3usb9281_config pi3usb9281_chips[] = { { .i2c_port = I2C_PORT_USB_CHARGER_1, .mux_lock = NULL, }, { .i2c_port = I2C_PORT_USB_CHARGER_2, .mux_lock = NULL, }, }; BUILD_ASSERT(ARRAY_SIZE(pi3usb9281_chips) == CONFIG_BC12_DETECT_PI3USB9281_CHIP_COUNT); struct usb_mux usb_muxes[CONFIG_USB_PD_PORT_COUNT] = { { .port_addr = 0xa8, .driver = &pi3usb30532_usb_mux_driver, }, { .port_addr = 0x20, .driver = &ps874x_usb_mux_driver, } }; #endif /** * Reset PD MCU */ void board_reset_pd_mcu(void) { gpio_set_level(GPIO_PD_RST_L, 0); usleep(100); gpio_set_level(GPIO_PD_RST_L, 1); } /* * */ static int therm_get_val(int idx, int *temp_ptr) { if (temp_ptr != NULL) { *temp_ptr = adc_read_channel(idx); return EC_SUCCESS; } return EC_ERROR_PARAM2; } #ifdef CONFIG_TEMP_SENSOR #if 0 /* Chromebook design uses ADC in BD99992GW PMIC */ const struct temp_sensor_t temp_sensors[] = { {"Battery", TEMP_SENSOR_TYPE_BATTERY, charge_get_battery_temp, 0, 4}, /* These BD99992GW temp sensors are only readable in S0 */ {"Ambient", TEMP_SENSOR_TYPE_BOARD, bd99992gw_get_val, BD99992GW_ADC_CHANNEL_SYSTHERM0, 4}, {"Charger", TEMP_SENSOR_TYPE_BOARD, bd99992gw_get_val, BD99992GW_ADC_CHANNEL_SYSTHERM1, 4}, {"DRAM", TEMP_SENSOR_TYPE_BOARD, bd99992gw_get_val, BD99992GW_ADC_CHANNEL_SYSTHERM2, 4}, {"Wifi", TEMP_SENSOR_TYPE_BOARD, bd99992gw_get_val, BD99992GW_ADC_CHANNEL_SYSTHERM3, 4}, }; BUILD_ASSERT(ARRAY_SIZE(temp_sensors) == TEMP_SENSOR_COUNT); #else /* mec1701_evb test I2C and EC ADC */ /* * battery charge_get_battery_temp requires CONFIG_CHARGER_V2 and * charger task running. * OR can we call into driver/battery/smart.c * int sb_read(int cmd, int *param) * sb_read(SB_TEMPERATURE, &batt_new.temperature) * Issue is functions in this table return a value from a memory array. * There's a task or hook that is actually reading the temperature. * We could implement a one second hook to call sb_read() and fill in * a static global in this module. */ const struct temp_sensor_t temp_sensors[] = { {"Battery", TEMP_SENSOR_TYPE_BATTERY, sb_temp, 0, 4}, {"Ambient", TEMP_SENSOR_TYPE_BOARD, ds1624_get_val, 0, 4}, {"Case", TEMP_SENSOR_TYPE_CASE, therm_get_val, (int)ADC_CASE, 4}, }; BUILD_ASSERT(ARRAY_SIZE(temp_sensors) == TEMP_SENSOR_COUNT); #endif #endif #ifdef CONFIG_ALS /* ALS instances. Must be in same order as enum als_id. */ struct als_t als[] = { {"TI", opt3001_init, opt3001_read_lux, 5}, }; BUILD_ASSERT(ARRAY_SIZE(als) == ALS_COUNT); #endif const struct button_config buttons[CONFIG_BUTTON_COUNT] = { {"Volume Down", KEYBOARD_BUTTON_VOLUME_DOWN, GPIO_VOLUME_DOWN_L, 30 * MSEC, 0}, {"Volume Up", KEYBOARD_BUTTON_VOLUME_UP, GPIO_VOLUME_UP_L, 30 * MSEC, 0}, }; /* MCHP mec1701_evb connected to Intel SKL RVP3 with Kabylake * processor we do not control the PMIC on SKL. */ static void board_pmic_init(void) { int rv, cfg; /* No need to re-init PMIC since settings are sticky across sysjump */ if (system_jumped_to_this_image()) return; #if 0 /* BD99992GW PMIC on a real Chromebook */ /* Set CSDECAYEN / VCCIO decays to 0V at assertion of SLP_S0# */ i2c_write8(I2C_PORT_PMIC, I2C_ADDR_BD99992, 0x30, 0x4a); /* * Set V100ACNT / V1.00A Control Register: * Nominal output = 1.0V. */ i2c_write8(I2C_PORT_PMIC, I2C_ADDR_BD99992, 0x37, 0x1a); /* * Set V085ACNT / V0.85A Control Register: * Lower power mode = 0.7V. * Nominal output = 1.0V. */ i2c_write8(I2C_PORT_PMIC, I2C_ADDR_BD99992, 0x38, 0x7a); /* VRMODECTRL - enable low-power mode for VCCIO and V0.85A */ i2c_write8(I2C_PORT_PMIC, I2C_ADDR_BD99992, 0x3b, 0x18); #else CPRINTS("HOOK_INIT - called board_pmic_init"); trace0(0, HOOK, 0, "HOOK_INIT - call board_pmic_init"); /* Config DS1624 temperature sensor for continuous conversion */ cfg = 0x66; rv = i2c_read8(I2C_PORT_THERMAL, DS1624_I2C_ADDR, DS1624_ACCESS_CFG, &cfg); trace2(0, BRD, 0, "Read DS1624 Config rv = %d cfg = 0x%02X", rv, cfg); if ((rv == EC_SUCCESS) && (cfg & (1u << 0))) { /* one-shot mode switch to continuous */ rv = i2c_write8(I2C_PORT_THERMAL, DS1624_I2C_ADDR, DS1624_ACCESS_CFG, 0); trace1(0, BRD, 0, "Write DS1624 Config to 0, rv = %d", rv); /* writes to config require 10ms until next I2C command */ if (rv == EC_SUCCESS) udelay(10000); } /* Send start command */ rv = i2c_write8(I2C_PORT_THERMAL, DS1624_I2C_ADDR, DS1624_CMD_START, 1); trace1(0, BRD, 0, "Send Start command to DS1624 rv = %d", rv); return; #endif } DECLARE_HOOK(HOOK_INIT, board_pmic_init, HOOK_PRIO_DEFAULT); /* Initialize board. */ static void board_init(void) { CPRINTS("MEC1701 HOOK_INIT - called board_init"); trace0(0, HOOK, 0, "HOOK_INIT - call board_init"); #ifdef CONFIG_USB_POWER_DELIVERY /* Enable PD MCU interrupt */ gpio_enable_interrupt(GPIO_PD_MCU_INT); /* Enable VBUS interrupt */ gpio_enable_interrupt(GPIO_USB_C0_VBUS_WAKE_L); gpio_enable_interrupt(GPIO_USB_C1_VBUS_WAKE_L); /* Enable pericom BC1.2 interrupts */ gpio_enable_interrupt(GPIO_USB_C0_BC12_INT_L); gpio_enable_interrupt(GPIO_USB_C1_BC12_INT_L); #endif /* Enable tablet mode interrupt for input device enable */ gpio_enable_interrupt(GPIO_TABLET_MODE_L); /* Provide AC status to the PCH */ gpio_set_level(GPIO_PCH_ACOK, extpower_is_present()); #ifdef HAS_TASK_MOTIONSENSE if (system_jumped_to_this_image() && chipset_in_state(CHIPSET_STATE_ON)) { trace0(0, BRD, 0, "board_init: S0 call board_spi_enable"); board_spi_enable(); } #endif } DECLARE_HOOK(HOOK_INIT, board_init, HOOK_PRIO_DEFAULT); /** * Buffer the AC present GPIO to the PCH. */ static void board_extpower(void) { CPRINTS("MEC1701 HOOK_AC_CHANGE - called board_extpower"); trace0(0, HOOK, 0, "HOOK_AC_CHANGET - call board_extpower"); gpio_set_level(GPIO_PCH_ACOK, extpower_is_present()); } DECLARE_HOOK(HOOK_AC_CHANGE, board_extpower, HOOK_PRIO_DEFAULT); #ifdef CONFIG_CHARGER /** * Set active charge port -- only one port can be active at a time. * * @param charge_port Charge port to enable. * * Returns EC_SUCCESS if charge port is accepted and made active, * EC_ERROR_* otherwise. */ int board_set_active_charge_port(int charge_port) { /* charge port is a realy physical port */ int is_real_port = (charge_port >= 0 && charge_port < CONFIG_USB_PD_PORT_COUNT); /* check if we are source vbus on that port */ int source = gpio_get_level(charge_port == 0 ? GPIO_USB_C0_5V_EN : GPIO_USB_C1_5V_EN); if (is_real_port && source) { CPRINTS("MEC1701 Skip enable p%d", charge_port); trace1(0, BOARD, 0, "Skip enable charge port %d", charge_port); return EC_ERROR_INVAL; } CPRINTS("MEC1701 New chg p%d", charge_port); trace1(0, BOARD, 0, "New charge port %d", charge_port); if (charge_port == CHARGE_PORT_NONE) { /* Disable both ports */ gpio_set_level(GPIO_USB_C0_CHARGE_EN_L, 1); gpio_set_level(GPIO_USB_C1_CHARGE_EN_L, 1); } else { /* Make sure non-charging port is disabled */ gpio_set_level(charge_port ? GPIO_USB_C0_CHARGE_EN_L : GPIO_USB_C1_CHARGE_EN_L, 1); /* Enable charging port */ gpio_set_level(charge_port ? GPIO_USB_C1_CHARGE_EN_L : GPIO_USB_C0_CHARGE_EN_L, 0); } return EC_SUCCESS; } /** * Set the charge limit based upon desired maximum. * * @param port Port number. * @param supplier Charge supplier type. * @param charge_ma Desired charge limit (mA). * @param charge_mv Negotiated charge voltage (mV). */ void board_set_charge_limit(int port, int supplier, int charge_ma, int max_ma, int charge_mv) { charge_set_input_current_limit(MAX(charge_ma, CONFIG_CHARGER_INPUT_CURRENT), charge_mv); } #else /* * TODO HACK providing functions from common/charge_state_v2.c * which is not compiled in when no charger */ int charge_want_shutdown(void) { return 0; } int charge_prevent_power_on(int power_button_pressed) { return 0; } #endif /* * Enable or disable input devices, * based upon chipset state and tablet mode */ static void enable_input_devices(void) { int kb_enable = 1; int tp_enable = 1; /* Disable both TP and KB in tablet mode */ if (!gpio_get_level(GPIO_TABLET_MODE_L)) kb_enable = tp_enable = 0; /* Disable TP if chipset is off */ else if (chipset_in_state(CHIPSET_STATE_ANY_OFF)) tp_enable = 0; keyboard_scan_enable(kb_enable, KB_SCAN_DISABLE_LID_ANGLE); gpio_set_level(GPIO_ENABLE_TOUCHPAD, tp_enable); } /* Called on AP S5 -> S3 transition */ static void board_chipset_startup(void) { CPRINTS("MEC1701 HOOK_CHIPSET_STARTUP - called board_chipset_startup"); trace0(0, HOOK, 0, "HOOK_CHIPSET_STARTUP - board_chipset_startup"); gpio_set_level(GPIO_USB1_ENABLE, 1); gpio_set_level(GPIO_USB2_ENABLE, 1); hook_call_deferred(&enable_input_devices_data, 0); } DECLARE_HOOK(HOOK_CHIPSET_STARTUP, board_chipset_startup, HOOK_PRIO_DEFAULT); /* Called on AP S3 -> S5 transition */ static void board_chipset_shutdown(void) { CPRINTS("MEC1701 HOOK_CHIPSET_SHUTDOWN board_chipset_shutdown"); trace0(0, HOOK, 0, "HOOK_CHIPSET_SHUTDOWN board_chipset_shutdown"); gpio_set_level(GPIO_USB1_ENABLE, 0); gpio_set_level(GPIO_USB2_ENABLE, 0); hook_call_deferred(&enable_input_devices_data, 0); } DECLARE_HOOK(HOOK_CHIPSET_SHUTDOWN, board_chipset_shutdown, HOOK_PRIO_DEFAULT); /* Called on AP S3 -> S0 transition */ static void board_chipset_resume(void) { CPRINTS("MEC1701_EVG HOOK_CHIPSET_RESUME"); trace0(0, HOOK, 0, "HOOK_CHIPSET_RESUME - board_chipset_resume"); gpio_set_level(GPIO_ENABLE_BACKLIGHT, 1); #if 0 /* TODO not implemented in gpio.inc */ gpio_set_level(GPIO_PP1800_DX_AUDIO_EN, 1); gpio_set_level(GPIO_PP1800_DX_SENSOR_EN, 1); #endif } DECLARE_HOOK(HOOK_CHIPSET_RESUME, board_chipset_resume, MOTION_SENSE_HOOK_PRIO-1); /* Called on AP S0 -> S3 transition */ static void board_chipset_suspend(void) { CPRINTS("MEC1701 HOOK_CHIPSET_SUSPEND - called board_chipset_resume"); trace0(0, HOOK, 0, "HOOK_CHIPSET_SUSPEND - board_chipset_suspend"); gpio_set_level(GPIO_ENABLE_BACKLIGHT, 0); #if 0 /* TODO not implemented in gpio.inc */ gpio_set_level(GPIO_PP1800_DX_AUDIO_EN, 0); gpio_set_level(GPIO_PP1800_DX_SENSOR_EN, 0); #endif } DECLARE_HOOK(HOOK_CHIPSET_SUSPEND, board_chipset_suspend, HOOK_PRIO_DEFAULT); void board_hibernate_late(void) { /* put host chipset into reset */ gpio_set_level(GPIO_SYS_RESET_L, 0); /* Turn off LEDs in hibernate */ gpio_set_level(GPIO_CHARGE_LED_1, 0); gpio_set_level(GPIO_CHARGE_LED_2, 0); /* * Set PD wake low so that it toggles high to generate a wake * event once we leave hibernate. */ gpio_set_level(GPIO_USB_PD_WAKE, 0); #ifdef CONFIG_USB_PD_PORT_COUNT /* * Leave USB-C charging enabled in hibernate, in order to * allow wake-on-plug. 5V enable must be pulled low. */ #if CONFIG_USB_PD_PORT_COUNT > 0 gpio_set_flags(GPIO_USB_C0_5V_EN, GPIO_PULL_DOWN | GPIO_INPUT); gpio_set_level(GPIO_USB_C0_CHARGE_EN_L, 0); #endif #if CONFIG_USB_PD_PORT_COUNT > 1 gpio_set_flags(GPIO_USB_C1_5V_EN, GPIO_PULL_DOWN | GPIO_INPUT); gpio_set_level(GPIO_USB_C1_CHARGE_EN_L, 0); #endif #endif /* CONFIG_USB_PD_PORT_COUNT */ } /* Any glados boards post version 2 should have ROP_LDO_EN stuffed. */ #define BOARD_MIN_ID_LOD_EN 2 /* Make the pmic re-sequence the power rails under these conditions. */ #define PMIC_RESET_FLAGS \ (RESET_FLAG_WATCHDOG | RESET_FLAG_SOFT | RESET_FLAG_HARD) static void board_handle_reboot(void) { #if 0 /* MEC17xx EVB + SKL-RVP3 does not use chromebook PMIC design */ int flags; #endif CPRINTS("MEC HOOK_INIT - called board_handle_reboot"); trace0(0, HOOK, 0, "HOOK_INIT - board_handle_reboot"); if (system_jumped_to_this_image()) return; if (system_get_board_version() < BOARD_MIN_ID_LOD_EN) return; #if 0 /* TODO MCHP KBL hack not PMIC system */ /* Interrogate current reset flags from previous reboot. */ flags = system_get_reset_flags(); if (!(flags & PMIC_RESET_FLAGS)) return; /* Preserve AP off request. */ if (flags & RESET_FLAG_AP_OFF) chip_save_reset_flags(RESET_FLAG_AP_OFF); ccprintf("Restarting system with PMIC.\n"); /* Flush console */ cflush(); /* Bring down all rails but RTC rail (including EC power). */ gpio_set_flags(GPIO_BATLOW_L_PMIC_LDO_EN, GPIO_OUT_HIGH); while (1) ; /* wait here */ #else return; #endif } DECLARE_HOOK(HOOK_INIT, board_handle_reboot, HOOK_PRIO_FIRST); static int sb_temp(int idx, int *temp_ptr) { if (idx != 0) return EC_ERROR_PARAM1; if (temp_ptr == NULL) return EC_ERROR_PARAM2; *temp_ptr = smart_batt_temp; return EC_SUCCESS; } static int ds1624_get_val(int idx, int *temp_ptr) { if (idx != 0) return EC_ERROR_PARAM1; if (temp_ptr == NULL) return EC_ERROR_PARAM2; *temp_ptr = ds1624_temp; return EC_SUCCESS; } /* call smart battery code to get its temperature * output is in tenth degrees C */ static void sb_update(void) { int rv __attribute__((unused)); rv = sb_read(SB_TEMPERATURE, &smart_batt_temp); smart_batt_temp = smart_batt_temp / 10; trace12(0, BRD, 0, "sb_read temperature rv=%d temp=%d K", rv, smart_batt_temp); } /* * Read temperature from Maxim DS1624 sensor. It only has internal sensor * and is configured for continuous reading mode by default. * DS1624 does not implement temperature limits or other features of * sensors like the TMP411. * Output format is 16-bit MSB first signed celcius temperature in units * of 0.0625 degree Celsius. * b[15]=sign bit * b[14]=2^6, b[13]=2^5, ..., b[8]=2^0 * b[7]=1/2, b[6]=1/4, b[5]=1/8, b[4]=1/16 * b[3:0]=0000b * */ static void ds1624_update(void) { uint32_t d; int temp; int rv __attribute__((unused)); rv = i2c_read16(I2C_PORT_THERMAL, (DS1624_I2C_ADDR | I2C_FLAG_BIG_ENDIAN), DS1624_READ_TEMP16, &temp); d = (temp & 0x7FFF) >> 8; if ((uint32_t)temp & (1 << 7)) d++; if ((uint32_t)temp & (1 << 15)) d |= (1u << 31); ds1624_temp = (int32_t)d; trace3(0, BRD, 0, "ds1624_update: rv=%d raw temp = 0x%04X tempC = %d", rv, temp, ds1624_temp); } /* Indicate scheduler is alive by blinking an LED. * Test I2C by reading a smart battery and temperature sensor. * Smart battery 16 bit temperature is in units of 1/10 degree C. */ static void board_one_sec(void) { trace0(0, BRD, 0, "HOOK_SECOND"); if (gpio_get_level(GPIO_CHARGE_LED_2)) gpio_set_level(GPIO_CHARGE_LED_2, 0); else gpio_set_level(GPIO_CHARGE_LED_2, 1); sb_update(); ds1624_update(); } DECLARE_HOOK(HOOK_SECOND, board_one_sec, HOOK_PRIO_DEFAULT); #ifdef HAS_TASK_MOTIONSENSE /* Motion sensors */ static struct mutex g_base_mutex; /* BMI160 private data */ static struct bmi160_drv_data_t g_bmi160_data; #ifdef CONFIG_ACCEL_KX022 static struct mutex g_lid_mutex; /* KX022 private data */ static struct kionix_accel_data g_kx022_data; #endif struct motion_sensor_t motion_sensors[] = { /* * Note: bmi160: supports accelerometer and gyro sensor * Requirement: accelerometer sensor must init before gyro sensor * DO NOT change the order of the following table. */ {.name = "Base Accel", .active_mask = SENSOR_ACTIVE_S0, .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 = CONFIG_SPI_ACCEL_PORT, .addr = BMI160_SET_SPI_ADDRESS(CONFIG_SPI_ACCEL_PORT), .rot_standard_ref = NULL, /* Identity matrix. */ .default_range = 2, /* g, enough for laptop. */ .min_frequency = BMI160_ACCEL_MIN_FREQ, .max_frequency = BMI160_ACCEL_MAX_FREQ, .config = { /* EC use accel for angle detection */ [SENSOR_CONFIG_EC_S0] = { .odr = 10000 | ROUND_UP_FLAG, .ec_rate = 100 * MSEC, }, }, }, {.name = "Base Gyro", .active_mask = SENSOR_ACTIVE_S0, .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 = CONFIG_SPI_ACCEL_PORT, .addr = BMI160_SET_SPI_ADDRESS(CONFIG_SPI_ACCEL_PORT), .default_range = 1000, /* dps */ .rot_standard_ref = NULL, /* Identity Matrix. */ .min_frequency = BMI160_GYRO_MIN_FREQ, .max_frequency = BMI160_GYRO_MAX_FREQ, }, #ifdef CONFIG_ACCEL_KX022 {.name = "Lid Accel", .active_mask = SENSOR_ACTIVE_S0, .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 = NULL, /* Identity matrix. */ .default_range = 2, /* g, enough for laptop. */ .min_frequency = KX022_ACCEL_MIN_FREQ, .max_frequency = KX022_ACCEL_MAX_FREQ, .config = { /* EC use accel for angle detection */ [SENSOR_CONFIG_EC_S0] = { .odr = 10000 | ROUND_UP_FLAG, .ec_rate = 100 * MSEC, }, }, #endif /* #ifdef CONFIG_ACCEL_KX022 */ }; const unsigned int motion_sensor_count = ARRAY_SIZE(motion_sensors); static void board_spi_enable(void) { trace0(0, BRD, 0, "HOOK_CHIPSET_STARTUP - board_spi_enable"); spi_enable(CONFIG_SPI_ACCEL_PORT, 1); /* Toggle SPI chip select to switch BMI160 from I2C mode * to SPI mode */ gpio_set_level(GPIO_SPI0_CS0, 0); udelay(10); gpio_set_level(GPIO_SPI0_CS0, 1); } DECLARE_HOOK(HOOK_CHIPSET_STARTUP, board_spi_enable, MOTION_SENSE_HOOK_PRIO - 1); static void board_spi_disable(void) { trace0(0, BRD, 0, "HOOK_CHIPSET_SHUTDOWN - board_spi_disable"); spi_enable(CONFIG_SPI_ACCEL_PORT, 0); } DECLARE_HOOK(HOOK_CHIPSET_SHUTDOWN, board_spi_disable, MOTION_SENSE_HOOK_PRIO + 1); #endif /* defined(HAS_TASK_MOTIONSENSE) */ #ifdef MEC1701_EVB_TACH_TEST /* PWM/TACH test */ void tach0_isr(void) { MCHP_INT_DISABLE(MCHP_TACH_GIRQ) = MCHP_TACH_GIRQ_BIT(0); MCHP_INT_SOURCE(MCHP_TACH_GIRQ) = MCHP_TACH_GIRQ_BIT(0); } DECLARE_IRQ(MCHP_IRQ_TACH_0, tach0_isr, 1); #endif