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

/*
 * linux/drivers/power/wm97xx_battery.c
 *
 * Battery measurement code for WM97xx
 *
 * based on tosa_battery.c
 *
 * Copyright (C) 2008 Marek Vasut <marek.vasut@gmail.com>
 *
 * 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/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/power_supply.h>
#include <linux/wm97xx.h>
#include <linux/spinlock.h>
#include <linux/interrupt.h>
#include <linux/gpio.h>
#include <linux/wm97xx_batt.h>

static DEFINE_MUTEX(bat_lock);
static struct work_struct bat_work;
struct mutex work_lock;
static int bat_status = POWER_SUPPLY_STATUS_UNKNOWN;
static struct wm97xx_batt_info *pdata;
static enum power_supply_property *prop;

static unsigned long wm97xx_read_bat(struct power_supply *bat_ps)
{
	return wm97xx_read_aux_adc(bat_ps->dev->parent->driver_data,
					pdata->batt_aux) * pdata->batt_mult /
					pdata->batt_div;
}

static unsigned long wm97xx_read_temp(struct power_supply *bat_ps)
{
	return wm97xx_read_aux_adc(bat_ps->dev->parent->driver_data,
					pdata->temp_aux) * pdata->temp_mult /
					pdata->temp_div;
}

static int wm97xx_bat_get_property(struct power_supply *bat_ps,
			    enum power_supply_property psp,
			    union power_supply_propval *val)
{
	switch (psp) {
	case POWER_SUPPLY_PROP_STATUS:
		val->intval = bat_status;
		break;
	case POWER_SUPPLY_PROP_TECHNOLOGY:
		val->intval = pdata->batt_tech;
		break;
	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
		if (pdata->batt_aux >= 0)
			val->intval = wm97xx_read_bat(bat_ps);
		else
			return -EINVAL;
		break;
	case POWER_SUPPLY_PROP_TEMP:
		if (pdata->temp_aux >= 0)
			val->intval = wm97xx_read_temp(bat_ps);
		else
			return -EINVAL;
		break;
	case POWER_SUPPLY_PROP_VOLTAGE_MAX:
		if (pdata->max_voltage >= 0)
			val->intval = pdata->max_voltage;
		else
			return -EINVAL;
		break;
	case POWER_SUPPLY_PROP_VOLTAGE_MIN:
		if (pdata->min_voltage >= 0)
			val->intval = pdata->min_voltage;
		else
			return -EINVAL;
		break;
	case POWER_SUPPLY_PROP_PRESENT:
		val->intval = 1;
		break;
	default:
		return -EINVAL;
	}
	return 0;
}

static void wm97xx_bat_external_power_changed(struct power_supply *bat_ps)
{
	schedule_work(&bat_work);
}

static void wm97xx_bat_update(struct power_supply *bat_ps)
{
	int old_status = bat_status;

	mutex_lock(&work_lock);

	bat_status = (pdata->charge_gpio >= 0) ?
			(gpio_get_value(pdata->charge_gpio) ?
			POWER_SUPPLY_STATUS_DISCHARGING :
			POWER_SUPPLY_STATUS_CHARGING) :
			POWER_SUPPLY_STATUS_UNKNOWN;

	if (old_status != bat_status) {
		pr_debug("%s: %i -> %i\n", bat_ps->name, old_status,
					bat_status);
		power_supply_changed(bat_ps);
	}

	mutex_unlock(&work_lock);
}

static struct power_supply bat_ps = {
	.type			= POWER_SUPPLY_TYPE_BATTERY,
	.get_property		= wm97xx_bat_get_property,
	.external_power_changed = wm97xx_bat_external_power_changed,
	.use_for_apm		= 1,
};

static void wm97xx_bat_work(struct work_struct *work)
{
	wm97xx_bat_update(&bat_ps);
}

#ifdef CONFIG_PM
static int wm97xx_bat_suspend(struct platform_device *dev, pm_message_t state)
{
	flush_scheduled_work();
	return 0;
}

static int wm97xx_bat_resume(struct platform_device *dev)
{
	schedule_work(&bat_work);
	return 0;
}
#else
#define wm97xx_bat_suspend NULL
#define wm97xx_bat_resume NULL
#endif

static int __devinit wm97xx_bat_probe(struct platform_device *dev)
{
	int ret = 0;
	int props = 1;	/* POWER_SUPPLY_PROP_PRESENT */
	int i = 0;

	if (dev->id != -1)
		return -EINVAL;

	mutex_init(&work_lock);

	if (!pdata) {
		dev_err(&dev->dev, "Please use wm97xx_bat_set_pdata\n");
		return -EINVAL;
	}

	if (pdata->charge_gpio >= 0 && gpio_is_valid(pdata->charge_gpio)) {
		ret = gpio_request(pdata->charge_gpio, "BATT CHRG");
		if (ret)
			goto err;
		ret = gpio_direction_input(pdata->charge_gpio);
		if (ret)
			goto err2;
		props++;	/* POWER_SUPPLY_PROP_STATUS */
	}

	if (pdata->batt_tech >= 0)
		props++;	/* POWER_SUPPLY_PROP_TECHNOLOGY */
	if (pdata->temp_aux >= 0)
		props++;	/* POWER_SUPPLY_PROP_TEMP */
	if (pdata->batt_aux >= 0)
		props++;	/* POWER_SUPPLY_PROP_VOLTAGE_NOW */
	if (pdata->max_voltage >= 0)
		props++;	/* POWER_SUPPLY_PROP_VOLTAGE_MAX */
	if (pdata->min_voltage >= 0)
		props++;	/* POWER_SUPPLY_PROP_VOLTAGE_MIN */

	prop = kzalloc(props * sizeof(*prop), GFP_KERNEL);
	if (!prop)
		goto err2;

	prop[i++] = POWER_SUPPLY_PROP_PRESENT;
	if (pdata->charge_gpio >= 0)
		prop[i++] = POWER_SUPPLY_PROP_STATUS;
	if (pdata->batt_tech >= 0)
		prop[i++] = POWER_SUPPLY_PROP_TECHNOLOGY;
	if (pdata->temp_aux >= 0)
		prop[i++] = POWER_SUPPLY_PROP_TEMP;
	if (pdata->batt_aux >= 0)
		prop[i++] = POWER_SUPPLY_PROP_VOLTAGE_NOW;
	if (pdata->max_voltage >= 0)
		prop[i++] = POWER_SUPPLY_PROP_VOLTAGE_MAX;
	if (pdata->min_voltage >= 0)
		prop[i++] = POWER_SUPPLY_PROP_VOLTAGE_MIN;

	INIT_WORK(&bat_work, wm97xx_bat_work);

	if (!pdata->batt_name) {
		dev_info(&dev->dev, "Please consider setting proper battery "
				"name in platform definition file, falling "
				"back to name \"wm97xx-batt\"\n");
		bat_ps.name = "wm97xx-batt";
	} else
		bat_ps.name = pdata->batt_name;

	bat_ps.properties = prop;
	bat_ps.num_properties = props;

	ret = power_supply_register(&dev->dev, &bat_ps);
	if (!ret)
		schedule_work(&bat_work);
	else
		goto err3;

	return 0;
