Lines Matching refs:di
1075 #define BQ27XXX_DM_BUF(di, i) { \ argument
1076 .class = (di)->dm_regs[i].subclass_id, \
1077 .block = (di)->dm_regs[i].offset / BQ27XXX_DM_SZ, \
1110 struct bq27xxx_device_info *di; in poll_interval_param_set() local
1119 list_for_each_entry(di, &bq27xxx_battery_devices, list) in poll_interval_param_set()
1120 mod_delayed_work(system_wq, &di->work, 0); in poll_interval_param_set()
1140 static inline int bq27xxx_read(struct bq27xxx_device_info *di, int reg_index, in bq27xxx_read() argument
1145 if (!di || di->regs[reg_index] == INVALID_REG_ADDR) in bq27xxx_read()
1148 ret = di->bus.read(di, di->regs[reg_index], single); in bq27xxx_read()
1150 dev_dbg(di->dev, "failed to read register 0x%02x (index %d)\n", in bq27xxx_read()
1151 di->regs[reg_index], reg_index); in bq27xxx_read()
1156 static inline int bq27xxx_write(struct bq27xxx_device_info *di, int reg_index, in bq27xxx_write() argument
1161 if (!di || di->regs[reg_index] == INVALID_REG_ADDR) in bq27xxx_write()
1164 if (!di->bus.write) in bq27xxx_write()
1167 ret = di->bus.write(di, di->regs[reg_index], value, single); in bq27xxx_write()
1169 dev_dbg(di->dev, "failed to write register 0x%02x (index %d)\n", in bq27xxx_write()
1170 di->regs[reg_index], reg_index); in bq27xxx_write()
1175 static inline int bq27xxx_read_block(struct bq27xxx_device_info *di, int reg_index, in bq27xxx_read_block() argument
1180 if (!di || di->regs[reg_index] == INVALID_REG_ADDR) in bq27xxx_read_block()
1183 if (!di->bus.read_bulk) in bq27xxx_read_block()
1186 ret = di->bus.read_bulk(di, di->regs[reg_index], data, len); in bq27xxx_read_block()
1188 dev_dbg(di->dev, "failed to read_bulk register 0x%02x (index %d)\n", in bq27xxx_read_block()
1189 di->regs[reg_index], reg_index); in bq27xxx_read_block()
1194 static inline int bq27xxx_write_block(struct bq27xxx_device_info *di, int reg_index, in bq27xxx_write_block() argument
1199 if (!di || di->regs[reg_index] == INVALID_REG_ADDR) in bq27xxx_write_block()
1202 if (!di->bus.write_bulk) in bq27xxx_write_block()
1205 ret = di->bus.write_bulk(di, di->regs[reg_index], data, len); in bq27xxx_write_block()
1207 dev_dbg(di->dev, "failed to write_bulk register 0x%02x (index %d)\n", in bq27xxx_write_block()
1208 di->regs[reg_index], reg_index); in bq27xxx_write_block()
1213 static int bq27xxx_battery_seal(struct bq27xxx_device_info *di) in bq27xxx_battery_seal() argument
1217 ret = bq27xxx_write(di, BQ27XXX_REG_CTRL, BQ27XXX_SEALED, false); in bq27xxx_battery_seal()
1219 dev_err(di->dev, "bus error on seal: %d\n", ret); in bq27xxx_battery_seal()
1226 static int bq27xxx_battery_unseal(struct bq27xxx_device_info *di) in bq27xxx_battery_unseal() argument
1230 if (di->unseal_key == 0) { in bq27xxx_battery_unseal()
1231 dev_err(di->dev, "unseal failed due to missing key\n"); in bq27xxx_battery_unseal()
1235 ret = bq27xxx_write(di, BQ27XXX_REG_CTRL, (u16)(di->unseal_key >> 16), false); in bq27xxx_battery_unseal()
1239 ret = bq27xxx_write(di, BQ27XXX_REG_CTRL, (u16)di->unseal_key, false); in bq27xxx_battery_unseal()
1246 dev_err(di->dev, "bus error on unseal: %d\n", ret); in bq27xxx_battery_unseal()
1262 static int bq27xxx_battery_read_dm_block(struct bq27xxx_device_info *di, in bq27xxx_battery_read_dm_block() argument
1269 ret = bq27xxx_write(di, BQ27XXX_DM_CLASS, buf->class, true); in bq27xxx_battery_read_dm_block()
1273 ret = bq27xxx_write(di, BQ27XXX_DM_BLOCK, buf->block, true); in bq27xxx_battery_read_dm_block()
1279 ret = bq27xxx_read_block(di, BQ27XXX_DM_DATA, buf->data, BQ27XXX_DM_SZ); in bq27xxx_battery_read_dm_block()
1283 ret = bq27xxx_read(di, BQ27XXX_DM_CKSUM, true); in bq27xxx_battery_read_dm_block()
1298 dev_err(di->dev, "bus error reading chip memory: %d\n", ret); in bq27xxx_battery_read_dm_block()
1302 static void bq27xxx_battery_update_dm_block(struct bq27xxx_device_info *di, argument
1307 struct bq27xxx_dm_reg *reg = &di->dm_regs[reg_id];
1312 dev_warn(di->dev, "buffer does not match %s dm spec\n", str);
1317 dev_warn(di->dev, "%s dm spec has unsupported byte size\n", str);
1325 dev_info(di->dev, "%s has %u\n", str, val);
1330 if (!(di->opts & BQ27XXX_O_RAM) && !bq27xxx_dt_to_nvm) {
1332 if (!(di->opts & BQ27XXX_O_RAM)) {
1335 dev_warn(di->dev, "%s has %u; update to %u disallowed "
1345 dev_info(di->dev, "update %s to %u\n", str, val);
1351 static int bq27xxx_battery_cfgupdate_priv(struct bq27xxx_device_info *di, bool active) argument
1357 ret = bq27xxx_write(di, BQ27XXX_REG_CTRL, cmd, false);
1363 ret = bq27xxx_read(di, BQ27XXX_REG_FLAGS, false);
1368 if (!try && di->chip != BQ27425) { // 425 has a bug
1369 dev_err(di->dev, "timed out waiting for cfgupdate flag %d\n", active);
1374 dev_warn(di->dev, "cfgupdate %d, retries %d\n", active, limit - try);
1379 static inline int bq27xxx_battery_set_cfgupdate(struct bq27xxx_device_info *di) argument
1381 int ret = bq27xxx_battery_cfgupdate_priv(di, true);
1383 dev_err(di->dev, "bus error on set_cfgupdate: %d\n", ret);
1388 static inline int bq27xxx_battery_soft_reset(struct bq27xxx_device_info *di) argument
1390 int ret = bq27xxx_battery_cfgupdate_priv(di, false);
1392 dev_err(di->dev, "bus error on soft_reset: %d\n", ret);
1397 static int bq27xxx_battery_write_dm_block(struct bq27xxx_device_info *di, argument
1400 bool cfgup = di->opts & BQ27XXX_O_CFGUP;
1407 ret = bq27xxx_battery_set_cfgupdate(di);
1412 ret = bq27xxx_write(di, BQ27XXX_DM_CTRL, 0, true);
1416 ret = bq27xxx_write(di, BQ27XXX_DM_CLASS, buf->class, true);
1420 ret = bq27xxx_write(di, BQ27XXX_DM_BLOCK, buf->block, true);
1426 ret = bq27xxx_write_block(di, BQ27XXX_DM_DATA, buf->data, BQ27XXX_DM_SZ);
1430 ret = bq27xxx_write(di, BQ27XXX_DM_CKSUM,
1442 ret = bq27xxx_battery_soft_reset(di);
1455 bq27xxx_battery_soft_reset(di);
1457 dev_err(di->dev, "bus error writing chip memory: %d\n", ret);
1461 static void bq27xxx_battery_set_config(struct bq27xxx_device_info *di, argument
1464 struct bq27xxx_dm_buf bd = BQ27XXX_DM_BUF(di, BQ27XXX_DM_DESIGN_CAPACITY);
1465 struct bq27xxx_dm_buf bt = BQ27XXX_DM_BUF(di, BQ27XXX_DM_TERMINATE_VOLTAGE);
1468 if (bq27xxx_battery_unseal(di) < 0)
1473 bq27xxx_battery_read_dm_block(di, &bd);
1475 bq27xxx_battery_update_dm_block(di, &bd,
1478 bq27xxx_battery_update_dm_block(di, &bd,
1486 bq27xxx_battery_read_dm_block(di, &bt);
1487 bq27xxx_battery_update_dm_block(di, same ? &bd : &bt,
1494 bq27xxx_battery_write_dm_block(di, &bd);
1495 bq27xxx_battery_write_dm_block(di, &bt);
1497 bq27xxx_battery_seal(di);
1499 if (updated && !(di->opts & BQ27XXX_O_CFGUP)) {
1500 bq27xxx_write(di, BQ27XXX_REG_CTRL, BQ27XXX_RESET, false);
1506 static void bq27xxx_battery_settings(struct bq27xxx_device_info *di) argument
1511 if (power_supply_get_battery_info(di->bat, &info) < 0)
1514 if (!di->dm_regs) {
1515 dev_warn(di->dev, "data memory update not supported for chip\n");
1521 dev_warn(di->dev, "missing battery:energy-full-design-microwatt-hours\n");
1523 dev_warn(di->dev, "missing battery:charge-full-design-microamp-hours\n");
1527 max = di->dm_regs[BQ27XXX_DM_DESIGN_ENERGY].max;
1529 dev_err(di->dev, "invalid battery:energy-full-design-microwatt-hours %d\n",
1535 max = di->dm_regs[BQ27XXX_DM_DESIGN_CAPACITY].max;
1537 dev_err(di->dev, "invalid battery:charge-full-design-microamp-hours %d\n",
1542 min = di->dm_regs[BQ27XXX_DM_TERMINATE_VOLTAGE].min;
1543 max = di->dm_regs[BQ27XXX_DM_TERMINATE_VOLTAGE].max;
1547 dev_err(di->dev, "invalid battery:voltage-min-design-microvolt %d\n",
1555 bq27xxx_battery_set_config(di, info);
1562 static int bq27xxx_battery_read_soc(struct bq27xxx_device_info *di) argument
1566 if (di->opts & BQ27XXX_O_SOC_SI)
1567 soc = bq27xxx_read(di, BQ27XXX_REG_SOC, true);
1569 soc = bq27xxx_read(di, BQ27XXX_REG_SOC, false);
1572 dev_dbg(di->dev, "error reading State-of-Charge\n");
1581 static int bq27xxx_battery_read_charge(struct bq27xxx_device_info *di, u8 reg) argument
1585 charge = bq27xxx_read(di, reg, false);
1587 dev_dbg(di->dev, "error reading charge register %02x: %d\n",
1592 if (di->opts & BQ27XXX_O_ZERO)
1604 static inline int bq27xxx_battery_read_nac(struct bq27xxx_device_info *di) argument
1606 return bq27xxx_battery_read_charge(di, BQ27XXX_REG_NAC);
1613 static inline int bq27xxx_battery_read_rc(struct bq27xxx_device_info *di) argument
1615 return bq27xxx_battery_read_charge(di, BQ27XXX_REG_RC);
1622 static inline int bq27xxx_battery_read_fcc(struct bq27xxx_device_info *di) argument
1624 return bq27xxx_battery_read_charge(di, BQ27XXX_REG_FCC);
1631 static int bq27xxx_battery_read_dcap(struct bq27xxx_device_info *di) argument
1635 if (di->opts & BQ27XXX_O_ZERO)
1636 dcap = bq27xxx_read(di, BQ27XXX_REG_DCAP, true);
1638 dcap = bq27xxx_read(di, BQ27XXX_REG_DCAP, false);
1641 dev_dbg(di->dev, "error reading initial last measured discharge\n");
1645 if (di->opts & BQ27XXX_O_ZERO)
1657 static int bq27xxx_battery_read_energy(struct bq27xxx_device_info *di) argument
1661 ae = bq27xxx_read(di, BQ27XXX_REG_AE, false);
1663 dev_dbg(di->dev, "error reading available energy\n");
1667 if (di->opts & BQ27XXX_O_ZERO)
1679 static int bq27xxx_battery_read_temperature(struct bq27xxx_device_info *di) argument
1683 temp = bq27xxx_read(di, BQ27XXX_REG_TEMP, false);
1685 dev_err(di->dev, "error reading temperature\n");
1689 if (di->opts & BQ27XXX_O_ZERO)
1699 static int bq27xxx_battery_read_cyct(struct bq27xxx_device_info *di) argument
1703 cyct = bq27xxx_read(di, BQ27XXX_REG_CYCT, false);
1705 dev_err(di->dev, "error reading cycle count total\n");
1714 static int bq27xxx_battery_read_time(struct bq27xxx_device_info *di, u8 reg) argument
1718 tval = bq27xxx_read(di, reg, false);
1720 dev_dbg(di->dev, "error reading time register %02x: %d\n",
1734 static bool bq27xxx_battery_overtemp(struct bq27xxx_device_info *di, u16 flags) argument
1736 if (di->opts & BQ27XXX_O_OTDC)
1738 if (di->opts & BQ27XXX_O_UTOT)
1747 static bool bq27xxx_battery_undertemp(struct bq27xxx_device_info *di, u16 flags) argument
1749 if (di->opts & BQ27XXX_O_UTOT)
1758 static bool bq27xxx_battery_dead(struct bq27xxx_device_info *di, u16 flags) argument
1760 if (di->opts & BQ27XXX_O_ZERO)
1762 else if (di->opts & BQ27Z561_O_BITS)
1771 static bool bq27xxx_battery_capacity_inaccurate(struct bq27xxx_device_info *di, argument
1774 if (di->opts & BQ27XXX_O_HAS_CI)
1780 static int bq27xxx_battery_read_health(struct bq27xxx_device_info *di) argument
1783 if (unlikely(bq27xxx_battery_overtemp(di, di->cache.flags)))
1785 if (unlikely(bq27xxx_battery_undertemp(di, di->cache.flags)))
1787 if (unlikely(bq27xxx_battery_dead(di, di->cache.flags)))
1789 if (unlikely(bq27xxx_battery_capacity_inaccurate(di, di->cache.flags)))
1795 static bool bq27xxx_battery_is_full(struct bq27xxx_device_info *di, int flags) argument
1797 if (di->opts & BQ27XXX_O_ZERO)
1799 else if (di->opts & BQ27Z561_O_BITS)
1811 struct bq27xxx_device_info *di, argument
1816 bool single_flags = (di->opts & BQ27XXX_O_ZERO);
1820 curr = bq27xxx_read(di, BQ27XXX_REG_AI, false);
1822 dev_err(di->dev, "error reading current\n");
1829 flags = bq27xxx_read(di, BQ27XXX_REG_FLAGS, single_flags);
1831 dev_err(di->dev, "error reading flags\n");
1836 if (di->opts & BQ27XXX_O_ZERO) {
1838 dev_dbg(di->dev, "negative current!\n");
1857 if (bq27xxx_battery_is_full(di, flags))
1868 static void bq27xxx_battery_update_unlocked(struct bq27xxx_device_info *di) argument
1870 union power_supply_propval status = di->last_status;
1872 bool has_singe_flag = di->opts & BQ27XXX_O_ZERO;
1874 cache.flags = bq27xxx_read(di, BQ27XXX_REG_FLAGS, has_singe_flag);
1878 cache.temperature = bq27xxx_battery_read_temperature(di);
1879 if (di->regs[BQ27XXX_REG_TTE] != INVALID_REG_ADDR)
1880 cache.time_to_empty = bq27xxx_battery_read_time(di, BQ27XXX_REG_TTE);
1881 if (di->regs[BQ27XXX_REG_TTECP] != INVALID_REG_ADDR)
1882 cache.time_to_empty_avg = bq27xxx_battery_read_time(di, BQ27XXX_REG_TTECP);
1883 if (di->regs[BQ27XXX_REG_TTF] != INVALID_REG_ADDR)
1884 cache.time_to_full = bq27xxx_battery_read_time(di, BQ27XXX_REG_TTF);
1886 cache.charge_full = bq27xxx_battery_read_fcc(di);
1887 cache.capacity = bq27xxx_battery_read_soc(di);
1888 if (di->regs[BQ27XXX_REG_AE] != INVALID_REG_ADDR)
1889 cache.energy = bq27xxx_battery_read_energy(di);
1890 di->cache.flags = cache.flags;
1891 cache.health = bq27xxx_battery_read_health(di);
1892 if (di->regs[BQ27XXX_REG_CYCT] != INVALID_REG_ADDR)
1893 cache.cycle_count = bq27xxx_battery_read_cyct(di);
1899 if (!(di->opts & BQ27XXX_O_ZERO))
1900 bq27xxx_battery_current_and_status(di, NULL, &status, &cache);
1903 if (di->charge_design_full <= 0)
1904 di->charge_design_full = bq27xxx_battery_read_dcap(di);
1907 if ((di->cache.capacity != cache.capacity) ||
1908 (di->cache.flags != cache.flags) ||
1909 (di->last_status.intval != status.intval)) {
1910 di->last_status.intval = status.intval;
1911 power_supply_changed(di->bat);
1914 if (memcmp(&di->cache, &cache, sizeof(cache)) != 0)
1915 di->cache = cache;
1917 di->last_update = jiffies;
1919 if (!di->removed && poll_interval > 0)
1920 mod_delayed_work(system_wq, &di->work, poll_interval * HZ);
1923 void bq27xxx_battery_update(struct bq27xxx_device_info *di) argument
1925 mutex_lock(&di->lock);
1926 bq27xxx_battery_update_unlocked(di);
1927 mutex_unlock(&di->lock);
1933 struct bq27xxx_device_info *di = local
1937 bq27xxx_battery_update(di);
1944 static int bq27xxx_battery_pwr_avg(struct bq27xxx_device_info *di, argument
1949 power = bq27xxx_read(di, BQ27XXX_REG_AP, false);
1951 dev_err(di->dev,
1957 if (di->opts & BQ27XXX_O_ZERO)
1966 static int bq27xxx_battery_capacity_level(struct bq27xxx_device_info *di, argument
1971 if (di->opts & BQ27XXX_O_ZERO) {
1972 if (di->cache.flags & BQ27000_FLAG_FC)
1974 else if (di->cache.flags & BQ27000_FLAG_EDVF)
1976 else if (di->cache.flags & BQ27000_FLAG_EDV1)
1980 } else if (di->opts & BQ27Z561_O_BITS) {
1981 if (di->cache.flags & BQ27Z561_FLAG_FC)
1983 else if (di->cache.flags & BQ27Z561_FLAG_FDC)
1988 if (di->cache.flags & BQ27XXX_FLAG_FC)
1990 else if (di->cache.flags & BQ27XXX_FLAG_SOCF)
1992 else if (di->cache.flags & BQ27XXX_FLAG_SOC1)
2007 static int bq27xxx_battery_voltage(struct bq27xxx_device_info *di, argument
2012 volt = bq27xxx_read(di, BQ27XXX_REG_VOLT, false);
2014 dev_err(di->dev, "error reading voltage\n");
2039 struct bq27xxx_device_info *di = power_supply_get_drvdata(psy); local
2041 mutex_lock(&di->lock);
2042 if (time_is_before_jiffies(di->last_update + 5 * HZ))
2043 bq27xxx_battery_update_unlocked(di);
2044 mutex_unlock(&di->lock);
2046 if (psp != POWER_SUPPLY_PROP_PRESENT && di->cache.flags < 0)
2051 ret = bq27xxx_battery_current_and_status(di, NULL, val, NULL);
2054 ret = bq27xxx_battery_voltage(di, val);
2057 val->intval = di->cache.flags < 0 ? 0 : 1;
2060 ret = bq27xxx_battery_current_and_status(di, val, NULL, NULL);
2063 ret = bq27xxx_simple_value(di->cache.capacity, val);
2066 ret = bq27xxx_battery_capacity_level(di, val);
2069 ret = bq27xxx_simple_value(di->cache.temperature, val);
2074 ret = bq27xxx_simple_value(di->cache.time_to_empty, val);
2077 ret = bq27xxx_simple_value(di->cache.time_to_empty_avg, val);
2080 ret = bq27xxx_simple_value(di->cache.time_to_full, val);
2083 if (di->opts & BQ27XXX_O_MUL_CHEM)
2089 if (di->regs[BQ27XXX_REG_NAC] != INVALID_REG_ADDR)
2090 ret = bq27xxx_simple_value(bq27xxx_battery_read_nac(di), val);
2092 ret = bq27xxx_simple_value(bq27xxx_battery_read_rc(di), val);
2095 ret = bq27xxx_simple_value(di->cache.charge_full, val);
2098 ret = bq27xxx_simple_value(di->charge_design_full, val);
2108 ret = bq27xxx_simple_value(di->cache.cycle_count, val);
2111 ret = bq27xxx_simple_value(di->cache.energy, val);
2114 ret = bq27xxx_battery_pwr_avg(di, val);
2117 ret = bq27xxx_simple_value(di->cache.health, val);
2131 struct bq27xxx_device_info *di = power_supply_get_drvdata(psy); local
2134 mod_delayed_work(system_wq, &di->work, HZ / 2);
2137 int bq27xxx_battery_setup(struct bq27xxx_device_info *di) argument
2141 .of_node = di->dev->of_node,
2142 .drv_data = di,
2145 INIT_DELAYED_WORK(&di->work, bq27xxx_battery_poll);
2146 mutex_init(&di->lock);
2148 di->regs = bq27xxx_chip_data[di->chip].regs;
2149 di->unseal_key = bq27xxx_chip_data[di->chip].unseal_key;
2150 di->dm_regs = bq27xxx_chip_data[di->chip].dm_regs;
2151 di->opts = bq27xxx_chip_data[di->chip].opts;
2153 psy_desc = devm_kzalloc(di->dev, sizeof(*psy_desc), GFP_KERNEL);
2157 psy_desc->name = di->name;
2159 psy_desc->properties = bq27xxx_chip_data[di->chip].props;
2160 psy_desc->num_properties = bq27xxx_chip_data[di->chip].props_size;
2164 di->bat = power_supply_register_no_ws(di->dev, psy_desc, &psy_cfg);
2165 if (IS_ERR(di->bat))
2166 return dev_err_probe(di->dev, PTR_ERR(di->bat),
2169 bq27xxx_battery_settings(di);
2170 bq27xxx_battery_update(di);
2173 list_add(&di->list, &bq27xxx_battery_devices);
2180 void bq27xxx_battery_teardown(struct bq27xxx_device_info *di) argument
2183 list_del(&di->list);
2187 mutex_lock(&di->lock);
2188 di->removed = true;
2189 mutex_unlock(&di->lock);
2191 cancel_delayed_work_sync(&di->work);
2193 power_supply_unregister(di->bat);
2194 mutex_destroy(&di->lock);