[linux-2.6-block.git] / drivers / power / generic-adc-battery.c

/*
 * Generic battery driver code using IIO
 * Copyright (C) 2012, Anish Kumar <anish198519851985@gmail.com>
 * based on jz4740-battery.c
 * based on s3c_adc_battery.c
 *
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file COPYING in the main directory of this archive for
 * more details.
 *
 */
#include <linux/interrupt.h>
#include <linux/platform_device.h>
#include <linux/power_supply.h>
#include <linux/gpio.h>
#include <linux/err.h>
#include <linux/timer.h>
#include <linux/jiffies.h>
#include <linux/errno.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/iio/consumer.h>
#include <linux/iio/types.h>
#include <linux/power/generic-adc-battery.h>

#define JITTER_DEFAULT 10 /* hope 10ms is enough */

enum gab_chan_type {
	GAB_VOLTAGE = 0,
	GAB_CURRENT,
	GAB_POWER,
	GAB_MAX_CHAN_TYPE
};

/*
 * gab_chan_name suggests the standard channel names for commonly used
 * channel types.
 */
static const char *const gab_chan_name[] = {
	[GAB_VOLTAGE]	= "voltage",
	[GAB_CURRENT]	= "current",
	[GAB_POWER]		= "power",
};

struct gab {
	struct power_supply	psy;
	struct iio_channel	*channel[GAB_MAX_CHAN_TYPE];
	struct gab_platform_data	*pdata;
	struct delayed_work bat_work;
	int	level;
	int	status;
	bool cable_plugged;
};

static struct gab *to_generic_bat(struct power_supply *psy)
{
	return container_of(psy, struct gab, psy);
}

static void gab_ext_power_changed(struct power_supply *psy)
{
	struct gab *adc_bat = to_generic_bat(psy);

	schedule_delayed_work(&adc_bat->bat_work, msecs_to_jiffies(0));
}

static const enum power_supply_property gab_props[] = {
	POWER_SUPPLY_PROP_STATUS,
	POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
	POWER_SUPPLY_PROP_CHARGE_EMPTY_DESIGN,
	POWER_SUPPLY_PROP_CHARGE_NOW,
	POWER_SUPPLY_PROP_VOLTAGE_NOW,
	POWER_SUPPLY_PROP_CURRENT_NOW,
	POWER_SUPPLY_PROP_TECHNOLOGY,
	POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
	POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN,
	POWER_SUPPLY_PROP_MODEL_NAME,
};

/*
 * This properties are set based on the received platform data and this
 * should correspond one-to-one with enum chan_type.
 */
static const enum power_supply_property gab_dyn_props[] = {
	POWER_SUPPLY_PROP_VOLTAGE_NOW,
	POWER_SUPPLY_PROP_CURRENT_NOW,
	POWER_SUPPLY_PROP_POWER_NOW,
};

static bool gab_charge_finished(struct gab *adc_bat)
{
	struct gab_platform_data *pdata = adc_bat->pdata;
	bool ret = gpio_get_value(pdata->gpio_charge_finished);
	bool inv = pdata->gpio_inverted;

	if (!gpio_is_valid(pdata->gpio_charge_finished))
		return false;
	return ret ^ inv;
}

static int gab_get_status(struct gab *adc_bat)
{
	struct gab_platform_data *pdata = adc_bat->pdata;
	struct power_supply_info *bat_info;

	bat_info = &pdata->battery_info;
	if (adc_bat->level == bat_info->charge_full_design)
		return POWER_SUPPLY_STATUS_FULL;
	return adc_bat->status;
}

static enum gab_chan_type gab_prop_to_chan(enum power_supply_property psp)
{
	switch (psp) {
	case POWER_SUPPLY_PROP_POWER_NOW:
		return GAB_POWER;
	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
		return GAB_VOLTAGE;
	case POWER_SUPPLY_PROP_CURRENT_NOW:
		return GAB_CURRENT;
	default:
		WARN_ON(1);
		break;
	}
	return GAB_POWER;
}

static int read_channel(struct gab *adc_bat, enum power_supply_property psp,
		int *result)
{
	int ret;
	int chan_index;

	chan_index = gab_prop_to_chan(psp);
	ret = iio_read_channel_processed(adc_bat->channel[chan_index],
			result);
	if (ret < 0)
		pr_err("read channel error\n");
	return ret;
}

