Lines Matching refs:di
1042 #define BQ27XXX_DM_BUF(di, i) { \
1043 .class = (di)->dm_regs[i].subclass_id, \
1044 .block = (di)->dm_regs[i].offset / BQ27XXX_DM_SZ, \
1077 struct bq27xxx_device_info *di;
1086 list_for_each_entry(di, &bq27xxx_battery_devices, list)
1087 mod_delayed_work(system_wq, &di->work, 0);
1107 static inline int bq27xxx_read(struct bq27xxx_device_info *di, int reg_index,
1112 if (!di || di->regs[reg_index] == INVALID_REG_ADDR)
1115 ret = di->bus.read(di, di->regs[reg_index], single);
1117 dev_dbg(di->dev, "failed to read register 0x%02x (index %d)\n",
1118 di->regs[reg_index], reg_index);
1123 static inline int bq27xxx_write(struct bq27xxx_device_info *di, int reg_index,
1128 if (!di || di->regs[reg_index] == INVALID_REG_ADDR)
1131 if (!di->bus.write)
1134 ret = di->bus.write(di, di->regs[reg_index], value, single);
1136 dev_dbg(di->dev, "failed to write register 0x%02x (index %d)\n",
1137 di->regs[reg_index], reg_index);
1142 static inline int bq27xxx_read_block(struct bq27xxx_device_info *di, int reg_index,
1147 if (!di || di->regs[reg_index] == INVALID_REG_ADDR)
1150 if (!di->bus.read_bulk)
1153 ret = di->bus.read_bulk(di, di->regs[reg_index], data, len);
1155 dev_dbg(di->dev, "failed to read_bulk register 0x%02x (index %d)\n",
1156 di->regs[reg_index], reg_index);
1161 static inline int bq27xxx_write_block(struct bq27xxx_device_info *di, int reg_index,
1166 if (!di || di->regs[reg_index] == INVALID_REG_ADDR)
1169 if (!di->bus.write_bulk)
1172 ret = di->bus.write_bulk(di, di->regs[reg_index], data, len);
1174 dev_dbg(di->dev, "failed to write_bulk register 0x%02x (index %d)\n",
1175 di->regs[reg_index], reg_index);
1180 static int bq27xxx_battery_seal(struct bq27xxx_device_info *di)
1184 ret = bq27xxx_write(di, BQ27XXX_REG_CTRL, BQ27XXX_SEALED, false);
1186 dev_err(di->dev, "bus error on seal: %d\n", ret);
1193 static int bq27xxx_battery_unseal(struct bq27xxx_device_info *di)
1197 if (di->unseal_key == 0) {
1198 dev_err(di->dev, "unseal failed due to missing key\n");
1202 ret = bq27xxx_write(di, BQ27XXX_REG_CTRL, (u16)(di->unseal_key >> 16), false);
1206 ret = bq27xxx_write(di, BQ27XXX_REG_CTRL, (u16)di->unseal_key, false);
1213 dev_err(di->dev, "bus error on unseal: %d\n", ret);
1229 static int bq27xxx_battery_read_dm_block(struct bq27xxx_device_info *di,
1236 ret = bq27xxx_write(di, BQ27XXX_DM_CLASS, buf->class, true);
1240 ret = bq27xxx_write(di, BQ27XXX_DM_BLOCK, buf->block, true);
1246 ret = bq27xxx_read_block(di, BQ27XXX_DM_DATA, buf->data, BQ27XXX_DM_SZ);
1250 ret = bq27xxx_read(di, BQ27XXX_DM_CKSUM, true);
1265 dev_err(di->dev, "bus error reading chip memory: %d\n", ret);
1269 static void bq27xxx_battery_update_dm_block(struct bq27xxx_device_info *di,
1274 struct bq27xxx_dm_reg *reg = &di->dm_regs[reg_id];
1279 dev_warn(di->dev, "buffer does not match %s dm spec\n", str);
1284 dev_warn(di->dev, "%s dm spec has unsupported byte size\n", str);
1292 dev_info(di->dev, "%s has %u\n", str, val);
1297 if (!(di->opts & BQ27XXX_O_RAM) && !bq27xxx_dt_to_nvm) {
1299 if (!(di->opts & BQ27XXX_O_RAM)) {
1302 dev_warn(di->dev, "%s has %u; update to %u disallowed "
1312 dev_info(di->dev, "update %s to %u\n", str, val);
1318 static int bq27xxx_battery_cfgupdate_priv(struct bq27xxx_device_info *di, bool active)
1324 ret = bq27xxx_write(di, BQ27XXX_REG_CTRL, cmd, false);
1330 ret = bq27xxx_read(di, BQ27XXX_REG_FLAGS, false);
1335 if (!try && di->chip != BQ27425) { // 425 has a bug
1336 dev_err(di->dev, "timed out waiting for cfgupdate flag %d\n", active);
1341 dev_warn(di->dev, "cfgupdate %d, retries %d\n", active, limit - try);
1346 static inline int bq27xxx_battery_set_cfgupdate(struct bq27xxx_device_info *di)
1348 int ret = bq27xxx_battery_cfgupdate_priv(di, true);
1350 dev_err(di->dev, "bus error on set_cfgupdate: %d\n", ret);
1355 static inline int bq27xxx_battery_soft_reset(struct bq27xxx_device_info *di)
1357 int ret = bq27xxx_battery_cfgupdate_priv(di, false);
1359 dev_err(di->dev, "bus error on soft_reset: %d\n", ret);
1364 static int bq27xxx_battery_write_dm_block(struct bq27xxx_device_info *di,
1367 bool cfgup = di->opts & BQ27XXX_O_CFGUP;
1374 ret = bq27xxx_battery_set_cfgupdate(di);
1379 ret = bq27xxx_write(di, BQ27XXX_DM_CTRL, 0, true);
1383 ret = bq27xxx_write(di, BQ27XXX_DM_CLASS, buf->class, true);
1387 ret = bq27xxx_write(di, BQ27XXX_DM_BLOCK, buf->block, true);
1393 ret = bq27xxx_write_block(di, BQ27XXX_DM_DATA, buf->data, BQ27XXX_DM_SZ);
1397 ret = bq27xxx_write(di, BQ27XXX_DM_CKSUM,
1409 ret = bq27xxx_battery_soft_reset(di);
1422 bq27xxx_battery_soft_reset(di);
1424 dev_err(di->dev, "bus error writing chip memory: %d\n", ret);
1428 static void bq27xxx_battery_set_config(struct bq27xxx_device_info *di,
1431 struct bq27xxx_dm_buf bd = BQ27XXX_DM_BUF(di, BQ27XXX_DM_DESIGN_CAPACITY);
1432 struct bq27xxx_dm_buf bt = BQ27XXX_DM_BUF(di, BQ27XXX_DM_TERMINATE_VOLTAGE);
1435 if (bq27xxx_battery_unseal(di) < 0)
1440 bq27xxx_battery_read_dm_block(di, &bd);
1442 bq27xxx_battery_update_dm_block(di, &bd,
1445 bq27xxx_battery_update_dm_block(di, &bd,
1453 bq27xxx_battery_read_dm_block(di, &bt);
1454 bq27xxx_battery_update_dm_block(di, same ? &bd : &bt,
1461 bq27xxx_battery_write_dm_block(di, &bd);
1462 bq27xxx_battery_write_dm_block(di, &bt);
1464 bq27xxx_battery_seal(di);
1466 if (updated && !(di->opts & BQ27XXX_O_CFGUP)) {
1467 bq27xxx_write(di, BQ27XXX_REG_CTRL, BQ27XXX_RESET, false);
1473 static void bq27xxx_battery_settings(struct bq27xxx_device_info *di)
1478 if (power_supply_get_battery_info(di->bat, &info) < 0)
1481 if (!di->dm_regs) {
1482 dev_warn(di->dev, "data memory update not supported for chip\n");
1488 dev_warn(di->dev, "missing battery:energy-full-design-microwatt-hours\n");
1490 dev_warn(di->dev, "missing battery:charge-full-design-microamp-hours\n");
1494 max = di->dm_regs[BQ27XXX_DM_DESIGN_ENERGY].max;
1496 dev_err(di->dev, "invalid battery:energy-full-design-microwatt-hours %d\n",
1502 max = di->dm_regs[BQ27XXX_DM_DESIGN_CAPACITY].max;
1504 dev_err(di->dev, "invalid battery:charge-full-design-microamp-hours %d\n",
1509 min = di->dm_regs[BQ27XXX_DM_TERMINATE_VOLTAGE].min;
1510 max = di->dm_regs[BQ27XXX_DM_TERMINATE_VOLTAGE].max;
1514 dev_err(di->dev, "invalid battery:voltage-min-design-microvolt %d\n",
1522 bq27xxx_battery_set_config(di, info);
1529 static int bq27xxx_battery_read_soc(struct bq27xxx_device_info *di)
1533 if (di->opts & BQ27XXX_O_SOC_SI)
1534 soc = bq27xxx_read(di, BQ27XXX_REG_SOC, true);
1536 soc = bq27xxx_read(di, BQ27XXX_REG_SOC, false);
1539 dev_dbg(di->dev, "error reading State-of-Charge\n");
1548 static int bq27xxx_battery_read_charge(struct bq27xxx_device_info *di, u8 reg)
1552 charge = bq27xxx_read(di, reg, false);
1554 dev_dbg(di->dev, "error reading charge register %02x: %d\n",
1559 if (di->opts & BQ27XXX_O_ZERO)
1571 static inline int bq27xxx_battery_read_nac(struct bq27xxx_device_info *di)
1573 return bq27xxx_battery_read_charge(di, BQ27XXX_REG_NAC);
1580 static inline int bq27xxx_battery_read_rc(struct bq27xxx_device_info *di)
1582 return bq27xxx_battery_read_charge(di, BQ27XXX_REG_RC);
1589 static inline int bq27xxx_battery_read_fcc(struct bq27xxx_device_info *di)
1591 return bq27xxx_battery_read_charge(di, BQ27XXX_REG_FCC);
1598 static int bq27xxx_battery_read_dcap(struct bq27xxx_device_info *di)
1602 if (di->opts & BQ27XXX_O_ZERO)
1603 dcap = bq27xxx_read(di, BQ27XXX_REG_DCAP, true);
1605 dcap = bq27xxx_read(di, BQ27XXX_REG_DCAP, false);
1608 dev_dbg(di->dev, "error reading initial last measured discharge\n");
1612 if (di->opts & BQ27XXX_O_ZERO)
1624 static int bq27xxx_battery_read_energy(struct bq27xxx_device_info *di)
1628 ae = bq27xxx_read(di, BQ27XXX_REG_AE, false);
1630 dev_dbg(di->dev, "error reading available energy\n");
1634 if (di->opts & BQ27XXX_O_ZERO)
1646 static int bq27xxx_battery_read_temperature(struct bq27xxx_device_info *di)
1650 temp = bq27xxx_read(di, BQ27XXX_REG_TEMP, false);
1652 dev_err(di->dev, "error reading temperature\n");
1656 if (di->opts & BQ27XXX_O_ZERO)
1666 static int bq27xxx_battery_read_cyct(struct bq27xxx_device_info *di)
1670 cyct = bq27xxx_read(di, BQ27XXX_REG_CYCT, false);
1672 dev_err(di->dev, "error reading cycle count total\n");
1681 static int bq27xxx_battery_read_time(struct bq27xxx_device_info *di, u8 reg)
1685 tval = bq27xxx_read(di, reg, false);
1687 dev_dbg(di->dev, "error reading time register %02x: %d\n",
1701 static bool bq27xxx_battery_overtemp(struct bq27xxx_device_info *di, u16 flags)
1703 if (di->opts & BQ27XXX_O_OTDC)
1705 if (di->opts & BQ27XXX_O_UTOT)
1714 static bool bq27xxx_battery_undertemp(struct bq27xxx_device_info *di, u16 flags)
1716 if (di->opts & BQ27XXX_O_UTOT)
1725 static bool bq27xxx_battery_dead(struct bq27xxx_device_info *di, u16 flags)
1727 if (di->opts & BQ27XXX_O_ZERO)
1729 else if (di->opts & BQ27Z561_O_BITS)
1738 static bool bq27xxx_battery_capacity_inaccurate(struct bq27xxx_device_info *di,
1741 if (di->opts & BQ27XXX_O_HAS_CI)
1747 static int bq27xxx_battery_read_health(struct bq27xxx_device_info *di)
1750 if (unlikely(bq27xxx_battery_overtemp(di, di->cache.flags)))
1752 if (unlikely(bq27xxx_battery_undertemp(di, di->cache.flags)))
1754 if (unlikely(bq27xxx_battery_dead(di, di->cache.flags)))
1756 if (unlikely(bq27xxx_battery_capacity_inaccurate(di, di->cache.flags)))
1762 static bool bq27xxx_battery_is_full(struct bq27xxx_device_info *di, int flags)
1764 if (di->opts & BQ27XXX_O_ZERO)
1766 else if (di->opts & BQ27Z561_O_BITS)
1778 struct bq27xxx_device_info *di,
1783 bool single_flags = (di->opts & BQ27XXX_O_ZERO);
1787 curr = bq27xxx_read(di, BQ27XXX_REG_AI, false);
1789 dev_err(di->dev, "error reading current\n");
1796 flags = bq27xxx_read(di, BQ27XXX_REG_FLAGS, single_flags);
1798 dev_err(di->dev, "error reading flags\n");
1803 if (di->opts & BQ27XXX_O_ZERO) {
1805 dev_dbg(di->dev, "negative current!\n");
1824 if (bq27xxx_battery_is_full(di, flags))
1835 static void bq27xxx_battery_update_unlocked(struct bq27xxx_device_info *di)
1837 union power_supply_propval status = di->last_status;
1839 bool has_singe_flag = di->opts & BQ27XXX_O_ZERO;
1841 cache.flags = bq27xxx_read(di, BQ27XXX_REG_FLAGS, has_singe_flag);
1845 cache.temperature = bq27xxx_battery_read_temperature(di);
1846 if (di->regs[BQ27XXX_REG_TTE] != INVALID_REG_ADDR)
1847 cache.time_to_empty = bq27xxx_battery_read_time(di, BQ27XXX_REG_TTE);
1848 if (di->regs[BQ27XXX_REG_TTECP] != INVALID_REG_ADDR)
1849 cache.time_to_empty_avg = bq27xxx_battery_read_time(di, BQ27XXX_REG_TTECP);
1850 if (di->regs[BQ27XXX_REG_TTF] != INVALID_REG_ADDR)
1851 cache.time_to_full = bq27xxx_battery_read_time(di, BQ27XXX_REG_TTF);
1853 cache.charge_full = bq27xxx_battery_read_fcc(di);
1854 cache.capacity = bq27xxx_battery_read_soc(di);
1855 if (di->regs[BQ27XXX_REG_AE] != INVALID_REG_ADDR)
1856 cache.energy = bq27xxx_battery_read_energy(di);
1857 di->cache.flags = cache.flags;
1858 cache.health = bq27xxx_battery_read_health(di);
1859 if (di->regs[BQ27XXX_REG_CYCT] != INVALID_REG_ADDR)
1860 cache.cycle_count = bq27xxx_battery_read_cyct(di);
1866 if (!(di->opts & BQ27XXX_O_ZERO))
1867 bq27xxx_battery_current_and_status(di, NULL, &status, &cache);
1870 if (di->charge_design_full <= 0)
1871 di->charge_design_full = bq27xxx_battery_read_dcap(di);
1874 if ((di->cache.capacity != cache.capacity) ||
1875 (di->cache.flags != cache.flags) ||
1876 (di->last_status.intval != status.intval)) {
1877 di->last_status.intval = status.intval;
1878 power_supply_changed(di->bat);
1881 if (memcmp(&di->cache, &cache, sizeof(cache)) != 0)
1882 di->cache = cache;
1884 di->last_update = jiffies;
1886 if (!di->removed && poll_interval > 0)
1887 mod_delayed_work(system_wq, &di->work, poll_interval * HZ);
1890 void bq27xxx_battery_update(struct bq27xxx_device_info *di)
1892 mutex_lock(&di->lock);
1893 bq27xxx_battery_update_unlocked(di);
1894 mutex_unlock(&di->lock);
1900 struct bq27xxx_device_info *di =
1904 bq27xxx_battery_update(di);
1911 static int bq27xxx_battery_pwr_avg(struct bq27xxx_device_info *di,
1916 power = bq27xxx_read(di, BQ27XXX_REG_AP, false);
1918 dev_err(di->dev,
1924 if (di->opts & BQ27XXX_O_ZERO)
1933 static int bq27xxx_battery_capacity_level(struct bq27xxx_device_info *di,
1938 if (di->opts & BQ27XXX_O_ZERO) {
1939 if (di->cache.flags & BQ27000_FLAG_FC)
1941 else if (di->cache.flags & BQ27000_FLAG_EDVF)
1943 else if (di->cache.flags & BQ27000_FLAG_EDV1)
1947 } else if (di->opts & BQ27Z561_O_BITS) {
1948 if (di->cache.flags & BQ27Z561_FLAG_FC)
1950 else if (di->cache.flags & BQ27Z561_FLAG_FDC)
1955 if (di->cache.flags & BQ27XXX_FLAG_FC)
1957 else if (di->cache.flags & BQ27XXX_FLAG_SOCF)
1959 else if (di->cache.flags & BQ27XXX_FLAG_SOC1)
1974 static int bq27xxx_battery_voltage(struct bq27xxx_device_info *di,
1979 volt = bq27xxx_read(di, BQ27XXX_REG_VOLT, false);
1981 dev_err(di->dev, "error reading voltage\n");
2006 struct bq27xxx_device_info *di = power_supply_get_drvdata(psy);
2008 mutex_lock(&di->lock);
2009 if (time_is_before_jiffies(di->last_update + 5 * HZ))
2010 bq27xxx_battery_update_unlocked(di);
2011 mutex_unlock(&di->lock);
2013 if (psp != POWER_SUPPLY_PROP_PRESENT && di->cache.flags < 0)
2018 ret = bq27xxx_battery_current_and_status(di, NULL, val, NULL);
2021 ret = bq27xxx_battery_voltage(di, val);
2024 val->intval = di->cache.flags < 0 ? 0 : 1;
2027 ret = bq27xxx_battery_current_and_status(di, val, NULL, NULL);
2030 ret = bq27xxx_simple_value(di->cache.capacity, val);
2033 ret = bq27xxx_battery_capacity_level(di, val);
2036 ret = bq27xxx_simple_value(di->cache.temperature, val);
2041 ret = bq27xxx_simple_value(di->cache.time_to_empty, val);
2044 ret = bq27xxx_simple_value(di->cache.time_to_empty_avg, val);
2047 ret = bq27xxx_simple_value(di->cache.time_to_full, val);
2050 if (di->opts & BQ27XXX_O_MUL_CHEM)
2056 if (di->regs[BQ27XXX_REG_NAC] != INVALID_REG_ADDR)
2057 ret = bq27xxx_simple_value(bq27xxx_battery_read_nac(di), val);
2059 ret = bq27xxx_simple_value(bq27xxx_battery_read_rc(di), val);
2062 ret = bq27xxx_simple_value(di->cache.charge_full, val);
2065 ret = bq27xxx_simple_value(di->charge_design_full, val);
2075 ret = bq27xxx_simple_value(di->cache.cycle_count, val);
2078 ret = bq27xxx_simple_value(di->cache.energy, val);
2081 ret = bq27xxx_battery_pwr_avg(di, val);
2084 ret = bq27xxx_simple_value(di->cache.health, val);
2098 struct bq27xxx_device_info *di = power_supply_get_drvdata(psy);
2101 mod_delayed_work(system_wq, &di->work, HZ / 2);
2104 int bq27xxx_battery_setup(struct bq27xxx_device_info *di)
2108 .of_node = di->dev->of_node,
2109 .drv_data = di,
2112 INIT_DELAYED_WORK(&di->work, bq27xxx_battery_poll);
2113 mutex_init(&di->lock);
2115 di->regs = bq27xxx_chip_data[di->chip].regs;
2116 di->unseal_key = bq27xxx_chip_data[di->chip].unseal_key;
2117 di->dm_regs = bq27xxx_chip_data[di->chip].dm_regs;
2118 di->opts = bq27xxx_chip_data[di->chip].opts;
2120 psy_desc = devm_kzalloc(di->dev, sizeof(*psy_desc), GFP_KERNEL);
2124 psy_desc->name = di->name;
2126 psy_desc->properties = bq27xxx_chip_data[di->chip].props;
2127 psy_desc->num_properties = bq27xxx_chip_data[di->chip].props_size;
2131 di->bat = power_supply_register_no_ws(di->dev, psy_desc, &psy_cfg);
2132 if (IS_ERR(di->bat))
2133 return dev_err_probe(di->dev, PTR_ERR(di->bat),
2136 bq27xxx_battery_settings(di);
2137 bq27xxx_battery_update(di);
2140 list_add(&di->list, &bq27xxx_battery_devices);
2147 void bq27xxx_battery_teardown(struct bq27xxx_device_info *di)
2150 list_del(&di->list);
2154 mutex_lock(&di->lock);
2155 di->removed = true;
2156 mutex_unlock(&di->lock);
2158 cancel_delayed_work_sync(&di->work);
2160 power_supply_unregister(di->bat);
2161 mutex_destroy(&di->lock);