[deliverable/linux.git] / drivers / power / bq24735-charger.c

/*
 * Battery charger driver for TI BQ24735
 *
 * Copyright (c) 2013, NVIDIA CORPORATION.  All rights reserved.
 *
 * 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;
 *
 * 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.,
 * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 */

#include <linux/err.h>
#include <linux/gpio.h>
#include <linux/i2c.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/of_gpio.h>
#include <linux/power_supply.h>
#include <linux/slab.h>

#include <linux/power/bq24735-charger.h>

#define BQ24735_CHG_OPT			0x12
#define BQ24735_CHG_OPT_CHARGE_DISABLE	(1 << 0)
#define BQ24735_CHG_OPT_AC_PRESENT	(1 << 4)
#define BQ24735_CHARGE_CURRENT		0x14
#define BQ24735_CHARGE_CURRENT_MASK	0x1fc0
#define BQ24735_CHARGE_VOLTAGE		0x15
#define BQ24735_CHARGE_VOLTAGE_MASK	0x7ff0
#define BQ24735_INPUT_CURRENT		0x3f
#define BQ24735_INPUT_CURRENT_MASK	0x1f80
#define BQ24735_MANUFACTURER_ID		0xfe
#define BQ24735_DEVICE_ID		0xff

struct bq24735 {
	struct power_supply	charger;
	struct i2c_client	*client;
	struct bq24735_platform	*pdata;
};

static inline struct bq24735 *to_bq24735(struct power_supply *psy)
{
	return container_of(psy, struct bq24735, charger);
}

static enum power_supply_property bq24735_charger_properties[] = {
	POWER_SUPPLY_PROP_ONLINE,
};

static inline int bq24735_write_word(struct i2c_client *client, u8 reg,
				     u16 value)
{
	return i2c_smbus_write_word_data(client, reg, le16_to_cpu(value));
}

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

	return ret < 0 ? ret : le16_to_cpu(ret);
}

static int bq24735_update_word(struct i2c_client *client, u8 reg,
			       u16 mask, u16 value)
{
	unsigned int tmp;
	int ret;

	ret = bq24735_read_word(client, reg);
	if (ret < 0)
		return ret;

	tmp = ret & ~mask;
	tmp |= value & mask;

	return bq24735_write_word(client, reg, tmp);
}

static inline int bq24735_enable_charging(struct bq24735 *charger)
{
	return bq24735_update_word(charger->client, BQ24735_CHG_OPT,
				   BQ24735_CHG_OPT_CHARGE_DISABLE,
				   ~BQ24735_CHG_OPT_CHARGE_DISABLE);
}

static inline int bq24735_disable_charging(struct bq24735 *charger)
{
	return bq24735_update_word(charger->client, BQ24735_CHG_OPT,
				   BQ24735_CHG_OPT_CHARGE_DISABLE,
				   BQ24735_CHG_OPT_CHARGE_DISABLE);
}

static int bq24735_config_charger(struct bq24735 *charger)
{
	struct bq24735_platform *pdata = charger->pdata;
	int ret;
	u16 value;

	if (pdata->charge_current) {
		value = pdata->charge_current & BQ24735_CHARGE_CURRENT_MASK;

		ret = bq24735_write_word(charger->client,
					 BQ24735_CHARGE_CURRENT, value);
		if (ret < 0) {
			dev_err(&charger->client->dev,
				"Failed to write charger current : %d\n",
				ret);
			return ret;
		}
	}

	if (pdata->charge_voltage) {
		value = pdata->charge_voltage & BQ24735_CHARGE_VOLTAGE_MASK;

		ret = bq24735_write_word(charger->client,
					 BQ24735_CHARGE_VOLTAGE, value);
		if (ret < 0) {
			dev_err(&charger->client->dev,
				"Failed to write charger voltage : %d\n",
				ret);
			return ret;
		}
	}

	if (pdata->input_current) {
		value = pdata->input_current & BQ24735_INPUT_CURRENT_MASK;

		ret = bq24735_write_word(charger->client,
					 BQ24735_INPUT_CURRENT, value);
		if (ret < 0) {
			dev_err(&charger->client->dev,
				"Failed to write input current : %d\n",
				ret);
			return ret;
		}
	}

	return 0;
}

