[linux-2.6-block.git] / drivers / power / max17042_battery.c

/*
 * Fuel gauge driver for Maxim 17042 / 8966 / 8997
 *  Note that Maxim 8966 and 8997 are mfd and this is its subdevice.
 *
 * Copyright (C) 2011 Samsung Electronics
 * MyungJoo Ham <myungjoo.ham@samsung.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * This driver is based on max17040_battery.c
 */

#include <linux/init.h>
#include <linux/slab.h>
#include <linux/i2c.h>
#include <linux/mod_devicetable.h>
#include <linux/power_supply.h>
#include <linux/power/max17042_battery.h>

struct max17042_chip {
	struct i2c_client *client;
	struct power_supply battery;
	struct max17042_platform_data *pdata;
};

static int max17042_write_reg(struct i2c_client *client, u8 reg, u16 value)
{
	int ret = i2c_smbus_write_word_data(client, reg, value);

	if (ret < 0)
		dev_err(&client->dev, "%s: err %d\n", __func__, ret);

	return ret;
}

static int max17042_read_reg(struct i2c_client *client, u8 reg)
{
	int ret = i2c_smbus_read_word_data(client, reg);

	if (ret < 0)
		dev_err(&client->dev, "%s: err %d\n", __func__, ret);

	return ret;
}

static void max17042_set_reg(struct i2c_client *client,
			     struct max17042_reg_data *data, int size)
{
	int i;

	for (i = 0; i < size; i++)
		max17042_write_reg(client, data[i].addr, data[i].data);
}

static enum power_supply_property max17042_battery_props[] = {
	POWER_SUPPLY_PROP_PRESENT,
	POWER_SUPPLY_PROP_CYCLE_COUNT,
	POWER_SUPPLY_PROP_VOLTAGE_MAX,
	POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
	POWER_SUPPLY_PROP_VOLTAGE_NOW,
	POWER_SUPPLY_PROP_VOLTAGE_AVG,
	POWER_SUPPLY_PROP_CAPACITY,
	POWER_SUPPLY_PROP_CHARGE_FULL,
	POWER_SUPPLY_PROP_TEMP,
	POWER_SUPPLY_PROP_CURRENT_NOW,
	POWER_SUPPLY_PROP_CURRENT_AVG,
};

static int max17042_get_property(struct power_supply *psy,
			    enum power_supply_property psp,
			    union power_supply_propval *val)
{
	struct max17042_chip *chip = container_of(psy,
				struct max17042_chip, battery);

