Quelle  ltc4162-l-charger.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 *  Driver for Analog Devices (Linear Technology)
 *  LTC4162-L 35V/3.2A Multi-Cell Lithium-Ion Step-Down Battery Charger
 *  LTC4162-F 35V/3.2A Multi-Cell LiFePO4 Step-Down Battery Charger
 *  LTC4162-S 35V/3.2A Lead-Acid Step-Down Battery Charger
 *  LTC4015 35V/3.2A Multichemistry Buck Battery Charger Controller
 *  Copyright (C) 2020, Topic Embedded Products
 */

#include <linux/bitfield.h>
#include <linux/module.h>
#include <linux/delay.h>
#include <linux/of.h>
#include <linux/pm_runtime.h>
#include <linux/power_supply.h>
#include <linux/i2c.h>
#include <linux/regmap.h>

/* Registers (names based on what datasheet uses) */
#define LTC4162L_EN_LIMIT_ALERTS_REG  0x0D
#define LTC4162L_EN_CHARGER_STATE_ALERTS_REG 0x0E
#define LTC4162L_EN_CHARGE_STATUS_ALERTS_REG 0x0F
#define LTC4162L_CONFIG_BITS_REG  0x14
#define LTC4162L_IIN_LIMIT_TARGET  0x15
#define LTC4162L_ARM_SHIP_MODE   0x19
#define LTC4162L_CHARGE_CURRENT_SETTING  0X1A
#define LTC4162L_VCHARGE_SETTING  0X1B
#define LTC4162L_C_OVER_X_THRESHOLD  0x1C
#define LTC4162L_MAX_CV_TIME   0X1D
#define LTC4162L_MAX_CHARGE_TIME  0X1E
#define LTC4162L_CHARGER_CONFIG_BITS  0x29
#define LTC4162L_CHARGER_STATE   0x34
#define LTC4162L_CHARGE_STATUS   0x35
#define LTC4162L_LIMIT_ALERTS_REG  0x36
#define LTC4162L_CHARGER_STATE_ALERTS_REG 0x37
#define LTC4162L_CHARGE_STATUS_ALERTS_REG 0x38
#define LTC4162L_SYSTEM_STATUS_REG  0x39
#define LTC4162L_VBAT    0x3A
#define LTC4162L_VIN    0x3B
#define LTC4162L_VOUT    0x3C
#define LTC4162L_IBAT    0x3D
#define LTC4162L_IIN    0x3E
#define LTC4162L_DIE_TEMPERATURE  0x3F
#define LTC4162L_THERMISTOR_VOLTAGE  0x40
#define LTC4162L_BSR    0x41
#define LTC4162L_JEITA_REGION   0x42
#define LTC4162L_CHEM_CELLS_REG   0x43
#define LTC4162L_ICHARGE_DAC   0x44
#define LTC4162L_VCHARGE_DAC   0x45
#define LTC4162L_IIN_LIMIT_DAC   0x46
#define LTC4162L_VBAT_FILT   0x47
#define LTC4162L_INPUT_UNDERVOLTAGE_DAC  0x4B

#define LTC4162L_CHEM_MASK   GENMASK(11, 8)

enum ltc4162_chem {
 ltc4162_lad,
 ltc4162_l42,
 ltc4162_l41,
 ltc4162_l40,
 ltc4162_fad,
 ltc4162_ffs,
 ltc4162_fst,
 ltc4162_sst = 8,
 ltc4162_sad,
};

/* Enumeration as in datasheet. Individual bits are mutually exclusive. */
enum ltc4162l_state {
 battery_detection = 2048,
 charger_suspended = 256,
 precharge = 128,   /* trickle on low bat voltage */
 cc_cv_charge = 64, /* normal charge */
 ntc_pause = 32,
 timer_term = 16,
 c_over_x_term = 8, /* battery is full */
 max_charge_time_fault = 4,
 bat_missing_fault = 2,
 bat_short_fault = 1
};

/* Individual bits are mutually exclusive. Only active in charging states.*/
enum ltc4162l_charge_status {
 ilim_reg_active = 32,
 thermal_reg_active = 16,
 vin_uvcl_active = 8,
 iin_limit_active = 4,
 constant_current = 2,
 constant_voltage = 1,
 charger_off = 0
};

/* Magic number to write to ARM_SHIP_MODE register */
#define LTC4162L_ARM_SHIP_MODE_MAGIC 21325

struct ltc4162l_info;

struct ltc4162l_chip_info {
 const char *name;
 int (*get_vbat)(struct ltc4162l_info *info, unsigned int reg,
   union power_supply_propval *val);
 int (*get_vcharge)(struct ltc4162l_info *info, unsigned int reg,
      union power_supply_propval *val);
 int (*set_vcharge)(struct ltc4162l_info *info, unsigned int reg,
      unsigned int value);
 int (*get_die_temp)(struct ltc4162l_info *info,
       union power_supply_propval *val);
 unsigned int ibat_resolution_pv;
 unsigned int vin_resolution_uv;
 u8 telemetry_mask;
};

struct ltc4162l_info {
 struct i2c_client *client;
 struct regmap  *regmap;
 struct power_supply *charger;
 const struct ltc4162l_chip_info *chip_info;
 u32 rsnsb; /* Series resistor that sets charge current, microOhm */
 u32 rsnsi; /* Series resistor to measure input current, microOhm */
 u8 cell_count; /* Number of connected cells, 0 while unknown */
};

