[linux-2.6-block.git] / drivers / power / ltc2941-battery-gauge.c

/*
 * I2C client/driver for the Linear Technology LTC2941 and LTC2943
 * Battery Gas Gauge IC
 *
 * Copyright (C) 2014 Topic Embedded Systems
 *
 * Author: Auryn Verwegen
 * Author: Mike Looijmans
 */
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/errno.h>
#include <linux/swab.h>
#include <linux/i2c.h>
#include <linux/delay.h>
#include <linux/power_supply.h>
#include <linux/slab.h>

#define I16_MSB(x)			((x >> 8) & 0xFF)
#define I16_LSB(x)			(x & 0xFF)

#define LTC294X_WORK_DELAY		10	/* Update delay in seconds */

#define LTC294X_MAX_VALUE		0xFFFF
#define LTC294X_MID_SUPPLY		0x7FFF

#define LTC2941_MAX_PRESCALER_EXP	7
#define LTC2943_MAX_PRESCALER_EXP	6

enum ltc294x_reg {
	LTC294X_REG_STATUS		= 0x00,
	LTC294X_REG_CONTROL		= 0x01,
	LTC294X_REG_ACC_CHARGE_MSB	= 0x02,
	LTC294X_REG_ACC_CHARGE_LSB	= 0x03,
	LTC294X_REG_THRESH_HIGH_MSB	= 0x04,
	LTC294X_REG_THRESH_HIGH_LSB	= 0x05,
	LTC294X_REG_THRESH_LOW_MSB	= 0x06,
	LTC294X_REG_THRESH_LOW_LSB	= 0x07,
	LTC294X_REG_VOLTAGE_MSB	= 0x08,
	LTC294X_REG_VOLTAGE_LSB	= 0x09,
	LTC294X_REG_CURRENT_MSB	= 0x0E,
	LTC294X_REG_CURRENT_LSB	= 0x0F,
	LTC294X_REG_TEMPERATURE_MSB	= 0x14,
	LTC294X_REG_TEMPERATURE_LSB	= 0x15,
};

#define LTC2943_REG_CONTROL_MODE_MASK (BIT(7) | BIT(6))
#define LTC2943_REG_CONTROL_MODE_SCAN BIT(7)
#define LTC294X_REG_CONTROL_PRESCALER_MASK	(BIT(5) | BIT(4) | BIT(3))
#define LTC294X_REG_CONTROL_SHUTDOWN_MASK	(BIT(0))
#define LTC294X_REG_CONTROL_PRESCALER_SET(x) \
	((x << 3) & LTC294X_REG_CONTROL_PRESCALER_MASK)
#define LTC294X_REG_CONTROL_ALCC_CONFIG_DISABLED	0

#define LTC2941_NUM_REGS	0x08
#define LTC2943_NUM_REGS	0x18

struct ltc294x_info {
	struct i2c_client *client;	/* I2C Client pointer */
	struct power_supply *supply;	/* Supply pointer */
	struct power_supply_desc supply_desc;	/* Supply description */
	struct delayed_work work;	/* Work scheduler */
	int num_regs;	/* Number of registers (chip type) */
	int charge;	/* Last charge register content */
	int r_sense;	/* mOhm */
	int Qlsb;	/* nAh */
};

static inline int convert_bin_to_uAh(
	const struct ltc294x_info *info, int Q)
{
	return ((Q * (info->Qlsb / 10))) / 100;
}

static inline int convert_uAh_to_bin(
	const struct ltc294x_info *info, int uAh)
{
	int Q;

	Q = (uAh * 100) / (info->Qlsb/10);
	return (Q < LTC294X_MAX_VALUE) ? Q : LTC294X_MAX_VALUE;
}

static int ltc294x_read_regs(struct i2c_client *client,
	enum ltc294x_reg reg, u8 *buf, int num_regs)
{
	int ret;
	struct i2c_msg msgs[2] = { };
	u8 reg_start = reg;

	msgs[0].addr	= client->addr;
	msgs[0].len	= 1;
	msgs[0].buf	= &reg_start;

	msgs[1].addr	= client->addr;
	msgs[1].len	= num_regs;
	msgs[1].buf	= buf;
	msgs[1].flags	= I2C_M_RD;

	ret = i2c_transfer(client->adapter, &msgs[0], 2);
	if (ret < 0) {
		dev_err(&client->dev, "ltc2941 read_reg failed!\n");
		return ret;
	}

	dev_dbg(&client->dev, "%s (%#x, %d) -> %#x\n",
		__func__, reg, num_regs, *buf);

	return 0;
}

static int ltc294x_write_regs(struct i2c_client *client,
	enum ltc294x_reg reg, const u8 *buf, int num_regs)
{
	int ret;
	u8 reg_start = reg;

	ret = i2c_smbus_write_i2c_block_data(client, reg_start, num_regs, buf);
	if (ret < 0) {
		dev_err(&client->dev, "ltc2941 write_reg failed!\n");
		return ret;
	}

