/* Charging power state initialization */
int charger_post_init(void)
{
int rv;
#ifdef CONFIG_CHARGER_ILIM_PIN_DISABLED
int option2;
#endif
/* Set charger input current limit */
rv = charger_set_input_current(CONFIG_CHARGER_INPUT_CURRENT);
#ifdef CONFIG_CHARGER_ILIM_PIN_DISABLED
if (rv)
return rv;
/* Disable the external ILIM pin. */
rv = i2c_read16(I2C_PORT_CHARGER, BQ24773_ADDR,
BQ24773_CHARGE_OPTION2, &option2);
if (rv)
return rv;
option2 &= ~OPTION2_EN_EXTILIM;
rv = i2c_write16(I2C_PORT_CHARGER, BQ24773_ADDR,
BQ24773_CHARGE_OPTION2, option2);
#endif
return rv;
}
static int test_i2c(void)
{
int res = EC_ERROR_UNKNOWN;
int dummy_data;
struct i2c_test_param_t *param;
param = i2c_test_params + (prng_no_seed() % (sizeof(i2c_test_params) /
sizeof(struct i2c_test_param_t)));
if (param->width == 8 && param->data == -1)
res = i2c_read8(param->port, param->addr,
param->offset, &dummy_data);
else if (param->width == 8 && param->data >= 0)
res = i2c_write8(param->port, param->addr,
param->offset, param->data);
else if (param->width == 16 && param->data == -1)
res = i2c_read16(param->port, param->addr,
param->offset, &dummy_data);
else if (param->width == 16 && param->data >= 0)
res = i2c_write16(param->port, param->addr,
param->offset, param->data);
else if (param->width == 32 && param->data == -1)
res = i2c_read32(param->port, param->addr,
param->offset, &dummy_data);
else if (param->width == 32 && param->data >= 0)
res = i2c_write32(param->port, param->addr,
param->offset, param->data);
return res;
}
int tcpm_alert_status(int port, int *alert)
{
int rv;
/* Read TCPC Alert register */
rv = i2c_read16(I2C_PORT_TCPC, I2C_ADDR_TCPC(port),
TCPC_REG_ALERT, alert);
return rv;
}
int smbus_read_word(uint8_t i2c_port, uint8_t slave_addr,
uint8_t smbus_cmd, uint16_t *p16)
{
int rv, d16 = 0;
rv = i2c_read16(i2c_port, slave_addr, smbus_cmd, &d16);
*p16 = d16;
return rv;
}
int I2C::i2c_read16(int addr, uint8_t reg, int16_t *value)
{
uint16_t temp = 0;
const int ret = i2c_read16(addr, reg, &temp);
if (!ret)
*value = static_cast<int16_t>(temp);
return ret;
}
/* Charging power state initialization */
int charger_post_init(void)
{
int rv, option;
#ifdef CONFIG_CHARGER_ILIM_PIN_DISABLED
int option2;
#endif
rv = charger_get_option(&option);
if (rv)
return rv;
option &= ~OPTION0_LEARN_ENABLE;
rv = charger_set_option(option);
if (rv)
return rv;
#ifndef BOARD_SAMUS
/* Turn off PROCHOT warning */
rv = i2c_write8(I2C_PORT_CHARGER, BQ24773_ADDR,
BQ24773_PROCHOT_OPTION1, 0);
#else
/* On Samus, use PROCHOT warning to detect charging problems */
/* Turn on PROCHOT warning */
rv = i2c_write16(I2C_PORT_CHARGER, BQ24773_ADDR,
BQ24773_PROCHOT_OPTION1, 0x8120);
/* Set PROCHOT ICRIT warning when IADP is >120% of IDPM */
rv |= i2c_write16(I2C_PORT_CHARGER, BQ24773_ADDR,
BQ24773_PROCHOT_OPTION0, 0x1b54);
#endif
if (rv)
return rv;
#ifdef CONFIG_CHARGER_ILIM_PIN_DISABLED
/* Read the external ILIM pin enabled flag. */
rv = i2c_read16(I2C_PORT_CHARGER, BQ24773_ADDR,
BQ24773_CHARGE_OPTION2, &option2);
if (rv)
return rv;
/* Set ILIM pin disabled if it is currently enabled. */
if (option2 & OPTION2_EN_EXTILIM) {
option2 &= ~OPTION2_EN_EXTILIM;
rv = i2c_write16(I2C_PORT_CHARGER, BQ24773_ADDR,
BQ24773_CHARGE_OPTION2, option2);
}
return rv;
#else
return EC_SUCCESS;
#endif
}
int charger_get_current(int *current)
{
int rv;
int reg;
rv = i2c_read16(I2C_PORT_CHARGER, BQ24773_ADDR,
BQ24773_CHARGE_CURRENT, ®);
if (rv)
return rv;
*current = REG_TO_CURRENT(reg, R_SNS);
return EC_SUCCESS;
}
int tcpm_init(int port)
{
int rv, err = 0;
while (1) {
rv = i2c_read16(I2C_PORT_TCPC, I2C_ADDR_TCPC(port),
TCPC_REG_ERROR_STATUS, &err);
/*
* If i2c succeeds and the uninitialized bit is clear, then
* initalization is complete, clear all alert bits and write
* the initial alert mask.
*/
if (rv == EC_SUCCESS && !(err & TCPC_REG_ERROR_STATUS_UNINIT)) {
i2c_write16(I2C_PORT_TCPC, I2C_ADDR_TCPC(port),
TCPC_REG_ALERT, 0xff);
return init_alert_mask(port);
}
msleep(10);
}
}
static inline int ch_raw_read16(int cmd, int *param,
enum bd99955_command map_cmd)
{
int rv;
/* Map the Charge command code to appropriate region */
mutex_lock(&bd99955_map_mutex);
if (charger_map_cmd != map_cmd) {
rv = i2c_write16(I2C_PORT_CHARGER, I2C_ADDR_CHARGER,
BD99955_CMD_MAP_SET, map_cmd);
if (rv)
goto bd99955_read_cleanup;
charger_map_cmd = map_cmd;
}
rv = i2c_read16(I2C_PORT_CHARGER, I2C_ADDR_CHARGER, cmd, param);
bd99955_read_cleanup:
mutex_unlock(&bd99955_map_mutex);
return rv;
}
int tcpm_get_message(int port, uint32_t *payload, int *head)
{
int rv, cnt, reg = TCPC_REG_RX_DATA;
rv = i2c_read8(I2C_PORT_TCPC, I2C_ADDR_TCPC(port),
TCPC_REG_RX_BYTE_CNT, &cnt);
rv |= i2c_read16(I2C_PORT_TCPC, I2C_ADDR_TCPC(port),
TCPC_REG_RX_HDR, (int *)head);
if (rv == EC_SUCCESS && cnt > 0) {
i2c_lock(I2C_PORT_TCPC, 1);
rv = i2c_xfer(I2C_PORT_TCPC, I2C_ADDR_TCPC(port),
(uint8_t *)®, 1, (uint8_t *)payload,
cnt, I2C_XFER_SINGLE);
i2c_lock(I2C_PORT_TCPC, 0);
}
/* Read complete, clear RX status alert bit */
i2c_write16(I2C_PORT_TCPC, I2C_ADDR_TCPC(port),
TCPC_REG_ALERT, TCPC_REG_ALERT_RX_STATUS);
return rv;
}
static inline int sbc_read(int cmd, int *param)
{
return i2c_read16(I2C_PORT_CHARGER, CHARGER_ADDR, cmd, param);
}
int charger_get_option(int *option)
{
return i2c_read16(I2C_PORT_CHARGER, BQ24773_ADDR,
BQ24773_CHARGE_OPTION0, option);
}
int charger_get_voltage(int *voltage)
{
return i2c_read16(I2C_PORT_CHARGER, BQ24773_ADDR,
BQ24773_MAX_CHARGE_VOLTAGE, voltage);
}
/**
* Read 16bit register from device.
*/
static inline int raw_read16(const int port, const int addr, const int reg,
int *data_ptr)
{
return i2c_read16(port, addr, reg, data_ptr);
}
