diff options
Diffstat (limited to 'firmware/e300/battery/ltc294x.c')
| -rw-r--r-- | firmware/e300/battery/ltc294x.c | 281 |
1 files changed, 281 insertions, 0 deletions
diff --git a/firmware/e300/battery/ltc294x.c b/firmware/e300/battery/ltc294x.c new file mode 100644 index 000000000..d62a5e57d --- /dev/null +++ b/firmware/e300/battery/ltc294x.c @@ -0,0 +1,281 @@ +/* USRP E310 Firmware Linear Technology LTC294X driver + * Copyright (C) 2014 Ettus Research + * This file is part of the USRP E310 Firmware + * The USRP E310 Firmware is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * The USRP E310 Firmware is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * You should have received a copy of the GNU General Public License + * along with the USRP E310 Firmware. If not, see <http://www.gnu.org/licenses/>. + */ + +#include <stdbool.h> +#include <string.h> +#include <util/atomic.h> +#include <avr/interrupt.h> + +#include "i2c_twi.h" +#include "io.h" +#include "ltc294x.h" +#include "utils.h" +#include "pmu.h" + +static const uint8_t LTC294X_I2C_ADDR = 0x64; + +#define ltc294x_read(reg, val) \ + (i2c_twi_read(LTC294X_I2C_ADDR, reg, val)) + +#define ltc294x_read16(reg, val) \ + (i2c_twi_read16(LTC294X_I2C_ADDR, reg, val)) + +#define ltc294x_write(reg, val) \ + (i2c_twi_write(LTC294X_I2C_ADDR, reg, val)) + +#define ltc294x_write16(reg, val) \ + (i2c_twi_write16(LTC294X_I2C_ADDR, reg, val)) + +static const uint8_t LTC294X_REG_STATUS = 0x00; +static const uint8_t LTC294X_REG_CONTROL = 0x01; +static const uint8_t LTC294X_REG_CHARGE_MSB = 0x2; +static const uint8_t LTC294X_REG_CHARGE_LSB = 0x3; +static const uint8_t LTC294X_REG_HIGH_TRESH_MSB = 0x4; +static const uint8_t LTC294X_REG_HIGH_THRESH_LSB = 0x5; +static const uint8_t LTC294X_REG_LOW_THRESH_MSB = 0x6; +static const uint8_t LTC294X_REG_LOW_THRESH_LSB = 0x7; +static const uint8_t LTC294X_REG_VOLTAGE_MSB = 0x8; +static const uint8_t LTC294X_REG_VOLTAGE_LSB = 0x9; +static const uint8_t LTC294X_REG_VOLTAGE_THRESH_HI = 0xa; +static const uint8_t LTC294X_REG_VOLTAGE_THRESH_LO = 0xb; +static const uint8_t LTC294X_REG_TEMP_MSB = 0xc; +static const uint8_t LTC294X_REG_TEMP_LSB = 0xd; +static const uint8_t LTC294X_REG_TEMP_THRESH_HI = 0xe; +static const uint8_t LTC294X_REG_TEMP_THRESH_LO = 0xf; + +/* status register */ +static const uint8_t LTC294X_CHIP_ID_MASK = BIT(7); +static const uint8_t LTC294X_CHIP_ID_SHIFT = 7; +static const uint8_t LTC294X_ACR_OVF_MASK = BIT(5); +static const uint8_t LTC294X_ACR_OVF_SHIFT = 5; +static const uint8_t LTC294X_TEMP_ALERT_MASK = BIT(4); +static const uint8_t LTC294X_TEMP_ALERT_SHIFT = 4; +static const uint8_t LTC294X_CH_ALERT_HIGH_MASK = BIT(3); +static const uint8_t LTC294X_CH_ALERT_HIGH_SHIFT = 3; +static const uint8_t LTC294X_CH_ALERT_LOW_MASK = BIT(2); +static const uint8_t LTC294X_CH_ALERT_LOW_SHIFT = 2; +static const uint8_t LTC294X_VOLT_ALERT_MASK = BIT(1); +static const uint8_t LTC294X_CH_VOLT_ALERT_SHIFT = 1; +static const uint8_t LTC294X_CH_UVOLT_MASK = BIT(0); +static const uint8_t LTC294X_CH_UVOLT_SHIFT = 0; + +/* control register */ +static const uint8_t LTC294X_ADC_MODE_MASK = BIT(7) | BIT(6); +static const uint8_t LTC294X_ADC_MODE_SHIFT = 6; +static const uint8_t LTC294X_PRESCALER_MASK = BIT(5) | BIT(4) | BIT(3); +static const uint8_t LTC294X_PRESCALER_SHIFT = 3; +static const uint8_t LTC294X_ALCC_CFG_MASK = BIT(2) | BIT(1); +static const uint8_t LTC294X_ALCC_CFG_SHIFT = 1; +static const uint8_t LTC294X_SHUTDOWN_MASK = BIT(0); +static const uint8_t LTC294X_SHUTDOWN_SHIFT = 0; + +/* acrh register */ + +/* acrl register */ + +struct ltc294x_gauge { + pmu_gauge_t pmu_gauge; + volatile uint8_t status; + uint16_t temp_thresh_high; + uint16_t temp_thresh_low; + uint16_t charge_lo_thesh; + bool first_time; +}; + +static struct ltc294x_gauge gauge; + +static io_pin_t FG_ALn_CC = IO_PA(0); + +static uint16_t ltc294x_get_charge(void) +{ + uint16_t val; + + (void) ltc294x_read16(LTC294X_REG_CHARGE_MSB, &val); + + return val; +} + +static void ltc294x_set_charge(uint16_t val) +{ + uint8_t ctrl_val; + + /* datasheet says to shutdown the analog part + * when writing the ACR */ + (void) ltc294x_read(LTC294X_REG_CONTROL, &ctrl_val); + + ctrl_val |= LTC294X_SHUTDOWN_MASK; + + (void) ltc294x_write(LTC294X_REG_CONTROL, ctrl_val); + + /* write the value ... */ + (void) ltc294x_write16(LTC294X_REG_CHARGE_MSB, val); + + ctrl_val &= ~LTC294X_SHUTDOWN_MASK; + + /* turn it on again ...*/ + (void) ltc294x_write(LTC294X_REG_CONTROL, ctrl_val); +} + +static uint16_t ltc294x_get_temp(void) +{ + uint16_t val; + + (void) ltc294x_read16(LTC294X_REG_TEMP_MSB, &val); + + return val; +} + +static uint16_t ltc294x_get_voltage(void) +{ + uint16_t val; + + (void) ltc294x_read16(LTC294X_REG_VOLTAGE_MSB, &val); + + return val; +} + +static int8_t ltc294x_set_charge_thresh(bool high, uint16_t val) +{ + int8_t ret; + + ret = ltc294x_write16( + high ? LTC294X_REG_HIGH_TRESH_MSB : LTC294X_REG_LOW_THRESH_MSB, val); + if (ret) + return ret; + return 0; +} + +static inline void ltc294x_pmu_set_charge_hi_thesh(uint16_t val) +{ + ltc294x_set_charge_thresh(true, val); +} + +static inline void ltc294x_pmu_set_charge_lo_thesh(uint16_t val) +{ + ltc294x_set_charge_thresh(false, val); +} + +uint8_t ltc294x_check_events(void) +{ + uint8_t status; + uint8_t flags = 0; + uint16_t value; + + ltc294x_read(LTC294X_REG_STATUS, &status); + + + if (status && (status != gauge.status)) { + + if (status & LTC294X_CH_ALERT_HIGH_MASK) + flags |= PMU_GAUGE_CHARGE_HI; + else if (status & LTC294X_CH_ALERT_LOW_MASK) + flags |= PMU_GAUGE_CHARGE_LO; + + if (status & LTC294X_VOLT_ALERT_MASK) { + /*flags |= PMU_GAUGE_VOLT_HI; + flags |= PMU_GAUGE_VOLT_LO; */ + /* TODO: Figure out which one */ + } + + if (status & LTC294X_ACR_OVF_MASK) { + value = ltc294x_get_charge(); + if (value <= gauge.charge_lo_thesh) + flags |= PMU_GAUGE_CHARGE_LO; + } + + if (status & LTC294X_TEMP_ALERT_MASK) { + value = ltc294x_get_temp(); + if (value > gauge.temp_thresh_high) + flags |= PMU_GAUGE_TEMP_HI; + else if (value <= gauge.temp_thresh_low) + flags |= PMU_GAUGE_TEMP_LO; + } + gauge.status = status; + } + + return flags; +} + +static const pmu_gauge_ops_t ltc294x_pmu_gauge_ops = { + .check_events = ltc294x_check_events, + .get_temperature = ltc294x_get_temp, + .get_charge = ltc294x_get_charge, + .set_charge = ltc294x_set_charge, + .set_low_threshold = ltc294x_pmu_set_charge_lo_thesh, + .get_voltage = ltc294x_get_voltage, +}; + +int8_t ltc294x_init(ltc294x_model_t model) +{ + uint8_t val; + int8_t ret; + + /* make input, set pullup */ + io_input_pin(FG_ALn_CC); + io_set_pin(FG_ALn_CC); + + gauge.pmu_gauge.ops = <c294x_pmu_gauge_ops; + + ret = ltc294x_read(LTC294X_REG_STATUS, &val); + if (ret) + goto fail_i2c_read; + val &= LTC294X_CHIP_ID_MASK; + val >>= LTC294X_CHIP_ID_SHIFT; + + if (val != model) + goto fail_id; + + /* set ACR to 0, this allows for calibrating by + * completely discharging the battery once */ + ltc294x_set_charge(0x0010); + + /* set low threshold to 10% assuming full is 0xeae4... */ + ltc294x_write16(LTC294X_REG_LOW_THRESH_MSB, 0x1794); + gauge.charge_lo_thesh = 0x1794; + + /* set high threshold for temperature to 85 C */ + ltc294x_write16(LTC294X_REG_TEMP_THRESH_HI, 0x98); + gauge.temp_thresh_high = 0x9800; + + /* set low threshold for temperature to -2 C */ + ltc294x_write16(LTC294X_REG_TEMP_THRESH_LO, 0x74); + gauge.temp_thresh_low = 0x7400; + + ret = ltc294x_read(LTC294X_REG_CONTROL, &val); + if (ret) + goto fail_i2c_read; + + /* enable automatic temp conversion */ + val &= ~LTC294X_ADC_MODE_MASK; + val |= 0x3 << LTC294X_ADC_MODE_SHIFT; + + /* set prescaler to 16 */ + val &= ~LTC294X_PRESCALER_MASK; + val |= 0x4 << LTC294X_PRESCALER_SHIFT; + + /* disable IRQ mode */ + val &= ~LTC294X_ALCC_CFG_MASK; + val |= 0x0 << LTC294X_ALCC_CFG_SHIFT; + + ret = ltc294x_write(LTC294X_REG_CONTROL, val); + + pmu_register_gauge(&gauge.pmu_gauge); + + return 0; + +fail_id: +fail_i2c_read: + return ret; +} |