[linux-2.6-block.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 power_supply_desc	charger_desc;
	struct i2c_client		*client;
	struct bq24735_platform		*pdata;
	struct mutex			lock;
	bool				charging;
};

static inline struct bq24735 *to_bq24735(struct power_supply *psy)
{
	return power_supply_get_drvdata(psy);
}

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

static int bq24735_charger_property_is_writeable(struct power_supply *psy,
						 enum power_supply_property psp)
{
	switch (psp) {
	case POWER_SUPPLY_PROP_STATUS:
		return 1;
	default:
		break;
	}

	return 0;
}

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)
{
	if (charger->pdata->ext_control)
		return 0;

	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)
{
	if (charger->pdata->ext_control)
		return 0;

	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->ext_control)
		return 0;

	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 int bq24735_charger_is_charging(struct bq24735 *charger)
{
	int ret = bq24735_read_word(charger->client, BQ24735_CHG_OPT);

	if (ret < 0)
		return ret;

	return !(ret & BQ24735_CHG_OPT_CHARGE_DISABLE);
}

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

	mutex_lock(&charger->lock);

	if (charger->charging && bq24735_charger_is_present(charger))
		bq24735_enable_charging(charger);
	else
		bq24735_disable_charging(charger);

	mutex_unlock(&charger->lock);

	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 = to_bq24735(psy);

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

	return 0;
}

