977 #define BQ27XXX_DM_BUF(di, i) { \  argument
978 	.class = (di)->dm_regs[i].subclass_id, \
979 	.block = (di)->dm_regs[i].offset / BQ27XXX_DM_SZ, \
1012 	struct bq27xxx_device_info *di;  in poll_interval_param_set()  local
1021 	list_for_each_entry(di, &bq27xxx_battery_devices, list) {  in poll_interval_param_set()
1022 		cancel_delayed_work_sync(&di->work);  in poll_interval_param_set()
1023 		schedule_delayed_work(&di->work, 0);  in poll_interval_param_set()
1044 static inline int bq27xxx_read(struct bq27xxx_device_info *di, int reg_index,  in bq27xxx_read()  argument
1049 	if (!di || di->regs[reg_index] == INVALID_REG_ADDR)  in bq27xxx_read()
1052 	ret = di->bus.read(di, di->regs[reg_index], single);  in bq27xxx_read()
1054 		dev_dbg(di->dev, "failed to read register 0x%02x (index %d)\n",  in bq27xxx_read()
1055 			di->regs[reg_index], reg_index);  in bq27xxx_read()
1060 static inline int bq27xxx_write(struct bq27xxx_device_info *di, int reg_index,  in bq27xxx_write()  argument
1065 	if (!di || di->regs[reg_index] == INVALID_REG_ADDR)  in bq27xxx_write()
1068 	if (!di->bus.write)  in bq27xxx_write()
1071 	ret = di->bus.write(di, di->regs[reg_index], value, single);  in bq27xxx_write()
1073 		dev_dbg(di->dev, "failed to write register 0x%02x (index %d)\n",  in bq27xxx_write()
1074 			di->regs[reg_index], reg_index);  in bq27xxx_write()
1079 static inline int bq27xxx_read_block(struct bq27xxx_device_info *di, int reg_index,  in bq27xxx_read_block()  argument
1084 	if (!di || di->regs[reg_index] == INVALID_REG_ADDR)  in bq27xxx_read_block()
1087 	if (!di->bus.read_bulk)  in bq27xxx_read_block()
1090 	ret = di->bus.read_bulk(di, di->regs[reg_index], data, len);  in bq27xxx_read_block()
1092 		dev_dbg(di->dev, "failed to read_bulk register 0x%02x (index %d)\n",  in bq27xxx_read_block()
1093 			di->regs[reg_index], reg_index);  in bq27xxx_read_block()
1098 static inline int bq27xxx_write_block(struct bq27xxx_device_info *di, int reg_index,  in bq27xxx_write_block()  argument
1103 	if (!di || di->regs[reg_index] == INVALID_REG_ADDR)  in bq27xxx_write_block()
1106 	if (!di->bus.write_bulk)  in bq27xxx_write_block()
1109 	ret = di->bus.write_bulk(di, di->regs[reg_index], data, len);  in bq27xxx_write_block()
1111 		dev_dbg(di->dev, "failed to write_bulk register 0x%02x (index %d)\n",  in bq27xxx_write_block()
1112 			di->regs[reg_index], reg_index);  in bq27xxx_write_block()
1117 static int bq27xxx_battery_seal(struct bq27xxx_device_info *di)  in bq27xxx_battery_seal()  argument
1121 	ret = bq27xxx_write(di, BQ27XXX_REG_CTRL, BQ27XXX_SEALED, false);  in bq27xxx_battery_seal()
1123 		dev_err(di->dev, "bus error on seal: %d\n", ret);  in bq27xxx_battery_seal()
1130 static int bq27xxx_battery_unseal(struct bq27xxx_device_info *di)  in bq27xxx_battery_unseal()  argument
1134 	if (di->unseal_key == 0) {  in bq27xxx_battery_unseal()
1135 		dev_err(di->dev, "unseal failed due to missing key\n");  in bq27xxx_battery_unseal()
1139 	ret = bq27xxx_write(di, BQ27XXX_REG_CTRL, (u16)(di->unseal_key >> 16), false);  in bq27xxx_battery_unseal()
1143 	ret = bq27xxx_write(di, BQ27XXX_REG_CTRL, (u16)di->unseal_key, false);  in bq27xxx_battery_unseal()
1150 	dev_err(di->dev, "bus error on unseal: %d\n", ret);  in bq27xxx_battery_unseal()
1166 static int bq27xxx_battery_read_dm_block(struct bq27xxx_device_info *di,  in bq27xxx_battery_read_dm_block()  argument
1173 	ret = bq27xxx_write(di, BQ27XXX_DM_CLASS, buf->class, true);  in bq27xxx_battery_read_dm_block()
1177 	ret = bq27xxx_write(di, BQ27XXX_DM_BLOCK, buf->block, true);  in bq27xxx_battery_read_dm_block()
1183 	ret = bq27xxx_read_block(di, BQ27XXX_DM_DATA, buf->data, BQ27XXX_DM_SZ);  in bq27xxx_battery_read_dm_block()
1187 	ret = bq27xxx_read(di, BQ27XXX_DM_CKSUM, true);  in bq27xxx_battery_read_dm_block()
1202 	dev_err(di->dev, "bus error reading chip memory: %d\n", ret);  in bq27xxx_battery_read_dm_block()
1206 static void bq27xxx_battery_update_dm_block(struct bq27xxx_device_info *di,  argument
1211 	struct bq27xxx_dm_reg *reg = &di->dm_regs[reg_id];
1216 		dev_warn(di->dev, "buffer does not match %s dm spec\n", str);
1221 		dev_warn(di->dev, "%s dm spec has unsupported byte size\n", str);
1229 		dev_info(di->dev, "%s has %u\n", str, val);
1234 	if (!(di->opts & BQ27XXX_O_RAM) && !bq27xxx_dt_to_nvm) {
1236 	if (!(di->opts & BQ27XXX_O_RAM)) {
1239 		dev_warn(di->dev, "%s has %u; update to %u disallowed "
1249 	dev_info(di->dev, "update %s to %u\n", str, val);
1255 static int bq27xxx_battery_cfgupdate_priv(struct bq27xxx_device_info *di, bool active)  argument
1261 	ret = bq27xxx_write(di, BQ27XXX_REG_CTRL, cmd, false);
1267 		ret = bq27xxx_read(di, BQ27XXX_REG_FLAGS, false);
1272 	if (!try && di->chip != BQ27425) { // 425 has a bug
1273 		dev_err(di->dev, "timed out waiting for cfgupdate flag %d\n", active);
1278 		dev_warn(di->dev, "cfgupdate %d, retries %d\n", active, limit - try);
1283 static inline int bq27xxx_battery_set_cfgupdate(struct bq27xxx_device_info *di)  argument
1285 	int ret = bq27xxx_battery_cfgupdate_priv(di, true);
1287 		dev_err(di->dev, "bus error on set_cfgupdate: %d\n", ret);
1292 static inline int bq27xxx_battery_soft_reset(struct bq27xxx_device_info *di)  argument
1294 	int ret = bq27xxx_battery_cfgupdate_priv(di, false);
1296 		dev_err(di->dev, "bus error on soft_reset: %d\n", ret);
1301 static int bq27xxx_battery_write_dm_block(struct bq27xxx_device_info *di,  argument
1304 	bool cfgup = di->opts & BQ27XXX_O_CFGUP;
1311 		ret = bq27xxx_battery_set_cfgupdate(di);
1316 	ret = bq27xxx_write(di, BQ27XXX_DM_CTRL, 0, true);
1320 	ret = bq27xxx_write(di, BQ27XXX_DM_CLASS, buf->class, true);
1324 	ret = bq27xxx_write(di, BQ27XXX_DM_BLOCK, buf->block, true);
1330 	ret = bq27xxx_write_block(di, BQ27XXX_DM_DATA, buf->data, BQ27XXX_DM_SZ);
1334 	ret = bq27xxx_write(di, BQ27XXX_DM_CKSUM,
1346 		ret = bq27xxx_battery_soft_reset(di);
1359 		bq27xxx_battery_soft_reset(di);
1361 	dev_err(di->dev, "bus error writing chip memory: %d\n", ret);
1365 static void bq27xxx_battery_set_config(struct bq27xxx_device_info *di,  argument
1368 	struct bq27xxx_dm_buf bd = BQ27XXX_DM_BUF(di, BQ27XXX_DM_DESIGN_CAPACITY);
1369 	struct bq27xxx_dm_buf bt = BQ27XXX_DM_BUF(di, BQ27XXX_DM_TERMINATE_VOLTAGE);
1372 	if (bq27xxx_battery_unseal(di) < 0)
1377 		bq27xxx_battery_read_dm_block(di, &bd);
1379 		bq27xxx_battery_update_dm_block(di, &bd,
1382 		bq27xxx_battery_update_dm_block(di, &bd,
1390 			bq27xxx_battery_read_dm_block(di, &bt);
1391 		bq27xxx_battery_update_dm_block(di, same ? &bd : &bt,
1398 	bq27xxx_battery_write_dm_block(di, &bd);
1399 	bq27xxx_battery_write_dm_block(di, &bt);
1401 	bq27xxx_battery_seal(di);
1403 	if (updated && !(di->opts & BQ27XXX_O_CFGUP)) {
1404 		bq27xxx_write(di, BQ27XXX_REG_CTRL, BQ27XXX_RESET, false);
1410 static void bq27xxx_battery_settings(struct bq27xxx_device_info *di)  argument
1415 	if (power_supply_get_battery_info(di->bat, &info) < 0)
1418 	if (!di->dm_regs) {
1419 		dev_warn(di->dev, "data memory update not supported for chip\n");
1425 			dev_warn(di->dev, "missing battery:energy-full-design-microwatt-hours\n");
1427 			dev_warn(di->dev, "missing battery:charge-full-design-microamp-hours\n");
1431 	max = di->dm_regs[BQ27XXX_DM_DESIGN_ENERGY].max;
1433 		dev_err(di->dev, "invalid battery:energy-full-design-microwatt-hours %d\n",
1439 	max = di->dm_regs[BQ27XXX_DM_DESIGN_CAPACITY].max;
1441 		dev_err(di->dev, "invalid battery:charge-full-design-microamp-hours %d\n",
1446 	min = di->dm_regs[BQ27XXX_DM_TERMINATE_VOLTAGE].min;
1447 	max = di->dm_regs[BQ27XXX_DM_TERMINATE_VOLTAGE].max;
1451 		dev_err(di->dev, "invalid battery:voltage-min-design-microvolt %d\n",
1459 		bq27xxx_battery_set_config(di, &info);
1466 static int bq27xxx_battery_read_soc(struct bq27xxx_device_info *di)  argument
1470 	if (di->opts & BQ27XXX_O_SOC_SI)
1471 		soc = bq27xxx_read(di, BQ27XXX_REG_SOC, true);
1473 		soc = bq27xxx_read(di, BQ27XXX_REG_SOC, false);
1476 		dev_dbg(di->dev, "error reading State-of-Charge\n");
1485 static int bq27xxx_battery_read_charge(struct bq27xxx_device_info *di, u8 reg)  argument
1489 	charge = bq27xxx_read(di, reg, false);
1491 		dev_dbg(di->dev, "error reading charge register %02x: %d\n",
1496 	if (di->opts & BQ27XXX_O_ZERO)
1508 static inline int bq27xxx_battery_read_nac(struct bq27xxx_device_info *di)  argument
1512 	if (di->opts & BQ27XXX_O_ZERO) {
1513 		flags = bq27xxx_read(di, BQ27XXX_REG_FLAGS, true);
1518 	return bq27xxx_battery_read_charge(di, BQ27XXX_REG_NAC);
1525 static inline int bq27xxx_battery_read_fcc(struct bq27xxx_device_info *di)  argument
1527 	return bq27xxx_battery_read_charge(di, BQ27XXX_REG_FCC);
1534 static int bq27xxx_battery_read_dcap(struct bq27xxx_device_info *di)  argument
1538 	if (di->opts & BQ27XXX_O_ZERO)
1539 		dcap = bq27xxx_read(di, BQ27XXX_REG_DCAP, true);
1541 		dcap = bq27xxx_read(di, BQ27XXX_REG_DCAP, false);
1544 		dev_dbg(di->dev, "error reading initial last measured discharge\n");
1548 	if (di->opts & BQ27XXX_O_ZERO)
1560 static int bq27xxx_battery_read_energy(struct bq27xxx_device_info *di)  argument
1564 	ae = bq27xxx_read(di, BQ27XXX_REG_AE, false);
1566 		dev_dbg(di->dev, "error reading available energy\n");
1570 	if (di->opts & BQ27XXX_O_ZERO)
1582 static int bq27xxx_battery_read_temperature(struct bq27xxx_device_info *di)  argument
1586 	temp = bq27xxx_read(di, BQ27XXX_REG_TEMP, false);
1588 		dev_err(di->dev, "error reading temperature\n");
1592 	if (di->opts & BQ27XXX_O_ZERO)
1602 static int bq27xxx_battery_read_cyct(struct bq27xxx_device_info *di)  argument
1606 	cyct = bq27xxx_read(di, BQ27XXX_REG_CYCT, false);
1608 		dev_err(di->dev, "error reading cycle count total\n");
1617 static int bq27xxx_battery_read_time(struct bq27xxx_device_info *di, u8 reg)  argument
1621 	tval = bq27xxx_read(di, reg, false);
1623 		dev_dbg(di->dev, "error reading time register %02x: %d\n",
1637 static bool bq27xxx_battery_overtemp(struct bq27xxx_device_info *di, u16 flags)  argument
1639 	if (di->opts & BQ27XXX_O_OTDC)
1641         if (di->opts & BQ27XXX_O_UTOT)
1650 static bool bq27xxx_battery_undertemp(struct bq27xxx_device_info *di, u16 flags)  argument
1652 	if (di->opts & BQ27XXX_O_UTOT)
1661 static bool bq27xxx_battery_dead(struct bq27xxx_device_info *di, u16 flags)  argument
1663 	if (di->opts & BQ27XXX_O_ZERO)
1665 	else if (di->opts & BQ27Z561_O_BITS)
1671 static int bq27xxx_battery_read_health(struct bq27xxx_device_info *di)  argument
1674 	if (unlikely(bq27xxx_battery_overtemp(di, di->cache.flags)))
1676 	if (unlikely(bq27xxx_battery_undertemp(di, di->cache.flags)))
1678 	if (unlikely(bq27xxx_battery_dead(di, di->cache.flags)))
1684 void bq27xxx_battery_update(struct bq27xxx_device_info *di)  argument
1687 	bool has_ci_flag = di->opts & BQ27XXX_O_HAS_CI;
1688 	bool has_singe_flag = di->opts & BQ27XXX_O_ZERO;
1690 	cache.flags = bq27xxx_read(di, BQ27XXX_REG_FLAGS, has_singe_flag);
1694 		cache.temperature = bq27xxx_battery_read_temperature(di);
1696 			dev_info_once(di->dev, "battery is not calibrated! ignoring capacity values\n");
1705 			if (di->regs[BQ27XXX_REG_TTE] != INVALID_REG_ADDR)
1706 				cache.time_to_empty = bq27xxx_battery_read_time(di, BQ27XXX_REG_TTE);
1707 			if (di->regs[BQ27XXX_REG_TTECP] != INVALID_REG_ADDR)
1708 				cache.time_to_empty_avg = bq27xxx_battery_read_time(di, BQ27XXX_REG_TTECP);
1709 			if (di->regs[BQ27XXX_REG_TTF] != INVALID_REG_ADDR)
1710 				cache.time_to_full = bq27xxx_battery_read_time(di, BQ27XXX_REG_TTF);
1712 			cache.charge_full = bq27xxx_battery_read_fcc(di);
1713 			cache.capacity = bq27xxx_battery_read_soc(di);
1714 			if (di->regs[BQ27XXX_REG_AE] != INVALID_REG_ADDR)
1715 				cache.energy = bq27xxx_battery_read_energy(di);
1716 			di->cache.flags = cache.flags;
1717 			cache.health = bq27xxx_battery_read_health(di);
1719 		if (di->regs[BQ27XXX_REG_CYCT] != INVALID_REG_ADDR)
1720 			cache.cycle_count = bq27xxx_battery_read_cyct(di);
1723 		if (di->charge_design_full <= 0)
1724 			di->charge_design_full = bq27xxx_battery_read_dcap(di);
1727 	if ((di->cache.capacity != cache.capacity) ||
1728 	    (di->cache.flags != cache.flags))
1729 		power_supply_changed(di->bat);
1731 	if (memcmp(&di->cache, &cache, sizeof(cache)) != 0)
1732 		di->cache = cache;
1734 	di->last_update = jiffies;
1740 	struct bq27xxx_device_info *di =  local
1744 	bq27xxx_battery_update(di);
1747 		schedule_delayed_work(&di->work, poll_interval * HZ);
1755 static int bq27xxx_battery_current(struct bq27xxx_device_info *di,  argument
1761 	curr = bq27xxx_read(di, BQ27XXX_REG_AI, false);
1763 		dev_err(di->dev, "error reading current\n");
1767 	if (di->opts & BQ27XXX_O_ZERO) {
1768 		flags = bq27xxx_read(di, BQ27XXX_REG_FLAGS, true);
1770 			dev_dbg(di->dev, "negative current!\n");
1787 static int bq27xxx_battery_pwr_avg(struct bq27xxx_device_info *di,  argument
1792 	power = bq27xxx_read(di, BQ27XXX_REG_AP, false);
1794 		dev_err(di->dev,
1800 	if (di->opts & BQ27XXX_O_ZERO)
1809 static int bq27xxx_battery_status(struct bq27xxx_device_info *di,  argument
1814 	if (di->opts & BQ27XXX_O_ZERO) {
1815 		if (di->cache.flags & BQ27000_FLAG_FC)
1817 		else if (di->cache.flags & BQ27000_FLAG_CHGS)
1821 	} else if (di->opts & BQ27Z561_O_BITS) {
1822 		if (di->cache.flags & BQ27Z561_FLAG_FC)
1824 		else if (di->cache.flags & BQ27Z561_FLAG_DIS_CH)
1829 		if (di->cache.flags & BQ27XXX_FLAG_FC)
1831 		else if (di->cache.flags & BQ27XXX_FLAG_DSC)
1838 	    (power_supply_am_i_supplied(di->bat) > 0))
1846 static int bq27xxx_battery_capacity_level(struct bq27xxx_device_info *di,  argument
1851 	if (di->opts & BQ27XXX_O_ZERO) {
1852 		if (di->cache.flags & BQ27000_FLAG_FC)
1854 		else if (di->cache.flags & BQ27000_FLAG_EDV1)
1856 		else if (di->cache.flags & BQ27000_FLAG_EDVF)
1860 	} else if (di->opts & BQ27Z561_O_BITS) {
1861 		if (di->cache.flags & BQ27Z561_FLAG_FC)
1863 		else if (di->cache.flags & BQ27Z561_FLAG_FDC)
1868 		if (di->cache.flags & BQ27XXX_FLAG_FC)
1870 		else if (di->cache.flags & BQ27XXX_FLAG_SOC1)
1872 		else if (di->cache.flags & BQ27XXX_FLAG_SOCF)
1887 static int bq27xxx_battery_voltage(struct bq27xxx_device_info *di,  argument
1892 	volt = bq27xxx_read(di, BQ27XXX_REG_VOLT, false);
1894 		dev_err(di->dev, "error reading voltage\n");
1919 	struct bq27xxx_device_info *di = power_supply_get_drvdata(psy);  local
1921 	mutex_lock(&di->lock);
1922 	if (time_is_before_jiffies(di->last_update + 5 * HZ)) {
1923 		cancel_delayed_work_sync(&di->work);
1924 		bq27xxx_battery_poll(&di->work.work);
1926 	mutex_unlock(&di->lock);
1928 	if (psp != POWER_SUPPLY_PROP_PRESENT && di->cache.flags < 0)
1933 		ret = bq27xxx_battery_status(di, val);
1936 		ret = bq27xxx_battery_voltage(di, val);
1939 		val->intval = di->cache.flags < 0 ? 0 : 1;
1942 		ret = bq27xxx_battery_current(di, val);
1945 		ret = bq27xxx_simple_value(di->cache.capacity, val);
1948 		ret = bq27xxx_battery_capacity_level(di, val);
1951 		ret = bq27xxx_simple_value(di->cache.temperature, val);
1956 		ret = bq27xxx_simple_value(di->cache.time_to_empty, val);
1959 		ret = bq27xxx_simple_value(di->cache.time_to_empty_avg, val);
1962 		ret = bq27xxx_simple_value(di->cache.time_to_full, val);
1965 		if (di->opts & BQ27XXX_O_MUL_CHEM)
1971 		ret = bq27xxx_simple_value(bq27xxx_battery_read_nac(di), val);
1974 		ret = bq27xxx_simple_value(di->cache.charge_full, val);
1977 		ret = bq27xxx_simple_value(di->charge_design_full, val);
1987 		ret = bq27xxx_simple_value(di->cache.cycle_count, val);
1990 		ret = bq27xxx_simple_value(di->cache.energy, val);
1993 		ret = bq27xxx_battery_pwr_avg(di, val);
1996 		ret = bq27xxx_simple_value(di->cache.health, val);
2010 	struct bq27xxx_device_info *di = power_supply_get_drvdata(psy);  local
2012 	cancel_delayed_work_sync(&di->work);
2013 	schedule_delayed_work(&di->work, 0);
2016 int bq27xxx_battery_setup(struct bq27xxx_device_info *di)  argument
2020 		.of_node = di->dev->of_node,
2021 		.drv_data = di,
2024 	INIT_DELAYED_WORK(&di->work, bq27xxx_battery_poll);
2025 	mutex_init(&di->lock);
2027 	di->regs       = bq27xxx_chip_data[di->chip].regs;
2028 	di->unseal_key = bq27xxx_chip_data[di->chip].unseal_key;
2029 	di->dm_regs    = bq27xxx_chip_data[di->chip].dm_regs;
2030 	di->opts       = bq27xxx_chip_data[di->chip].opts;
2032 	psy_desc = devm_kzalloc(di->dev, sizeof(*psy_desc), GFP_KERNEL);
2036 	psy_desc->name = di->name;
2038 	psy_desc->properties = bq27xxx_chip_data[di->chip].props;
2039 	psy_desc->num_properties = bq27xxx_chip_data[di->chip].props_size;
2043 	di->bat = power_supply_register_no_ws(di->dev, psy_desc, &psy_cfg);
2044 	if (IS_ERR(di->bat))
2045 		return dev_err_probe(di->dev, PTR_ERR(di->bat),
2048 	bq27xxx_battery_settings(di);
2049 	bq27xxx_battery_update(di);
2052 	list_add(&di->list, &bq27xxx_battery_devices);
2059 void bq27xxx_battery_teardown(struct bq27xxx_device_info *di)  argument
2069 	cancel_delayed_work_sync(&di->work);
2071 	power_supply_unregister(di->bat);
2074 	list_del(&di->list);
2077 	mutex_destroy(&di->lock);