static bool bq24735_charger_is_present(struct bq24735 *charger)
{
	struct bq24735_platform *pdata = charger->pdata;
	int ret;

	if (pdata->status_gpio_valid) {
		ret = gpio_get_value_cansleep(pdata->status_gpio);
		return ret ^= pdata->status_gpio_active_low == 0;
	} else {
		int ac = 0;

		ac = bq24735_read_word(charger->client, BQ24735_CHG_OPT);
		if (ac < 0) {
			dev_err(&charger->client->dev,
				"Failed to read charger options : %d\n",
				ac);
			return false;
		}
		return (ac & BQ24735_CHG_OPT_AC_PRESENT) ? true : false;
	}

	return false;
}

static irqreturn_t bq24735_charger_isr(int irq, void *devid)
{
	struct power_supply *psy = devid;
	struct bq24735 *charger = to_bq24735(psy);

	if (bq24735_charger_is_present(charger))
		bq24735_enable_charging(charger);
	else
		bq24735_disable_charging(charger);

	power_supply_changed(psy);

	return IRQ_HANDLED;
}

static int bq24735_charger_get_property(struct power_supply *psy,
					enum power_supply_property psp,
					union power_supply_propval *val)
{
	struct bq24735 *charger;

	charger = container_of(psy, struct bq24735, charger);

	switch (psp) {
	case POWER_SUPPLY_PROP_ONLINE:
		val->intval = bq24735_charger_is_present(charger) ? 1 : 0;
		break;
	default:
		return -EINVAL;
	}

	return 0;
}

static struct bq24735_platform *bq24735_parse_dt_data(struct i2c_client *client)
{
	struct bq24735_platform *pdata;
	struct device_node *np = client->dev.of_node;
	u32 val;
	int ret;
	enum of_gpio_flags flags;

	pdata = devm_kzalloc(&client->dev, sizeof(*pdata), GFP_KERNEL);
	if (!pdata) {
		dev_err(&client->dev,
			"Memory alloc for bq24735 pdata failed\n");
		return NULL;
	}

	pdata->status_gpio = of_get_named_gpio_flags(np, "ti,ac-detect-gpios",
						     0, &flags);

	if (flags & OF_GPIO_ACTIVE_LOW)
		pdata->status_gpio_active_low = 1;

	ret = of_property_read_u32(np, "ti,charge-current", &val);
	if (!ret)
		pdata->charge_current = val;

	ret = of_property_read_u32(np, "ti,charge-voltage", &val);
	if (!ret)
		pdata->charge_voltage = val;

	ret = of_property_read_u32(np, "ti,input-current", &val);
	if (!ret)
		pdata->input_current = val;

	return pdata;
}