static u8 ltc4162l_get_cell_count(struct ltc4162l_info *info)
{
 int ret;
 unsigned int val;

 /* Once read successfully */
 if (info->cell_count)
  return info->cell_count;

 ret = regmap_read(info->regmap, LTC4162L_CHEM_CELLS_REG, &val);
 if (ret)
  return 0;

 /* Lower 4 bits is the cell count, or 0 if the chip doesn't know yet */
 val &= 0x0f;
 if (!val)
  return 0;

 /* Once determined, keep the value */
 info->cell_count = val;

 return val;
};

static u8 ltc4162l_get_chem_type(struct ltc4162l_info *info)
{
 int ret;
 unsigned int val;

 ret = regmap_read(info->regmap, LTC4162L_CHEM_CELLS_REG, &val);
 if (ret)
  return ret;

 return FIELD_GET(LTC4162L_CHEM_MASK, val);
};

/* Convert enum value to POWER_SUPPLY_STATUS value */
static int ltc4162l_state_decode(enum ltc4162l_state value)
{
 switch (value) {
 case precharge:
 case cc_cv_charge:
  return POWER_SUPPLY_STATUS_CHARGING;
 case c_over_x_term:
  return POWER_SUPPLY_STATUS_FULL;
 case bat_missing_fault:
 case bat_short_fault:
  return POWER_SUPPLY_STATUS_UNKNOWN;
 default:
  return POWER_SUPPLY_STATUS_NOT_CHARGING;
 }
};

static int ltc4162l_get_status(struct ltc4162l_info *info,
          union power_supply_propval *val)
{
 unsigned int regval;
 int ret;

 ret = regmap_read(info->regmap, LTC4162L_CHARGER_STATE, ®val);
 if (ret) {
  dev_err(&info->client->dev, "Failed to read CHARGER_STATE\n");
  return ret;
 }

 val->intval = ltc4162l_state_decode(regval);

 return 0;
}

static int ltc4162l_charge_status_decode(enum ltc4162l_charge_status value)
{
 if (!value)
  return POWER_SUPPLY_CHARGE_TYPE_NONE;

 /* constant voltage/current and input_current limit are "fast" modes */
 if (value <= iin_limit_active)
  return POWER_SUPPLY_CHARGE_TYPE_FAST;

 /* Anything that's not fast we'll return as trickle */
 return POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
}

static int ltc4162l_get_charge_type(struct ltc4162l_info *info,
        union power_supply_propval *val)
{
 unsigned int regval;
 int ret;

 ret = regmap_read(info->regmap, LTC4162L_CHARGE_STATUS, ®val);
 if (ret)
  return ret;

 val->intval = ltc4162l_charge_status_decode(regval);

 return 0;
}

static int ltc4162l_state_to_health(enum ltc4162l_state value)
{
 switch (value) {
 case ntc_pause:
  return POWER_SUPPLY_HEALTH_OVERHEAT;
 case timer_term:
  return POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE;
 case max_charge_time_fault:
  return POWER_SUPPLY_HEALTH_WATCHDOG_TIMER_EXPIRE;
 case bat_missing_fault:
  return POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
 case bat_short_fault:
  return POWER_SUPPLY_HEALTH_DEAD;
 default:
  return POWER_SUPPLY_HEALTH_GOOD;
 }
}

static int ltc4162l_get_health(struct ltc4162l_info *info,
          union power_supply_propval *val)
{
 unsigned int regval;
 int ret;

 ret = regmap_read(info->regmap, LTC4162L_CHARGER_STATE, ®val);
 if (ret)
  return ret;

 val->intval = ltc4162l_state_to_health(regval);

 return 0;
}

static int ltc4162l_get_online(struct ltc4162l_info *info,
          union power_supply_propval *val)
{
 unsigned int regval;
 int ret;

 ret = regmap_read(info->regmap, LTC4162L_SYSTEM_STATUS_REG, ®val);
 if (ret)
  return ret;

 /* BIT(2) indicates if input voltage is sufficient to charge */
 val->intval = !!(regval & BIT(2));

 return 0;
}

static int ltc4162l_get_vbat(struct ltc4162l_info *info,
      unsigned int reg,
      union power_supply_propval *val)
{
 unsigned int regval, chem_type;
 int ret;

 ret = regmap_read(info->regmap, reg, ®val);
 if (ret)
  return ret;

 /*
  * cell_count × scaling factor
  * For ltc4162-s, it uses a cell_count value of 2 for each group of 3
  * physical (2V) cells, thus will return 2, 4, 6, 8 for 6V, 12V, 18V,
  * and 24V respectively, and has to divide by 2 to multiply the scale
  * factor by 1, 2, 3, or 4 to represent a 6V, 12V, 18V, or 24V battery
  * respectively.
 */
 chem_type = ltc4162l_get_chem_type(info);
 switch (chem_type) {
 case ltc4162_lad ... ltc4162_fst:
  regval *= 1924;
  regval *= ltc4162l_get_cell_count(info);
  regval /= 10;
  val->intval = regval;

  return 0;
 case ltc4162_sst ... ltc4162_sad:
  regval *= 3848;
  regval *= ltc4162l_get_cell_count(info) / 2;
  regval /= 10;
  val->intval = regval;

  return 0;
 default:
  return -EINVAL;
 }
}

