341 lines
9.1 KiB
C
341 lines
9.1 KiB
C
/*
|
|
* Copyright 2021 Matija Tudan
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
|
|
#include <zephyr/drivers/i2c.h>
|
|
#include <zephyr/drivers/sensor.h>
|
|
|
|
#include <zephyr/logging/log.h>
|
|
LOG_MODULE_REGISTER(max17262, CONFIG_SENSOR_LOG_LEVEL);
|
|
|
|
#include "max17262.h"
|
|
|
|
#define DT_DRV_COMPAT maxim_max17262
|
|
|
|
/**
|
|
* @brief Read a register value
|
|
*
|
|
* Registers have an address and a 16-bit value
|
|
*
|
|
* @param dev MAX17262 device to access
|
|
* @param reg_addr Register address to read
|
|
* @param valp Place to put the value on success
|
|
* @return 0 if successful, or negative error code from I2C API
|
|
*/
|
|
static int max17262_reg_read(const struct device *dev, uint8_t reg_addr,
|
|
int16_t *valp)
|
|
{
|
|
const struct max17262_config *cfg = dev->config;
|
|
uint8_t i2c_data[2];
|
|
int rc;
|
|
|
|
rc = i2c_burst_read_dt(&cfg->i2c, reg_addr, i2c_data, 2);
|
|
if (rc < 0) {
|
|
LOG_ERR("Unable to read register");
|
|
return rc;
|
|
}
|
|
*valp = ((int16_t)i2c_data[1] << 8) | i2c_data[0];
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief Write a register value
|
|
*
|
|
* Registers have an address and a 16-bit value
|
|
*
|
|
* @param dev MAX17262 device to access
|
|
* @param reg_addr Register address to write to
|
|
* @param val Register value to write
|
|
* @return 0 if successful, or negative error code from I2C API
|
|
*/
|
|
static int max17262_reg_write(const struct device *dev, uint8_t reg_addr,
|
|
int16_t val)
|
|
{
|
|
const struct max17262_config *cfg = dev->config;
|
|
uint8_t i2c_data[3] = {reg_addr, val & 0xFF, (uint16_t)val >> 8};
|
|
|
|
return i2c_write_dt(&cfg->i2c, i2c_data, sizeof(i2c_data));
|
|
}
|
|
|
|
/**
|
|
* @brief Convert sensor value from millis
|
|
*
|
|
* @param val Where to store converted value in sensor_value format
|
|
* @param val_millis Value in millis
|
|
*/
|
|
static void convert_millis(struct sensor_value *val, int32_t val_millis)
|
|
{
|
|
val->val1 = val_millis / 1000;
|
|
val->val2 = (val_millis % 1000) * 1000;
|
|
}
|
|
|
|
/**
|
|
* @brief Convert raw register values for specific channel
|
|
*
|
|
* @param dev MAX17262 device to access
|
|
* @param chan Channel number to read
|
|
* @param valp Returns the sensor value read on success
|
|
* @return 0 if successful
|
|
* @return -ENOTSUP for unsupported channels
|
|
*/
|
|
static int max17262_channel_get(const struct device *dev,
|
|
enum sensor_channel chan,
|
|
struct sensor_value *valp)
|
|
{
|
|
const struct max17262_config *const config = dev->config;
|
|
struct max17262_data *const data = dev->data;
|
|
int32_t tmp;
|
|
|
|
switch (chan) {
|
|
case SENSOR_CHAN_GAUGE_VOLTAGE:
|
|
/* Get voltage in uV */
|
|
tmp = data->voltage * VOLTAGE_MULTIPLIER_UV;
|
|
/* Convert to V */
|
|
valp->val1 = tmp / 1000000;
|
|
valp->val2 = tmp % 1000000;
|
|
break;
|
|
case SENSOR_CHAN_GAUGE_AVG_CURRENT: {
|
|
int current;
|
|
/* Get avg current in nA */
|
|
current = data->avg_current * CURRENT_MULTIPLIER_NA;
|
|
/* Convert to mA */
|
|
valp->val1 = current / 1000000;
|
|
valp->val2 = current % 1000000;
|
|
break;
|
|
}
|
|
case SENSOR_CHAN_GAUGE_STATE_OF_CHARGE:
|
|
valp->val1 = data->state_of_charge / 256;
|
|
valp->val2 = data->state_of_charge % 256 * 1000000 / 256;
|
|
break;
|
|
case SENSOR_CHAN_GAUGE_TEMP:
|
|
valp->val1 = data->internal_temp / 256;
|
|
valp->val2 = data->internal_temp % 256 * 1000000 / 256;
|
|
break;
|
|
case SENSOR_CHAN_GAUGE_FULL_CHARGE_CAPACITY:
|
|
convert_millis(valp, data->full_cap);
|
|
break;
|
|
case SENSOR_CHAN_GAUGE_REMAINING_CHARGE_CAPACITY:
|
|
convert_millis(valp, data->remaining_cap);
|
|
break;
|
|
case SENSOR_CHAN_GAUGE_TIME_TO_EMPTY:
|
|
/* Get time in ms */
|
|
if (data->time_to_empty == 0xffff) {
|
|
valp->val1 = 0;
|
|
valp->val2 = 0;
|
|
} else {
|
|
tmp = data->time_to_empty * TIME_MULTIPLIER_MS;
|
|
convert_millis(valp, tmp);
|
|
}
|
|
break;
|
|
case SENSOR_CHAN_GAUGE_TIME_TO_FULL:
|
|
/* Get time in ms */
|
|
if (data->time_to_full == 0xffff) {
|
|
valp->val1 = 0;
|
|
valp->val2 = 0;
|
|
} else {
|
|
tmp = data->time_to_full * TIME_MULTIPLIER_MS;
|
|
convert_millis(valp, tmp);
|
|
}
|
|
break;
|
|
case SENSOR_CHAN_GAUGE_CYCLE_COUNT:
|
|
valp->val1 = data->cycle_count / 100;
|
|
valp->val2 = data->cycle_count % 100 * 10000;
|
|
break;
|
|
case SENSOR_CHAN_GAUGE_NOM_AVAIL_CAPACITY:
|
|
convert_millis(valp, data->design_cap);
|
|
break;
|
|
case SENSOR_CHAN_GAUGE_DESIGN_VOLTAGE:
|
|
convert_millis(valp, config->design_voltage);
|
|
break;
|
|
case SENSOR_CHAN_GAUGE_DESIRED_VOLTAGE:
|
|
convert_millis(valp, config->desired_voltage);
|
|
break;
|
|
case SENSOR_CHAN_GAUGE_DESIRED_CHARGING_CURRENT:
|
|
valp->val1 = data->ichg_term;
|
|
valp->val2 = 0;
|
|
break;
|
|
case MAX17262_COULOMB_COUNTER:
|
|
/* Get spent capacity in mAh */
|
|
data->coulomb_counter = 0xffff - data->coulomb_counter;
|
|
valp->val1 = data->coulomb_counter / 2;
|
|
valp->val2 = data->coulomb_counter % 2 * 10 / 2;
|
|
break;
|
|
default:
|
|
LOG_ERR("Unsupported channel!");
|
|
return -ENOTSUP;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief Read register values for supported channels
|
|
*
|
|
* @param dev MAX17262 device to access
|
|
* @return 0 if successful, or negative error code from I2C API
|
|
*/
|
|
static int max17262_sample_fetch(const struct device *dev,
|
|
enum sensor_channel chan)
|
|
{
|
|
struct max17262_data *data = dev->data;
|
|
struct {
|
|
int reg_addr;
|
|
int16_t *dest;
|
|
} regs[] = {
|
|
{ VCELL, &data->voltage },
|
|
{ AVG_CURRENT, &data->avg_current },
|
|
{ ICHG_TERM, &data->ichg_term },
|
|
{ REP_SOC, &data->state_of_charge },
|
|
{ INT_TEMP, &data->internal_temp },
|
|
{ REP_CAP, &data->remaining_cap },
|
|
{ FULL_CAP_REP, &data->full_cap },
|
|
{ TTE, &data->time_to_empty },
|
|
{ TTF, &data->time_to_full },
|
|
{ CYCLES, &data->cycle_count },
|
|
{ DESIGN_CAP, &data->design_cap },
|
|
{ COULOMB_COUNTER, &data->coulomb_counter },
|
|
};
|
|
|
|
__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL);
|
|
for (size_t i = 0; i < ARRAY_SIZE(regs); i++) {
|
|
int rc;
|
|
|
|
rc = max17262_reg_read(dev, regs[i].reg_addr, regs[i].dest);
|
|
if (rc != 0) {
|
|
LOG_ERR("Failed to read channel %d", chan);
|
|
return rc;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief Initialise the fuel gauge
|
|
*
|
|
* @param dev MAX17262 device to access
|
|
* @return 0 for success
|
|
* @return -EINVAL if the I2C controller could not be found
|
|
*/
|
|
static int max17262_gauge_init(const struct device *dev)
|
|
{
|
|
const struct max17262_config *const config = dev->config;
|
|
int16_t tmp, hibcfg;
|
|
|
|
if (!device_is_ready(config->i2c.bus)) {
|
|
LOG_ERR("Bus device is not ready");
|
|
return -ENODEV;
|
|
}
|
|
|
|
/* Read Status register */
|
|
max17262_reg_read(dev, STATUS, &tmp);
|
|
|
|
if (!(tmp & STATUS_POR)) {
|
|
/*
|
|
* Status.POR bit is set to 1 when MAX17262 detects that
|
|
* a software or hardware POR event has occurred and
|
|
* therefore a custom configuration needs to be set...
|
|
* If POR event did not happen (Status.POR == 0), skip
|
|
* init and continue with measurements.
|
|
*/
|
|
LOG_DBG("No POR event detected - skip device configuration");
|
|
return 0;
|
|
}
|
|
LOG_DBG("POR detected, setting custom device configuration...");
|
|
|
|
/** STEP 1 */
|
|
max17262_reg_read(dev, FSTAT, &tmp);
|
|
|
|
/* Do not continue until FSTAT.DNR bit is cleared */
|
|
while (tmp & FSTAT_DNR) {
|
|
k_sleep(K_MSEC(10));
|
|
max17262_reg_read(dev, FSTAT, &tmp);
|
|
}
|
|
|
|
/** STEP 2 */
|
|
/* Store original HibCFG value */
|
|
max17262_reg_read(dev, HIBCFG, &hibcfg);
|
|
|
|
/* Exit Hibernate Mode step 1 */
|
|
max17262_reg_write(dev, SOFT_WAKEUP, 0x0090);
|
|
/* Exit Hibernate Mode step 2 */
|
|
max17262_reg_write(dev, HIBCFG, 0x0000);
|
|
/* Exit Hibernate Mode step 3 */
|
|
max17262_reg_write(dev, SOFT_WAKEUP, 0x0000);
|
|
|
|
/** STEP 2.1 --> OPTION 1 EZ Config (No INI file is needed) */
|
|
/* Write DesignCap */
|
|
max17262_reg_write(dev, DESIGN_CAP, config->design_cap);
|
|
|
|
/* Write IChgTerm */
|
|
max17262_reg_write(dev, ICHG_TERM, config->desired_charging_current);
|
|
|
|
/* Write VEmpty */
|
|
max17262_reg_write(dev, VEMPTY, ((config->empty_voltage / 10) << 7) |
|
|
((config->recovery_voltage / 40) & 0x7F));
|
|
|
|
/* Write ModelCFG */
|
|
if (config->charge_voltage > 4275) {
|
|
max17262_reg_write(dev, MODELCFG, 0x8400);
|
|
} else {
|
|
max17262_reg_write(dev, MODELCFG, 0x8000);
|
|
}
|
|
|
|
/*
|
|
* Read ModelCFG.Refresh (highest bit),
|
|
* proceed to Step 3 when ModelCFG.Refresh == 0
|
|
*/
|
|
max17262_reg_read(dev, MODELCFG, &tmp);
|
|
|
|
/* Do not continue until ModelCFG.Refresh == 0 */
|
|
while (tmp & MODELCFG_REFRESH) {
|
|
k_sleep(K_MSEC(10));
|
|
max17262_reg_read(dev, MODELCFG, &tmp);
|
|
}
|
|
|
|
/* Restore Original HibCFG value */
|
|
max17262_reg_write(dev, HIBCFG, hibcfg);
|
|
|
|
/** STEP 3 */
|
|
/* Read Status register */
|
|
max17262_reg_read(dev, STATUS, &tmp);
|
|
|
|
/* Clear PowerOnReset bit */
|
|
tmp &= ~STATUS_POR;
|
|
max17262_reg_write(dev, STATUS, tmp);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const struct sensor_driver_api max17262_battery_driver_api = {
|
|
.sample_fetch = max17262_sample_fetch,
|
|
.channel_get = max17262_channel_get,
|
|
};
|
|
|
|
#define MAX17262_INIT(n) \
|
|
static struct max17262_data max17262_data_##n; \
|
|
\
|
|
static const struct max17262_config max17262_config_##n = { \
|
|
.i2c = I2C_DT_SPEC_INST_GET(n), \
|
|
.design_voltage = DT_INST_PROP(n, design_voltage), \
|
|
.desired_voltage = DT_INST_PROP(n, desired_voltage), \
|
|
.desired_charging_current = \
|
|
DT_INST_PROP(n, desired_charging_current), \
|
|
.design_cap = DT_INST_PROP(n, design_cap), \
|
|
.empty_voltage = DT_INST_PROP(n, empty_voltage), \
|
|
.recovery_voltage = DT_INST_PROP(n, recovery_voltage), \
|
|
.charge_voltage = DT_INST_PROP(n, charge_voltage), \
|
|
}; \
|
|
\
|
|
DEVICE_DT_INST_DEFINE(n, &max17262_gauge_init, \
|
|
NULL, \
|
|
&max17262_data_##n, \
|
|
&max17262_config_##n, POST_KERNEL, \
|
|
CONFIG_SENSOR_INIT_PRIORITY, \
|
|
&max17262_battery_driver_api);
|
|
|
|
DT_INST_FOREACH_STATUS_OKAY(MAX17262_INIT)
|