Commit 297a533b authored by Lars-Peter Clausen's avatar Lars-Peter Clausen
Browse files

bq27x00: Cache battery registers 



This patch adds a register cache to the bq27x00 battery driver.
Usually multiple, if not all, power_supply properties are queried at once,
for example when an uevent is generated. Since some registers are used by
multiple properties caching the registers should reduce the number of
reads.

The cache is valid for 5 seconds this roughly matches the internal update
interval of the current register for the bq27000/bq27200.

Fast changing properties(*_NOW) which can be obtained by reading a single
register are not cached.

It will also be used in the follow up patch to check if the battery status
has been changed since the last update to emit power_supply_changed events.

Signed-off-by: default avatarLars-Peter Clausen <lars@metafoo.de>
Tested-by: default avatarGrazvydas Ignotas <notasas@gmail.com>
parent 7fb7ba58

drivers/power/bq27x00_battery.c

+150 −121
Original line number Diff line number Diff line
@@ -51,17 +51,30 @@ 


struct bq27x00_device_info;

struct bq27x00_access_methods {

	int (*read)(struct bq27x00_device_info *, u8 reg, int *rt_value,

			bool single);

	int (*read)(struct bq27x00_device_info *di, u8 reg, bool single);

};



enum bq27x00_chip { BQ27000, BQ27500 };



struct bq27x00_reg_cache {

	int temperature;

	int time_to_empty;

	int time_to_empty_avg;

	int time_to_full;

	int capacity;

	int flags;



	int current_now;

};



struct bq27x00_device_info {

	struct device 		*dev;

	int			id;

	enum bq27x00_chip	chip;



	struct bq27x00_reg_cache cache;

	unsigned long last_update;



	struct power_supply	bat;