static int bq24735_charger_set_property(struct power_supply *psy,
					enum power_supply_property psp,
					const union power_supply_propval *val)
{
	struct bq24735 *charger = to_bq24735(psy);
	int ret;

	switch (psp) {
	case POWER_SUPPLY_PROP_STATUS:
		switch (val->intval) {
		case POWER_SUPPLY_STATUS_CHARGING:
			mutex_lock(&charger->lock);
			charger->charging = true;
			ret = bq24735_enable_charging(charger);
			mutex_unlock(&charger->lock);
			if (ret)
				return ret;
			bq24735_config_charger(charger);
			break;
		case POWER_SUPPLY_STATUS_DISCHARGING:
		case POWER_SUPPLY_STATUS_NOT_CHARGING:
			mutex_lock(&charger->lock);
			charger->charging = false;
			ret = bq24735_disable_charging(charger);
			mutex_unlock(&charger->lock);
			if (ret)
				return ret;
			break;
		default:
			return -EINVAL;
		}
		power_supply_changed(psy);
		break;
	default:
		return -EPERM;
	}

	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;

	pdata->ext_control = of_property_read_bool(np, "ti,external-control");

	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_desc *supply_desc;
	struct power_supply_config psy_cfg = {};
	char *name;

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

	mutex_init(&charger->lock);
	charger->charging = true;
	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 = devm_kasprintf(&client->dev, 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_desc = &charger->charger_desc;

	supply_desc->name = name;
	supply_desc->type = POWER_SUPPLY_TYPE_MAINS;
	supply_desc->properties = bq24735_charger_properties;
	supply_desc->num_properties = ARRAY_SIZE(bq24735_charger_properties);
	supply_desc->get_property = bq24735_charger_get_property;
	supply_desc->set_property = bq24735_charger_set_property;
	supply_desc->property_is_writeable =
				bq24735_charger_property_is_writeable;

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

	i2c_set_clientdata(client, charger);

	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;
	}

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

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

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

	/* 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");
			return ret;
		}
	}

	charger->charger = devm_power_supply_register(&client->dev, supply_desc,
						      &psy_cfg);
	if (IS_ERR(charger->charger)) {
		ret = PTR_ERR(charger->charger);
		dev_err(&client->dev, "Failed to register power supply: %d\n",
			ret);
		return ret;
	}

	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_desc->name,
						charger->charger);
		if (ret) {
			dev_err(&client->dev,
				"Unable to register IRQ %d err %d\n",
				client->irq, ret);
			return ret;
		}
	}

	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",
		.of_match_table = bq24735_match_ids,
	},
	.probe = bq24735_charger_probe,
	.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 {
297d716f KK	47	struct power_supply *charger;
	48	struct power_supply_desc charger_desc;
	49	struct i2c_client *client;
	50	struct bq24735_platform *pdata;
5b7a0187 PR	51	struct mutex lock;
5b7a0187 PR	52	bool charging;
ce773992 DS	53	};
	54
	55	static inline struct bq24735 to_bq24735(struct power_supply psy)
	56	{
297d716f	57	return power_supply_get_drvdata(psy);
ce773992 DS	58	}
	59
	60	static enum power_supply_property bq24735_charger_properties[] = {
5b7a0187	61	POWER_SUPPLY_PROP_STATUS,
ce773992 DS	62	POWER_SUPPLY_PROP_ONLINE,
	63	};
	64
5b7a0187 PR	65	static int bq24735_charger_property_is_writeable(struct power_supply *psy,
	66	enum power_supply_property psp)
	67	{
	68	switch (psp) {
	69	case POWER_SUPPLY_PROP_STATUS:
	70	return 1;
	71	default:
	72	break;
	73	}
	74
	75	return 0;
	76	}
	77
ce773992 DS	78	static inline int bq24735_write_word(struct i2c_client *client, u8 reg,
	79	u16 value)
	80	{
	81	return i2c_smbus_write_word_data(client, reg, le16_to_cpu(value));
	82	}
	83
	84	static inline int bq24735_read_word(struct i2c_client *client, u8 reg)
	85	{
	86	s32 ret = i2c_smbus_read_word_data(client, reg);
	87
	88	return ret < 0 ? ret : le16_to_cpu(ret);
	89	}
	90
	91	static int bq24735_update_word(struct i2c_client *client, u8 reg,
	92	u16 mask, u16 value)
	93	{
	94	unsigned int tmp;
	95	int ret;
	96
	97	ret = bq24735_read_word(client, reg);
	98	if (ret < 0)
	99	return ret;
	100
	101	tmp = ret & ~mask;
	102	tmp \|= value & mask;
	103
	104	return bq24735_write_word(client, reg, tmp);
	105	}
	106
	107	static inline int bq24735_enable_charging(struct bq24735 *charger)
	108	{
64024ac7 JT	109	if (charger->pdata->ext_control)
	110	return 0;
	111
ce773992 DS	112	return bq24735_update_word(charger->client, BQ24735_CHG_OPT,
	113	BQ24735_CHG_OPT_CHARGE_DISABLE,
	114	~BQ24735_CHG_OPT_CHARGE_DISABLE);
	115	}
	116
	117	static inline int bq24735_disable_charging(struct bq24735 *charger)
	118	{
64024ac7 JT	119	if (charger->pdata->ext_control)
	120	return 0;
	121
ce773992 DS	122	return bq24735_update_word(charger->client, BQ24735_CHG_OPT,
	123	BQ24735_CHG_OPT_CHARGE_DISABLE,
	124	BQ24735_CHG_OPT_CHARGE_DISABLE);
	125	}
	126
	127	static int bq24735_config_charger(struct bq24735 *charger)
	128	{
	129	struct bq24735_platform *pdata = charger->pdata;
	130	int ret;
	131	u16 value;
	132
64024ac7 JT	133	if (pdata->ext_control)
	134	return 0;
	135
ce773992 DS	136	if (pdata->charge_current) {
	137	value = pdata->charge_current & BQ24735_CHARGE_CURRENT_MASK;
	138
	139	ret = bq24735_write_word(charger->client,
	140	BQ24735_CHARGE_CURRENT, value);
	141	if (ret < 0) {
	142	dev_err(&charger->client->dev,
	143	"Failed to write charger current : %d\n",
	144	ret);
	145	return ret;
	146	}
	147	}
	148
	149	if (pdata->charge_voltage) {
	150	value = pdata->charge_voltage & BQ24735_CHARGE_VOLTAGE_MASK;
	151
	152	ret = bq24735_write_word(charger->client,
	153	BQ24735_CHARGE_VOLTAGE, value);
	154	if (ret < 0) {
	155	dev_err(&charger->client->dev,
	156	"Failed to write charger voltage : %d\n",
	157	ret);
	158	return ret;
	159	}
	160	}
	161
	162	if (pdata->input_current) {
	163	value = pdata->input_current & BQ24735_INPUT_CURRENT_MASK;
	164
	165	ret = bq24735_write_word(charger->client,
	166	BQ24735_INPUT_CURRENT, value);
	167	if (ret < 0) {
	168	dev_err(&charger->client->dev,
	169	"Failed to write input current : %d\n",
	170	ret);
	171	return ret;
	172	}
	173	}
	174
	175	return 0;
	176	}
	177
	178	static bool bq24735_charger_is_present(struct bq24735 *charger)
	179	{
	180	struct bq24735_platform *pdata = charger->pdata;
	181	int ret;
	182
	183	if (pdata->status_gpio_valid) {
	184	ret = gpio_get_value_cansleep(pdata->status_gpio);
	185	return ret ^= pdata->status_gpio_active_low == 0;
	186	} else {
	187	int ac = 0;
	188
	189	ac = bq24735_read_word(charger->client, BQ24735_CHG_OPT);
	190	if (ac < 0) {
	191	dev_err(&charger->client->dev,
	192	"Failed to read charger options : %d\n",
	193	ac);
	194	return false;
	195	}
	196	return (ac & BQ24735_CHG_OPT_AC_PRESENT) ? true : false;
	197	}
	198
	199	return false;
200	}
201
5b7a0187 PR	202	static int bq24735_charger_is_charging(struct bq24735 *charger)
	203	{
	204	int ret = bq24735_read_word(charger->client, BQ24735_CHG_OPT);
	205
	206	if (ret < 0)
	207	return ret;
	208
	209	return !(ret & BQ24735_CHG_OPT_CHARGE_DISABLE);
	210	}
	211
ce773992 DS	212	static irqreturn_t bq24735_charger_isr(int irq, void *devid)
	213	{
	214	struct power_supply *psy = devid;
	215	struct bq24735 *charger = to_bq24735(psy);
	216
5b7a0187 PR	217	mutex_lock(&charger->lock);
	218
	219	if (charger->charging && bq24735_charger_is_present(charger))
ce773992 DS	220	bq24735_enable_charging(charger);
	221	else
	222	bq24735_disable_charging(charger);
	223
5b7a0187 PR	224	mutex_unlock(&charger->lock);
5b7a0187 PR	225
ce773992 DS	226	power_supply_changed(psy);
	227
	228	return IRQ_HANDLED;
	229	}
	230
	231	static int bq24735_charger_get_property(struct power_supply *psy,
	232	enum power_supply_property psp,
	233	union power_supply_propval *val)
	234	{
297d716f	235	struct bq24735 *charger = to_bq24735(psy);
ce773992 DS	236
	237	switch (psp) {
	238	case POWER_SUPPLY_PROP_ONLINE:
	239	val->intval = bq24735_charger_is_present(charger) ? 1 : 0;
	240	break;
5b7a0187 PR	241	case POWER_SUPPLY_PROP_STATUS:
	242	switch (bq24735_charger_is_charging(charger)) {
	243	case 1:
	244	val->intval = POWER_SUPPLY_STATUS_CHARGING;
	245	break;
	246	case 0:
	247	val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
	248	break;
	249	default:
	250	val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
	251	break;
	252	}
	253	break;
ce773992 DS	254	default:
	255	return -EINVAL;
	256	}
	257
	258	return 0;
	259	}
	260
5b7a0187 PR	261	static int bq24735_charger_set_property(struct power_supply *psy,
	262	enum power_supply_property psp,
	263	const union power_supply_propval *val)
	264	{
	265	struct bq24735 *charger = to_bq24735(psy);
	266	int ret;
	267
	268	switch (psp) {
	269	case POWER_SUPPLY_PROP_STATUS:
	270	switch (val->intval) {
	271	case POWER_SUPPLY_STATUS_CHARGING:
	272	mutex_lock(&charger->lock);
	273	charger->charging = true;
	274	ret = bq24735_enable_charging(charger);
	275	mutex_unlock(&charger->lock);
	276	if (ret)
	277	return ret;
	278	bq24735_config_charger(charger);
	279	break;
	280	case POWER_SUPPLY_STATUS_DISCHARGING:
	281	case POWER_SUPPLY_STATUS_NOT_CHARGING:
	282	mutex_lock(&charger->lock);
	283	charger->charging = false;
	284	ret = bq24735_disable_charging(charger);
	285	mutex_unlock(&charger->lock);
	286	if (ret)
	287	return ret;
	288	break;
	289	default:
	290	return -EINVAL;
	291	}
	292	power_supply_changed(psy);
	293	break;
	294	default:
	295	return -EPERM;
	296	}
	297
	298	return 0;
	299	}
	300
ce773992 DS	301	static struct bq24735_platform bq24735_parse_dt_data(struct i2c_client client)
	302	{
	303	struct bq24735_platform *pdata;
	304	struct device_node *np = client->dev.of_node;
	305	u32 val;
	306	int ret;
	307	enum of_gpio_flags flags;
	308
	309	pdata = devm_kzalloc(&client->dev, sizeof(*pdata), GFP_KERNEL);
	310	if (!pdata) {
	311	dev_err(&client->dev,
	312	"Memory alloc for bq24735 pdata failed\n");
	313	return NULL;
	314	}
	315
	316	pdata->status_gpio = of_get_named_gpio_flags(np, "ti,ac-detect-gpios",
	317	0, &flags);
	318
	319	if (flags & OF_GPIO_ACTIVE_LOW)
	320	pdata->status_gpio_active_low = 1;
	321
	322	ret = of_property_read_u32(np, "ti,charge-current", &val);
	323	if (!ret)
	324	pdata->charge_current = val;
	325
	326	ret = of_property_read_u32(np, "ti,charge-voltage", &val);
	327	if (!ret)
	328	pdata->charge_voltage = val;
	329
	330	ret = of_property_read_u32(np, "ti,input-current", &val);
	331	if (!ret)
	332	pdata->input_current = val;
	333
64024ac7 JT	334	pdata->ext_control = of_property_read_bool(np, "ti,external-control");
64024ac7 JT	335
ce773992 DS	336	return pdata;
	337	}
	338
	339	static int bq24735_charger_probe(struct i2c_client *client,
	340	const struct i2c_device_id *id)
	341	{
	342	int ret;
	343	struct bq24735 *charger;
297d716f	344	struct power_supply_desc *supply_desc;
2dc9215d	345	struct power_supply_config psy_cfg = {};
ce773992 DS	346	char *name;
	347
	348	charger = devm_kzalloc(&client->dev, sizeof(*charger), GFP_KERNEL);
	349	if (!charger)
	350	return -ENOMEM;
	351
5b7a0187 PR	352	mutex_init(&charger->lock);
5b7a0187 PR	353	charger->charging = true;
ce773992 DS	354	charger->pdata = client->dev.platform_data;
	355
	356	if (IS_ENABLED(CONFIG_OF) && !charger->pdata && client->dev.of_node)
	357	charger->pdata = bq24735_parse_dt_data(client);
	358
	359	if (!charger->pdata) {
	360	dev_err(&client->dev, "no platform data provided\n");
	361	return -EINVAL;
	362	}
	363
	364	name = (char *)charger->pdata->name;
	365	if (!name) {
71a5a508 VT	366	name = devm_kasprintf(&client->dev, GFP_KERNEL,
	367	"bq24735@%s",
	368	dev_name(&client->dev));
ce773992 DS	369	if (!name) {
	370	dev_err(&client->dev, "Failed to alloc device name\n");
	371	return -ENOMEM;
	372	}
	373	}
	374
	375	charger->client = client;
	376
297d716f	377	supply_desc = &charger->charger_desc;
ce773992	378
297d716f KK	379	supply_desc->name = name;
	380	supply_desc->type = POWER_SUPPLY_TYPE_MAINS;
	381	supply_desc->properties = bq24735_charger_properties;
	382	supply_desc->num_properties = ARRAY_SIZE(bq24735_charger_properties);
	383	supply_desc->get_property = bq24735_charger_get_property;
5b7a0187 PR	384	supply_desc->set_property = bq24735_charger_set_property;
	385	supply_desc->property_is_writeable =
	386	bq24735_charger_property_is_writeable;
2dc9215d KK	387
	388	psy_cfg.supplied_to = charger->pdata->supplied_to;
	389	psy_cfg.num_supplicants = charger->pdata->num_supplicants;
	390	psy_cfg.of_node = client->dev.of_node;
297d716f	391	psy_cfg.drv_data = charger;
ce773992 DS	392
	393	i2c_set_clientdata(client, charger);
	394
ce773992 DS	395	if (gpio_is_valid(charger->pdata->status_gpio)) {
	396	ret = devm_gpio_request(&client->dev,
	397	charger->pdata->status_gpio,
	398	name);
	399	if (ret) {
	400	dev_err(&client->dev,
	401	"Failed GPIO request for GPIO %d: %d\n",
	402	charger->pdata->status_gpio, ret);
	403	}
	404
	405	charger->pdata->status_gpio_valid = !ret;
	406	}
	407
1a3adce1 JT	408	if (!charger->pdata->status_gpio_valid
	409	\|\| bq24735_charger_is_present(charger)) {
	410	ret = bq24735_read_word(client, BQ24735_MANUFACTURER_ID);
	411	if (ret < 0) {
	412	dev_err(&client->dev, "Failed to read manufacturer id : %d\n",
	413	ret);
	414	return ret;
	415	} else if (ret != 0x0040) {
	416	dev_err(&client->dev,
	417	"manufacturer id mismatch. 0x0040 != 0x%04x\n", ret);
	418	return -ENODEV;
	419	}
	420
	421	ret = bq24735_read_word(client, BQ24735_DEVICE_ID);
	422	if (ret < 0) {
	423	dev_err(&client->dev, "Failed to read device id : %d\n", ret);
	424	return ret;
	425	} else if (ret != 0x000B) {
	426	dev_err(&client->dev,
	427	"device id mismatch. 0x000b != 0x%04x\n", ret);
	428	return -ENODEV;
	429	}
	430	}
	431
ce773992 DS	432	ret = bq24735_config_charger(charger);
	433	if (ret < 0) {
	434	dev_err(&client->dev, "failed in configuring charger");
71a5a508	435	return ret;
ce773992 DS	436	}
	437
	438	/* check for AC adapter presence */
	439	if (bq24735_charger_is_present(charger)) {
	440	ret = bq24735_enable_charging(charger);
	441	if (ret < 0) {
	442	dev_err(&client->dev, "Failed to enable charging\n");
71a5a508	443	return ret;
ce773992 DS	444	}
	445	}
	446
71a5a508 VT	447	charger->charger = devm_power_supply_register(&client->dev, supply_desc,
71a5a508 VT	448	&psy_cfg);
297d716f KK	449	if (IS_ERR(charger->charger)) {
297d716f KK	450	ret = PTR_ERR(charger->charger);
ce773992 DS	451	dev_err(&client->dev, "Failed to register power supply: %d\n",
ce773992 DS	452	ret);
71a5a508	453	return ret;
ce773992 DS	454	}
	455
	456	if (client->irq) {
	457	ret = devm_request_threaded_irq(&client->dev, client->irq,
	458	NULL, bq24735_charger_isr,
	459	IRQF_TRIGGER_RISING \|
	460	IRQF_TRIGGER_FALLING \|
	461	IRQF_ONESHOT,
297d716f KK	462	supply_desc->name,
297d716f KK	463	charger->charger);
ce773992 DS	464	if (ret) {
	465	dev_err(&client->dev,
	466	"Unable to register IRQ %d err %d\n",
	467	client->irq, ret);
71a5a508	468	return ret;
ce773992 DS	469	}
	470	}
	471
ce773992 DS	472	return 0;
	473	}
	474
	475	static const struct i2c_device_id bq24735_charger_id[] = {
	476	{ "bq24735-charger", 0 },
	477	{}
	478	};
	479	MODULE_DEVICE_TABLE(i2c, bq24735_charger_id);
	480
	481	static const struct of_device_id bq24735_match_ids[] = {
	482	{ .compatible = "ti,bq24735", },
	483	{ /* end */ }
	484	};
	485	MODULE_DEVICE_TABLE(of, bq24735_match_ids);
	486
	487	static struct i2c_driver bq24735_charger_driver = {
	488	.driver = {
	489	.name = "bq24735-charger",
ce773992 DS	490	.of_match_table = bq24735_match_ids,
	491	},
	492	.probe = bq24735_charger_probe,
ce773992 DS	493	.id_table = bq24735_charger_id,
	494	};
	495
	496	module_i2c_driver(bq24735_charger_driver);
	497
	498	MODULE_DESCRIPTION("bq24735 battery charging driver");
	499	MODULE_AUTHOR("Darbha Sriharsha <dsriharsha@nvidia.com>");
	500	MODULE_LICENSE("GPL v2");