coreboot-mirror
/
chrome-ec
mirror of https://review.coreboot.org/chrome-ec.git
1
0
Fork 0
Code Issues Releases Wiki Activity
chrome-ec/board/servo_v4/board.c

464 lines
12 KiB
C
Raw Blame History

/* Copyright 2016 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.
*/
/* Servo V4 configuration */
#include "adc.h"
#include "adc_chip.h"
#include "common.h"
#include "console.h"
#include "ec_version.h"
#include "gpio.h"
#include "hooks.h"
#include "i2c.h"
#include "queue_policies.h"
#include "registers.h"
#include "spi.h"
#include "system.h"
#include "task.h"
#include "timer.h"
#include "update_fw.h"
#include "usart-stm32f0.h"
#include "usart_tx_dma.h"
#include "usart_rx_dma.h"
#include "usb_gpio.h"
#include "usb_i2c.h"
#include "usb_pd.h"
#include "usb_spi.h"
#include "usb-stream.h"
#include "util.h"
/******************************************************************************
* GPIO interrupt handlers.
*/
static void vbus0_evt(enum gpio_signal signal)
{
task_wake(TASK_ID_PD_C0);
}
static void vbus1_evt(enum gpio_signal signal)
{
task_wake(TASK_ID_PD_C1);
}
#include "gpio_list.h"
#define CPRINTS(format, args...) cprints(CC_SYSTEM, format, ## args)
#define CPRINTF(format, args...) cprintf(CC_SYSTEM, format, ## args)
/******************************************************************************
* Board pre-init function.
*/
void board_config_pre_init(void)
{
/* enable SYSCFG clock */
STM32_RCC_APB2ENR |= BIT(0);
/*
* the DMA mapping is :
* Chan 2 : TIM1_CH1 (CHG RX) - Default mapping
* Chan 3 : SPI1_TX (CHG TX) - Default mapping
* Chan 4 : USART1 TX - Remapped from default Chan 2
* Chan 5 : USART1 RX - Remapped from default Chan 3
* Chan 6 : TIM3_CH1 (DUT RX) - Remapped from default Chan 4
* Chan 7 : SPI2_TX (DUT TX) - Remapped from default Chan 5
*
* As described in the comments above, both USART1 TX/RX and DUT Tx/RX
* channels must be remapped from the defulat locations. Remapping is
* acoomplished by setting the following bits in the STM32_SYSCFG_CFGR1
* register. Information about this register and its settings can be
* found in section 11.3.7 DMA Request Mapping of the STM RM0091
* Reference Manual
*/
/* Remap USART1 Tx from DMA channel 2 to channel 4 */
STM32_SYSCFG_CFGR1 |= BIT(9);
/* Remap USART1 Rx from DMA channel 3 to channel 5 */
STM32_SYSCFG_CFGR1 |= BIT(10);
/* Remap TIM3_CH1 from DMA channel 4 to channel 6 */
STM32_SYSCFG_CFGR1 |= BIT(30);
/* Remap SPI2 Tx from DMA channel 5 to channel 7 */
STM32_SYSCFG_CFGR1 |= BIT(24);
}
/******************************************************************************
* Set up USB PD
*/
/* ADC channels */
const struct adc_t adc_channels[] = {
/* USB PD CC lines sensing. Converted to mV (3300mV/4096). */
[ADC_CHG_CC1_PD] = {"CHG_CC1_PD", 3300, 4096, 0, STM32_AIN(2)},
[ADC_CHG_CC2_PD] = {"CHG_CC2_PD", 3300, 4096, 0, STM32_AIN(4)},
[ADC_DUT_CC1_PD] = {"DUT_CC1_PD", 3300, 4096, 0, STM32_AIN(0)},
[ADC_DUT_CC2_PD] = {"DUT_CC2_PD", 3300, 4096, 0, STM32_AIN(5)},
[ADC_SBU1_DET] = {"SBU1_DET", 3300, 4096, 0, STM32_AIN(3)},
[ADC_SBU2_DET] = {"SBU2_DET", 3300, 4096, 0, STM32_AIN(7)},
[ADC_SUB_C_REF] = {"SUB_C_REF", 3300, 4096, 0, STM32_AIN(1)},
};
BUILD_ASSERT(ARRAY_SIZE(adc_channels) == ADC_CH_COUNT);
/******************************************************************************
* Forward UARTs as a USB serial interface.
*/
#define USB_STREAM_RX_SIZE 16
#define USB_STREAM_TX_SIZE 16
/******************************************************************************
* Forward USART3 as a simple USB serial interface.
*/
static struct usart_config const usart3;
struct usb_stream_config const usart3_usb;
static struct queue const usart3_to_usb = QUEUE_DIRECT(64, uint8_t,
usart3.producer, usart3_usb.consumer);
static struct queue const usb_to_usart3 = QUEUE_DIRECT(64, uint8_t,
usart3_usb.producer, usart3.consumer);
static struct usart_config const usart3 =
USART_CONFIG(usart3_hw,
usart_rx_interrupt,
usart_tx_interrupt,
115200,
0,
usart3_to_usb,
usb_to_usart3);
USB_STREAM_CONFIG(usart3_usb,
USB_IFACE_USART3_STREAM,
USB_STR_USART3_STREAM_NAME,
USB_EP_USART3_STREAM,
USB_STREAM_RX_SIZE,
USB_STREAM_TX_SIZE,
usb_to_usart3,
usart3_to_usb)
/******************************************************************************
* Forward USART4 as a simple USB serial interface.
*/
static struct usart_config const usart4;
struct usb_stream_config const usart4_usb;
static struct queue const usart4_to_usb = QUEUE_DIRECT(64, uint8_t,
usart4.producer, usart4_usb.consumer);
static struct queue const usb_to_usart4 = QUEUE_DIRECT(64, uint8_t,
usart4_usb.producer, usart4.consumer);
static struct usart_config const usart4 =
USART_CONFIG(usart4_hw,
usart_rx_interrupt,
usart_tx_interrupt,
9600,
0,
usart4_to_usb,
usb_to_usart4);
USB_STREAM_CONFIG(usart4_usb,
USB_IFACE_USART4_STREAM,
USB_STR_USART4_STREAM_NAME,
USB_EP_USART4_STREAM,
USB_STREAM_RX_SIZE,
USB_STREAM_TX_SIZE,
usb_to_usart4,
usart4_to_usb)
/******************************************************************************
* Define the strings used in our USB descriptors.
*/
const void *const usb_strings[] = {
[USB_STR_DESC] = usb_string_desc,
[USB_STR_VENDOR] = USB_STRING_DESC("Google Inc."),
[USB_STR_PRODUCT] = USB_STRING_DESC("Servo V4"),
[USB_STR_SERIALNO] = USB_STRING_DESC("1234-a"),
[USB_STR_VERSION] = USB_STRING_DESC(CROS_EC_VERSION32),
[USB_STR_I2C_NAME] = USB_STRING_DESC("I2C"),
[USB_STR_CONSOLE_NAME] = USB_STRING_DESC("Servo EC Shell"),
[USB_STR_USART3_STREAM_NAME] = USB_STRING_DESC("DUT UART"),
[USB_STR_USART4_STREAM_NAME] = USB_STRING_DESC("Atmega UART"),
[USB_STR_UPDATE_NAME] = USB_STRING_DESC("Firmware update"),
};
BUILD_ASSERT(ARRAY_SIZE(usb_strings) == USB_STR_COUNT);
/******************************************************************************
* Support I2C bridging over USB.
*/
/* I2C ports */
const struct i2c_port_t i2c_ports[] = {
{"master", I2C_PORT_MASTER, 100,
GPIO_MASTER_I2C_SCL, GPIO_MASTER_I2C_SDA},
};
const unsigned int i2c_ports_used = ARRAY_SIZE(i2c_ports);
int usb_i2c_board_is_enabled(void) { return 1; }
/******************************************************************************
* Initialize board.
*/
/*
* Support tca6416 I2C ioexpander.
*/
#define GPIOX_I2C_ADDR_FLAGS 0x20
#define GPIOX_IN_PORT_A 0x0
#define GPIOX_IN_PORT_B 0x1
#define GPIOX_OUT_PORT_A 0x2
#define GPIOX_OUT_PORT_B 0x3
#define GPIOX_DIR_PORT_A 0x6
#define GPIOX_DIR_PORT_B 0x7
/* Write a GPIO output on the tca6416 I2C ioexpander. */
static void write_ioexpander(int bank, int gpio, int val)
{
int tmp;
/* Read output port register */
i2c_read8(1, GPIOX_I2C_ADDR_FLAGS, GPIOX_OUT_PORT_A + bank, &tmp);
if (val)
tmp |= BIT(gpio);
else
tmp &= ~BIT(gpio);
/* Write back modified output port register */
i2c_write8(1, GPIOX_I2C_ADDR_FLAGS, GPIOX_OUT_PORT_A + bank, tmp);
}
/* Read a single GPIO input on the tca6416 I2C ioexpander. */
static int read_ioexpander_bit(int bank, int bit)
{
int tmp;
int mask = 1 << bit;
/* Read input port register */
i2c_read8(1, GPIOX_I2C_ADDR_FLAGS, GPIOX_IN_PORT_A + bank, &tmp);
return (tmp & mask) >> bit;
}
/* Enable uservo USB. */
static void init_uservo_port(void)
{
/* Write USERVO_POWER_EN */
write_ioexpander(0, 7, 1);
/* Write USERVO_FASTBOOT_MUX_SEL */
write_ioexpander(1, 0, 0);
}
/* Enable blue USB port to DUT. */
static void init_usb3_port(void)
{
/* Write USB3.0_TYPEA_MUX_SEL */
write_ioexpander(0, 3, 1);
/* Write USB3.0_TYPEA_MUX_EN_L */
write_ioexpander(0, 4, 0);
/* Write USB3.0_TYPE_A_PWR_EN */
write_ioexpander(0, 5, 1);
}
/* Enable all ioexpander outputs. */
static void init_ioexpander(void)
{
/* Write all GPIO to output 0 */
i2c_write8(1, GPIOX_I2C_ADDR_FLAGS, GPIOX_OUT_PORT_A, 0x0);
i2c_write8(1, GPIOX_I2C_ADDR_FLAGS, GPIOX_OUT_PORT_B, 0x0);
/*
* Write GPIO direction: strap resistors to input,
* all others to output.
*/
i2c_write8(1, GPIOX_I2C_ADDR_FLAGS, GPIOX_DIR_PORT_A, 0x0);
i2c_write8(1, GPIOX_I2C_ADDR_FLAGS, GPIOX_DIR_PORT_B, 0x18);
}
/*
* Define voltage thresholds for SBU USB detection.
*
* Max observed USB low across sampled systems: 666mV
* Min observed USB high across sampled systems: 3026mV
*/
#define GND_MAX_MV 700
#define USB_HIGH_MV 2500
#define SBU_DIRECT 0
#define SBU_FLIP 1
#define MODE_SBU_DISCONNECT 0
#define MODE_SBU_CONNECT 1
#define MODE_SBU_FLIP 2
#define MODE_SBU_OTHER 3
static void ccd_measure_sbu(void);
DECLARE_DEFERRED(ccd_measure_sbu);
static void ccd_measure_sbu(void)
{
int sbu1;
int sbu2;
int mux_en;
static int count /* = 0 */;
static int last /* = 0 */;
static int polarity /* = 0 */;
/* Read sbu voltage levels */
sbu1 = adc_read_channel(ADC_SBU1_DET);
sbu2 = adc_read_channel(ADC_SBU2_DET);
mux_en = gpio_get_level(GPIO_SBU_MUX_EN);
/*
* While SBU_MUX is disabled (SuzyQ unplugged), we'll poll the SBU lines
* to check if an idling, unconfigured USB device is present.
* USB FS pulls one line high for connect request.
* If so, and it persists for 500ms, we'll enable the SuzyQ in that
* orientation.
*/
if ((!mux_en) && (sbu1 > USB_HIGH_MV) && (sbu2 < GND_MAX_MV)) {
/* Check flip connection polarity. */
if (last != MODE_SBU_FLIP) {
last = MODE_SBU_FLIP;
polarity = SBU_FLIP;
count = 0;
} else {
count++;
}
} else if ((!mux_en) && (sbu2 > USB_HIGH_MV) && (sbu1 < GND_MAX_MV)) {
/* Check direct connection polarity. */
if (last != MODE_SBU_CONNECT) {
last = MODE_SBU_CONNECT;
polarity = SBU_DIRECT;
count = 0;
} else {
count++;
}
/*
* If SuzyQ is enabled, we'll poll for a persistent no-signal for
* 500ms. Since USB is differential, we should never see GND/GND
* while the device is connected.
* If disconnected, electrically remove SuzyQ.
*/
} else if ((mux_en) && (sbu1 < GND_MAX_MV) && (sbu2 < GND_MAX_MV)) {
/* Check for SBU disconnect if connected. */
if (last != MODE_SBU_DISCONNECT) {
last = MODE_SBU_DISCONNECT;
count = 0;
} else {
count++;
}
} else {
/* Didn't find anything, reset state. */
last = MODE_SBU_OTHER;
count = 0;
}
/*
* We have seen a new state continuously for 500ms.
* Let's update the mux to enable/disable SuzyQ appropriately.
*/
if (count > 5) {
if (mux_en) {
/* Disable mux as it's disconnected now. */
gpio_set_level(GPIO_SBU_MUX_EN, 0);
msleep(10);
CPRINTS("CCD: disconnected.");
} else {
/* SBU flip = polarity */
write_ioexpander(0, 2, polarity);
gpio_set_level(GPIO_SBU_MUX_EN, 1);
msleep(10);
CPRINTS("CCD: connected %s",
polarity ? "flip" : "noflip");
}
}
/* Measure every 100ms, forever. */
hook_call_deferred(&ccd_measure_sbu_data, 100 * MSEC);
}
void ccd_enable(int enable)
{
/*
* We may use this if displayport is ever enabled.
* For now, CCD is always enabled on SBU.
*/
}
int board_get_version(void)
{
static int ver = -1;
if (ver < 0) {
uint8_t id0, id1;
id0 = read_ioexpander_bit(1, 3);
id1 = read_ioexpander_bit(1, 4);
ver = (id1 * 2) + id0;
CPRINTS("Board ID = %d", ver);
}
return ver;
}
static void board_init(void)
{
/* USB to serial queues */
queue_init(&usart3_to_usb);
queue_init(&usb_to_usart3);
queue_init(&usart4_to_usb);
queue_init(&usb_to_usart4);
/* UART init */
usart_init(&usart3);
usart_init(&usart4);
/* Delay DUT hub to avoid brownout. */
usleep(1000);
gpio_set_flags(GPIO_DUT_HUB_USB_RESET_L, GPIO_OUT_HIGH);
/*
* Write USB3 Mode to PS8742 USB/DP Mux.
* 0x0:disable 0x20:enable.
*/
i2c_write8(1, 0x10, 0x0, 0x0);
/* Enable uservo USB by default. */
init_ioexpander();
init_uservo_port();
init_usb3_port();
/* Clear BBRAM, we don't want any PD state carried over on reset. */
system_set_bbram(SYSTEM_BBRAM_IDX_PD0, 0);
system_set_bbram(SYSTEM_BBRAM_IDX_PD1, 0);
/*
* Disable SBU mux. The polarity is set each time a presense is detected
* on SBU, and wired thorugh. On missing voltage on SBU. SBU wires are
* disconnected.
*/
gpio_set_level(GPIO_SBU_MUX_EN, 0);
/*
* Voltage transition needs to occur in lockstep between the CHG and
* DUT ports, so initially limit voltage to 5V.
*/
pd_set_max_voltage(PD_MIN_MV);
/* Enable VBUS detection to wake PD tasks fast enough */
gpio_enable_interrupt(GPIO_USB_DET_PP_CHG);
gpio_enable_interrupt(GPIO_USB_DET_PP_DUT);
hook_call_deferred(&ccd_measure_sbu_data, 1000 * MSEC);
}
DECLARE_HOOK(HOOK_INIT, board_init, HOOK_PRIO_DEFAULT);
Reference in New Issue View Git Blame Copy Permalink