static int ltc4015_get_vbat(struct ltc4162l_info *info,
       unsigned int reg,
       union power_supply_propval *val)
{
 unsigned int regval, chem_type;
 int ret;

 ret = regmap_read(info->regmap, reg, ®val);
 if (ret)
  return ret;

 /*
  * cell count x scaling factor
  * ltc4015 lead-acid fixed and lead-acid programmable corresponds to
  * 0x7 and 0x8 chem respectively
 */
 chem_type = ltc4162l_get_chem_type(info);
 switch (chem_type) {
 case ltc4162_lad ... ltc4162_fst:
  regval *= 192264;
  regval *= ltc4162l_get_cell_count(info);
  regval /= 1000;
  val->intval = regval;

  return 0;
 case ltc4162_sst - 1 ... ltc4162_sad - 1:
  regval *= 128176;
  regval *= ltc4162l_get_cell_count(info);
  regval /= 1000;
  val->intval = regval;

  return 0;
 default:
  return -EINVAL;
 }
}

static int ltc4162l_get_ibat(struct ltc4162l_info *info,
        union power_supply_propval *val)
{
 const struct ltc4162l_chip_info *chip_info = info->chip_info;
 unsigned int regval;
 int ret;

 ret = regmap_read(info->regmap, LTC4162L_IBAT, ®val);
 if (ret)
  return ret;

 ret = (s16)(regval & 0xFFFF);
 val->intval = mult_frac(ret, chip_info->ibat_resolution_pv, info->rsnsb);

 return 0;
}


static int ltc4162l_get_input_voltage(struct ltc4162l_info *info,
          union power_supply_propval *val)
{
 const struct ltc4162l_chip_info *chip_info = info->chip_info;
 unsigned int regval;
 int ret;

 ret = regmap_read(info->regmap, LTC4162L_VIN, ®val);
 if (ret)
  return ret;

 val->intval =  regval * chip_info->vin_resolution_uv;

 return 0;
}

static int ltc4162l_get_input_current(struct ltc4162l_info *info,
          union power_supply_propval *val)
{
 const struct ltc4162l_chip_info *chip_info = info->chip_info;
 unsigned int regval;
 int ret;

 ret = regmap_read(info->regmap, LTC4162L_IIN, ®val);
 if (ret)
  return ret;

 ret = (s16)(regval & 0xFFFF);
 ret *= chip_info->ibat_resolution_pv;
 ret /= info->rsnsi;

 val->intval = ret;

 return 0;
}

static int ltc4162l_get_icharge(struct ltc4162l_info *info,
    unsigned int reg,
    union power_supply_propval *val)
{
 unsigned int regval;
 int ret;

 ret = regmap_read(info->regmap, reg, ®val);
 if (ret)
  return ret;

 regval &= GENMASK(5, 0);

 /* The charge current servo level: (icharge_dac + 1) × 1mV/RSNSB */
 ++regval;
 val->intval = 10000u * mult_frac(regval, 100000u, info->rsnsb);

 return 0;
}

static int ltc4162l_set_icharge(struct ltc4162l_info *info,
    unsigned int reg,
    unsigned int value)
{
 value = mult_frac(value, info->rsnsb, 100000u);
 value /= 10000u;

 /* Round to lowest possible */
 if (value)
  --value;

 if (value > 31)
  return -EINVAL;

 return regmap_write(info->regmap, reg, value);
}


static int ltc4162l_get_vcharge(struct ltc4162l_info *info,
    unsigned int reg,
    union power_supply_propval *val)
{
 unsigned int regval, chem_type;
 int ret;
 u32 voltage;

 ret = regmap_read(info->regmap, reg, ®val);
 if (ret)
  return ret;

 regval &= GENMASK(5, 0);

 /*
  * charge voltage setting can be computed from
  * cell_count × (vcharge_setting × a + b)
  * where vcharge_setting ranges from 0 to c (d).
  * for ltc4162l: a = 12.5mV , b = 3.8125V, c = 31, d = 4.2Vmax
  * for ltc4162f: a = 12.5mV , b = 3.4125V, c = 31, d = 3.8Vmax
  *
  * for ltc4162s, the charge voltage setting can be computed from
  * N x (vcharge_setting x 28.571mV + 6.0V)
  * where N is 1, 2, 3, or 4 for 6V, 12V, 18V, or 24V battery respectively,
  * and vcharge_setting ranges from 0 to 31
 */
 chem_type = ltc4162l_get_chem_type(info);
 switch (chem_type) {
 case ltc4162_lad ... ltc4162_l40:
  voltage = 3812500 + (regval * 12500);
  voltage *= ltc4162l_get_cell_count(info);
  val->intval = voltage;

  return 0;
 case ltc4162_fad ... ltc4162_fst:
  voltage = 3412500 + (regval * 12500);
  voltage *= ltc4162l_get_cell_count(info);
  val->intval = voltage;

  return 0;
 case ltc4162_sst ... ltc4162_sad:
  voltage = 6000000 + (regval * 28571);
  voltage *= ltc4162l_get_cell_count(info) / 2;
  val->intval = voltage;

  return 0;
 default:
  return -EINVAL;
 }
}