	struct bq27x00_access_methods bus;
@@ -85,158 +98,178 @@ static enum power_supply_property bq27x00_battery_props[] = { 
 */



static inline int bq27x00_read(struct bq27x00_device_info *di, u8 reg,

		int *rt_value, bool single)

		bool single)

{

	return di->bus.read(di, reg, rt_value, single);

	return di->bus.read(di, reg, single);

}



/*

 * Return the battery temperature in tenths of degree Celsius

 * Return the battery Relative State-of-Charge

 * Or < 0 if something fails.

 */

static int bq27x00_battery_temperature(struct bq27x00_device_info *di)

static int bq27x00_battery_read_rsoc(struct bq27x00_device_info *di)

{

	int ret;

	int temp = 0;



	ret = bq27x00_read(di, BQ27x00_REG_TEMP, &temp, false);

	if (ret) {

		dev_err(di->dev, "error reading temperature\n");

		return ret;

	}

	int rsoc;



	if (di->chip == BQ27500)

		return temp - 2731;

		rsoc = bq27x00_read(di, BQ27500_REG_SOC, false);

	else

		return ((temp * 5) - 5463) / 2;

		rsoc = bq27x00_read(di, BQ27000_REG_RSOC, true);



	if (rsoc < 0)

		dev_err(di->dev, "error reading relative State-of-Charge\n");



	return rsoc;

}



/*

 * Return the battery Voltage in milivolts

 * Or < 0 if something fails.

 * Read a time register.

 * Return < 0 if something fails.

 */

static int bq27x00_battery_voltage(struct bq27x00_device_info *di)

static int bq27x00_battery_read_time(struct bq27x00_device_info *di, u8 reg)

{

	int ret;

	int volt = 0;

	int tval;



	ret = bq27x00_read(di, BQ27x00_REG_VOLT, &volt, false);

	if (ret) {

		dev_err(di->dev, "error reading voltage\n");

		return ret;

	tval = bq27x00_read(di, reg, false);

	if (tval < 0) {

		dev_err(di->dev, "error reading register %02x: %d\n", reg, tval);

		return tval;

	}



	return volt * 1000;

	if (tval == 65535)

		return -ENODATA;



	return tval * 60;

}



/*

 * Return the battery average current

 * Note that current can be negative signed as well

 * Or 0 if something fails.

 */

static int bq27x00_battery_current(struct bq27x00_device_info *di)

static void bq27x00_update(struct bq27x00_device_info *di)

{

	int ret;

	int curr = 0;

	int flags = 0;

	struct bq27x00_reg_cache cache = {0, };

	bool is_bq27500 = di->chip == BQ27500;



	ret = bq27x00_read(di, BQ27x00_REG_AI, &curr, false);

	if (ret) {

		dev_err(di->dev, "error reading current\n");

		return 0;

	}

	cache.flags = bq27x00_read(di, BQ27x00_REG_FLAGS, is_bq27500);

	if (cache.flags >= 0) {

		cache.capacity = bq27x00_battery_read_rsoc(di);

		cache.temperature = bq27x00_read(di, BQ27x00_REG_TEMP, false);

		cache.time_to_empty = bq27x00_battery_read_time(di, BQ27x00_REG_TTE);

		cache.time_to_empty_avg = bq27x00_battery_read_time(di, BQ27x00_REG_TTECP);

		cache.time_to_full = bq27x00_battery_read_time(di, BQ27x00_REG_TTF);



	if (di->chip == BQ27500) {

		/* bq27500 returns signed value */

		curr = (int)((s16)curr) * 1000;

	} else {

		ret = bq27x00_read(di, BQ27x00_REG_FLAGS, &flags, false);

		if (ret < 0) {

			dev_err(di->dev, "error reading flags\n");

			return 0;

		}

		if (flags & BQ27000_FLAG_CHGS) {

			dev_dbg(di->dev, "negative current!\n");

			curr = -curr;

		if (!is_bq27500)

			cache.current_now = bq27x00_read(di, BQ27x00_REG_AI, false);

	}

		curr = curr * 3570 / BQ27000_RS;



	/* Ignore current_now which is a snapshot of the current battery state

	 * and is likely to be different even between two consecutive reads */

	if (memcmp(&di->cache, &cache, sizeof(cache) - sizeof(int)) != 0) {

		di->cache = cache;

		power_supply_changed(&di->bat);

	}



	return curr;

	di->last_update = jiffies;

}



/*

 * Return the battery Relative State-of-Charge

 * Return the battery temperature in tenths of degree Celsius

 * Or < 0 if something fails.

 */

static int bq27x00_battery_rsoc(struct bq27x00_device_info *di)

static int bq27x00_battery_temperature(struct bq27x00_device_info *di,

	union power_supply_propval *val)

{

	int ret;

	int rsoc = 0;

	if (di->cache.temperature < 0)

		return di->cache.temperature;



	if (di->chip == BQ27500)

		ret = bq27x00_read(di, BQ27500_REG_SOC, &rsoc, false);

		val->intval = di->cache.temperature - 2731;

	else

		ret = bq27x00_read(di, BQ27000_REG_RSOC, &rsoc, true);

	if (ret) {

		dev_err(di->dev, "error reading relative State-of-Charge\n");

		return ret;

		val->intval = ((di->cache.temperature * 5) - 5463) / 2;



	return 0;

}



	return rsoc;

/*

 * Return the battery average current

 * Note that current can be negative signed as well

 * Or 0 if something fails.

 */

static int bq27x00_battery_current(struct bq27x00_device_info *di,

	union power_supply_propval *val)

{

	int curr;



	if (di->chip == BQ27500)

	    curr = bq27x00_read(di, BQ27x00_REG_AI, false);

	else

	    curr = di->cache.current_now;



	if (curr < 0)

		return curr;



	if (di->chip == BQ27500) {

		/* bq27500 returns signed value */

		val->intval = (int)((s16)curr) * 1000;

	} else {

		if (di->cache.flags & BQ27000_FLAG_CHGS) {

			dev_dbg(di->dev, "negative current!\n");

			curr = -curr;

		}



		val->intval = curr * 3570 / BQ27000_RS;

	}



	return 0;

}



static int bq27x00_battery_status(struct bq27x00_device_info *di,

	union power_supply_propval *val)

{

	int flags = 0;

	int status;

	int ret;



	ret = bq27x00_read(di, BQ27x00_REG_FLAGS, &flags, false);

	if (ret < 0) {

		dev_err(di->dev, "error reading flags\n");

		return ret;

	}



	if (di->chip == BQ27500) {

		if (flags & BQ27500_FLAG_FC)

		if (di->cache.flags & BQ27500_FLAG_FC)

			status = POWER_SUPPLY_STATUS_FULL;

		else if (flags & BQ27500_FLAG_DSC)

		else if (di->cache.flags & BQ27500_FLAG_DSC)

			status = POWER_SUPPLY_STATUS_DISCHARGING;

		else

			status = POWER_SUPPLY_STATUS_CHARGING;

	} else {

		if (flags & BQ27000_FLAG_CHGS)

		if (di->cache.flags & BQ27000_FLAG_CHGS)

			status = POWER_SUPPLY_STATUS_CHARGING;

		else

			status = POWER_SUPPLY_STATUS_DISCHARGING;

	}



	val->intval = status;



	return 0;

}



/*

 * Read a time register.

 * Return < 0 if something fails.

 * Return the battery Voltage in milivolts

 * Or < 0 if something fails.

 */

static int bq27x00_battery_time(struct bq27x00_device_info *di, int reg,

static int bq27x00_battery_voltage(struct bq27x00_device_info *di,

	union power_supply_propval *val)

{

	int tval = 0;

	int ret;

	int volt;



	ret = bq27x00_read(di, reg, &tval, false);

	if (ret) {

		dev_err(di->dev, "error reading register %02x\n", reg);

		return ret;

	volt = bq27x00_read(di, BQ27x00_REG_VOLT, false);

	if (volt < 0)

		return volt;



	val->intval = volt * 1000;



	return 0;

}



	if (tval == 65535)

		return -ENODATA;

static int bq27x00_simple_value(int value,

	union power_supply_propval *val)

{

	if (value < 0)

		return value;



	val->intval = value;



	val->intval = tval * 60;

	return 0;

}
@@ -249,9 +282,11 @@ static int bq27x00_battery_get_property(struct power_supply *psy, 
{

	int ret = 0;

	struct bq27x00_device_info *di = to_bq27x00_device_info(psy);

	int voltage = bq27x00_battery_voltage(di);



	if (psp != POWER_SUPPLY_PROP_PRESENT && voltage <= 0)

	if (time_is_before_jiffies(di->last_update + 5 * HZ))

		bq27x00_update(di);



	if (psp != POWER_SUPPLY_PROP_PRESENT && di->cache.flags < 0)

		return -ENODEV;



	switch (psp) {
@@ -259,29 +294,28 @@ static int bq27x00_battery_get_property(struct power_supply *psy, 
		ret = bq27x00_battery_status(di, val);

		break;

	case POWER_SUPPLY_PROP_VOLTAGE_NOW:

		val->intval = voltage;

		ret = bq27x00_battery_voltage(di, val);

		break;

	case POWER_SUPPLY_PROP_PRESENT:

		if (psp == POWER_SUPPLY_PROP_PRESENT)

			val->intval = voltage <= 0 ? 0 : 1;

		val->intval = di->cache.flags < 0 ? 0 : 1;

		break;

	case POWER_SUPPLY_PROP_CURRENT_NOW:

		val->intval = bq27x00_battery_current(di);

		ret = bq27x00_battery_current(di, val);

		break;

	case POWER_SUPPLY_PROP_CAPACITY:

		val->intval = bq27x00_battery_rsoc(di);

		ret = bq27x00_simple_value(di->cache.capacity, val);

		break;

	case POWER_SUPPLY_PROP_TEMP:

		val->intval = bq27x00_battery_temperature(di);

		ret = bq27x00_battery_temperature(di, val);

		break;

	case POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW:

		ret = bq27x00_battery_time(di, BQ27x00_REG_TTE, val);

		ret = bq27x00_simple_value(di->cache.time_to_empty, val);

		break;

	case POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG:

		ret = bq27x00_battery_time(di, BQ27x00_REG_TTECP, val);

		ret = bq27x00_simple_value(di->cache.time_to_empty_avg, val);

		break;

	case POWER_SUPPLY_PROP_TIME_TO_FULL_NOW:

		ret = bq27x00_battery_time(di, BQ27x00_REG_TTF, val);

		ret = bq27x00_simple_value(di->cache.time_to_full, val);

		break;

	case POWER_SUPPLY_PROP_TECHNOLOGY:

		val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
@@ -311,6 +345,8 @@ static int bq27x00_powersupply_init(struct bq27x00_device_info *di) 


	dev_info(di->dev, "support ver. %s enabled\n", DRIVER_VERSION);



	bq27x00_update(di);



	return 0;

}
@@ -324,13 +360,12 @@ static int bq27x00_powersupply_init(struct bq27x00_device_info *di) 
static DEFINE_IDR(battery_id);

static DEFINE_MUTEX(battery_mutex);



static int bq27x00_read_i2c(struct bq27x00_device_info *di, u8 reg,

			int *rt_value, bool single)

static int bq27x00_read_i2c(struct bq27x00_device_info *di, u8 reg, bool single)

{

	struct i2c_client *client = to_i2c_client(di->dev);

	struct i2c_msg msg[1];

	unsigned char data[2];

	int err;

	int ret;



	if (!client->adapter)

		return -ENODEV;
@@ -341,26 +376,24 @@ static int bq27x00_read_i2c(struct bq27x00_device_info *di, u8 reg, 
	msg->buf = data;



	data[0] = reg;

	err = i2c_transfer(client->adapter, msg, 1);

	ret = i2c_transfer(client->adapter, msg, 1);



	if (err >= 0) {

	if (ret >= 0) {

		if (!single)

			msg->len = 2;

		else

			msg->len = 1;



		msg->flags = I2C_M_RD;

		err = i2c_transfer(client->adapter, msg, 1);

		if (err >= 0) {

		ret = i2c_transfer(client->adapter, msg, 1);

		if (ret >= 0) {

			if (!single)

				*rt_value = get_unaligned_le16(data);

				ret = get_unaligned_le16(data);

			else

				*rt_value = data[0];



			return 0;

				ret = data[0];

		}

	}

	return err;

	return ret;

}



static int bq27x00_battery_probe(struct i2c_client *client,
@@ -477,7 +510,7 @@ static inline void bq27x00_battery_i2c_exit(void) {}; 
#ifdef CONFIG_BATTERY_BQ27X00_PLATFORM



static int bq27000_read_platform(struct bq27x00_device_info *di, u8 reg,

			int *rt_value, bool single)

			bool single)

{

	struct device *dev = di->dev;

	struct bq27000_platform_data *pdata = dev->platform_data;
@@ -504,14 +537,10 @@ static int bq27000_read_platform(struct bq27x00_device_info *di, u8 reg, 
		if (timeout == 0)

			return -EIO;



		*rt_value = (upper << 8) | lower;

	} else {

		lower = pdata->read(dev, reg);

		if (lower < 0)

			return lower;

		*rt_value = lower;

		return (upper << 8) | lower;

	}

	return 0;



	return pdata->read(dev, reg);

}



static int __devinit bq27000_battery_probe(struct platform_device *pdev)

CRA Git | Maintained and supported by SUSTech CRA and CCSE