static int gab_get_property(struct power_supply *psy,
		enum power_supply_property psp, union power_supply_propval *val)
{
	struct gab *adc_bat;
	struct gab_platform_data *pdata;
	struct power_supply_info *bat_info;
	int result = 0;
	int ret = 0;

	adc_bat = to_generic_bat(psy);
	if (!adc_bat) {
		dev_err(psy->dev, "no battery infos ?!\n");
		return -EINVAL;
	}
	pdata = adc_bat->pdata;
	bat_info = &pdata->battery_info;

	switch (psp) {
	case POWER_SUPPLY_PROP_STATUS:
		gab_get_status(adc_bat);
		break;
	case POWER_SUPPLY_PROP_CHARGE_EMPTY_DESIGN:
		val->intval = 0;
		break;
	case POWER_SUPPLY_PROP_CHARGE_NOW:
		val->intval = pdata->cal_charge(result);
		break;
	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
	case POWER_SUPPLY_PROP_CURRENT_NOW:
	case POWER_SUPPLY_PROP_POWER_NOW:
		ret = read_channel(adc_bat, psp, &result);
		if (ret < 0)
			goto err;
		val->intval = result;
		break;
	case POWER_SUPPLY_PROP_TECHNOLOGY:
		val->intval = bat_info->technology;
		break;
	case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
		val->intval = bat_info->voltage_min_design;
		break;
	case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
		val->intval = bat_info->voltage_max_design;
		break;
	case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
		val->intval = bat_info->charge_full_design;
		break;
	case POWER_SUPPLY_PROP_MODEL_NAME:
		val->strval = bat_info->name;
		break;
	default:
		return -EINVAL;
	}
err:
	return ret;
}

static void gab_work(struct work_struct *work)
{
	struct gab *adc_bat;
	struct gab_platform_data *pdata;
	struct delayed_work *delayed_work;
	bool is_plugged;
	int status;

	delayed_work = container_of(work, struct delayed_work, work);
	adc_bat = container_of(delayed_work, struct gab, bat_work);
	pdata = adc_bat->pdata;
	status = adc_bat->status;

	is_plugged = power_supply_am_i_supplied(&adc_bat->psy);
	adc_bat->cable_plugged = is_plugged;

	if (!is_plugged)
		adc_bat->status =  POWER_SUPPLY_STATUS_DISCHARGING;
	else if (gab_charge_finished(adc_bat))
		adc_bat->status = POWER_SUPPLY_STATUS_NOT_CHARGING;
	else
		adc_bat->status = POWER_SUPPLY_STATUS_CHARGING;

	if (status != adc_bat->status)
		power_supply_changed(&adc_bat->psy);
}

static irqreturn_t gab_charged(int irq, void *dev_id)
{
	struct gab *adc_bat = dev_id;
	struct gab_platform_data *pdata = adc_bat->pdata;
	int delay;

	delay = pdata->jitter_delay ? pdata->jitter_delay : JITTER_DEFAULT;
	schedule_delayed_work(&adc_bat->bat_work,
			msecs_to_jiffies(delay));
	return IRQ_HANDLED;
}