static int ltc4015_get_vcharge(struct ltc4162l_info *info,
          unsigned int reg,
          union power_supply_propval *val)
{
 unsigned int regval, chem_type;
 int ret;
 u32 voltage;

 ret = regmap_read(info->regmap, reg, ®val);
 if (ret)
  return ret;

 regval &= GENMASK(5, 0);

 /*
  * charge voltage setting can be computed from:
  * cell_count × (vcharge_setting × a + b)
  * where vcharge_setting ranges from 0 to c (d).
  * Li-Ion: a = 1/80V, b = 3.8125V, c = 31, d = 4.2Vmax
  * LiFePO4: a = 1/80V, b = 3.4125V, c = 31, d = 3.8Vmax
  * Lead Acid: a = 1/105V, b = 2V, c = 35, d = 2.6Vmax
 */
 chem_type = ltc4162l_get_chem_type(info);
 switch (chem_type) {
 case ltc4162_lad ... ltc4162_l40:
  voltage = 3812500 + (regval * 12500);
  voltage *= ltc4162l_get_cell_count(info);
  val->intval = voltage;

  return 0;
 case ltc4162_fad ... ltc4162_fst:
  voltage = 3412500 + (regval * 12500);
  voltage *= ltc4162l_get_cell_count(info);
  val->intval = voltage;

  return 0;
 case ltc4162_sst - 1 ... ltc4162_sad - 1:
  voltage = 2000000 + mult_frac(regval, 1000000, 105);
  voltage *= ltc4162l_get_cell_count(info);
  val->intval = voltage;

  return 0;
 default:
  return -EINVAL;
 }
}

static int ltc4162l_vcharge(unsigned int base_voltage,
       unsigned int scale_factor,
       unsigned int range,
       unsigned int value,
       u8 cell_count)
{
 value /= cell_count;

 if (value < base_voltage)
  return -EINVAL;

 value -= base_voltage;
 value /= scale_factor;

 if (value > range)
  return -EINVAL;

 return value;
}

static int ltc4162l_set_vcharge(struct ltc4162l_info *info,
    unsigned int reg,
    unsigned int value)
{
 unsigned int chem_type;
 u8 cell_count;

 chem_type = ltc4162l_get_chem_type(info);
 switch (chem_type) {
 case ltc4162_lad ... ltc4162_l40:
  cell_count = ltc4162l_get_cell_count(info);
  if (!cell_count)
   return -EBUSY;

  value = ltc4162l_vcharge(3812500, 12500, 31, value, cell_count);
  return regmap_write(info->regmap, reg, value);
 case ltc4162_fad ... ltc4162_fst:
  cell_count = ltc4162l_get_cell_count(info);
  if (!cell_count)
   return -EBUSY;

  value = ltc4162l_vcharge(3412500, 12500, 31, value, cell_count);
  return regmap_write(info->regmap, reg, value);
 case ltc4162_sst ... ltc4162_sad:
  cell_count = ltc4162l_get_cell_count(info) / 2;
  if (!cell_count)
   return -EBUSY;

  value = ltc4162l_vcharge(6000000, 28571, 31, value, cell_count);
  return regmap_write(info->regmap, reg, value);
 default:
  return -EINVAL;
 }
}

static int ltc4015_set_vcharge(struct ltc4162l_info *info,
          unsigned int reg,
          unsigned int value)
{
 unsigned int chem_type;
 u8 cell_count;

 chem_type = ltc4162l_get_chem_type(info);
 switch (chem_type) {
 case ltc4162_lad ... ltc4162_l40:
  cell_count = ltc4162l_get_cell_count(info);
  if (!cell_count)
   return -EBUSY;

  value = ltc4162l_vcharge(3812500, 12500, 31, value, cell_count);
  return regmap_write(info->regmap, reg, value);
 case ltc4162_fad ... ltc4162_fst:
  cell_count = ltc4162l_get_cell_count(info);
  if (!cell_count)
   return -EBUSY;

  value = ltc4162l_vcharge(3412500, 12500, 31, value, cell_count);
  return regmap_write(info->regmap, reg, value);
 case ltc4162_sst - 1 ... ltc4162_sad - 1:
  cell_count = ltc4162l_get_cell_count(info);
  if (!cell_count)
   return -EBUSY;

  value = ltc4162l_vcharge(2000000, 1000000 / 105, 35,
      value, cell_count);
  return regmap_write(info->regmap, reg, value);
 default:
  return -EINVAL;
 }
}

static int ltc4162l_get_iin_limit_dac(struct ltc4162l_info *info,
         union power_supply_propval *val)
{
 unsigned int regval;
 int ret;

 ret = regmap_read(info->regmap, LTC4162L_IIN_LIMIT_DAC, ®val);
 if (ret)
  return ret;

 regval &= GENMASK(5, 0);

 /* (iin_limit_dac + 1) × 500μV / RSNSI */
 ++regval;
 regval *= 5000000u;
 regval /= info->rsnsi;
 val->intval = 100u * regval;

 return 0;
}