	dev_dbg(&client->dev, "%s (%#x, %d) -> %#x\n",
		__func__, reg, num_regs, *buf);

	return 0;
}

static int ltc294x_reset(const struct ltc294x_info *info, int prescaler_exp)
{
	int ret;
	u8 value;
	u8 control;

	/* Read status and control registers */
	ret = ltc294x_read_regs(info->client, LTC294X_REG_CONTROL, &value, 1);
	if (ret < 0) {
		dev_err(&info->client->dev,
			"Could not read registers from device\n");
		goto error_exit;
	}

	control = LTC294X_REG_CONTROL_PRESCALER_SET(prescaler_exp) |
				LTC294X_REG_CONTROL_ALCC_CONFIG_DISABLED;
	/* Put the 2943 into "monitor" mode, so it measures every 10 sec */
	if (info->num_regs == LTC2943_NUM_REGS)
		control |= LTC2943_REG_CONTROL_MODE_SCAN;

	if (value != control) {
		ret = ltc294x_write_regs(info->client,
			LTC294X_REG_CONTROL, &control, 1);
		if (ret < 0) {
			dev_err(&info->client->dev,
				"Could not write register\n");
			goto error_exit;
		}
	}

	return 0;

error_exit:
	return ret;
}

static int ltc294x_read_charge_register(const struct ltc294x_info *info)
{
	int ret;
	u8 datar[2];

	ret = ltc294x_read_regs(info->client,
		LTC294X_REG_ACC_CHARGE_MSB, &datar[0], 2);
	if (ret < 0)
		return ret;
	return (datar[0] << 8) + datar[1];
}

static int ltc294x_get_charge_now(const struct ltc294x_info *info, int *val)
{
	int value = ltc294x_read_charge_register(info);

	if (value < 0)
		return value;
	/* When r_sense < 0, this counts up when the battery discharges */
	if (info->Qlsb < 0)
		value -= 0xFFFF;
	*val = convert_bin_to_uAh(info, value);
	return 0;
}

static int ltc294x_set_charge_now(const struct ltc294x_info *info, int val)
{
	int ret;
	u8 dataw[2];
	u8 ctrl_reg;
	s32 value;

	value = convert_uAh_to_bin(info, val);
	/* Direction depends on how sense+/- were connected */
	if (info->Qlsb < 0)
		value += 0xFFFF;
	if ((value < 0) || (value > 0xFFFF)) /* input validation */
		return -EINVAL;

	/* Read control register */
	ret = ltc294x_read_regs(info->client,
		LTC294X_REG_CONTROL, &ctrl_reg, 1);
	if (ret < 0)
		return ret;
	/* Disable analog section */
	ctrl_reg |= LTC294X_REG_CONTROL_SHUTDOWN_MASK;
	ret = ltc294x_write_regs(info->client,
		LTC294X_REG_CONTROL, &ctrl_reg, 1);
	if (ret < 0)
		return ret;
	/* Set new charge value */
	dataw[0] = I16_MSB(value);
	dataw[1] = I16_LSB(value);
	ret = ltc294x_write_regs(info->client,
		LTC294X_REG_ACC_CHARGE_MSB, &dataw[0], 2);
	if (ret < 0)
		goto error_exit;
	/* Enable analog section */
error_exit:
	ctrl_reg &= ~LTC294X_REG_CONTROL_SHUTDOWN_MASK;
	ret = ltc294x_write_regs(info->client,
		LTC294X_REG_CONTROL, &ctrl_reg, 1);

	return ret < 0 ? ret : 0;
}

static int ltc294x_get_charge_counter(
	const struct ltc294x_info *info, int *val)
{
	int value = ltc294x_read_charge_register(info);

	if (value < 0)
		return value;
	value -= LTC294X_MID_SUPPLY;
	*val = convert_bin_to_uAh(info, value);
	return 0;
}

static int ltc294x_get_voltage(const struct ltc294x_info *info, int *val)
{
	int ret;
	u8 datar[2];
	u32 value;

	ret = ltc294x_read_regs(info->client,
		LTC294X_REG_VOLTAGE_MSB, &datar[0], 2);
	value = (datar[0] << 8) | datar[1];
	*val = ((value * 23600) / 0xFFFF) * 1000; /* in uV */
	return ret;
}

static int ltc294x_get_current(const struct ltc294x_info *info, int *val)
{
	int ret;
	u8 datar[2];
	s32 value;

	ret = ltc294x_read_regs(info->client,
		LTC294X_REG_CURRENT_MSB, &datar[0], 2);
	value = (datar[0] << 8) | datar[1];
	value -= 0x7FFF;
	/* Value is in range -32k..+32k, r_sense is usually 10..50 mOhm,
	 * the formula below keeps everything in s32 range while preserving
	 * enough digits */
	*val = 1000 * ((60000 * value) / (info->r_sense * 0x7FFF)); /* in uA */
	return ret;
}

