[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / power / ds2782_battery.c

/*
 * I2C client/driver for the Maxim/Dallas DS2782 Stand-Alone Fuel Gauge IC
 *
 * Copyright (C) 2009 Bluewater Systems Ltd
 *
 * Author: Ryan Mallon <ryan@bluewatersys.com>
 *
 * DS2786 added by Yulia Vilensky <vilensky@compulab.co.il>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 */

#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/idr.h>
#include <linux/power_supply.h>
#include <linux/slab.h>
#include <linux/ds2782_battery.h>

#define DS2782_REG_RARC		0x06	/* Remaining active relative capacity */

#define DS278x_REG_VOLT_MSB	0x0c
#define DS278x_REG_TEMP_MSB	0x0a
#define DS278x_REG_CURRENT_MSB	0x0e

/* EEPROM Block */
#define DS2782_REG_RSNSP	0x69	/* Sense resistor value */

/* Current unit measurement in uA for a 1 milli-ohm sense resistor */
#define DS2782_CURRENT_UNITS	1563

#define DS2786_REG_RARC		0x02	/* Remaining active relative capacity */

#define DS2786_CURRENT_UNITS	25

struct ds278x_info;

struct ds278x_battery_ops {
	int	(*get_current)(struct ds278x_info *info, int *current_uA);
	int	(*get_voltage)(struct ds278x_info *info, int *voltage_uA);
	int	(*get_capacity)(struct ds278x_info *info, int *capacity_uA);

};

#define to_ds278x_info(x) container_of(x, struct ds278x_info, battery)

struct ds278x_info {
	struct i2c_client	*client;
	struct power_supply	battery;
	struct ds278x_battery_ops  *ops;
	int			id;
	int                     rsns;
};

static DEFINE_IDR(battery_id);
static DEFINE_MUTEX(battery_lock);

static inline int ds278x_read_reg(struct ds278x_info *info, int reg, u8 *val)
{
	int ret;

	ret = i2c_smbus_read_byte_data(info->client, reg);
	if (ret < 0) {
		dev_err(&info->client->dev, "register read failed\n");
		return ret;
	}

	*val = ret;
	return 0;
}

static inline int ds278x_read_reg16(struct ds278x_info *info, int reg_msb,
				    s16 *val)
{
	int ret;

	ret = swab16(i2c_smbus_read_word_data(info->client, reg_msb));
	if (ret < 0) {
		dev_err(&info->client->dev, "register read failed\n");
		return ret;
	}

	*val = ret;
	return 0;
}

static int ds278x_get_temp(struct ds278x_info *info, int *temp)
{
	s16 raw;
	int err;

	/*
	 * Temperature is measured in units of 0.125 degrees celcius, the
	 * power_supply class measures temperature in tenths of degrees
	 * celsius. The temperature value is stored as a 10 bit number, plus
	 * sign in the upper bits of a 16 bit register.
	 */
	err = ds278x_read_reg16(info, DS278x_REG_TEMP_MSB, &raw);
	if (err)
		return err;
	*temp = ((raw / 32) * 125) / 100;
	return 0;
}

static int ds2782_get_current(struct ds278x_info *info, int *current_uA)
{
	int sense_res;
	int err;
	u8 sense_res_raw;
	s16 raw;

	/*
	 * The units of measurement for current are dependent on the value of
	 * the sense resistor.
	 */
	err = ds278x_read_reg(info, DS2782_REG_RSNSP, &sense_res_raw);
	if (err)
		return err;
	if (sense_res_raw == 0) {
		dev_err(&info->client->dev, "sense resistor value is 0\n");
		return -ENXIO;
	}
	sense_res = 1000 / sense_res_raw;

	dev_dbg(&info->client->dev, "sense resistor = %d milli-ohms\n",
		sense_res);
	err = ds278x_read_reg16(info, DS278x_REG_CURRENT_MSB, &raw);
	if (err)
		return err;
	*current_uA = raw * (DS2782_CURRENT_UNITS / sense_res);
	return 0;
}

static int ds2782_get_voltage(struct ds278x_info *info, int *voltage_uA)
{
	s16 raw;
	int err;

	/*
	 * Voltage is measured in units of 4.88mV. The voltage is stored as
	 * a 10-bit number plus sign, in the upper bits of a 16-bit register
	 */
	err = ds278x_read_reg16(info, DS278x_REG_VOLT_MSB, &raw);
	if (err)
		return err;
	*voltage_uA = (raw / 32) * 4800;
	return 0;
}

static int ds2782_get_capacity(struct ds278x_info *info, int *capacity)
{
	int err;
	u8 raw;

	err = ds278x_read_reg(info, DS2782_REG_RARC, &raw);
	if (err)
		return err;
	*capacity = raw;
	return raw;
}

static int ds2786_get_current(struct ds278x_info *info, int *current_uA)
{
	int err;
	s16 raw;

	err = ds278x_read_reg16(info, DS278x_REG_CURRENT_MSB, &raw);
	if (err)
		return err;
	*current_uA = (raw / 16) * (DS2786_CURRENT_UNITS / info->rsns);
	return 0;
}

static int ds2786_get_voltage(struct ds278x_info *info, int *voltage_uA)
{
	s16 raw;
	int err;

	/*
	 * Voltage is measured in units of 1.22mV. The voltage is stored as
	 * a 10-bit number plus sign, in the upper bits of a 16-bit register
	 */
	err = ds278x_read_reg16(info, DS278x_REG_VOLT_MSB, &raw);
	if (err)
		return err;
	*voltage_uA = (raw / 8) * 1220;
	return 0;
}

static int ds2786_get_capacity(struct ds278x_info *info, int *capacity)
{
	int err;
	u8 raw;

	err = ds278x_read_reg(info, DS2786_REG_RARC, &raw);
	if (err)
		return err;
	/* Relative capacity is displayed with resolution 0.5 % */
	*capacity = raw/2 ;
	return 0;
}

static int ds278x_get_status(struct ds278x_info *info, int *status)
{
	int err;
	int current_uA;
	int capacity;

	err = info->ops->get_current(info, &current_uA);
	if (err)
		return err;

	err = info->ops->get_capacity(info, &capacity);
	if (err)
		return err;

	if (capacity == 100)
		*status = POWER_SUPPLY_STATUS_FULL;
	else if (current_uA == 0)
		*status = POWER_SUPPLY_STATUS_NOT_CHARGING;
	else if (current_uA < 0)
		*status = POWER_SUPPLY_STATUS_DISCHARGING;
	else
		*status = POWER_SUPPLY_STATUS_CHARGING;

	return 0;
}

static int ds278x_battery_get_property(struct power_supply *psy,
				       enum power_supply_property prop,
				       union power_supply_propval *val)
{
	struct ds278x_info *info = to_ds278x_info(psy);
	int ret;

	switch (prop) {
	case POWER_SUPPLY_PROP_STATUS:
		ret = ds278x_get_status(info, &val->intval);
		break;

	case POWER_SUPPLY_PROP_CAPACITY:
		ret = info->ops->get_capacity(info, &val->intval);
		break;

	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
		ret = info->ops->get_voltage(info, &val->intval);
		break;

	case POWER_SUPPLY_PROP_CURRENT_NOW:
		ret = info->ops->get_current(info, &val->intval);
		break;

	case POWER_SUPPLY_PROP_TEMP:
		ret = ds278x_get_temp(info, &val->intval);
		break;

	default:
		ret = -EINVAL;
	}

	return ret;
}

static enum power_supply_property ds278x_battery_props[] = {
	POWER_SUPPLY_PROP_STATUS,
	POWER_SUPPLY_PROP_CAPACITY,
	POWER_SUPPLY_PROP_VOLTAGE_NOW,
	POWER_SUPPLY_PROP_CURRENT_NOW,
	POWER_SUPPLY_PROP_TEMP,
};

static void ds278x_power_supply_init(struct power_supply *battery)
{
	battery->type			= POWER_SUPPLY_TYPE_BATTERY;
	battery->properties		= ds278x_battery_props;
	battery->num_properties		= ARRAY_SIZE(ds278x_battery_props);
	battery->get_property		= ds278x_battery_get_property;
	battery->external_power_changed	= NULL;
}

static int ds278x_battery_remove(struct i2c_client *client)
{
	struct ds278x_info *info = i2c_get_clientdata(client);

	power_supply_unregister(&info->battery);
	kfree(info->battery.name);

	mutex_lock(&battery_lock);
	idr_remove(&battery_id, info->id);
	mutex_unlock(&battery_lock);

	kfree(info);
	return 0;
}

enum ds278x_num_id {
	DS2782 = 0,
	DS2786,
};

static struct ds278x_battery_ops ds278x_ops[] = {
	[DS2782] = {
		.get_current  = ds2782_get_current,
		.get_voltage  = ds2782_get_voltage,
		.get_capacity = ds2782_get_capacity,
	},
	[DS2786] = {
		.get_current  = ds2786_get_current,
		.get_voltage  = ds2786_get_voltage,
		.get_capacity = ds2786_get_capacity,
	}
};

static int ds278x_battery_probe(struct i2c_client *client,
				const struct i2c_device_id *id)
{
	struct ds278x_platform_data *pdata = client->dev.platform_data;
	struct ds278x_info *info;
	int ret;
	int num;

	/*
	 * ds2786 should have the sense resistor value set
	 * in the platform data
	 */
	if (id->driver_data == DS2786 && !pdata) {
		dev_err(&client->dev, "missing platform data for ds2786\n");
		return -EINVAL;
	}

	/* Get an ID for this battery */
	ret = idr_pre_get(&battery_id, GFP_KERNEL);
	if (ret == 0) {
		ret = -ENOMEM;
		goto fail_id;
	}

	mutex_lock(&battery_lock);
	ret = idr_get_new(&battery_id, client, &num);
	mutex_unlock(&battery_lock);
	if (ret < 0)
		goto fail_id;

	info = kzalloc(sizeof(*info), GFP_KERNEL);
	if (!info) {
		ret = -ENOMEM;
		goto fail_info;
	}

	info->battery.name = kasprintf(GFP_KERNEL, "%s-%d", client->name, num);
	if (!info->battery.name) {
		ret = -ENOMEM;
		goto fail_name;
	}

	if (id->driver_data == DS2786)
		info->rsns = pdata->rsns;

	i2c_set_clientdata(client, info);
	info->client = client;
	info->id = num;
	info->ops  = &ds278x_ops[id->driver_data];
	ds278x_power_supply_init(&info->battery);

	ret = power_supply_register(&client->dev, &info->battery);
	if (ret) {
		dev_err(&client->dev, "failed to register battery\n");
		goto fail_register;
	}

	return 0;

fail_register:
	kfree(info->battery.name);
fail_name:
	kfree(info);
fail_info:
	mutex_lock(&battery_lock);
	idr_remove(&battery_id, num);
	mutex_unlock(&battery_lock);
fail_id:
	return ret;
}

static const struct i2c_device_id ds278x_id[] = {
	{"ds2782", DS2782},
	{"ds2786", DS2786},
	{},
};

static struct i2c_driver ds278x_battery_driver = {
	.driver 	= {
		.name	= "ds2782-battery",
	},
	.probe		= ds278x_battery_probe,
	.remove		= ds278x_battery_remove,
	.id_table	= ds278x_id,
};

static int __init ds278x_init(void)
{
	return i2c_add_driver(&ds278x_battery_driver);
}
module_init(ds278x_init);

static void __exit ds278x_exit(void)
{
	i2c_del_driver(&ds278x_battery_driver);
}
module_exit(ds278x_exit);

MODULE_AUTHOR("Ryan Mallon <ryan@bluewatersys.com>");
MODULE_DESCRIPTION("Maxim/Dallas DS2782 Stand-Alone Fuel Gauage IC driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
bfdb46ce RM	1	/*
	2	* I2C client/driver for the Maxim/Dallas DS2782 Stand-Alone Fuel Gauge IC
	3	*
	4	* Copyright (C) 2009 Bluewater Systems Ltd
	5	*
	6	* Author: Ryan Mallon <ryan@bluewatersys.com>
	7	*
9b9ade6b YV	8	* DS2786 added by Yulia Vilensky <vilensky@compulab.co.il>
9b9ade6b YV	9	*
bfdb46ce RM	10	* This program is free software; you can redistribute it and/or modify
	11	* it under the terms of the GNU General Public License version 2 as
	12	* published by the Free Software Foundation.
	13	*
	14	*/
	15
	16	#include <linux/kernel.h>
	17	#include <linux/module.h>
	18	#include <linux/types.h>
	19	#include <linux/errno.h>
	20	#include <linux/swab.h>
	21	#include <linux/i2c.h>
	22	#include <linux/idr.h>
	23	#include <linux/power_supply.h>
5a0e3ad6	24	#include <linux/slab.h>
9b9ade6b	25	#include <linux/ds2782_battery.h>
bfdb46ce RM	26
	27	#define DS2782_REG_RARC 0x06 /* Remaining active relative capacity */
	28
9b9ade6b YV	29	#define DS278x_REG_VOLT_MSB 0x0c
	30	#define DS278x_REG_TEMP_MSB 0x0a
	31	#define DS278x_REG_CURRENT_MSB 0x0e
bfdb46ce RM	32
	33	/* EEPROM Block */
	34	#define DS2782_REG_RSNSP 0x69 /* Sense resistor value */
	35
	36	/* Current unit measurement in uA for a 1 milli-ohm sense resistor */
	37	#define DS2782_CURRENT_UNITS 1563
	38
9b9ade6b YV	39	#define DS2786_REG_RARC 0x02 /* Remaining active relative capacity */
	40
	41	#define DS2786_CURRENT_UNITS 25
	42
	43	struct ds278x_info;
	44
	45	struct ds278x_battery_ops {
	46	int (get_current)(struct ds278x_info info, int *current_uA);
	47	int (get_voltage)(struct ds278x_info info, int *voltage_uA);
	48	int (get_capacity)(struct ds278x_info info, int *capacity_uA);
	49
	50	};
	51
	52	#define to_ds278x_info(x) container_of(x, struct ds278x_info, battery)
bfdb46ce	53
9b9ade6b	54	struct ds278x_info {
bfdb46ce RM	55	struct i2c_client *client;
bfdb46ce RM	56	struct power_supply battery;
9b9ade6b	57	struct ds278x_battery_ops *ops;
bfdb46ce	58	int id;
9b9ade6b	59	int rsns;
bfdb46ce RM	60	};
	61
	62	static DEFINE_IDR(battery_id);
	63	static DEFINE_MUTEX(battery_lock);
	64
9b9ade6b	65	static inline int ds278x_read_reg(struct ds278x_info info, int reg, u8 val)
bfdb46ce RM	66	{
	67	int ret;
	68
	69	ret = i2c_smbus_read_byte_data(info->client, reg);
	70	if (ret < 0) {
	71	dev_err(&info->client->dev, "register read failed\n");
	72	return ret;
	73	}
	74
	75	*val = ret;
	76	return 0;
	77	}
	78
9b9ade6b	79	static inline int ds278x_read_reg16(struct ds278x_info *info, int reg_msb,
bfdb46ce RM	80	s16 *val)
	81	{
	82	int ret;
	83
	84	ret = swab16(i2c_smbus_read_word_data(info->client, reg_msb));
	85	if (ret < 0) {
	86	dev_err(&info->client->dev, "register read failed\n");
	87	return ret;
	88	}
	89
	90	*val = ret;
	91	return 0;
	92	}
	93
9b9ade6b	94	static int ds278x_get_temp(struct ds278x_info info, int temp)
bfdb46ce RM	95	{
	96	s16 raw;
	97	int err;
	98
	99	/*
	100	* Temperature is measured in units of 0.125 degrees celcius, the
	101	* power_supply class measures temperature in tenths of degrees
	102	* celsius. The temperature value is stored as a 10 bit number, plus
	103	* sign in the upper bits of a 16 bit register.
	104	*/
9b9ade6b	105	err = ds278x_read_reg16(info, DS278x_REG_TEMP_MSB, &raw);
bfdb46ce RM	106	if (err)
	107	return err;
	108	temp = ((raw / 32) 125) / 100;
	109	return 0;
	110	}
	111
9b9ade6b	112	static int ds2782_get_current(struct ds278x_info info, int current_uA)
bfdb46ce RM	113	{
	114	int sense_res;
	115	int err;
	116	u8 sense_res_raw;
	117	s16 raw;
	118
	119	/*
	120	* The units of measurement for current are dependent on the value of
	121	* the sense resistor.
	122	*/
9b9ade6b	123	err = ds278x_read_reg(info, DS2782_REG_RSNSP, &sense_res_raw);
bfdb46ce RM	124	if (err)
	125	return err;
	126	if (sense_res_raw == 0) {
	127	dev_err(&info->client->dev, "sense resistor value is 0\n");
	128	return -ENXIO;
	129	}
	130	sense_res = 1000 / sense_res_raw;
	131
	132	dev_dbg(&info->client->dev, "sense resistor = %d milli-ohms\n",
	133	sense_res);
9b9ade6b	134	err = ds278x_read_reg16(info, DS278x_REG_CURRENT_MSB, &raw);
bfdb46ce RM	135	if (err)
	136	return err;
	137	current_uA = raw (DS2782_CURRENT_UNITS / sense_res);
	138	return 0;
	139	}
	140
9b9ade6b	141	static int ds2782_get_voltage(struct ds278x_info info, int voltage_uA)
bfdb46ce RM	142	{
	143	s16 raw;
	144	int err;
	145
	146	/*
	147	* Voltage is measured in units of 4.88mV. The voltage is stored as
	148	* a 10-bit number plus sign, in the upper bits of a 16-bit register
	149	*/
9b9ade6b	150	err = ds278x_read_reg16(info, DS278x_REG_VOLT_MSB, &raw);
bfdb46ce RM	151	if (err)
	152	return err;
	153	voltage_uA = (raw / 32) 4800;
	154	return 0;
	155	}
	156
9b9ade6b	157	static int ds2782_get_capacity(struct ds278x_info info, int capacity)
bfdb46ce RM	158	{
	159	int err;
	160	u8 raw;
	161
9b9ade6b	162	err = ds278x_read_reg(info, DS2782_REG_RARC, &raw);
bfdb46ce RM	163	if (err)
	164	return err;
	165	*capacity = raw;
	166	return raw;
	167	}
	168
9b9ade6b YV	169	static int ds2786_get_current(struct ds278x_info info, int current_uA)
	170	{
	171	int err;
	172	s16 raw;
	173
	174	err = ds278x_read_reg16(info, DS278x_REG_CURRENT_MSB, &raw);
	175	if (err)
	176	return err;
	177	current_uA = (raw / 16) (DS2786_CURRENT_UNITS / info->rsns);
	178	return 0;
	179	}
	180
	181	static int ds2786_get_voltage(struct ds278x_info info, int voltage_uA)
	182	{
	183	s16 raw;
	184	int err;
	185
	186	/*
	187	* Voltage is measured in units of 1.22mV. The voltage is stored as
	188	* a 10-bit number plus sign, in the upper bits of a 16-bit register
	189	*/
	190	err = ds278x_read_reg16(info, DS278x_REG_VOLT_MSB, &raw);
	191	if (err)
	192	return err;
	193	voltage_uA = (raw / 8) 1220;
	194	return 0;
	195	}
	196
	197	static int ds2786_get_capacity(struct ds278x_info info, int capacity)
	198	{
	199	int err;
	200	u8 raw;
	201
	202	err = ds278x_read_reg(info, DS2786_REG_RARC, &raw);
	203	if (err)
	204	return err;
	205	/* Relative capacity is displayed with resolution 0.5 % */
	206	*capacity = raw/2 ;
	207	return 0;
	208	}
	209
	210	static int ds278x_get_status(struct ds278x_info info, int status)
bfdb46ce RM	211	{
	212	int err;
	213	int current_uA;
	214	int capacity;
	215
9b9ade6b	216	err = info->ops->get_current(info, &current_uA);
bfdb46ce RM	217	if (err)
	218	return err;
	219
9b9ade6b	220	err = info->ops->get_capacity(info, &capacity);
bfdb46ce RM	221	if (err)
	222	return err;
	223
	224	if (capacity == 100)
	225	*status = POWER_SUPPLY_STATUS_FULL;
	226	else if (current_uA == 0)
	227	*status = POWER_SUPPLY_STATUS_NOT_CHARGING;
	228	else if (current_uA < 0)
	229	*status = POWER_SUPPLY_STATUS_DISCHARGING;
	230	else
	231	*status = POWER_SUPPLY_STATUS_CHARGING;
	232
	233	return 0;
	234	}
	235
9b9ade6b	236	static int ds278x_battery_get_property(struct power_supply *psy,
bfdb46ce RM	237	enum power_supply_property prop,
	238	union power_supply_propval *val)
	239	{
9b9ade6b	240	struct ds278x_info *info = to_ds278x_info(psy);
bfdb46ce RM	241	int ret;
	242
	243	switch (prop) {
	244	case POWER_SUPPLY_PROP_STATUS:
9b9ade6b	245	ret = ds278x_get_status(info, &val->intval);
bfdb46ce RM	246	break;
	247
	248	case POWER_SUPPLY_PROP_CAPACITY:
9b9ade6b	249	ret = info->ops->get_capacity(info, &val->intval);
bfdb46ce RM	250	break;
	251
	252	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
9b9ade6b	253	ret = info->ops->get_voltage(info, &val->intval);
bfdb46ce RM	254	break;
	255
	256	case POWER_SUPPLY_PROP_CURRENT_NOW:
9b9ade6b	257	ret = info->ops->get_current(info, &val->intval);
bfdb46ce RM	258	break;
	259
	260	case POWER_SUPPLY_PROP_TEMP:
9b9ade6b	261	ret = ds278x_get_temp(info, &val->intval);
bfdb46ce RM	262	break;
	263
	264	default:
	265	ret = -EINVAL;
	266	}
	267
	268	return ret;
	269	}
	270
9b9ade6b	271	static enum power_supply_property ds278x_battery_props[] = {
bfdb46ce RM	272	POWER_SUPPLY_PROP_STATUS,
	273	POWER_SUPPLY_PROP_CAPACITY,
	274	POWER_SUPPLY_PROP_VOLTAGE_NOW,
	275	POWER_SUPPLY_PROP_CURRENT_NOW,
	276	POWER_SUPPLY_PROP_TEMP,
	277	};
	278
9b9ade6b	279	static void ds278x_power_supply_init(struct power_supply *battery)
bfdb46ce RM	280	{
bfdb46ce RM	281	battery->type = POWER_SUPPLY_TYPE_BATTERY;
9b9ade6b YV	282	battery->properties = ds278x_battery_props;
	283	battery->num_properties = ARRAY_SIZE(ds278x_battery_props);
	284	battery->get_property = ds278x_battery_get_property;
bfdb46ce RM	285	battery->external_power_changed = NULL;
	286	}
	287
9b9ade6b	288	static int ds278x_battery_remove(struct i2c_client *client)
bfdb46ce	289	{
9b9ade6b	290	struct ds278x_info *info = i2c_get_clientdata(client);
bfdb46ce RM	291
	292	power_supply_unregister(&info->battery);
	293	kfree(info->battery.name);
	294
	295	mutex_lock(&battery_lock);
	296	idr_remove(&battery_id, info->id);
	297	mutex_unlock(&battery_lock);
	298
bfdb46ce RM	299	kfree(info);
	300	return 0;
	301	}
	302
ab6cc8f9 AV	303	enum ds278x_num_id {
	304	DS2782 = 0,
	305	DS2786,
	306	};
	307
9b9ade6b	308	static struct ds278x_battery_ops ds278x_ops[] = {
ab6cc8f9	309	[DS2782] = {
9b9ade6b YV	310	.get_current = ds2782_get_current,
	311	.get_voltage = ds2782_get_voltage,
	312	.get_capacity = ds2782_get_capacity,
	313	},
ab6cc8f9	314	[DS2786] = {
9b9ade6b YV	315	.get_current = ds2786_get_current,
	316	.get_voltage = ds2786_get_voltage,
	317	.get_capacity = ds2786_get_capacity,
	318	}
	319	};
	320
	321	static int ds278x_battery_probe(struct i2c_client *client,
bfdb46ce RM	322	const struct i2c_device_id *id)
bfdb46ce RM	323	{
9b9ade6b YV	324	struct ds278x_platform_data *pdata = client->dev.platform_data;
9b9ade6b YV	325	struct ds278x_info *info;
bfdb46ce RM	326	int ret;
	327	int num;
	328
9b9ade6b YV	329	/*
	330	* ds2786 should have the sense resistor value set
	331	* in the platform data
	332	*/
ab6cc8f9	333	if (id->driver_data == DS2786 && !pdata) {
9b9ade6b YV	334	dev_err(&client->dev, "missing platform data for ds2786\n");
	335	return -EINVAL;
	336	}
	337
bfdb46ce RM	338	/* Get an ID for this battery */
	339	ret = idr_pre_get(&battery_id, GFP_KERNEL);
	340	if (ret == 0) {
	341	ret = -ENOMEM;
	342	goto fail_id;
	343	}
	344
	345	mutex_lock(&battery_lock);
	346	ret = idr_get_new(&battery_id, client, &num);
	347	mutex_unlock(&battery_lock);
	348	if (ret < 0)
	349	goto fail_id;
	350
	351	info = kzalloc(sizeof(*info), GFP_KERNEL);
	352	if (!info) {
	353	ret = -ENOMEM;
	354	goto fail_info;
	355	}
	356
9b9ade6b	357	info->battery.name = kasprintf(GFP_KERNEL, "%s-%d", client->name, num);
bfdb46ce RM	358	if (!info->battery.name) {
	359	ret = -ENOMEM;
	360	goto fail_name;
	361	}
	362
ab6cc8f9	363	if (id->driver_data == DS2786)
9b9ade6b YV	364	info->rsns = pdata->rsns;
9b9ade6b YV	365
bfdb46ce RM	366	i2c_set_clientdata(client, info);
bfdb46ce RM	367	info->client = client;
9b9ade6b YV	368	info->id = num;
	369	info->ops = &ds278x_ops[id->driver_data];
	370	ds278x_power_supply_init(&info->battery);
bfdb46ce RM	371
	372	ret = power_supply_register(&client->dev, &info->battery);
	373	if (ret) {
	374	dev_err(&client->dev, "failed to register battery\n");
	375	goto fail_register;
	376	}
	377
	378	return 0;
	379
	380	fail_register:
	381	kfree(info->battery.name);
	382	fail_name:
bfdb46ce RM	383	kfree(info);
	384	fail_info:
	385	mutex_lock(&battery_lock);
	386	idr_remove(&battery_id, num);
	387	mutex_unlock(&battery_lock);
	388	fail_id:
	389	return ret;
	390	}
	391
9b9ade6b	392	static const struct i2c_device_id ds278x_id[] = {
ab6cc8f9 AV	393	{"ds2782", DS2782},
ab6cc8f9 AV	394	{"ds2786", DS2786},
bfdb46ce RM	395	{},
	396	};
	397
9b9ade6b	398	static struct i2c_driver ds278x_battery_driver = {
bfdb46ce RM	399	.driver = {
	400	.name = "ds2782-battery",
	401	},
9b9ade6b YV	402	.probe = ds278x_battery_probe,
	403	.remove = ds278x_battery_remove,
	404	.id_table = ds278x_id,
bfdb46ce RM	405	};
bfdb46ce RM	406
9b9ade6b	407	static int __init ds278x_init(void)
bfdb46ce	408	{
9b9ade6b	409	return i2c_add_driver(&ds278x_battery_driver);
bfdb46ce	410	}
9b9ade6b	411	module_init(ds278x_init);
bfdb46ce	412
9b9ade6b	413	static void __exit ds278x_exit(void)
bfdb46ce	414	{
9b9ade6b	415	i2c_del_driver(&ds278x_battery_driver);
bfdb46ce	416	}
9b9ade6b	417	module_exit(ds278x_exit);
bfdb46ce RM	418
	419	MODULE_AUTHOR("Ryan Mallon <ryan@bluewatersys.com>");
	420	MODULE_DESCRIPTION("Maxim/Dallas DS2782 Stand-Alone Fuel Gauage IC driver");
	421	MODULE_LICENSE("GPL");