static int ltc4162l_set_iin_limit(struct ltc4162l_info *info,
      unsigned int value)
{
 unsigned int regval;

 regval = mult_frac(value, info->rsnsi, 50000u);
 regval /= 10000u;
 if (regval)
  --regval;
 if (regval > 63)
  regval = 63;

 return regmap_write(info->regmap, LTC4162L_IIN_LIMIT_TARGET, regval);
}

static int ltc4162l_get_die_temp(struct ltc4162l_info *info,
     union power_supply_propval *val)
{
 unsigned int regval;
 int ret;

 ret = regmap_read(info->regmap, LTC4162L_DIE_TEMPERATURE, ®val);
 if (ret)
  return ret;

 /* die_temp × 0.0215°C/LSB - 264.4°C */
 ret = (s16)(regval & 0xFFFF);
 ret *= 215;
 ret /= 100; /* Centidegrees scale */
 ret -= 26440;
 val->intval = ret;

 return 0;
}

static int ltc4015_get_die_temp(struct ltc4162l_info *info,
    union power_supply_propval *val)
{
 unsigned int regval;
 int ret;

 ret = regmap_read(info->regmap, LTC4162L_DIE_TEMPERATURE, ®val);
 if (ret)
  return ret;

 /* (die_temp - 12010) / 45.6°C */
 ret = (s16)(regval & 0xFFFF);
 ret -= 12010;
 ret *= 1000;
 ret /= 456;
 val->intval = ret;

 return 0;
}

static int ltc4162l_get_term_current(struct ltc4162l_info *info,
         union power_supply_propval *val)
{
 const struct ltc4162l_chip_info *chip_info = info->chip_info;
 unsigned int regval;
 int ret;

 ret = regmap_read(info->regmap, LTC4162L_CHARGER_CONFIG_BITS, ®val);
 if (ret)
  return ret;

 /* Check if C_OVER_X_THRESHOLD is enabled */
 if (!(regval & BIT(2))) {
  val->intval = 0;
  return 0;
 }

 ret = regmap_read(info->regmap, LTC4162L_C_OVER_X_THRESHOLD, ®val);
 if (ret)
  return ret;

 regval *= chip_info->ibat_resolution_pv;
 regval /= info->rsnsb;
 val->intval = regval;

 return 0;
}

static int ltc4162l_set_term_current(struct ltc4162l_info *info,
         unsigned int value)
{
 int ret;
 unsigned int regval;

 if (!value) {
  /* Disable en_c_over_x_term when set to zero */
  return regmap_update_bits(info->regmap,
       LTC4162L_CHARGER_CONFIG_BITS,
       BIT(2), 0);
 }

 regval = mult_frac(value, info->rsnsb, 14660u);
 regval /= 100u;

 ret =  regmap_write(info->regmap, LTC4162L_C_OVER_X_THRESHOLD, regval);
 if (ret)
  return ret;

 /* Set en_c_over_x_term after changing the threshold value */
 return regmap_update_bits(info->regmap, LTC4162L_CHARGER_CONFIG_BITS,
      BIT(2), BIT(2));
}

/* Custom properties */
static const char * const ltc4162l_charge_status_name[] = {
 "ilim_reg_active", /* 32 */
 "thermal_reg_active",
 "vin_uvcl_active",
 "iin_limit_active",
 "constant_current",
 "constant_voltage",
 "charger_off" /* 0 */
};

static ssize_t charge_status_show(struct device *dev,
      struct device_attribute *attr, char *buf)
{
 struct power_supply *psy = to_power_supply(dev);
 struct ltc4162l_info *info = power_supply_get_drvdata(psy);
 const char *result = ltc4162l_charge_status_name[
    ARRAY_SIZE(ltc4162l_charge_status_name) - 1];
 unsigned int regval;
 unsigned int mask;
 unsigned int index;
 int ret;

 ret = regmap_read(info->regmap, LTC4162L_CHARGE_STATUS, ®val);
 if (ret)
  return ret;

 /* Only one bit is set according to datasheet, let's be safe here */
 for (mask = 32, index = 0; mask != 0; mask >>= 1, ++index) {
  if (regval & mask) {
   result = ltc4162l_charge_status_name[index];
   break;
  }
 }

 return sysfs_emit(buf, "%s\n", result);
}
static DEVICE_ATTR_RO(charge_status);

static ssize_t vbat_show(struct device *dev,
      struct device_attribute *attr, char *buf)
{
 struct power_supply *psy = to_power_supply(dev);
 struct ltc4162l_info *info = power_supply_get_drvdata(psy);
 const struct ltc4162l_chip_info *chip_info = info->chip_info;
 union power_supply_propval val;
 int ret;

 ret = chip_info->get_vbat(info, LTC4162L_VBAT, &val);
 if (ret)
  return ret;

 return sysfs_emit(buf, "%d\n", val.intval);
}
static DEVICE_ATTR_RO(vbat);

static ssize_t vbat_avg_show(struct device *dev,
      struct device_attribute *attr, char *buf)
{
 struct power_supply *psy = to_power_supply(dev);
 struct ltc4162l_info *info = power_supply_get_drvdata(psy);
 const struct ltc4162l_chip_info *chip_info = info->chip_info;
 union power_supply_propval val;
 int ret;

 ret = chip_info->get_vbat(info, LTC4162L_VBAT_FILT, &val);
 if (ret)
  return ret;