static int ltc294x_get_temperature(const struct ltc294x_info *info, int *val)
{
	int ret;
	u8 datar[2];
	u32 value;

	ret = ltc294x_read_regs(info->client,
		LTC294X_REG_TEMPERATURE_MSB, &datar[0], 2);
	value = (datar[0] << 8) | datar[1];
	/* Full-scale is 510 Kelvin, convert to centidegrees  */
	*val = (((51000 * value) / 0xFFFF) - 27215);
	return ret;
}

static int ltc294x_get_property(struct power_supply *psy,
				enum power_supply_property prop,
				union power_supply_propval *val)
{
	struct ltc294x_info *info = power_supply_get_drvdata(psy);

	switch (prop) {
	case POWER_SUPPLY_PROP_CHARGE_NOW:
		return ltc294x_get_charge_now(info, &val->intval);
	case POWER_SUPPLY_PROP_CHARGE_COUNTER:
		return ltc294x_get_charge_counter(info, &val->intval);
	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
		return ltc294x_get_voltage(info, &val->intval);
	case POWER_SUPPLY_PROP_CURRENT_NOW:
		return ltc294x_get_current(info, &val->intval);
	case POWER_SUPPLY_PROP_TEMP:
		return ltc294x_get_temperature(info, &val->intval);
	default:
		return -EINVAL;
	}
}

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

	switch (psp) {
	case POWER_SUPPLY_PROP_CHARGE_NOW:
		return ltc294x_set_charge_now(info, val->intval);
	default:
		return -EPERM;
	}
}

static int ltc294x_property_is_writeable(
	struct power_supply *psy, enum power_supply_property psp)
{
	switch (psp) {
	case POWER_SUPPLY_PROP_CHARGE_NOW:
		return 1;
	default:
		return 0;
	}
}

static void ltc294x_update(struct ltc294x_info *info)
{
	int charge = ltc294x_read_charge_register(info);

	if (charge != info->charge) {
		info->charge = charge;
		power_supply_changed(info->supply);
	}
}

static void ltc294x_work(struct work_struct *work)
{
	struct ltc294x_info *info;

	info = container_of(work, struct ltc294x_info, work.work);
	ltc294x_update(info);
	schedule_delayed_work(&info->work, LTC294X_WORK_DELAY * HZ);
}

static enum power_supply_property ltc294x_properties[] = {
	POWER_SUPPLY_PROP_CHARGE_COUNTER,
	POWER_SUPPLY_PROP_CHARGE_NOW,
	POWER_SUPPLY_PROP_VOLTAGE_NOW,
	POWER_SUPPLY_PROP_CURRENT_NOW,
	POWER_SUPPLY_PROP_TEMP,
};

static int ltc294x_i2c_remove(struct i2c_client *client)
{
	struct ltc294x_info *info = i2c_get_clientdata(client);

	cancel_delayed_work(&info->work);
	power_supply_unregister(info->supply);
	return 0;
}

static int ltc294x_i2c_probe(struct i2c_client *client,
	const struct i2c_device_id *id)
{
	struct power_supply_config psy_cfg = {};
	struct ltc294x_info *info;
	int ret;
	u32 prescaler_exp;
	s32 r_sense;
	struct device_node *np;

	info = devm_kzalloc(&client->dev, sizeof(*info), GFP_KERNEL);
	if (info == NULL)
		return -ENOMEM;

	i2c_set_clientdata(client, info);

	np = of_node_get(client->dev.of_node);

	info->num_regs = id->driver_data;
	info->supply_desc.name = np->name;

	/* r_sense can be negative, when sense+ is connected to the battery
	 * instead of the sense-. This results in reversed measurements. */
	ret = of_property_read_u32(np, "lltc,resistor-sense", &r_sense);
	if (ret < 0) {
		dev_err(&client->dev,
			"Could not find lltc,resistor-sense in devicetree\n");
		return ret;
	}
	info->r_sense = r_sense;

	ret = of_property_read_u32(np, "lltc,prescaler-exponent",
		&prescaler_exp);
	if (ret < 0) {
		dev_warn(&client->dev,
			"lltc,prescaler-exponent not in devicetree\n");
		prescaler_exp = LTC2941_MAX_PRESCALER_EXP;
	}

	if (info->num_regs == LTC2943_NUM_REGS) {
		if (prescaler_exp > LTC2943_MAX_PRESCALER_EXP)
			prescaler_exp = LTC2943_MAX_PRESCALER_EXP;
		info->Qlsb = ((340 * 50000) / r_sense) /
				(4096 / (1 << (2*prescaler_exp)));
	} else {
		if (prescaler_exp > LTC2941_MAX_PRESCALER_EXP)
			prescaler_exp = LTC2941_MAX_PRESCALER_EXP;
		info->Qlsb = ((85 * 50000) / r_sense) /
				(128 / (1 << prescaler_exp));
	}

	info->client = client;
	info->supply_desc.type = POWER_SUPPLY_TYPE_BATTERY;
	info->supply_desc.properties = ltc294x_properties;
	if (info->num_regs >= LTC294X_REG_TEMPERATURE_LSB)
		info->supply_desc.num_properties =
			ARRAY_SIZE(ltc294x_properties);
	else if (info->num_regs >= LTC294X_REG_CURRENT_LSB)
		info->supply_desc.num_properties =
			ARRAY_SIZE(ltc294x_properties) - 1;
	else if (info->num_regs >= LTC294X_REG_VOLTAGE_LSB)
		info->supply_desc.num_properties =
			ARRAY_SIZE(ltc294x_properties) - 2;
	else
		info->supply_desc.num_properties =
			ARRAY_SIZE(ltc294x_properties) - 3;
	info->supply_desc.get_property = ltc294x_get_property;
	info->supply_desc.set_property = ltc294x_set_property;
	info->supply_desc.property_is_writeable = ltc294x_property_is_writeable;
	info->supply_desc.external_power_changed	= NULL;

	psy_cfg.drv_data = info;

	INIT_DELAYED_WORK(&info->work, ltc294x_work);

	ret = ltc294x_reset(info, prescaler_exp);
	if (ret < 0) {
		dev_err(&client->dev, "Communication with chip failed\n");
		return ret;
	}

	info->supply = power_supply_register(&client->dev, &info->supply_desc,
					     &psy_cfg);
	if (IS_ERR(info->supply)) {
		dev_err(&client->dev, "failed to register ltc2941\n");
		return PTR_ERR(info->supply);
	} else {
		schedule_delayed_work(&info->work, LTC294X_WORK_DELAY * HZ);
	}

	return 0;
}