	switch (psp) {
	case POWER_SUPPLY_PROP_PRESENT:
		val->intval = max17042_read_reg(chip->client,
				MAX17042_STATUS);
		if (val->intval & MAX17042_STATUS_BattAbsent)
			val->intval = 0;
		else
			val->intval = 1;
		break;
	case POWER_SUPPLY_PROP_CYCLE_COUNT:
		val->intval = max17042_read_reg(chip->client,
				MAX17042_Cycles);
		break;
	case POWER_SUPPLY_PROP_VOLTAGE_MAX:
		val->intval = max17042_read_reg(chip->client,
				MAX17042_MinMaxVolt);
		val->intval >>= 8;
		val->intval *= 20000; /* Units of LSB = 20mV */
		break;
	case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
		val->intval = max17042_read_reg(chip->client,
				MAX17042_V_empty);
		val->intval >>= 7;
		val->intval *= 10000; /* Units of LSB = 10mV */
		break;
	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
		val->intval = max17042_read_reg(chip->client,
				MAX17042_VCELL) * 83; /* 1000 / 12 = 83 */
		break;
	case POWER_SUPPLY_PROP_VOLTAGE_AVG:
		val->intval = max17042_read_reg(chip->client,
				MAX17042_AvgVCELL) * 83;
		break;
	case POWER_SUPPLY_PROP_CAPACITY:
		val->intval = max17042_read_reg(chip->client,
				MAX17042_SOC) / 256;
		break;
	case POWER_SUPPLY_PROP_CHARGE_FULL:
		val->intval = max17042_read_reg(chip->client,
				MAX17042_RepSOC);
		if ((val->intval / 256) >= MAX17042_BATTERY_FULL)
			val->intval = 1;
		else if (val->intval >= 0)
			val->intval = 0;
		break;
	case POWER_SUPPLY_PROP_TEMP:
		val->intval = max17042_read_reg(chip->client,
				MAX17042_TEMP);
		/* The value is signed. */
		if (val->intval & 0x8000) {
			val->intval = (0x7fff & ~val->intval) + 1;
			val->intval *= -1;
		}
		/* The value is converted into deci-centigrade scale */
		/* Units of LSB = 1 / 256 degree Celsius */
		val->intval = val->intval * 10 / 256;
		break;
	case POWER_SUPPLY_PROP_CURRENT_NOW:
		if (chip->pdata->enable_current_sense) {
			val->intval = max17042_read_reg(chip->client,
					MAX17042_Current);
			if (val->intval & 0x8000) {
				/* Negative */
				val->intval = ~val->intval & 0x7fff;
				val->intval++;
				val->intval *= -1;
			}
			val->intval >>= 4;
			val->intval *= 1000000 * 25 / chip->pdata->r_sns;
		} else {
			return -EINVAL;
		}
		break;
	case POWER_SUPPLY_PROP_CURRENT_AVG:
		if (chip->pdata->enable_current_sense) {
			val->intval = max17042_read_reg(chip->client,
					MAX17042_AvgCurrent);
			if (val->intval & 0x8000) {
				/* Negative */
				val->intval = ~val->intval & 0x7fff;
				val->intval++;
				val->intval *= -1;
			}
			val->intval *= 1562500 / chip->pdata->r_sns;
		} else {
			return -EINVAL;
		}
		break;
	default:
		return -EINVAL;
	}
	return 0;
}

static int __devinit max17042_probe(struct i2c_client *client,
			const struct i2c_device_id *id)
{
	struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
	struct max17042_chip *chip;
	int ret;

	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA))
		return -EIO;

	chip = kzalloc(sizeof(*chip), GFP_KERNEL);
	if (!chip)
		return -ENOMEM;

	chip->client = client;
	chip->pdata = client->dev.platform_data;

	i2c_set_clientdata(client, chip);

	chip->battery.name		= "max17042_battery";
	chip->battery.type		= POWER_SUPPLY_TYPE_BATTERY;
	chip->battery.get_property	= max17042_get_property;
	chip->battery.properties	= max17042_battery_props;
	chip->battery.num_properties	= ARRAY_SIZE(max17042_battery_props);

	/* When current is not measured,
	 * CURRENT_NOW and CURRENT_AVG properties should be invisible. */
	if (!chip->pdata->enable_current_sense)
		chip->battery.num_properties -= 2;

	if (chip->pdata->r_sns == 0)
		chip->pdata->r_sns = MAX17042_DEFAULT_SNS_RESISTOR;

	ret = power_supply_register(&client->dev, &chip->battery);
	if (ret) {
		dev_err(&client->dev, "failed: power supply register\n");
		kfree(chip);
		return ret;
	}

	/* Initialize registers according to values from the platform data */
	if (chip->pdata->init_data)
		max17042_set_reg(client, chip->pdata->init_data,
				 chip->pdata->num_init_data);

	if (!chip->pdata->enable_current_sense) {
		max17042_write_reg(client, MAX17042_CGAIN, 0x0000);
		max17042_write_reg(client, MAX17042_MiscCFG, 0x0003);
		max17042_write_reg(client, MAX17042_LearnCFG, 0x0007);
	}

	return 0;
}

static int __devexit max17042_remove(struct i2c_client *client)
{
	struct max17042_chip *chip = i2c_get_clientdata(client);

	power_supply_unregister(&chip->battery);
	kfree(chip);
	return 0;
}