 return sysfs_emit(buf, "%d\n", val.intval);
}
static DEVICE_ATTR_RO(vbat_avg);

static ssize_t ibat_show(struct device *dev,
      struct device_attribute *attr, char *buf)
{
 struct power_supply *psy = to_power_supply(dev);
 struct ltc4162l_info *info = power_supply_get_drvdata(psy);
 union power_supply_propval val;
 int ret;

 ret = ltc4162l_get_ibat(info, &val);
 if (ret)
  return ret;

 return sysfs_emit(buf, "%d\n", val.intval);
}
static DEVICE_ATTR_RO(ibat);

static ssize_t force_telemetry_show(struct device *dev,
        struct device_attribute *attr, char *buf)
{
 struct power_supply *psy = to_power_supply(dev);
 struct ltc4162l_info *info = power_supply_get_drvdata(psy);
 unsigned int regval;
 int ret;

 ret = regmap_read(info->regmap, LTC4162L_CONFIG_BITS_REG, ®val);
 if (ret)
  return ret;

 return sysfs_emit(buf, "%u\n", regval &
     info->chip_info->telemetry_mask ? 1 : 0);
}

static ssize_t force_telemetry_store(struct device *dev,
 struct device_attribute *attr,
 const char *buf,
 size_t count)
{
 struct power_supply *psy = to_power_supply(dev);
 struct ltc4162l_info *info = power_supply_get_drvdata(psy);
 int ret;
 unsigned int value;

 ret = kstrtouint(buf, 0, &value);
 if (ret < 0)
  return ret;

 ret = regmap_update_bits(info->regmap, LTC4162L_CONFIG_BITS_REG,
     info->chip_info->telemetry_mask,
     value ? info->chip_info->telemetry_mask : 0);
 if (ret < 0)
  return ret;

 return count;
}

static DEVICE_ATTR_RW(force_telemetry);

static ssize_t arm_ship_mode_show(struct device *dev,
        struct device_attribute *attr, char *buf)
{
 struct power_supply *psy = to_power_supply(dev);
 struct ltc4162l_info *info = power_supply_get_drvdata(psy);
 unsigned int regval;
 int ret;

 ret = regmap_read(info->regmap, LTC4162L_ARM_SHIP_MODE, ®val);
 if (ret)
  return ret;

 return sysfs_emit(buf, "%u\n",
  regval == LTC4162L_ARM_SHIP_MODE_MAGIC ? 1 : 0);
}

static ssize_t arm_ship_mode_store(struct device *dev,
 struct device_attribute *attr,
 const char *buf,
 size_t count)
{
 struct power_supply *psy = to_power_supply(dev);
 struct ltc4162l_info *info = power_supply_get_drvdata(psy);
 int ret;
 unsigned int value;

 ret = kstrtouint(buf, 0, &value);
 if (ret < 0)
  return ret;

 ret = regmap_write(info->regmap, LTC4162L_ARM_SHIP_MODE,
    value ? LTC4162L_ARM_SHIP_MODE_MAGIC : 0);
 if (ret < 0)
  return ret;

 return count;
}

static DEVICE_ATTR_RW(arm_ship_mode);

static struct attribute *ltc4162l_sysfs_entries[] = {
 &dev_attr_charge_status.attr,
 &dev_attr_ibat.attr,
 &dev_attr_vbat.attr,
 &dev_attr_vbat_avg.attr,
 &dev_attr_force_telemetry.attr,
 &dev_attr_arm_ship_mode.attr,
 NULL,
};

static const struct attribute_group ltc4162l_attr_group = {
 .name = NULL, /* put in device directory */
 .attrs = ltc4162l_sysfs_entries,
};

static const struct attribute_group *ltc4162l_attr_groups[] = {
 <c4162l_attr_group,
 NULL,
};

static int ltc4162l_get_property(struct power_supply *psy,
     enum power_supply_property psp,
     union power_supply_propval *val)
{
 struct ltc4162l_info *info = power_supply_get_drvdata(psy);
 const struct ltc4162l_chip_info *chip_info = info->chip_info;

 switch (psp) {
 case POWER_SUPPLY_PROP_STATUS:
  return ltc4162l_get_status(info, val);
 case POWER_SUPPLY_PROP_CHARGE_TYPE:
  return ltc4162l_get_charge_type(info, val);
 case POWER_SUPPLY_PROP_HEALTH:
  return ltc4162l_get_health(info, val);
 case POWER_SUPPLY_PROP_ONLINE:
  return ltc4162l_get_online(info, val);
 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
  return ltc4162l_get_input_voltage(info, val);
 case POWER_SUPPLY_PROP_CURRENT_NOW:
  return ltc4162l_get_input_current(info, val);
 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
  return ltc4162l_get_icharge(info,
    LTC4162L_ICHARGE_DAC, val);
 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
  return ltc4162l_get_icharge(info,
    LTC4162L_CHARGE_CURRENT_SETTING, val);
 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
  return chip_info->get_vcharge(info, LTC4162L_VCHARGE_DAC, val);
 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
  return chip_info->get_vcharge(info, LTC4162L_VCHARGE_SETTING, val);
 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
  return ltc4162l_get_iin_limit_dac(info, val);
 case POWER_SUPPLY_PROP_TEMP:
  return chip_info->get_die_temp(info, val);
 case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT:
  return ltc4162l_get_term_current(info, val);
 default:
  return -EINVAL;
 }
}