#ifdef CONFIG_PM_SLEEP

static int ltc294x_suspend(struct device *dev)
{
	struct i2c_client *client = to_i2c_client(dev);
	struct ltc294x_info *info = i2c_get_clientdata(client);

	cancel_delayed_work(&info->work);
	return 0;
}

static int ltc294x_resume(struct device *dev)
{
	struct i2c_client *client = to_i2c_client(dev);
	struct ltc294x_info *info = i2c_get_clientdata(client);

	schedule_delayed_work(&info->work, LTC294X_WORK_DELAY * HZ);
	return 0;
}

static SIMPLE_DEV_PM_OPS(ltc294x_pm_ops, ltc294x_suspend, ltc294x_resume);
#define LTC294X_PM_OPS (&ltc294x_pm_ops)

#else
#define LTC294X_PM_OPS NULL
#endif /* CONFIG_PM_SLEEP */


static const struct i2c_device_id ltc294x_i2c_id[] = {
	{"ltc2941", LTC2941_NUM_REGS},
	{"ltc2943", LTC2943_NUM_REGS},
	{ },
};
MODULE_DEVICE_TABLE(i2c, ltc294x_i2c_id);

static struct i2c_driver ltc294x_driver = {
	.driver = {
		.name	= "LTC2941",
		.pm	= LTC294X_PM_OPS,
	},
	.probe		= ltc294x_i2c_probe,
	.remove		= ltc294x_i2c_remove,
	.id_table	= ltc294x_i2c_id,
};
module_i2c_driver(ltc294x_driver);