static const struct i2c_device_id max17042_id[] = {
	{ "max17042", 0 },
	{ }
};
MODULE_DEVICE_TABLE(i2c, max17042_id);

static struct i2c_driver max17042_i2c_driver = {
	.driver	= {
		.name	= "max17042",
	},
	.probe		= max17042_probe,
	.remove		= __devexit_p(max17042_remove),
	.id_table	= max17042_id,
};

static int __init max17042_init(void)
{
	return i2c_add_driver(&max17042_i2c_driver);
}
module_init(max17042_init);

static void __exit max17042_exit(void)
{
	i2c_del_driver(&max17042_i2c_driver);
}
module_exit(max17042_exit);

MODULE_AUTHOR("MyungJoo Ham <myungjoo.ham@samsung.com>");
MODULE_DESCRIPTION("MAX17042 Fuel Gauge");
MODULE_LICENSE("GPL");
Commit	Line	Data
359ab9f5 MH	1	/*
	2	* Fuel gauge driver for Maxim 17042 / 8966 / 8997
	3	* Note that Maxim 8966 and 8997 are mfd and this is its subdevice.
	4	*
	5	* Copyright (C) 2011 Samsung Electronics
	6	* MyungJoo Ham <myungjoo.ham@samsung.com>
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License as published by
	10	* the Free Software Foundation; either version 2 of the License, or
	11	* (at your option) any later version.
	12	*
	13	* This program is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	* GNU General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU General Public License
	19	* along with this program; if not, write to the Free Software
	20	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	21	*
	22	* This driver is based on max17040_battery.c
	23	*/
	24
	25	#include <linux/init.h>
	26	#include <linux/slab.h>
	27	#include <linux/i2c.h>
	28	#include <linux/mod_devicetable.h>
	29	#include <linux/power_supply.h>
	30	#include <linux/power/max17042_battery.h>
	31
359ab9f5 MH	32	struct max17042_chip {
	33	struct i2c_client *client;
	34	struct power_supply battery;
	35	struct max17042_platform_data *pdata;
	36	};
	37
	38	static int max17042_write_reg(struct i2c_client *client, u8 reg, u16 value)
	39	{
	40	int ret = i2c_smbus_write_word_data(client, reg, value);
	41
	42	if (ret < 0)
	43	dev_err(&client->dev, "%s: err %d\n", __func__, ret);
	44
	45	return ret;
	46	}
	47
	48	static int max17042_read_reg(struct i2c_client *client, u8 reg)
	49	{
	50	int ret = i2c_smbus_read_word_data(client, reg);
	51
	52	if (ret < 0)
	53	dev_err(&client->dev, "%s: err %d\n", __func__, ret);
	54
	55	return ret;
	56	}
	57
086ef502 DK	58	static void max17042_set_reg(struct i2c_client *client,
	59	struct max17042_reg_data *data, int size)
	60	{
	61	int i;
	62
	63	for (i = 0; i < size; i++)
	64	max17042_write_reg(client, data[i].addr, data[i].data);
	65	}
	66