static int bq24735_charger_probe(struct i2c_client *client,
				 const struct i2c_device_id *id)
{
	int ret;
	struct bq24735 *charger;
	struct power_supply *supply;
	struct power_supply_config psy_cfg = {};
	char *name;

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

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

	if (IS_ENABLED(CONFIG_OF) && !charger->pdata && client->dev.of_node)
		charger->pdata = bq24735_parse_dt_data(client);

	if (!charger->pdata) {
		dev_err(&client->dev, "no platform data provided\n");
		return -EINVAL;
	}

	name = (char *)charger->pdata->name;
	if (!name) {
		name = kasprintf(GFP_KERNEL, "bq24735@%s",
				 dev_name(&client->dev));
		if (!name) {
			dev_err(&client->dev, "Failed to alloc device name\n");
			return -ENOMEM;
		}
	}

	charger->client = client;

	supply = &charger->charger;

	supply->name = name;
	supply->type = POWER_SUPPLY_TYPE_MAINS;
	supply->properties = bq24735_charger_properties;
	supply->num_properties = ARRAY_SIZE(bq24735_charger_properties);
	supply->get_property = bq24735_charger_get_property;

	psy_cfg.supplied_to = charger->pdata->supplied_to;
	psy_cfg.num_supplicants = charger->pdata->num_supplicants;
	psy_cfg.of_node = client->dev.of_node;

	i2c_set_clientdata(client, charger);

	ret = bq24735_read_word(client, BQ24735_MANUFACTURER_ID);
	if (ret < 0) {
		dev_err(&client->dev, "Failed to read manufacturer id : %d\n",
			ret);
		goto err_free_name;
	} else if (ret != 0x0040) {
		dev_err(&client->dev,
			"manufacturer id mismatch. 0x0040 != 0x%04x\n", ret);
		ret = -ENODEV;
		goto err_free_name;
	}

	ret = bq24735_read_word(client, BQ24735_DEVICE_ID);
	if (ret < 0) {
		dev_err(&client->dev, "Failed to read device id : %d\n", ret);
		goto err_free_name;
	} else if (ret != 0x000B) {
		dev_err(&client->dev,
			"device id mismatch. 0x000b != 0x%04x\n", ret);
		ret = -ENODEV;
		goto err_free_name;
	}

	if (gpio_is_valid(charger->pdata->status_gpio)) {
		ret = devm_gpio_request(&client->dev,
					charger->pdata->status_gpio,
					name);
		if (ret) {
			dev_err(&client->dev,
				"Failed GPIO request for GPIO %d: %d\n",
				charger->pdata->status_gpio, ret);
		}

		charger->pdata->status_gpio_valid = !ret;
	}

	ret = bq24735_config_charger(charger);
	if (ret < 0) {
		dev_err(&client->dev, "failed in configuring charger");
		goto err_free_name;
	}

	/* check for AC adapter presence */
	if (bq24735_charger_is_present(charger)) {
		ret = bq24735_enable_charging(charger);
		if (ret < 0) {
			dev_err(&client->dev, "Failed to enable charging\n");
			goto err_free_name;
		}
	}

	ret = power_supply_register(&client->dev, supply, &psy_cfg);
	if (ret < 0) {
		dev_err(&client->dev, "Failed to register power supply: %d\n",
			ret);
		goto err_free_name;
	}

	if (client->irq) {
		ret = devm_request_threaded_irq(&client->dev, client->irq,
						NULL, bq24735_charger_isr,
						IRQF_TRIGGER_RISING |
						IRQF_TRIGGER_FALLING |
						IRQF_ONESHOT,
						supply->name, supply);
		if (ret) {
			dev_err(&client->dev,
				"Unable to register IRQ %d err %d\n",
				client->irq, ret);
			goto err_unregister_supply;
		}
	}

	return 0;
err_unregister_supply:
	power_supply_unregister(supply);
err_free_name:
	if (name != charger->pdata->name)
		kfree(name);

	return ret;
}

static int bq24735_charger_remove(struct i2c_client *client)
{
	struct bq24735 *charger = i2c_get_clientdata(client);

	if (charger->client->irq)
		devm_free_irq(&charger->client->dev, charger->client->irq,
			      &charger->charger);

	power_supply_unregister(&charger->charger);

	if (charger->charger.name != charger->pdata->name)
		kfree(charger->charger.name);

	return 0;
}

static const struct i2c_device_id bq24735_charger_id[] = {
	{ "bq24735-charger", 0 },
	{}
};
MODULE_DEVICE_TABLE(i2c, bq24735_charger_id);

static const struct of_device_id bq24735_match_ids[] = {
	{ .compatible = "ti,bq24735", },
	{ /* end */ }
};
MODULE_DEVICE_TABLE(of, bq24735_match_ids);