static int gab_probe(struct platform_device *pdev)
{
	struct gab *adc_bat;
	struct power_supply *psy;
	struct gab_platform_data *pdata = pdev->dev.platform_data;
	enum power_supply_property *properties;
	int ret = 0;
	int chan;
	int index = 0;

	adc_bat = devm_kzalloc(&pdev->dev, sizeof(*adc_bat), GFP_KERNEL);
	if (!adc_bat) {
		dev_err(&pdev->dev, "failed to allocate memory\n");
		return -ENOMEM;
	}

	psy = &adc_bat->psy;
	psy->name = pdata->battery_info.name;

	/* bootup default values for the battery */
	adc_bat->cable_plugged = false;
	adc_bat->status = POWER_SUPPLY_STATUS_DISCHARGING;
	psy->type = POWER_SUPPLY_TYPE_BATTERY;
	psy->get_property = gab_get_property;
	psy->external_power_changed = gab_ext_power_changed;
	adc_bat->pdata = pdata;

	/*
	 * copying the static properties and allocating extra memory for holding
	 * the extra configurable properties received from platform data.
	 */
	psy->properties = kcalloc(ARRAY_SIZE(gab_props) +
					ARRAY_SIZE(gab_chan_name),
					sizeof(*psy->properties), GFP_KERNEL);
	if (!psy->properties) {
		ret = -ENOMEM;
		goto first_mem_fail;
	}

	memcpy(psy->properties, gab_props, sizeof(gab_props));
	properties = (enum power_supply_property *)
				((char *)psy->properties + sizeof(gab_props));

	/*
	 * getting channel from iio and copying the battery properties
	 * based on the channel supported by consumer device.
	 */
	for (chan = 0; chan < ARRAY_SIZE(gab_chan_name); chan++) {
		adc_bat->channel[chan] = iio_channel_get(&pdev->dev,
							 gab_chan_name[chan]);
		if (IS_ERR(adc_bat->channel[chan])) {
			ret = PTR_ERR(adc_bat->channel[chan]);
			adc_bat->channel[chan] = NULL;
		} else {
			/* copying properties for supported channels only */
			memcpy(properties + sizeof(*(psy->properties)) * index,
					&gab_dyn_props[chan],
					sizeof(gab_dyn_props[chan]));
			index++;
		}
	}

	/* none of the channels are supported so let's bail out */
	if (index == ARRAY_SIZE(gab_chan_name))
		goto second_mem_fail;

	/*
	 * Total number of properties is equal to static properties
	 * plus the dynamic properties.Some properties may not be set
	 * as come channels may be not be supported by the device.So
	 * we need to take care of that.
	 */
	psy->num_properties = ARRAY_SIZE(gab_props) + index;

	ret = power_supply_register(&pdev->dev, psy);
	if (ret)
		goto err_reg_fail;

	INIT_DELAYED_WORK(&adc_bat->bat_work, gab_work);

	if (gpio_is_valid(pdata->gpio_charge_finished)) {
		int irq;
		ret = gpio_request(pdata->gpio_charge_finished, "charged");
		if (ret)
			goto gpio_req_fail;

		irq = gpio_to_irq(pdata->gpio_charge_finished);
		ret = request_any_context_irq(irq, gab_charged,
				IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
				"battery charged", adc_bat);
		if (ret < 0)
			goto err_gpio;
	}

	platform_set_drvdata(pdev, adc_bat);

	/* Schedule timer to check current status */
	schedule_delayed_work(&adc_bat->bat_work,
			msecs_to_jiffies(0));
	return 0;

err_gpio:
	gpio_free(pdata->gpio_charge_finished);
gpio_req_fail:
	power_supply_unregister(psy);
err_reg_fail:
	for (chan = 0; chan < ARRAY_SIZE(gab_chan_name); chan++) {
		if (adc_bat->channel[chan])
			iio_channel_release(adc_bat->channel[chan]);
	}
second_mem_fail:
	kfree(psy->properties);
first_mem_fail:
	return ret;
}

static int gab_remove(struct platform_device *pdev)
{
	int chan;
	struct gab *adc_bat = platform_get_drvdata(pdev);
	struct gab_platform_data *pdata = adc_bat->pdata;

	power_supply_unregister(&adc_bat->psy);

	if (gpio_is_valid(pdata->gpio_charge_finished)) {
		free_irq(gpio_to_irq(pdata->gpio_charge_finished), adc_bat);
		gpio_free(pdata->gpio_charge_finished);
	}

	for (chan = 0; chan < ARRAY_SIZE(gab_chan_name); chan++) {
		if (adc_bat->channel[chan])
			iio_channel_release(adc_bat->channel[chan]);
	}

	kfree(adc_bat->psy.properties);
	cancel_delayed_work(&adc_bat->bat_work);
	return 0;
}

#ifdef CONFIG_PM
static int gab_suspend(struct device *dev)
{
	struct gab *adc_bat = dev_get_drvdata(dev);

	cancel_delayed_work_sync(&adc_bat->bat_work);
	adc_bat->status = POWER_SUPPLY_STATUS_UNKNOWN;
	return 0;
}

static int gab_resume(struct device *dev)
{
	struct gab *adc_bat = dev_get_drvdata(dev);
	struct gab_platform_data *pdata = adc_bat->pdata;
	int delay;

	delay = pdata->jitter_delay ? pdata->jitter_delay : JITTER_DEFAULT;

	/* Schedule timer to check current status */
	schedule_delayed_work(&adc_bat->bat_work,
			msecs_to_jiffies(delay));
	return 0;
}