359ab9f5	67	static enum power_supply_property max17042_battery_props[] = {
086ef502 DK	68	POWER_SUPPLY_PROP_PRESENT,
	69	POWER_SUPPLY_PROP_CYCLE_COUNT,
	70	POWER_SUPPLY_PROP_VOLTAGE_MAX,
	71	POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
359ab9f5 MH	72	POWER_SUPPLY_PROP_VOLTAGE_NOW,
	73	POWER_SUPPLY_PROP_VOLTAGE_AVG,
	74	POWER_SUPPLY_PROP_CAPACITY,
086ef502 DK	75	POWER_SUPPLY_PROP_CHARGE_FULL,
	76	POWER_SUPPLY_PROP_TEMP,
	77	POWER_SUPPLY_PROP_CURRENT_NOW,
	78	POWER_SUPPLY_PROP_CURRENT_AVG,
359ab9f5 MH	79	};
	80
	81	static int max17042_get_property(struct power_supply *psy,
	82	enum power_supply_property psp,
	83	union power_supply_propval *val)
	84	{
	85	struct max17042_chip *chip = container_of(psy,
	86	struct max17042_chip, battery);
	87
	88	switch (psp) {
086ef502 DK	89	case POWER_SUPPLY_PROP_PRESENT:
	90	val->intval = max17042_read_reg(chip->client,
	91	MAX17042_STATUS);
	92	if (val->intval & MAX17042_STATUS_BattAbsent)
	93	val->intval = 0;
	94	else
	95	val->intval = 1;
	96	break;
	97	case POWER_SUPPLY_PROP_CYCLE_COUNT:
	98	val->intval = max17042_read_reg(chip->client,
	99	MAX17042_Cycles);
	100	break;
	101	case POWER_SUPPLY_PROP_VOLTAGE_MAX:
	102	val->intval = max17042_read_reg(chip->client,
	103	MAX17042_MinMaxVolt);
	104	val->intval >>= 8;
	105	val->intval = 20000; / Units of LSB = 20mV */
	106	break;
	107	case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
	108	val->intval = max17042_read_reg(chip->client,
	109	MAX17042_V_empty);
	110	val->intval >>= 7;
	111	val->intval = 10000; / Units of LSB = 10mV */
	112	break;
359ab9f5 MH	113	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
	114	val->intval = max17042_read_reg(chip->client,
	115	MAX17042_VCELL) * 83; /* 1000 / 12 = 83 */
	116	break;
	117	case POWER_SUPPLY_PROP_VOLTAGE_AVG:
	118	val->intval = max17042_read_reg(chip->client,
	119	MAX17042_AvgVCELL) * 83;
	120	break;
	121	case POWER_SUPPLY_PROP_CAPACITY:
	122	val->intval = max17042_read_reg(chip->client,
	123	MAX17042_SOC) / 256;
	124	break;
086ef502 DK	125	case POWER_SUPPLY_PROP_CHARGE_FULL:
	126	val->intval = max17042_read_reg(chip->client,
	127	MAX17042_RepSOC);
	128	if ((val->intval / 256) >= MAX17042_BATTERY_FULL)
	129	val->intval = 1;
	130	else if (val->intval >= 0)
	131	val->intval = 0;
	132	break;
	133	case POWER_SUPPLY_PROP_TEMP:
	134	val->intval = max17042_read_reg(chip->client,
	135	MAX17042_TEMP);
	136	/* The value is signed. */
	137	if (val->intval & 0x8000) {
	138	val->intval = (0x7fff & ~val->intval) + 1;
	139	val->intval *= -1;
	140	}
	141	/* The value is converted into deci-centigrade scale */
	142	/* Units of LSB = 1 / 256 degree Celsius */
	143	val->intval = val->intval * 10 / 256;
	144	break;
	145	case POWER_SUPPLY_PROP_CURRENT_NOW:
	146	if (chip->pdata->enable_current_sense) {
	147	val->intval = max17042_read_reg(chip->client,
	148	MAX17042_Current);
	149	if (val->intval & 0x8000) {
	150	/* Negative */
	151	val->intval = ~val->intval & 0x7fff;
	152	val->intval++;
	153	val->intval *= -1;
	154	}
	155	val->intval >>= 4;
	156	val->intval = 1000000 25 / chip->pdata->r_sns;
	157	} else {
	158	return -EINVAL;
	159	}
	160	break;
	161	case POWER_SUPPLY_PROP_CURRENT_AVG:
	162	if (chip->pdata->enable_current_sense) {
	163	val->intval = max17042_read_reg(chip->client,
	164	MAX17042_AvgCurrent);
	165	if (val->intval & 0x8000) {
	166	/* Negative */
	167	val->intval = ~val->intval & 0x7fff;
	168	val->intval++;
	169	val->intval *= -1;
	170	}
	171	val->intval *= 1562500 / chip->pdata->r_sns;
	172	} else {
	173	return -EINVAL;
	174	}
	175	break;
359ab9f5 MH	176	default:
	177	return -EINVAL;
	178	}
	179	return 0;
	180	}
	181
	182	static int __devinit max17042_probe(struct i2c_client *client,
	183	const struct i2c_device_id *id)
	184	{
	185	struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
	186	struct max17042_chip *chip;
	187	int ret;
	188
	189	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA))
	190	return -EIO;
	191
	192	chip = kzalloc(sizeof(*chip), GFP_KERNEL);
	193	if (!chip)
	194	return -ENOMEM;
	195
	196	chip->client = client;
	197	chip->pdata = client->dev.platform_data;
	198
	199	i2c_set_clientdata(client, chip);
	200
	201	chip->battery.name = "max17042_battery";
	202	chip->battery.type = POWER_SUPPLY_TYPE_BATTERY;
	203	chip->battery.get_property = max17042_get_property;
	204	chip->battery.properties = max17042_battery_props;
	205	chip->battery.num_properties = ARRAY_SIZE(max17042_battery_props);
	206