err3:
	kfree(prop);
err2:
	gpio_free(pdata->charge_gpio);
err:
	return ret;
}

static int __devexit wm97xx_bat_remove(struct platform_device *dev)
{
	if (pdata && pdata->charge_gpio && pdata->charge_gpio >= 0)
		gpio_free(pdata->charge_gpio);
	flush_scheduled_work();
	power_supply_unregister(&bat_ps);
	kfree(prop);
	return 0;
}

static struct platform_driver wm97xx_bat_driver = {
	.driver	= {
		.name	= "wm97xx-battery",
		.owner	= THIS_MODULE,
	},
	.probe		= wm97xx_bat_probe,
	.remove		= __devexit_p(wm97xx_bat_remove),
	.suspend	= wm97xx_bat_suspend,
	.resume		= wm97xx_bat_resume,
};

static int __init wm97xx_bat_init(void)
{
	return platform_driver_register(&wm97xx_bat_driver);
}

static void __exit wm97xx_bat_exit(void)
{
	platform_driver_unregister(&wm97xx_bat_driver);
}

void __init wm97xx_bat_set_pdata(struct wm97xx_batt_info *data)
{
	pdata = data;
}
EXPORT_SYMBOL_GPL(wm97xx_bat_set_pdata);

module_init(wm97xx_bat_init);
module_exit(wm97xx_bat_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Marek Vasut <marek.vasut@gmail.com>");
MODULE_DESCRIPTION("WM97xx battery driver");
Commit	Line	Data
4e9687d9 MV	1	/*
	2	* linux/drivers/power/wm97xx_battery.c
	3	*
	4	* Battery measurement code for WM97xx
	5	*
	6	* based on tosa_battery.c
	7	*
	8	* Copyright (C) 2008 Marek Vasut <marek.vasut@gmail.com>
	9	*
	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/init.h>
	17	#include <linux/kernel.h>
	18	#include <linux/module.h>
	19	#include <linux/platform_device.h>
	20	#include <linux/power_supply.h>
	21	#include <linux/wm97xx.h>
	22	#include <linux/spinlock.h>
	23	#include <linux/interrupt.h>
	24	#include <linux/gpio.h>
	25	#include <linux/wm97xx_batt.h>
	26
	27	static DEFINE_MUTEX(bat_lock);
	28	static struct work_struct bat_work;
	29	struct mutex work_lock;
	30	static int bat_status = POWER_SUPPLY_STATUS_UNKNOWN;
	31	static struct wm97xx_batt_info *pdata;
	32	static enum power_supply_property *prop;
	33
	34	static unsigned long wm97xx_read_bat(struct power_supply *bat_ps)
	35	{
	36	return wm97xx_read_aux_adc(bat_ps->dev->parent->driver_data,
	37	pdata->batt_aux) * pdata->batt_mult /
	38	pdata->batt_div;
	39	}
	40
	41	static unsigned long wm97xx_read_temp(struct power_supply *bat_ps)
	42	{
	43	return wm97xx_read_aux_adc(bat_ps->dev->parent->driver_data,
	44	pdata->temp_aux) * pdata->temp_mult /
	45	pdata->temp_div;
	46	}
	47
	48	static int wm97xx_bat_get_property(struct power_supply *bat_ps,
	49	enum power_supply_property psp,
	50	union power_supply_propval *val)
	51	{
	52	switch (psp) {
	53	case POWER_SUPPLY_PROP_STATUS:
	54	val->intval = bat_status;
	55	break;
	56	case POWER_SUPPLY_PROP_TECHNOLOGY:
	57	val->intval = pdata->batt_tech;
	58	break;
	59	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
	60	if (pdata->batt_aux >= 0)
	61	val->intval = wm97xx_read_bat(bat_ps);
	62	else
	63	return -EINVAL;
	64	break;
65	case POWER_SUPPLY_PROP_TEMP:
66	if (pdata->temp_aux >= 0)
67	val->intval = wm97xx_read_temp(bat_ps);
68	else
69	return -EINVAL;
70	break;
71	case POWER_SUPPLY_PROP_VOLTAGE_MAX:
72	if (pdata->max_voltage >= 0)
73	val->intval = pdata->max_voltage;
74	else
75	return -EINVAL;
76	break;
77	case POWER_SUPPLY_PROP_VOLTAGE_MIN:
78	if (pdata->min_voltage >= 0)
79	val->intval = pdata->min_voltage;
80	else
81	return -EINVAL;
82	break;
83	case POWER_SUPPLY_PROP_PRESENT:
84	val->intval = 1;
85	break;
86	default:
87	return -EINVAL;
88	}
89	return 0;
90	}
91
92	static void wm97xx_bat_external_power_changed(struct power_supply *bat_ps)
93	{
94	schedule_work(&bat_work);
95	}
96
97	static void wm97xx_bat_update(struct power_supply *bat_ps)
98	{
99	int old_status = bat_status;
100
101	mutex_lock(&work_lock);
102
103	bat_status = (pdata->charge_gpio >= 0) ?
104	(gpio_get_value(pdata->charge_gpio) ?
105	POWER_SUPPLY_STATUS_DISCHARGING :
106	POWER_SUPPLY_STATUS_CHARGING) :
107	POWER_SUPPLY_STATUS_UNKNOWN;
108
109	if (old_status != bat_status) {
110	pr_debug("%s: %i -> %i\n", bat_ps->name, old_status,
111	bat_status);
112	power_supply_changed(bat_ps);
113	}
114
115	mutex_unlock(&work_lock);
116	}
117
118	static struct power_supply bat_ps = {
119	.type = POWER_SUPPLY_TYPE_BATTERY,
120	.get_property = wm97xx_bat_get_property,
121	.external_power_changed = wm97xx_bat_external_power_changed,
122	.use_for_apm = 1,
123	};
124
125	static void wm97xx_bat_work(struct work_struct *work)
126	{
127	wm97xx_bat_update(&bat_ps);
128	}
129
130	#ifdef CONFIG_PM
131	static int wm97xx_bat_suspend(struct platform_device *dev, pm_message_t state)
132	{
133	flush_scheduled_work();
134	return 0;
135	}
136
137	static int wm97xx_bat_resume(struct platform_device *dev)
138	{
139	schedule_work(&bat_work);
140	return 0;
141	}
142	#else
143	#define wm97xx_bat_suspend NULL
144	#define wm97xx_bat_resume NULL
145	#endif
146
147	static int __devinit wm97xx_bat_probe(struct platform_device *dev)
148	{
149	int ret = 0;
150	int props = 1; /* POWER_SUPPLY_PROP_PRESENT */
151	int i = 0;
152
153	if (dev->id != -1)
154	return -EINVAL;
155
156	mutex_init(&work_lock);
157
158	if (!pdata) {
159	dev_err(&dev->dev, "Please use wm97xx_bat_set_pdata\n");
160	return -EINVAL;
161	}
162
163	if (pdata->charge_gpio >= 0 && gpio_is_valid(pdata->charge_gpio)) {
164	ret = gpio_request(pdata->charge_gpio, "BATT CHRG");
165	if (ret)
166	goto err;
167	ret = gpio_direction_input(pdata->charge_gpio);
168	if (ret)
169	goto err2;
170	props++; /* POWER_SUPPLY_PROP_STATUS */
171	}
172
173	if (pdata->batt_tech >= 0)
174	props++; /* POWER_SUPPLY_PROP_TECHNOLOGY */
175	if (pdata->temp_aux >= 0)
176	props++; /* POWER_SUPPLY_PROP_TEMP */
177	if (pdata->batt_aux >= 0)
178	props++; /* POWER_SUPPLY_PROP_VOLTAGE_NOW */
179	if (pdata->max_voltage >= 0)
180	props++; /* POWER_SUPPLY_PROP_VOLTAGE_MAX */
181	if (pdata->min_voltage >= 0)
182	props++; /* POWER_SUPPLY_PROP_VOLTAGE_MIN */
183
184	prop = kzalloc(props * sizeof(*prop), GFP_KERNEL);
185	if (!prop)
186	goto err2;
187
188	prop[i++] = POWER_SUPPLY_PROP_PRESENT;
189	if (pdata->charge_gpio >= 0)
190	prop[i++] = POWER_SUPPLY_PROP_STATUS;
191	if (pdata->batt_tech >= 0)
192	prop[i++] = POWER_SUPPLY_PROP_TECHNOLOGY;
193	if (pdata->temp_aux >= 0)
194	prop[i++] = POWER_SUPPLY_PROP_TEMP;
195	if (pdata->batt_aux >= 0)
196	prop[i++] = POWER_SUPPLY_PROP_VOLTAGE_NOW;
197	if (pdata->max_voltage >= 0)
198	prop[i++] = POWER_SUPPLY_PROP_VOLTAGE_MAX;
199	if (pdata->min_voltage >= 0)
200	prop[i++] = POWER_SUPPLY_PROP_VOLTAGE_MIN;
201
202	INIT_WORK(&bat_work, wm97xx_bat_work);
203
204	if (!pdata->batt_name) {
205	dev_info(&dev->dev, "Please consider setting proper battery "
206	"name in platform definition file, falling "
207	"back to name \"wm97xx-batt\"\n");
208	bat_ps.name = "wm97xx-batt";
209	} else
210	bat_ps.name = pdata->batt_name;
211
212	bat_ps.properties = prop;
213	bat_ps.num_properties = props;
214
215	ret = power_supply_register(&dev->dev, &bat_ps);
216	if (!ret)
217	schedule_work(&bat_work);
218	else
219	goto err3;
220
221	return 0;
222	err3:
223	kfree(prop);
224	err2:
225	gpio_free(pdata->charge_gpio);
226	err:
227	return ret;
228	}
229
230	static int __devexit wm97xx_bat_remove(struct platform_device *dev)
231	{
232	if (pdata && pdata->charge_gpio && pdata->charge_gpio >= 0)
233	gpio_free(pdata->charge_gpio);
234	flush_scheduled_work();
235	power_supply_unregister(&bat_ps);
236	kfree(prop);
237	return 0;
238	}
239
240	static struct platform_driver wm97xx_bat_driver = {
241	.driver = {
242	.name = "wm97xx-battery",
243	.owner = THIS_MODULE,
244	},
245	.probe = wm97xx_bat_probe,
246	.remove = __devexit_p(wm97xx_bat_remove),
247	.suspend = wm97xx_bat_suspend,
248	.resume = wm97xx_bat_resume,
249	};
250
251	static int __init wm97xx_bat_init(void)
252	{
253	return platform_driver_register(&wm97xx_bat_driver);
254	}
255
256	static void __exit wm97xx_bat_exit(void)
257	{
258	platform_driver_unregister(&wm97xx_bat_driver);
259	}
260
261	void __init wm97xx_bat_set_pdata(struct wm97xx_batt_info *data)
262	{
263	pdata = data;
264	}
265	EXPORT_SYMBOL_GPL(wm97xx_bat_set_pdata);
266
267	module_init(wm97xx_bat_init);
268	module_exit(wm97xx_bat_exit);
269
270	MODULE_LICENSE("GPL");
271	MODULE_AUTHOR("Marek Vasut <marek.vasut@gmail.com>");
272	MODULE_DESCRIPTION("WM97xx battery driver");