static struct i2c_driver bq24735_charger_driver = {
	.driver = {
		.name = "bq24735-charger",
		.owner = THIS_MODULE,
		.of_match_table = bq24735_match_ids,
	},
	.probe = bq24735_charger_probe,
	.remove = bq24735_charger_remove,
	.id_table = bq24735_charger_id,
};

module_i2c_driver(bq24735_charger_driver);

MODULE_DESCRIPTION("bq24735 battery charging driver");
MODULE_AUTHOR("Darbha Sriharsha <dsriharsha@nvidia.com>");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
ce773992 DS	1	/*
	2	* Battery charger driver for TI BQ24735
	3	*
	4	* Copyright (c) 2013, NVIDIA CORPORATION. All rights reserved.
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation;
	9	*
	10	* This program is distributed in the hope that it will be useful, but WITHOUT
	11	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	12	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	13	* more details.
	14	*
	15	* You should have received a copy of the GNU General Public License along
	16	* with this program; if not, write to the Free Software Foundation, Inc.,
	17	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
	18	*/
	19
	20	#include <linux/err.h>
	21	#include <linux/gpio.h>
	22	#include <linux/i2c.h>
	23	#include <linux/init.h>
	24	#include <linux/interrupt.h>
	25	#include <linux/kernel.h>
	26	#include <linux/module.h>
	27	#include <linux/of.h>
	28	#include <linux/of_gpio.h>
	29	#include <linux/power_supply.h>
	30	#include <linux/slab.h>
	31
	32	#include <linux/power/bq24735-charger.h>
	33
	34	#define BQ24735_CHG_OPT 0x12
	35	#define BQ24735_CHG_OPT_CHARGE_DISABLE (1 << 0)
	36	#define BQ24735_CHG_OPT_AC_PRESENT (1 << 4)
	37	#define BQ24735_CHARGE_CURRENT 0x14
	38	#define BQ24735_CHARGE_CURRENT_MASK 0x1fc0
	39	#define BQ24735_CHARGE_VOLTAGE 0x15
	40	#define BQ24735_CHARGE_VOLTAGE_MASK 0x7ff0
	41	#define BQ24735_INPUT_CURRENT 0x3f
	42	#define BQ24735_INPUT_CURRENT_MASK 0x1f80
	43	#define BQ24735_MANUFACTURER_ID 0xfe
	44	#define BQ24735_DEVICE_ID 0xff
	45
	46	struct bq24735 {
	47	struct power_supply charger;
	48	struct i2c_client *client;
	49	struct bq24735_platform *pdata;
	50	};
	51
	52	static inline struct bq24735 to_bq24735(struct power_supply psy)
	53	{
	54	return container_of(psy, struct bq24735, charger);
	55	}
	56
	57	static enum power_supply_property bq24735_charger_properties[] = {
	58	POWER_SUPPLY_PROP_ONLINE,
	59	};
	60
	61	static inline int bq24735_write_word(struct i2c_client *client, u8 reg,
	62	u16 value)
	63	{
	64	return i2c_smbus_write_word_data(client, reg, le16_to_cpu(value));
65	}
66
67	static inline int bq24735_read_word(struct i2c_client *client, u8 reg)
68	{
69	s32 ret = i2c_smbus_read_word_data(client, reg);
70
71	return ret < 0 ? ret : le16_to_cpu(ret);
72	}
73
74	static int bq24735_update_word(struct i2c_client *client, u8 reg,
75	u16 mask, u16 value)
76	{
77	unsigned int tmp;
78	int ret;
79
80	ret = bq24735_read_word(client, reg);
81	if (ret < 0)
82	return ret;
83
84	tmp = ret & ~mask;
85	tmp \|= value & mask;
86
87	return bq24735_write_word(client, reg, tmp);
88	}
89
90	static inline int bq24735_enable_charging(struct bq24735 *charger)
91	{
92	return bq24735_update_word(charger->client, BQ24735_CHG_OPT,
93	BQ24735_CHG_OPT_CHARGE_DISABLE,
94	~BQ24735_CHG_OPT_CHARGE_DISABLE);
95	}
96
97	static inline int bq24735_disable_charging(struct bq24735 *charger)
98	{
99	return bq24735_update_word(charger->client, BQ24735_CHG_OPT,
100	BQ24735_CHG_OPT_CHARGE_DISABLE,
101	BQ24735_CHG_OPT_CHARGE_DISABLE);
102	}
103
104	static int bq24735_config_charger(struct bq24735 *charger)
105	{
106	struct bq24735_platform *pdata = charger->pdata;
107	int ret;
108	u16 value;
109
110	if (pdata->charge_current) {
111	value = pdata->charge_current & BQ24735_CHARGE_CURRENT_MASK;
112
113	ret = bq24735_write_word(charger->client,
114	BQ24735_CHARGE_CURRENT, value);
115	if (ret < 0) {
116	dev_err(&charger->client->dev,
117	"Failed to write charger current : %d\n",
118	ret);
119	return ret;
120	}
121	}
122
123	if (pdata->charge_voltage) {
124	value = pdata->charge_voltage & BQ24735_CHARGE_VOLTAGE_MASK;
125
126	ret = bq24735_write_word(charger->client,
127	BQ24735_CHARGE_VOLTAGE, value);
128	if (ret < 0) {
129	dev_err(&charger->client->dev,
130	"Failed to write charger voltage : %d\n",
131	ret);
132	return ret;
133	}
134	}
135
136	if (pdata->input_current) {
137	value = pdata->input_current & BQ24735_INPUT_CURRENT_MASK;
138
139	ret = bq24735_write_word(charger->client,
140	BQ24735_INPUT_CURRENT, value);
141	if (ret < 0) {
142	dev_err(&charger->client->dev,
143	"Failed to write input current : %d\n",
144	ret);
145	return ret;
146	}
147	}
148
149	return 0;
150	}
151
152	static bool bq24735_charger_is_present(struct bq24735 *charger)
153	{
154	struct bq24735_platform *pdata = charger->pdata;
155	int ret;
156
157	if (pdata->status_gpio_valid) {
158	ret = gpio_get_value_cansleep(pdata->status_gpio);
159	return ret ^= pdata->status_gpio_active_low == 0;
160	} else {
161	int ac = 0;
162
163	ac = bq24735_read_word(charger->client, BQ24735_CHG_OPT);
164	if (ac < 0) {
165	dev_err(&charger->client->dev,
166	"Failed to read charger options : %d\n",
167	ac);
168	return false;
169	}
170	return (ac & BQ24735_CHG_OPT_AC_PRESENT) ? true : false;
171	}
172
173	return false;
174	}
175
176	static irqreturn_t bq24735_charger_isr(int irq, void *devid)
177	{
178	struct power_supply *psy = devid;
179	struct bq24735 *charger = to_bq24735(psy);
180
181	if (bq24735_charger_is_present(charger))
182	bq24735_enable_charging(charger);
183	else
184	bq24735_disable_charging(charger);
185
186	power_supply_changed(psy);
187
188	return IRQ_HANDLED;
189	}
190
191	static int bq24735_charger_get_property(struct power_supply *psy,
192	enum power_supply_property psp,
193	union power_supply_propval *val)
194	{
195	struct bq24735 *charger;
196
197	charger = container_of(psy, struct bq24735, charger);
198
199	switch (psp) {
200	case POWER_SUPPLY_PROP_ONLINE:
201	val->intval = bq24735_charger_is_present(charger) ? 1 : 0;
202	break;
203	default:
204	return -EINVAL;
205	}
206
207	return 0;
208	}
209
210	static struct bq24735_platform bq24735_parse_dt_data(struct i2c_client client)
211	{
212	struct bq24735_platform *pdata;
213	struct device_node *np = client->dev.of_node;
214	u32 val;
215	int ret;
216	enum of_gpio_flags flags;
217
218	pdata = devm_kzalloc(&client->dev, sizeof(*pdata), GFP_KERNEL);
219	if (!pdata) {
220	dev_err(&client->dev,
221	"Memory alloc for bq24735 pdata failed\n");
222	return NULL;
223	}
224
225	pdata->status_gpio = of_get_named_gpio_flags(np, "ti,ac-detect-gpios",
226	0, &flags);
227
228	if (flags & OF_GPIO_ACTIVE_LOW)
229	pdata->status_gpio_active_low = 1;
230
231	ret = of_property_read_u32(np, "ti,charge-current", &val);
232	if (!ret)
233	pdata->charge_current = val;
234
235	ret = of_property_read_u32(np, "ti,charge-voltage", &val);
236	if (!ret)
237	pdata->charge_voltage = val;
238
239	ret = of_property_read_u32(np, "ti,input-current", &val);
240	if (!ret)
241	pdata->input_current = val;
242
243	return pdata;
244	}
245
246	static int bq24735_charger_probe(struct i2c_client *client,
247	const struct i2c_device_id *id)
248	{
249	int ret;
250	struct bq24735 *charger;
251	struct power_supply *supply;
2dc9215d	252	struct power_supply_config psy_cfg = {};
ce773992 DS	253	char *name;
	254
	255	charger = devm_kzalloc(&client->dev, sizeof(*charger), GFP_KERNEL);
	256	if (!charger)
	257	return -ENOMEM;
	258
	259	charger->pdata = client->dev.platform_data;
	260
	261	if (IS_ENABLED(CONFIG_OF) && !charger->pdata && client->dev.of_node)
	262	charger->pdata = bq24735_parse_dt_data(client);
	263
	264	if (!charger->pdata) {
	265	dev_err(&client->dev, "no platform data provided\n");
	266	return -EINVAL;
	267	}
	268
	269	name = (char *)charger->pdata->name;
	270	if (!name) {
	271	name = kasprintf(GFP_KERNEL, "bq24735@%s",
	272	dev_name(&client->dev));
	273	if (!name) {
	274	dev_err(&client->dev, "Failed to alloc device name\n");
	275	return -ENOMEM;
	276	}
	277	}
	278
	279	charger->client = client;
	280
	281	supply = &charger->charger;
	282
	283	supply->name = name;
	284	supply->type = POWER_SUPPLY_TYPE_MAINS;
	285	supply->properties = bq24735_charger_properties;
	286	supply->num_properties = ARRAY_SIZE(bq24735_charger_properties);
	287	supply->get_property = bq24735_charger_get_property;
2dc9215d KK	288
	289	psy_cfg.supplied_to = charger->pdata->supplied_to;
	290	psy_cfg.num_supplicants = charger->pdata->num_supplicants;
	291	psy_cfg.of_node = client->dev.of_node;
ce773992 DS	292
	293	i2c_set_clientdata(client, charger);
	294
	295	ret = bq24735_read_word(client, BQ24735_MANUFACTURER_ID);
	296	if (ret < 0) {
	297	dev_err(&client->dev, "Failed to read manufacturer id : %d\n",
	298	ret);
	299	goto err_free_name;
	300	} else if (ret != 0x0040) {
	301	dev_err(&client->dev,
	302	"manufacturer id mismatch. 0x0040 != 0x%04x\n", ret);
	303	ret = -ENODEV;
	304	goto err_free_name;
	305	}
	306
	307	ret = bq24735_read_word(client, BQ24735_DEVICE_ID);
	308	if (ret < 0) {
	309	dev_err(&client->dev, "Failed to read device id : %d\n", ret);
	310	goto err_free_name;
	311	} else if (ret != 0x000B) {
	312	dev_err(&client->dev,
	313	"device id mismatch. 0x000b != 0x%04x\n", ret);
	314	ret = -ENODEV;
	315	goto err_free_name;
	316	}
	317
	318	if (gpio_is_valid(charger->pdata->status_gpio)) {
	319	ret = devm_gpio_request(&client->dev,
	320	charger->pdata->status_gpio,
	321	name);
	322	if (ret) {
	323	dev_err(&client->dev,
	324	"Failed GPIO request for GPIO %d: %d\n",
	325	charger->pdata->status_gpio, ret);
	326	}
	327
	328	charger->pdata->status_gpio_valid = !ret;
	329	}
	330
	331	ret = bq24735_config_charger(charger);
	332	if (ret < 0) {
	333	dev_err(&client->dev, "failed in configuring charger");
	334	goto err_free_name;
	335	}
	336
	337	/* check for AC adapter presence */
	338	if (bq24735_charger_is_present(charger)) {
	339	ret = bq24735_enable_charging(charger);
	340	if (ret < 0) {
	341	dev_err(&client->dev, "Failed to enable charging\n");
	342	goto err_free_name;
	343	}
	344	}
	345
2dc9215d	346	ret = power_supply_register(&client->dev, supply, &psy_cfg);
ce773992 DS	347	if (ret < 0) {
	348	dev_err(&client->dev, "Failed to register power supply: %d\n",
	349	ret);
	350	goto err_free_name;
	351	}
	352
	353	if (client->irq) {
	354	ret = devm_request_threaded_irq(&client->dev, client->irq,
	355	NULL, bq24735_charger_isr,
	356	IRQF_TRIGGER_RISING \|
	357	IRQF_TRIGGER_FALLING \|
	358	IRQF_ONESHOT,
	359	supply->name, supply);
	360	if (ret) {
	361	dev_err(&client->dev,
	362	"Unable to register IRQ %d err %d\n",
	363	client->irq, ret);
	364	goto err_unregister_supply;
	365	}
	366	}
	367
	368	return 0;
	369	err_unregister_supply:
	370	power_supply_unregister(supply);
	371	err_free_name:
	372	if (name != charger->pdata->name)
	373	kfree(name);
	374
	375	return ret;
	376	}
	377
	378	static int bq24735_charger_remove(struct i2c_client *client)
	379	{
	380	struct bq24735 *charger = i2c_get_clientdata(client);
	381
	382	if (charger->client->irq)
	383	devm_free_irq(&charger->client->dev, charger->client->irq,
	384	&charger->charger);
	385
	386	power_supply_unregister(&charger->charger);
	387
	388	if (charger->charger.name != charger->pdata->name)
	389	kfree(charger->charger.name);
	390
	391	return 0;
	392	}
	393
	394	static const struct i2c_device_id bq24735_charger_id[] = {
	395	{ "bq24735-charger", 0 },
	396	{}
	397	};
	398	MODULE_DEVICE_TABLE(i2c, bq24735_charger_id);
	399
	400	static const struct of_device_id bq24735_match_ids[] = {
	401	{ .compatible = "ti,bq24735", },
	402	{ /* end */ }
	403	};
	404	MODULE_DEVICE_TABLE(of, bq24735_match_ids);
	405
	406	static struct i2c_driver bq24735_charger_driver = {
	407	.driver = {
	408	.name = "bq24735-charger",
	409	.owner = THIS_MODULE,
	410	.of_match_table = bq24735_match_ids,
411	},
412	.probe = bq24735_charger_probe,
413	.remove = bq24735_charger_remove,
414	.id_table = bq24735_charger_id,
415	};
416
417	module_i2c_driver(bq24735_charger_driver);
418
419	MODULE_DESCRIPTION("bq24735 battery charging driver");
420	MODULE_AUTHOR("Darbha Sriharsha <dsriharsha@nvidia.com>");
421	MODULE_LICENSE("GPL v2");