static const struct dev_pm_ops gab_pm_ops = {
	.suspend        = gab_suspend,
	.resume         = gab_resume,
};

#define GAB_PM_OPS       (&gab_pm_ops)
#else
#define GAB_PM_OPS       (NULL)
#endif

static struct platform_driver gab_driver = {
	.driver		= {
		.name	= "generic-adc-battery",
		.owner	= THIS_MODULE,
		.pm	= GAB_PM_OPS
	},
	.probe		= gab_probe,
	.remove		= gab_remove,
};
module_platform_driver(gab_driver);

MODULE_AUTHOR("anish kumar <anish198519851985@gmail.com>");
MODULE_DESCRIPTION("generic battery driver using IIO");
MODULE_LICENSE("GPL");
Commit	Line	Data
e60fea79	1	/*
	2	* Generic battery driver code using IIO
	3	* Copyright (C) 2012, Anish Kumar <anish198519851985@gmail.com>
	4	* based on jz4740-battery.c
	5	* based on s3c_adc_battery.c
	6	*
	7	* This file is subject to the terms and conditions of the GNU General Public
	8	* License. See the file COPYING in the main directory of this archive for
	9	* more details.
	10	*
	11	*/
	12	#include <linux/interrupt.h>
	13	#include <linux/platform_device.h>
	14	#include <linux/power_supply.h>
	15	#include <linux/gpio.h>
	16	#include <linux/err.h>
	17	#include <linux/timer.h>
	18	#include <linux/jiffies.h>
	19	#include <linux/errno.h>
	20	#include <linux/init.h>
	21	#include <linux/module.h>
	22	#include <linux/slab.h>
	23	#include <linux/iio/consumer.h>
	24	#include <linux/iio/types.h>
	25	#include <linux/power/generic-adc-battery.h>
	26
	27	#define JITTER_DEFAULT 10 /* hope 10ms is enough */
	28
	29	enum gab_chan_type {
	30	GAB_VOLTAGE = 0,
	31	GAB_CURRENT,
	32	GAB_POWER,
	33	GAB_MAX_CHAN_TYPE
	34	};
	35
	36	/*
	37	* gab_chan_name suggests the standard channel names for commonly used
	38	* channel types.
	39	*/
	40	static const char *const gab_chan_name[] = {
	41	[GAB_VOLTAGE] = "voltage",
	42	[GAB_CURRENT] = "current",
	43	[GAB_POWER] = "power",
	44	};
	45
	46	struct gab {
	47	struct power_supply psy;
	48	struct iio_channel *channel[GAB_MAX_CHAN_TYPE];
	49	struct gab_platform_data *pdata;
	50	struct delayed_work bat_work;
	51	int level;
	52	int status;
	53	bool cable_plugged;
	54	};
	55
	56	static struct gab to_generic_bat(struct power_supply psy)
	57	{
	58	return container_of(psy, struct gab, psy);
	59	}
	60
	61	static void gab_ext_power_changed(struct power_supply *psy)
	62	{
	63	struct gab *adc_bat = to_generic_bat(psy);
	64
65	schedule_delayed_work(&adc_bat->bat_work, msecs_to_jiffies(0));
66	}
67
68	static const enum power_supply_property gab_props[] = {
69	POWER_SUPPLY_PROP_STATUS,
70	POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
71	POWER_SUPPLY_PROP_CHARGE_EMPTY_DESIGN,
72	POWER_SUPPLY_PROP_CHARGE_NOW,
73	POWER_SUPPLY_PROP_VOLTAGE_NOW,
74	POWER_SUPPLY_PROP_CURRENT_NOW,
75	POWER_SUPPLY_PROP_TECHNOLOGY,
76	POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
77	POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN,
78	POWER_SUPPLY_PROP_MODEL_NAME,
79	};
80
81	/*
82	* This properties are set based on the received platform data and this
83	* should correspond one-to-one with enum chan_type.
84	*/
85	static const enum power_supply_property gab_dyn_props[] = {
86	POWER_SUPPLY_PROP_VOLTAGE_NOW,
87	POWER_SUPPLY_PROP_CURRENT_NOW,
88	POWER_SUPPLY_PROP_POWER_NOW,
89	};
90
91	static bool gab_charge_finished(struct gab *adc_bat)
92	{
93	struct gab_platform_data *pdata = adc_bat->pdata;
94	bool ret = gpio_get_value(pdata->gpio_charge_finished);
95	bool inv = pdata->gpio_inverted;
96
97	if (!gpio_is_valid(pdata->gpio_charge_finished))
98	return false;
99	return ret ^ inv;
100	}
101
102	static int gab_get_status(struct gab *adc_bat)
103	{
104	struct gab_platform_data *pdata = adc_bat->pdata;
105	struct power_supply_info *bat_info;
106
107	bat_info = &pdata->battery_info;
108	if (adc_bat->level == bat_info->charge_full_design)
109	return POWER_SUPPLY_STATUS_FULL;
110	return adc_bat->status;
111	}
112
113	static enum gab_chan_type gab_prop_to_chan(enum power_supply_property psp)
114	{
115	switch (psp) {
116	case POWER_SUPPLY_PROP_POWER_NOW:
117	return GAB_POWER;
118	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
119	return GAB_VOLTAGE;
120	case POWER_SUPPLY_PROP_CURRENT_NOW:
121	return GAB_CURRENT;
122	default:
123	WARN_ON(1);
124	break;
125	}
126	return GAB_POWER;
127	}
128
129	static int read_channel(struct gab *adc_bat, enum power_supply_property psp,
130	int *result)
131	{
132	int ret;
133	int chan_index;
134
135	chan_index = gab_prop_to_chan(psp);
136	ret = iio_read_channel_processed(adc_bat->channel[chan_index],
137	result);
138	if (ret < 0)
139	pr_err("read channel error\n");
140	return ret;
141	}
142
143	static int gab_get_property(struct power_supply *psy,
144	enum power_supply_property psp, union power_supply_propval *val)
145	{
146	struct gab *adc_bat;
147	struct gab_platform_data *pdata;
148	struct power_supply_info *bat_info;
149	int result = 0;
150	int ret = 0;
151
152	adc_bat = to_generic_bat(psy);
153	if (!adc_bat) {
154	dev_err(psy->dev, "no battery infos ?!\n");
155	return -EINVAL;
156	}
157	pdata = adc_bat->pdata;
158	bat_info = &pdata->battery_info;
159
160	switch (psp) {
161	case POWER_SUPPLY_PROP_STATUS:
162	gab_get_status(adc_bat);
163	break;
164	case POWER_SUPPLY_PROP_CHARGE_EMPTY_DESIGN:
165	val->intval = 0;
166	break;
167	case POWER_SUPPLY_PROP_CHARGE_NOW:
168	val->intval = pdata->cal_charge(result);
169	break;
170	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
171	case POWER_SUPPLY_PROP_CURRENT_NOW:
172	case POWER_SUPPLY_PROP_POWER_NOW:
173	ret = read_channel(adc_bat, psp, &result);
174	if (ret < 0)
175	goto err;
176	val->intval = result;
177	break;
178	case POWER_SUPPLY_PROP_TECHNOLOGY:
179	val->intval = bat_info->technology;
180	break;
181	case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
182	val->intval = bat_info->voltage_min_design;
183	break;
184	case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
185	val->intval = bat_info->voltage_max_design;
186	break;
187	case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
188	val->intval = bat_info->charge_full_design;
189	break;
190	case POWER_SUPPLY_PROP_MODEL_NAME:
191	val->strval = bat_info->name;
192	break;
193	default:
194	return -EINVAL;
195	}
196	err:
197	return ret;
198	}
199
200	static void gab_work(struct work_struct *work)
201	{
202	struct gab *adc_bat;
203	struct gab_platform_data *pdata;
204	struct delayed_work *delayed_work;
205	bool is_plugged;
206	int status;
207
208	delayed_work = container_of(work, struct delayed_work, work);
209	adc_bat = container_of(delayed_work, struct gab, bat_work);
210	pdata = adc_bat->pdata;
211	status = adc_bat->status;
212
213	is_plugged = power_supply_am_i_supplied(&adc_bat->psy);
214	adc_bat->cable_plugged = is_plugged;
215
216	if (!is_plugged)
217	adc_bat->status = POWER_SUPPLY_STATUS_DISCHARGING;
218	else if (gab_charge_finished(adc_bat))
219	adc_bat->status = POWER_SUPPLY_STATUS_NOT_CHARGING;
220	else
221	adc_bat->status = POWER_SUPPLY_STATUS_CHARGING;
222
223	if (status != adc_bat->status)
224	power_supply_changed(&adc_bat->psy);
225	}
226
227	static irqreturn_t gab_charged(int irq, void *dev_id)
228	{
229	struct gab *adc_bat = dev_id;
230	struct gab_platform_data *pdata = adc_bat->pdata;
231	int delay;
232
233	delay = pdata->jitter_delay ? pdata->jitter_delay : JITTER_DEFAULT;
234	schedule_delayed_work(&adc_bat->bat_work,
235	msecs_to_jiffies(delay));
236	return IRQ_HANDLED;
237	}
238
c8afa640	239	static int gab_probe(struct platform_device *pdev)
e60fea79	240	{
	241	struct gab *adc_bat;
	242	struct power_supply *psy;
	243	struct gab_platform_data *pdata = pdev->dev.platform_data;
	244	enum power_supply_property *properties;
	245	int ret = 0;
	246	int chan;
	247	int index = 0;
	248
	249	adc_bat = devm_kzalloc(&pdev->dev, sizeof(*adc_bat), GFP_KERNEL);
	250	if (!adc_bat) {
	251	dev_err(&pdev->dev, "failed to allocate memory\n");
	252	return -ENOMEM;
	253	}
	254
	255	psy = &adc_bat->psy;
	256	psy->name = pdata->battery_info.name;
	257
	258	/* bootup default values for the battery */
	259	adc_bat->cable_plugged = false;
	260	adc_bat->status = POWER_SUPPLY_STATUS_DISCHARGING;
	261	psy->type = POWER_SUPPLY_TYPE_BATTERY;
	262	psy->get_property = gab_get_property;
	263	psy->external_power_changed = gab_ext_power_changed;
	264	adc_bat->pdata = pdata;
	265
e60fea79	266	/*
	267	* copying the static properties and allocating extra memory for holding
	268	* the extra configurable properties received from platform data.
	269	*/
	270	psy->properties = kcalloc(ARRAY_SIZE(gab_props) +
	271	ARRAY_SIZE(gab_chan_name),
	272	sizeof(*psy->properties), GFP_KERNEL);
	273	if (!psy->properties) {
	274	ret = -ENOMEM;
	275	goto first_mem_fail;
	276	}
	277
	278	memcpy(psy->properties, gab_props, sizeof(gab_props));
a77d60ae DC	279	properties = (enum power_supply_property *)
a77d60ae DC	280	((char *)psy->properties + sizeof(gab_props));
e60fea79	281
	282	/*
	283	* getting channel from iio and copying the battery properties
	284	* based on the channel supported by consumer device.
	285	*/
	286	for (chan = 0; chan < ARRAY_SIZE(gab_chan_name); chan++) {
5aa57f0a GR	287	adc_bat->channel[chan] = iio_channel_get(&pdev->dev,
5aa57f0a GR	288	gab_chan_name[chan]);
e60fea79	289	if (IS_ERR(adc_bat->channel[chan])) {
e60fea79	290	ret = PTR_ERR(adc_bat->channel[chan]);
64d26f22	291	adc_bat->channel[chan] = NULL;
e60fea79	292	} else {
	293	/* copying properties for supported channels only */
	294	memcpy(properties + sizeof((psy->properties)) index,
	295	&gab_dyn_props[chan],
	296	sizeof(gab_dyn_props[chan]));
	297	index++;
	298	}
	299	}
	300
	301	/* none of the channels are supported so let's bail out */
	302	if (index == ARRAY_SIZE(gab_chan_name))
	303	goto second_mem_fail;
	304
	305	/*
	306	* Total number of properties is equal to static properties
	307	* plus the dynamic properties.Some properties may not be set
	308	* as come channels may be not be supported by the device.So
	309	* we need to take care of that.
	310	*/
	311	psy->num_properties = ARRAY_SIZE(gab_props) + index;
	312
	313	ret = power_supply_register(&pdev->dev, psy);
	314	if (ret)
	315	goto err_reg_fail;
	316
	317	INIT_DELAYED_WORK(&adc_bat->bat_work, gab_work);
	318
	319	if (gpio_is_valid(pdata->gpio_charge_finished)) {
	320	int irq;
	321	ret = gpio_request(pdata->gpio_charge_finished, "charged");
	322	if (ret)
	323	goto gpio_req_fail;
	324
	325	irq = gpio_to_irq(pdata->gpio_charge_finished);
	326	ret = request_any_context_irq(irq, gab_charged,
	327	IRQF_TRIGGER_RISING \| IRQF_TRIGGER_FALLING,
	328	"battery charged", adc_bat);
a5af0922	329	if (ret < 0)
e60fea79	330	goto err_gpio;
	331	}
	332
	333	platform_set_drvdata(pdev, adc_bat);
	334
	335	/* Schedule timer to check current status */
	336	schedule_delayed_work(&adc_bat->bat_work,
	337	msecs_to_jiffies(0));
	338	return 0;
	339
	340	err_gpio:
	341	gpio_free(pdata->gpio_charge_finished);
	342	gpio_req_fail:
	343	power_supply_unregister(psy);
	344	err_reg_fail:
64d26f22 DC	345	for (chan = 0; chan < ARRAY_SIZE(gab_chan_name); chan++) {
	346	if (adc_bat->channel[chan])
	347	iio_channel_release(adc_bat->channel[chan]);
	348	}
e60fea79	349	second_mem_fail:
	350	kfree(psy->properties);
	351	first_mem_fail:
	352	return ret;
	353	}
	354