static int ltc4162l_set_property(struct power_supply *psy,
      enum power_supply_property psp,
      const union power_supply_propval *val)
{
 struct ltc4162l_info *info = power_supply_get_drvdata(psy);

 switch (psp) {
 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
  return ltc4162l_set_icharge(info,
    LTC4162L_CHARGE_CURRENT_SETTING, val->intval);
 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
  return ltc4162l_set_vcharge(info,
    LTC4162L_VCHARGE_SETTING, val->intval);
 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
  return ltc4162l_set_iin_limit(info, val->intval);
 case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT:
  return ltc4162l_set_term_current(info, val->intval);
 default:
  return -EINVAL;
 }
}

static int ltc4162l_property_is_writeable(struct power_supply *psy,
      enum power_supply_property psp)
{
 switch (psp) {
 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
 case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT:
  return 1;
 default:
  return 0;
 }
}

/* Charger power supply property routines */
static enum power_supply_property ltc4162l_properties[] = {
 POWER_SUPPLY_PROP_STATUS,
 POWER_SUPPLY_PROP_CHARGE_TYPE,
 POWER_SUPPLY_PROP_HEALTH,
 POWER_SUPPLY_PROP_ONLINE,
 POWER_SUPPLY_PROP_VOLTAGE_NOW,
 POWER_SUPPLY_PROP_CURRENT_NOW,
 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,
 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX,
 POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,
 POWER_SUPPLY_PROP_TEMP,
 POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT,
};

static const struct power_supply_desc ltc4162l_desc = {
 .type  = POWER_SUPPLY_TYPE_MAINS,
 .properties = ltc4162l_properties,
 .num_properties = ARRAY_SIZE(ltc4162l_properties),
 .get_property = ltc4162l_get_property,
 .set_property = ltc4162l_set_property,
 .property_is_writeable = ltc4162l_property_is_writeable,
};

static const struct ltc4162l_chip_info ltc4162l_chip_info = {
 .name = "ltc4162-l",
 .get_vbat = ltc4162l_get_vbat,
 .get_vcharge = ltc4162l_get_vcharge,
 .set_vcharge = ltc4162l_set_vcharge,
 .get_die_temp = ltc4162l_get_die_temp,
 .ibat_resolution_pv = 1466000,
 .vin_resolution_uv = 1649,
 .telemetry_mask = BIT(2),
};

static const struct ltc4162l_chip_info ltc4162f_chip_info = {
 .name = "ltc4162-f",
 .get_vbat = ltc4162l_get_vbat,
 .get_vcharge = ltc4162l_get_vcharge,
 .set_vcharge = ltc4162l_set_vcharge,
 .get_die_temp = ltc4162l_get_die_temp,
 .ibat_resolution_pv = 1466000,
 .vin_resolution_uv = 1649,
 .telemetry_mask = BIT(2),
};

static const struct ltc4162l_chip_info ltc4162s_chip_info = {
 .name = "ltc4162-s",
 .get_vbat = ltc4162l_get_vbat,
 .get_vcharge = ltc4162l_get_vcharge,
 .set_vcharge = ltc4162l_set_vcharge,
 .get_die_temp = ltc4162l_get_die_temp,
 .ibat_resolution_pv = 1466000,
 .vin_resolution_uv = 1649,
 .telemetry_mask = BIT(2),
};

static const struct ltc4162l_chip_info ltc4015_chip_info = {
 .name = "ltc4015",
 .get_vbat = ltc4015_get_vbat,
 .get_vcharge = ltc4015_get_vcharge,
 .set_vcharge = ltc4015_set_vcharge,
 .get_die_temp = ltc4015_get_die_temp,
 .ibat_resolution_pv = 1464870,
 .vin_resolution_uv = 1648,
 .telemetry_mask = BIT(4),
};

static bool ltc4162l_is_writeable_reg(struct device *dev, unsigned int reg)
{
 /* all registers up to this one are writeable */
 if (reg <= LTC4162L_CHARGER_CONFIG_BITS)
  return true;

 /* The ALERTS registers can be written to clear alerts */
 if (reg >= LTC4162L_LIMIT_ALERTS_REG &&
     reg <= LTC4162L_CHARGE_STATUS_ALERTS_REG)
  return true;

 return false;
}

static bool ltc4162l_is_volatile_reg(struct device *dev, unsigned int reg)
{
 /* all registers after this one are read-only status registers */
 return reg > LTC4162L_CHARGER_CONFIG_BITS;
}

static const struct regmap_config ltc4162l_regmap_config = {
 .reg_bits = 8,
 .val_bits = 16,
 .val_format_endian = REGMAP_ENDIAN_LITTLE,
 .writeable_reg = ltc4162l_is_writeable_reg,
 .volatile_reg = ltc4162l_is_volatile_reg,
 .max_register = LTC4162L_INPUT_UNDERVOLTAGE_DAC,
 .cache_type = REGCACHE_MAPLE,
};