MODULE_AUTHOR("Auryn Verwegen, Topic Embedded Systems");
MODULE_AUTHOR("Mike Looijmans, Topic Embedded Products");
MODULE_DESCRIPTION("LTC2941/LTC2943 Battery Gas Gauge IC driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
085bc24d ML	1	/*
	2	* I2C client/driver for the Linear Technology LTC2941 and LTC2943
	3	* Battery Gas Gauge IC
	4	*
	5	* Copyright (C) 2014 Topic Embedded Systems
	6	*
	7	* Author: Auryn Verwegen
	8	* Author: Mike Looijmans
	9	*/
	10	#include <linux/kernel.h>
	11	#include <linux/module.h>
	12	#include <linux/types.h>
	13	#include <linux/errno.h>
	14	#include <linux/swab.h>
	15	#include <linux/i2c.h>
	16	#include <linux/delay.h>
085bc24d ML	17	#include <linux/power_supply.h>
	18	#include <linux/slab.h>
	19
	20	#define I16_MSB(x) ((x >> 8) & 0xFF)
	21	#define I16_LSB(x) (x & 0xFF)
	22
	23	#define LTC294X_WORK_DELAY 10 /* Update delay in seconds */
	24
	25	#define LTC294X_MAX_VALUE 0xFFFF
	26	#define LTC294X_MID_SUPPLY 0x7FFF
	27
	28	#define LTC2941_MAX_PRESCALER_EXP 7
	29	#define LTC2943_MAX_PRESCALER_EXP 6
	30
	31	enum ltc294x_reg {
	32	LTC294X_REG_STATUS = 0x00,
	33	LTC294X_REG_CONTROL = 0x01,
	34	LTC294X_REG_ACC_CHARGE_MSB = 0x02,
	35	LTC294X_REG_ACC_CHARGE_LSB = 0x03,
	36	LTC294X_REG_THRESH_HIGH_MSB = 0x04,
	37	LTC294X_REG_THRESH_HIGH_LSB = 0x05,
	38	LTC294X_REG_THRESH_LOW_MSB = 0x06,
	39	LTC294X_REG_THRESH_LOW_LSB = 0x07,
	40	LTC294X_REG_VOLTAGE_MSB = 0x08,
	41	LTC294X_REG_VOLTAGE_LSB = 0x09,
	42	LTC294X_REG_CURRENT_MSB = 0x0E,
	43	LTC294X_REG_CURRENT_LSB = 0x0F,
	44	LTC294X_REG_TEMPERATURE_MSB = 0x14,
	45	LTC294X_REG_TEMPERATURE_LSB = 0x15,
	46	};
	47
	48	#define LTC2943_REG_CONTROL_MODE_MASK (BIT(7) \| BIT(6))
	49	#define LTC2943_REG_CONTROL_MODE_SCAN BIT(7)
	50	#define LTC294X_REG_CONTROL_PRESCALER_MASK (BIT(5) \| BIT(4) \| BIT(3))
	51	#define LTC294X_REG_CONTROL_SHUTDOWN_MASK (BIT(0))
	52	#define LTC294X_REG_CONTROL_PRESCALER_SET(x) \
	53	((x << 3) & LTC294X_REG_CONTROL_PRESCALER_MASK)
	54	#define LTC294X_REG_CONTROL_ALCC_CONFIG_DISABLED 0
	55
	56	#define LTC2941_NUM_REGS 0x08
	57	#define LTC2943_NUM_REGS 0x18
	58
	59	struct ltc294x_info {
	60	struct i2c_client client; / I2C Client pointer */
297d716f KK	61	struct power_supply supply; / Supply pointer */
297d716f KK	62	struct power_supply_desc supply_desc; /* Supply description */
085bc24d ML	63	struct delayed_work work; /* Work scheduler */
085bc24d ML	64	int num_regs; /* Number of registers (chip type) */
085bc24d ML	65	int charge; /* Last charge register content */
	66	int r_sense; /* mOhm */
	67	int Qlsb; /* nAh */
	68	};
	69
085bc24d ML	70	static inline int convert_bin_to_uAh(
	71	const struct ltc294x_info *info, int Q)
	72	{
	73	return ((Q * (info->Qlsb / 10))) / 100;
	74	}
	75
	76	static inline int convert_uAh_to_bin(
	77	const struct ltc294x_info *info, int uAh)
	78	{
	79	int Q;
	80
	81	Q = (uAh * 100) / (info->Qlsb/10);
	82	return (Q < LTC294X_MAX_VALUE) ? Q : LTC294X_MAX_VALUE;
	83	}
	84
	85	static int ltc294x_read_regs(struct i2c_client *client,
	86	enum ltc294x_reg reg, u8 *buf, int num_regs)
	87	{
	88	int ret;
	89	struct i2c_msg msgs[2] = { };
	90	u8 reg_start = reg;
	91
	92	msgs[0].addr = client->addr;
	93	msgs[0].len = 1;
	94	msgs[0].buf = &reg_start;
	95
	96	msgs[1].addr = client->addr;
	97	msgs[1].len = num_regs;
	98	msgs[1].buf = buf;
	99	msgs[1].flags = I2C_M_RD;
	100
	101	ret = i2c_transfer(client->adapter, &msgs[0], 2);
	102	if (ret < 0) {
	103	dev_err(&client->dev, "ltc2941 read_reg failed!\n");
	104	return ret;
	105	}
	106
	107	dev_dbg(&client->dev, "%s (%#x, %d) -> %#x\n",
	108	__func__, reg, num_regs, *buf);
	109
	110	return 0;
	111	}
	112
	113	static int ltc294x_write_regs(struct i2c_client *client,
	114	enum ltc294x_reg reg, const u8 *buf, int num_regs)
	115	{
	116	int ret;
	117	u8 reg_start = reg;
	118
	119	ret = i2c_smbus_write_i2c_block_data(client, reg_start, num_regs, buf);
	120	if (ret < 0) {
	121	dev_err(&client->dev, "ltc2941 write_reg failed!\n");
	122	return ret;
	123	}
	124
	125	dev_dbg(&client->dev, "%s (%#x, %d) -> %#x\n",
	126	__func__, reg, num_regs, *buf);
	127
	128	return 0;
	129	}
	130
	131	static int ltc294x_reset(const struct ltc294x_info *info, int prescaler_exp)
	132	{
	133	int ret;
134	u8 value;
135	u8 control;
136
137	/* Read status and control registers */
138	ret = ltc294x_read_regs(info->client, LTC294X_REG_CONTROL, &value, 1);
139	if (ret < 0) {
140	dev_err(&info->client->dev,
141	"Could not read registers from device\n");
142	goto error_exit;
143	}
144
145	control = LTC294X_REG_CONTROL_PRESCALER_SET(prescaler_exp) \|
146	LTC294X_REG_CONTROL_ALCC_CONFIG_DISABLED;
147	/* Put the 2943 into "monitor" mode, so it measures every 10 sec */
148	if (info->num_regs == LTC2943_NUM_REGS)
149	control \|= LTC2943_REG_CONTROL_MODE_SCAN;
150
151	if (value != control) {
152	ret = ltc294x_write_regs(info->client,
153	LTC294X_REG_CONTROL, &control, 1);
154	if (ret < 0) {
155	dev_err(&info->client->dev,
156	"Could not write register\n");
157	goto error_exit;
158	}
159	}
160
161	return 0;
162
163	error_exit:
164	return ret;
165	}
166
167	static int ltc294x_read_charge_register(const struct ltc294x_info *info)
168	{
169	int ret;
170	u8 datar[2];
171
172	ret = ltc294x_read_regs(info->client,
173	LTC294X_REG_ACC_CHARGE_MSB, &datar[0], 2);
174	if (ret < 0)
175	return ret;
176	return (datar[0] << 8) + datar[1];
177	}
178
179	static int ltc294x_get_charge_now(const struct ltc294x_info info, int val)
180	{
181	int value = ltc294x_read_charge_register(info);
182
183	if (value < 0)
184	return value;
185	/* When r_sense < 0, this counts up when the battery discharges */
186	if (info->Qlsb < 0)
187	value -= 0xFFFF;
188	*val = convert_bin_to_uAh(info, value);
189	return 0;
190	}
191
192	static int ltc294x_set_charge_now(const struct ltc294x_info *info, int val)
193	{
194	int ret;
195	u8 dataw[2];
196	u8 ctrl_reg;
197	s32 value;
198
199	value = convert_uAh_to_bin(info, val);
200	/* Direction depends on how sense+/- were connected */
201	if (info->Qlsb < 0)
202	value += 0xFFFF;
203	if ((value < 0) \|\| (value > 0xFFFF)) /* input validation */
204	return -EINVAL;
205
206	/* Read control register */
207	ret = ltc294x_read_regs(info->client,
208	LTC294X_REG_CONTROL, &ctrl_reg, 1);
209	if (ret < 0)
210	return ret;
211	/* Disable analog section */
212	ctrl_reg \|= LTC294X_REG_CONTROL_SHUTDOWN_MASK;
213	ret = ltc294x_write_regs(info->client,
214	LTC294X_REG_CONTROL, &ctrl_reg, 1);
215	if (ret < 0)
216	return ret;
217	/* Set new charge value */
218	dataw[0] = I16_MSB(value);
219	dataw[1] = I16_LSB(value);
220	ret = ltc294x_write_regs(info->client,
221	LTC294X_REG_ACC_CHARGE_MSB, &dataw[0], 2);
222	if (ret < 0)
223	goto error_exit;
224	/* Enable analog section */
225	error_exit:
226	ctrl_reg &= ~LTC294X_REG_CONTROL_SHUTDOWN_MASK;
227	ret = ltc294x_write_regs(info->client,
228	LTC294X_REG_CONTROL, &ctrl_reg, 1);
229
230	return ret < 0 ? ret : 0;
231	}
232
233	static int ltc294x_get_charge_counter(
234	const struct ltc294x_info info, int val)
235	{
236	int value = ltc294x_read_charge_register(info);
237
238	if (value < 0)
239	return value;
240	value -= LTC294X_MID_SUPPLY;
241	*val = convert_bin_to_uAh(info, value);
242	return 0;
243	}
244
245	static int ltc294x_get_voltage(const struct ltc294x_info info, int val)
246	{
247	int ret;
248	u8 datar[2];
249	u32 value;
250
251	ret = ltc294x_read_regs(info->client,
252	LTC294X_REG_VOLTAGE_MSB, &datar[0], 2);
253	value = (datar[0] << 8) \| datar[1];
254	val = ((value 23600) / 0xFFFF) * 1000; /* in uV */
255	return ret;
256	}
257
258	static int ltc294x_get_current(const struct ltc294x_info info, int val)
259	{
260	int ret;
261	u8 datar[2];
262	s32 value;
263
264	ret = ltc294x_read_regs(info->client,
265	LTC294X_REG_CURRENT_MSB, &datar[0], 2);
266	value = (datar[0] << 8) \| datar[1];
267	value -= 0x7FFF;
268	/* Value is in range -32k..+32k, r_sense is usually 10..50 mOhm,
269	* the formula below keeps everything in s32 range while preserving
270	* enough digits */
271	val = 1000 ((60000 * value) / (info->r_sense * 0x7FFF)); /* in uA */
272	return ret;
273	}
274
275	static int ltc294x_get_temperature(const struct ltc294x_info info, int val)
276	{
277	int ret;
278	u8 datar[2];
279	u32 value;
280
281	ret = ltc294x_read_regs(info->client,
282	LTC294X_REG_TEMPERATURE_MSB, &datar[0], 2);
283	value = (datar[0] << 8) \| datar[1];
284	/* Full-scale is 510 Kelvin, convert to centidegrees */
285	val = (((51000 value) / 0xFFFF) - 27215);
286	return ret;
287	}
288
289	static int ltc294x_get_property(struct power_supply *psy,
290	enum power_supply_property prop,
291	union power_supply_propval *val)
292	{
297d716f	293	struct ltc294x_info *info = power_supply_get_drvdata(psy);
085bc24d ML	294
	295	switch (prop) {
	296	case POWER_SUPPLY_PROP_CHARGE_NOW:
	297	return ltc294x_get_charge_now(info, &val->intval);
	298	case POWER_SUPPLY_PROP_CHARGE_COUNTER:
	299	return ltc294x_get_charge_counter(info, &val->intval);
	300	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
	301	return ltc294x_get_voltage(info, &val->intval);
	302	case POWER_SUPPLY_PROP_CURRENT_NOW:
	303	return ltc294x_get_current(info, &val->intval);
	304	case POWER_SUPPLY_PROP_TEMP:
	305	return ltc294x_get_temperature(info, &val->intval);
	306	default:
	307	return -EINVAL;
	308	}
	309	}
	310
	311	static int ltc294x_set_property(struct power_supply *psy,
	312	enum power_supply_property psp,
	313	const union power_supply_propval *val)
	314	{
297d716f	315	struct ltc294x_info *info = power_supply_get_drvdata(psy);
085bc24d ML	316
	317	switch (psp) {
	318	case POWER_SUPPLY_PROP_CHARGE_NOW:
	319	return ltc294x_set_charge_now(info, val->intval);
	320	default:
	321	return -EPERM;
	322	}
	323	}
	324
	325	static int ltc294x_property_is_writeable(
	326	struct power_supply *psy, enum power_supply_property psp)
	327	{
	328	switch (psp) {
	329	case POWER_SUPPLY_PROP_CHARGE_NOW:
	330	return 1;
	331	default:
	332	return 0;
	333	}
	334	}
	335
	336	static void ltc294x_update(struct ltc294x_info *info)
	337	{
	338	int charge = ltc294x_read_charge_register(info);
	339
	340	if (charge != info->charge) {
	341	info->charge = charge;
297d716f	342	power_supply_changed(info->supply);
085bc24d ML	343	}
	344	}
	345
	346	static void ltc294x_work(struct work_struct *work)
	347	{
	348	struct ltc294x_info *info;
	349
	350	info = container_of(work, struct ltc294x_info, work.work);
	351	ltc294x_update(info);
	352	schedule_delayed_work(&info->work, LTC294X_WORK_DELAY * HZ);
	353	}
	354
	355	static enum power_supply_property ltc294x_properties[] = {
	356	POWER_SUPPLY_PROP_CHARGE_COUNTER,
	357	POWER_SUPPLY_PROP_CHARGE_NOW,
	358	POWER_SUPPLY_PROP_VOLTAGE_NOW,
	359	POWER_SUPPLY_PROP_CURRENT_NOW,
	360	POWER_SUPPLY_PROP_TEMP,
	361	};
	362
	363	static int ltc294x_i2c_remove(struct i2c_client *client)
	364	{
	365	struct ltc294x_info *info = i2c_get_clientdata(client);
	366
	367	cancel_delayed_work(&info->work);
297d716f	368	power_supply_unregister(info->supply);
085bc24d ML	369	return 0;
	370	}
	371
	372	static int ltc294x_i2c_probe(struct i2c_client *client,
	373	const struct i2c_device_id *id)
	374	{
297d716f	375	struct power_supply_config psy_cfg = {};
085bc24d ML	376	struct ltc294x_info *info;
085bc24d ML	377	int ret;
085bc24d ML	378	u32 prescaler_exp;
	379	s32 r_sense;
	380	struct device_node *np;
	381
085bc24d	382	info = devm_kzalloc(&client->dev, sizeof(*info), GFP_KERNEL);
377b641a ML	383	if (info == NULL)
377b641a ML	384	return -ENOMEM;
085bc24d ML	385
	386	i2c_set_clientdata(client, info);
	387
085bc24d ML	388	np = of_node_get(client->dev.of_node);
085bc24d ML	389
377b641a ML	390	info->num_regs = id->driver_data;
	391	info->supply_desc.name = np->name;
	392
085bc24d ML	393	/* r_sense can be negative, when sense+ is connected to the battery
	394	* instead of the sense-. This results in reversed measurements. */
	395	ret = of_property_read_u32(np, "lltc,resistor-sense", &r_sense);
	396	if (ret < 0) {
	397	dev_err(&client->dev,
	398	"Could not find lltc,resistor-sense in devicetree\n");
377b641a	399	return ret;
085bc24d ML	400	}
	401	info->r_sense = r_sense;
	402
	403	ret = of_property_read_u32(np, "lltc,prescaler-exponent",
	404	&prescaler_exp);
	405	if (ret < 0) {
	406	dev_warn(&client->dev,
	407	"lltc,prescaler-exponent not in devicetree\n");
	408	prescaler_exp = LTC2941_MAX_PRESCALER_EXP;
	409	}
	410
	411	if (info->num_regs == LTC2943_NUM_REGS) {
	412	if (prescaler_exp > LTC2943_MAX_PRESCALER_EXP)
	413	prescaler_exp = LTC2943_MAX_PRESCALER_EXP;
	414	info->Qlsb = ((340 * 50000) / r_sense) /
	415	(4096 / (1 << (2*prescaler_exp)));
	416	} else {
	417	if (prescaler_exp > LTC2941_MAX_PRESCALER_EXP)
	418	prescaler_exp = LTC2941_MAX_PRESCALER_EXP;
4bf828cf	419	info->Qlsb = ((85 * 50000) / r_sense) /
085bc24d ML	420	(128 / (1 << prescaler_exp));
	421	}
	422
	423	info->client = client;
297d716f KK	424	info->supply_desc.type = POWER_SUPPLY_TYPE_BATTERY;
297d716f KK	425	info->supply_desc.properties = ltc294x_properties;
085bc24d	426	if (info->num_regs >= LTC294X_REG_TEMPERATURE_LSB)
297d716f	427	info->supply_desc.num_properties =
085bc24d ML	428	ARRAY_SIZE(ltc294x_properties);
085bc24d ML	429	else if (info->num_regs >= LTC294X_REG_CURRENT_LSB)
297d716f	430	info->supply_desc.num_properties =
085bc24d ML	431	ARRAY_SIZE(ltc294x_properties) - 1;
085bc24d ML	432	else if (info->num_regs >= LTC294X_REG_VOLTAGE_LSB)
297d716f	433	info->supply_desc.num_properties =
085bc24d ML	434	ARRAY_SIZE(ltc294x_properties) - 2;
085bc24d ML	435	else
297d716f	436	info->supply_desc.num_properties =
085bc24d	437	ARRAY_SIZE(ltc294x_properties) - 3;
297d716f KK	438	info->supply_desc.get_property = ltc294x_get_property;
	439	info->supply_desc.set_property = ltc294x_set_property;
	440	info->supply_desc.property_is_writeable = ltc294x_property_is_writeable;
	441	info->supply_desc.external_power_changed = NULL;
	442
	443	psy_cfg.drv_data = info;
085bc24d ML	444
	445	INIT_DELAYED_WORK(&info->work, ltc294x_work);
	446
	447	ret = ltc294x_reset(info, prescaler_exp);
	448	if (ret < 0) {
	449	dev_err(&client->dev, "Communication with chip failed\n");
377b641a	450	return ret;
085bc24d ML	451	}
085bc24d ML	452
297d716f KK	453	info->supply = power_supply_register(&client->dev, &info->supply_desc,
	454	&psy_cfg);
	455	if (IS_ERR(info->supply)) {
085bc24d	456	dev_err(&client->dev, "failed to register ltc2941\n");
377b641a	457	return PTR_ERR(info->supply);
085bc24d ML	458	} else {
	459	schedule_delayed_work(&info->work, LTC294X_WORK_DELAY * HZ);
	460	}
	461
	462	return 0;
085bc24d ML	463	}
	464
	465	#ifdef CONFIG_PM_SLEEP
	466
	467	static int ltc294x_suspend(struct device *dev)
	468	{
	469	struct i2c_client *client = to_i2c_client(dev);
	470	struct ltc294x_info *info = i2c_get_clientdata(client);
	471
	472	cancel_delayed_work(&info->work);
	473	return 0;
	474	}
	475
	476	static int ltc294x_resume(struct device *dev)
	477	{
	478	struct i2c_client *client = to_i2c_client(dev);
	479	struct ltc294x_info *info = i2c_get_clientdata(client);
	480
	481	schedule_delayed_work(&info->work, LTC294X_WORK_DELAY * HZ);
	482	return 0;
	483	}
	484
	485	static SIMPLE_DEV_PM_OPS(ltc294x_pm_ops, ltc294x_suspend, ltc294x_resume);
	486	#define LTC294X_PM_OPS (&ltc294x_pm_ops)
	487
	488	#else
	489	#define LTC294X_PM_OPS NULL
	490	#endif /* CONFIG_PM_SLEEP */
	491
	492
	493	static const struct i2c_device_id ltc294x_i2c_id[] = {
	494	{"ltc2941", LTC2941_NUM_REGS},
	495	{"ltc2943", LTC2943_NUM_REGS},
	496	{ },
	497	};
	498	MODULE_DEVICE_TABLE(i2c, ltc294x_i2c_id);
	499
	500	static struct i2c_driver ltc294x_driver = {
	501	.driver = {
	502	.name = "LTC2941",
	503	.pm = LTC294X_PM_OPS,
	504	},
	505	.probe = ltc294x_i2c_probe,
	506	.remove = ltc294x_i2c_remove,
	507	.id_table = ltc294x_i2c_id,
	508	};
	509	module_i2c_driver(ltc294x_driver);
	510
	511	MODULE_AUTHOR("Auryn Verwegen, Topic Embedded Systems");
	512	MODULE_AUTHOR("Mike Looijmans, Topic Embedded Products");
	513	MODULE_DESCRIPTION("LTC2941/LTC2943 Battery Gas Gauge IC driver");
	514	MODULE_LICENSE("GPL");