086ef502 DK	207	/* When current is not measured,
	208	* CURRENT_NOW and CURRENT_AVG properties should be invisible. */
	209	if (!chip->pdata->enable_current_sense)
	210	chip->battery.num_properties -= 2;
	211
4cfa892c PR	212	if (chip->pdata->r_sns == 0)
	213	chip->pdata->r_sns = MAX17042_DEFAULT_SNS_RESISTOR;
	214
359ab9f5 MH	215	ret = power_supply_register(&client->dev, &chip->battery);
	216	if (ret) {
	217	dev_err(&client->dev, "failed: power supply register\n");
359ab9f5 MH	218	kfree(chip);
	219	return ret;
	220	}
	221
086ef502 DK	222	/* Initialize registers according to values from the platform data */
	223	if (chip->pdata->init_data)
	224	max17042_set_reg(client, chip->pdata->init_data,
	225	chip->pdata->num_init_data);
	226
359ab9f5 MH	227	if (!chip->pdata->enable_current_sense) {
	228	max17042_write_reg(client, MAX17042_CGAIN, 0x0000);
	229	max17042_write_reg(client, MAX17042_MiscCFG, 0x0003);
	230	max17042_write_reg(client, MAX17042_LearnCFG, 0x0007);
	231	}
	232
	233	return 0;
	234	}
	235
	236	static int __devexit max17042_remove(struct i2c_client *client)
	237	{
	238	struct max17042_chip *chip = i2c_get_clientdata(client);
	239
	240	power_supply_unregister(&chip->battery);
359ab9f5 MH	241	kfree(chip);
	242	return 0;
	243	}
	244
	245	static const struct i2c_device_id max17042_id[] = {
	246	{ "max17042", 0 },
	247	{ }
	248	};
	249	MODULE_DEVICE_TABLE(i2c, max17042_id);
	250
	251	static struct i2c_driver max17042_i2c_driver = {
	252	.driver = {
	253	.name = "max17042",
	254	},
	255	.probe = max17042_probe,
	256	.remove = __devexit_p(max17042_remove),
	257	.id_table = max17042_id,
	258	};
	259
	260	static int __init max17042_init(void)
	261	{
	262	return i2c_add_driver(&max17042_i2c_driver);
	263	}
	264	module_init(max17042_init);
	265
	266	static void __exit max17042_exit(void)
	267	{
	268	i2c_del_driver(&max17042_i2c_driver);
	269	}
	270	module_exit(max17042_exit);
	271
	272	MODULE_AUTHOR("MyungJoo Ham <myungjoo.ham@samsung.com>");
	273	MODULE_DESCRIPTION("MAX17042 Fuel Gauge");
	274	MODULE_LICENSE("GPL");