static void ltc4162l_clear_interrupts(struct ltc4162l_info *info)
{
 /* Acknowledge interrupt to chip by clearing all events */
 regmap_write(info->regmap, LTC4162L_LIMIT_ALERTS_REG, 0);
 regmap_write(info->regmap, LTC4162L_CHARGER_STATE_ALERTS_REG, 0);
 regmap_write(info->regmap, LTC4162L_CHARGE_STATUS_ALERTS_REG, 0);
}

static int ltc4162l_probe(struct i2c_client *client)
{
 struct i2c_adapter *adapter = client->adapter;
 struct device *dev = &client->dev;
 struct ltc4162l_info *info;
 struct power_supply_config ltc4162l_config = {};
 struct power_supply_desc *desc;
 const struct ltc4162l_chip_info *chip_info;
 u32 value;
 int ret;

 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA)) {
  dev_err(dev, "No support for SMBUS_WORD_DATA\n");
  return -ENODEV;
 }
 info = devm_kzalloc(dev, sizeof(*info), GFP_KERNEL);
 if (!info)
  return -ENOMEM;

 info->client = client;
 i2c_set_clientdata(client, info);

 chip_info = i2c_get_match_data(client);
 if (!chip_info)
  return -ENODEV;

 info->chip_info = chip_info;

 info->regmap = devm_regmap_init_i2c(client, <c4162l_regmap_config);
 if (IS_ERR(info->regmap)) {
  dev_err(dev, "Failed to initialize register map\n");
  return PTR_ERR(info->regmap);
 }

 ret = device_property_read_u32(dev, "lltc,rsnsb-micro-ohms",
           &info->rsnsb);
 if (ret) {
  dev_err(dev, "Missing lltc,rsnsb-micro-ohms property\n");
  return ret;
 }
 if (!info->rsnsb)
  return -EINVAL;

 ret = device_property_read_u32(dev, "lltc,rsnsi-micro-ohms",
           &info->rsnsi);
 if (ret) {
  dev_err(dev, "Missing lltc,rsnsi-micro-ohms property\n");
  return ret;
 }
 if (!info->rsnsi)
  return -EINVAL;

 if (!device_property_read_u32(dev, "lltc,cell-count", &value))
  info->cell_count = value;

 ltc4162l_config.fwnode = dev_fwnode(dev);
 ltc4162l_config.drv_data = info;
 ltc4162l_config.attr_grp = ltc4162l_attr_groups;

 /* Duplicate the default descriptor to set name based on chip_info. */
 desc = devm_kmemdup(dev, <c4162l_desc,
       sizeof(struct power_supply_desc), GFP_KERNEL);
 if (!desc)
  return -ENOMEM;

 desc->name = chip_info->name;

 info->charger = devm_power_supply_register(dev, desc, <c4162l_config);
 if (IS_ERR(info->charger)) {
  dev_err(dev, "Failed to register charger\n");
  return PTR_ERR(info->charger);
 }

 /* Disable the threshold alerts, we're not using them */
 regmap_write(info->regmap, LTC4162L_EN_LIMIT_ALERTS_REG, 0);

 /* Enable interrupts on all status changes */
 regmap_write(info->regmap, LTC4162L_EN_CHARGER_STATE_ALERTS_REG,
       0x1fff);
 regmap_write(info->regmap, LTC4162L_EN_CHARGE_STATUS_ALERTS_REG, 0x1f);

 ltc4162l_clear_interrupts(info);

 return 0;
}

static void ltc4162l_alert(struct i2c_client *client,
      enum i2c_alert_protocol type, unsigned int flag)
{
 struct ltc4162l_info *info = i2c_get_clientdata(client);

 if (type != I2C_PROTOCOL_SMBUS_ALERT)
  return;

 ltc4162l_clear_interrupts(info);
 power_supply_changed(info->charger);
}

static const struct i2c_device_id ltc4162l_i2c_id_table[] = {
 { "ltc4015", (kernel_ulong_t)<c4015_chip_info },
 { "ltc4162-f", (kernel_ulong_t)<c4162f_chip_info },
 { "ltc4162-l", (kernel_ulong_t)<c4162l_chip_info },
 { "ltc4162-s", (kernel_ulong_t)<c4162s_chip_info },
 { }
};
MODULE_DEVICE_TABLE(i2c, ltc4162l_i2c_id_table);

static const struct of_device_id ltc4162l_of_match[] __maybe_unused = {
 { .compatible = "lltc,ltc4015", .data = <c4015_chip_info },
 { .compatible = "lltc,ltc4162-f", .data = <c4162f_chip_info },
 { .compatible = "lltc,ltc4162-l", .data = <c4162l_chip_info },
 { .compatible = "lltc,ltc4162-s", .data = <c4162s_chip_info },
 { }
};
MODULE_DEVICE_TABLE(of, ltc4162l_of_match);

static struct i2c_driver ltc4162l_driver = {
 .probe  = ltc4162l_probe,
 .alert  = ltc4162l_alert,
 .id_table = ltc4162l_i2c_id_table,
 .driver = {
  .name  = "ltc4162-l-charger",
  .of_match_table = of_match_ptr(ltc4162l_of_match),
 },
};
module_i2c_driver(ltc4162l_driver);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mike Looijmans <mike.looijmans@topic.nl>");
MODULE_DESCRIPTION("LTC4162-L charger driver");