415ec69f	355	static int gab_remove(struct platform_device *pdev)
e60fea79	356	{
	357	int chan;
	358	struct gab *adc_bat = platform_get_drvdata(pdev);
	359	struct gab_platform_data *pdata = adc_bat->pdata;
	360
	361	power_supply_unregister(&adc_bat->psy);
	362
	363	if (gpio_is_valid(pdata->gpio_charge_finished)) {
	364	free_irq(gpio_to_irq(pdata->gpio_charge_finished), adc_bat);
	365	gpio_free(pdata->gpio_charge_finished);
	366	}
	367
64d26f22 DC	368	for (chan = 0; chan < ARRAY_SIZE(gab_chan_name); chan++) {
	369	if (adc_bat->channel[chan])
	370	iio_channel_release(adc_bat->channel[chan]);
	371	}
e60fea79	372
	373	kfree(adc_bat->psy.properties);
	374	cancel_delayed_work(&adc_bat->bat_work);
	375	return 0;
	376	}
	377
	378	#ifdef CONFIG_PM
	379	static int gab_suspend(struct device *dev)
	380	{
	381	struct gab *adc_bat = dev_get_drvdata(dev);
	382
	383	cancel_delayed_work_sync(&adc_bat->bat_work);
	384	adc_bat->status = POWER_SUPPLY_STATUS_UNKNOWN;
	385	return 0;
	386	}
	387
	388	static int gab_resume(struct device *dev)
	389	{
	390	struct gab *adc_bat = dev_get_drvdata(dev);
	391	struct gab_platform_data *pdata = adc_bat->pdata;
	392	int delay;
	393
	394	delay = pdata->jitter_delay ? pdata->jitter_delay : JITTER_DEFAULT;
	395
	396	/* Schedule timer to check current status */
	397	schedule_delayed_work(&adc_bat->bat_work,
	398	msecs_to_jiffies(delay));
	399	return 0;
	400	}
	401
	402	static const struct dev_pm_ops gab_pm_ops = {
	403	.suspend = gab_suspend,
	404	.resume = gab_resume,
	405	};
	406
	407	#define GAB_PM_OPS (&gab_pm_ops)
	408	#else
	409	#define GAB_PM_OPS (NULL)
	410	#endif
	411
	412	static struct platform_driver gab_driver = {
	413	.driver = {
	414	.name = "generic-adc-battery",
	415	.owner = THIS_MODULE,
	416	.pm = GAB_PM_OPS
	417	},
	418	.probe = gab_probe,
28ea73f4	419	.remove = gab_remove,
e60fea79	420	};
	421	module_platform_driver(gab_driver);
	422
	423	MODULE_AUTHOR("anish kumar <anish198519851985@gmail.com>");
	424	MODULE_DESCRIPTION("generic battery driver using IIO");
	425	MODULE_LICENSE("GPL");