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

/*
 * Dumb driver for LiIon batteries using TWL4030 madc.
 *
 * Copyright 2013 Golden Delicious Computers
 * Lukas Märdian <lukas@goldelico.com>
 *
 * Based on dumb driver for gta01 battery
 * Copyright 2009 Openmoko, Inc
 * Balaji Rao <balajirrao@openmoko.org>
 */

#include <linux/module.h>
#include <linux/param.h>
#include <linux/delay.h>
#include <linux/workqueue.h>
#include <linux/platform_device.h>
#include <linux/power_supply.h>
#include <linux/slab.h>
#include <linux/sort.h>
#include <linux/i2c/twl4030-madc.h>
#include <linux/power/twl4030_madc_battery.h>
#include <linux/iio/consumer.h>

struct twl4030_madc_battery {
	struct power_supply *psy;
	struct twl4030_madc_bat_platform_data *pdata;
	struct iio_channel *channel_temp;
	struct iio_channel *channel_ichg;
	struct iio_channel *channel_vbat;
};

static enum power_supply_property twl4030_madc_bat_props[] = {
	POWER_SUPPLY_PROP_PRESENT,
	POWER_SUPPLY_PROP_STATUS,
	POWER_SUPPLY_PROP_TECHNOLOGY,
	POWER_SUPPLY_PROP_VOLTAGE_NOW,
	POWER_SUPPLY_PROP_CURRENT_NOW,
	POWER_SUPPLY_PROP_CAPACITY,
	POWER_SUPPLY_PROP_CHARGE_FULL,
	POWER_SUPPLY_PROP_CHARGE_NOW,
	POWER_SUPPLY_PROP_TEMP,
	POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
};

static int madc_read(struct iio_channel *channel)
{
	int val, err;
	err = iio_read_channel_processed(channel, &val);
	if (err < 0)
		return err;

	return val;
}

static int twl4030_madc_bat_get_charging_status(struct twl4030_madc_battery *bt)
{
	return (madc_read(bt->channel_ichg) > 0) ? 1 : 0;
}

static int twl4030_madc_bat_get_voltage(struct twl4030_madc_battery *bt)
{
	return madc_read(bt->channel_vbat);
}

static int twl4030_madc_bat_get_current(struct twl4030_madc_battery *bt)
{
	return madc_read(bt->channel_ichg) * 1000;
}

static int twl4030_madc_bat_get_temp(struct twl4030_madc_battery *bt)
{
	return madc_read(bt->channel_temp) * 10;
}

static int twl4030_madc_bat_voltscale(struct twl4030_madc_battery *bat,
					int volt)
{
	struct twl4030_madc_bat_calibration *calibration;
	int i, res = 0;

	/* choose charging curve */
	if (twl4030_madc_bat_get_charging_status(bat))
		calibration = bat->pdata->charging;
	else
		calibration = bat->pdata->discharging;

	if (volt > calibration[0].voltage) {
		res = calibration[0].level;
	} else {
		for (i = 0; calibration[i+1].voltage >= 0; i++) {
			if (volt <= calibration[i].voltage &&
					volt >= calibration[i+1].voltage) {
				/* interval found - interpolate within range */
				res = calibration[i].level -
					((calibration[i].voltage - volt) *
					(calibration[i].level -
					calibration[i+1].level)) /
					(calibration[i].voltage -
					calibration[i+1].voltage);
				break;
			}
		}
	}
	return res;
}

static int twl4030_madc_bat_get_property(struct power_supply *psy,
					enum power_supply_property psp,
					union power_supply_propval *val)
{
	struct twl4030_madc_battery *bat = power_supply_get_drvdata(psy);

	switch (psp) {
	case POWER_SUPPLY_PROP_STATUS:
		if (twl4030_madc_bat_voltscale(bat,
				twl4030_madc_bat_get_voltage(bat)) > 95)
			val->intval = POWER_SUPPLY_STATUS_FULL;
		else {
			if (twl4030_madc_bat_get_charging_status(bat))
				val->intval = POWER_SUPPLY_STATUS_CHARGING;
			else
				val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
		}
		break;
	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
		val->intval = twl4030_madc_bat_get_voltage(bat) * 1000;
		break;
	case POWER_SUPPLY_PROP_TECHNOLOGY:
		val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
		break;
	case POWER_SUPPLY_PROP_CURRENT_NOW:
		val->intval = twl4030_madc_bat_get_current(bat);
		break;
	case POWER_SUPPLY_PROP_PRESENT:
		/* assume battery is always present */
		val->intval = 1;
		break;
	case POWER_SUPPLY_PROP_CHARGE_NOW: {
			int percent = twl4030_madc_bat_voltscale(bat,
					twl4030_madc_bat_get_voltage(bat));
			val->intval = (percent * bat->pdata->capacity) / 100;
			break;
		}
	case POWER_SUPPLY_PROP_CAPACITY:
		val->intval = twl4030_madc_bat_voltscale(bat,
					twl4030_madc_bat_get_voltage(bat));
		break;
	case POWER_SUPPLY_PROP_CHARGE_FULL:
		val->intval = bat->pdata->capacity;
		break;
	case POWER_SUPPLY_PROP_TEMP:
		val->intval = twl4030_madc_bat_get_temp(bat);
		break;
	case POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW: {
			int percent = twl4030_madc_bat_voltscale(bat,
					twl4030_madc_bat_get_voltage(bat));
			/* in mAh */
			int chg = (percent * (bat->pdata->capacity/1000))/100;

			/* assume discharge with 400 mA (ca. 1.5W) */
			val->intval = (3600l * chg) / 400;
			break;
		}
	default:
		return -EINVAL;
	}

	return 0;
}

static void twl4030_madc_bat_ext_changed(struct power_supply *psy)
{
	power_supply_changed(psy);
}

static const struct power_supply_desc twl4030_madc_bat_desc = {
	.name			= "twl4030_battery",
	.type			= POWER_SUPPLY_TYPE_BATTERY,
	.properties		= twl4030_madc_bat_props,
	.num_properties		= ARRAY_SIZE(twl4030_madc_bat_props),
	.get_property		= twl4030_madc_bat_get_property,
	.external_power_changed	= twl4030_madc_bat_ext_changed,

};

static int twl4030_cmp(const void *a, const void *b)
{
	return ((struct twl4030_madc_bat_calibration *)b)->voltage -
		((struct twl4030_madc_bat_calibration *)a)->voltage;
}

static int twl4030_madc_battery_probe(struct platform_device *pdev)
{
	struct twl4030_madc_battery *twl4030_madc_bat;
	struct twl4030_madc_bat_platform_data *pdata = pdev->dev.platform_data;
	struct power_supply_config psy_cfg = {};
	int ret = 0;

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

	twl4030_madc_bat->channel_temp = iio_channel_get(&pdev->dev, "temp");
	if (IS_ERR(twl4030_madc_bat->channel_temp)) {
		ret = PTR_ERR(twl4030_madc_bat->channel_temp);
		goto err;
	}

	twl4030_madc_bat->channel_ichg = iio_channel_get(&pdev->dev, "ichg");
	if (IS_ERR(twl4030_madc_bat->channel_ichg)) {
		ret = PTR_ERR(twl4030_madc_bat->channel_ichg);
		goto err_temp;
	}

	twl4030_madc_bat->channel_vbat = iio_channel_get(&pdev->dev, "vbat");
	if (IS_ERR(twl4030_madc_bat->channel_vbat)) {
		ret = PTR_ERR(twl4030_madc_bat->channel_vbat);
		goto err_ichg;
	}

	/* sort charging and discharging calibration data */
	sort(pdata->charging, pdata->charging_size,
		sizeof(struct twl4030_madc_bat_calibration),
		twl4030_cmp, NULL);
	sort(pdata->discharging, pdata->discharging_size,
		sizeof(struct twl4030_madc_bat_calibration),
		twl4030_cmp, NULL);

	twl4030_madc_bat->pdata = pdata;
	platform_set_drvdata(pdev, twl4030_madc_bat);
	psy_cfg.drv_data = twl4030_madc_bat;
	twl4030_madc_bat->psy = power_supply_register(&pdev->dev,
						      &twl4030_madc_bat_desc,
						      &psy_cfg);
	if (IS_ERR(twl4030_madc_bat->psy)) {
		ret = PTR_ERR(twl4030_madc_bat->psy);
		goto err_vbat;
	}

	return 0;

err_vbat:
	iio_channel_release(twl4030_madc_bat->channel_vbat);
err_ichg:
	iio_channel_release(twl4030_madc_bat->channel_ichg);
err_temp:
	iio_channel_release(twl4030_madc_bat->channel_temp);
err:
	return ret;
}

static int twl4030_madc_battery_remove(struct platform_device *pdev)
{
	struct twl4030_madc_battery *bat = platform_get_drvdata(pdev);

	power_supply_unregister(bat->psy);

	iio_channel_release(bat->channel_vbat);
	iio_channel_release(bat->channel_ichg);
	iio_channel_release(bat->channel_temp);

	return 0;
}

static struct platform_driver twl4030_madc_battery_driver = {
	.driver = {
		.name = "twl4030_madc_battery",
	},
	.probe  = twl4030_madc_battery_probe,
	.remove = twl4030_madc_battery_remove,
};
module_platform_driver(twl4030_madc_battery_driver);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Lukas Märdian <lukas@goldelico.com>");
MODULE_DESCRIPTION("twl4030_madc battery driver");
MODULE_ALIAS("platform:twl4030_madc_battery");
Commit	Line	Data
da0a00eb MB	1	/*
	2	* Dumb driver for LiIon batteries using TWL4030 madc.
	3	*
	4	* Copyright 2013 Golden Delicious Computers
	5	* Lukas Märdian <lukas@goldelico.com>
	6	*
	7	* Based on dumb driver for gta01 battery
	8	* Copyright 2009 Openmoko, Inc
	9	* Balaji Rao <balajirrao@openmoko.org>
	10	*/
	11
	12	#include <linux/module.h>
	13	#include <linux/param.h>
	14	#include <linux/delay.h>
	15	#include <linux/workqueue.h>
	16	#include <linux/platform_device.h>
	17	#include <linux/power_supply.h>
	18	#include <linux/slab.h>
	19	#include <linux/sort.h>
	20	#include <linux/i2c/twl4030-madc.h>
	21	#include <linux/power/twl4030_madc_battery.h>
7e5e4389	22	#include <linux/iio/consumer.h>
da0a00eb MB	23
da0a00eb MB	24	struct twl4030_madc_battery {
297d716f	25	struct power_supply *psy;
da0a00eb	26	struct twl4030_madc_bat_platform_data *pdata;
7e5e4389 MB	27	struct iio_channel *channel_temp;
	28	struct iio_channel *channel_ichg;
	29	struct iio_channel *channel_vbat;
da0a00eb MB	30	};
	31
	32	static enum power_supply_property twl4030_madc_bat_props[] = {
	33	POWER_SUPPLY_PROP_PRESENT,
	34	POWER_SUPPLY_PROP_STATUS,
	35	POWER_SUPPLY_PROP_TECHNOLOGY,
	36	POWER_SUPPLY_PROP_VOLTAGE_NOW,
	37	POWER_SUPPLY_PROP_CURRENT_NOW,
	38	POWER_SUPPLY_PROP_CAPACITY,
	39	POWER_SUPPLY_PROP_CHARGE_FULL,
	40	POWER_SUPPLY_PROP_CHARGE_NOW,
	41	POWER_SUPPLY_PROP_TEMP,
	42	POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
	43	};
	44
7e5e4389	45	static int madc_read(struct iio_channel *channel)
da0a00eb	46	{
7e5e4389 MB	47	int val, err;
	48	err = iio_read_channel_processed(channel, &val);
	49	if (err < 0)
	50	return err;
da0a00eb	51
7e5e4389	52	return val;
da0a00eb MB	53	}
da0a00eb MB	54
7e5e4389	55	static int twl4030_madc_bat_get_charging_status(struct twl4030_madc_battery *bt)
da0a00eb	56	{
7e5e4389	57	return (madc_read(bt->channel_ichg) > 0) ? 1 : 0;
da0a00eb MB	58	}
da0a00eb MB	59
7e5e4389	60	static int twl4030_madc_bat_get_voltage(struct twl4030_madc_battery *bt)
da0a00eb	61	{
7e5e4389	62	return madc_read(bt->channel_vbat);
da0a00eb MB	63	}
da0a00eb MB	64
7e5e4389	65	static int twl4030_madc_bat_get_current(struct twl4030_madc_battery *bt)
da0a00eb	66	{
7e5e4389	67	return madc_read(bt->channel_ichg) * 1000;
da0a00eb MB	68	}
da0a00eb MB	69
7e5e4389	70	static int twl4030_madc_bat_get_temp(struct twl4030_madc_battery *bt)
da0a00eb	71	{
7e5e4389	72	return madc_read(bt->channel_temp) * 10;
da0a00eb MB	73	}
	74
	75	static int twl4030_madc_bat_voltscale(struct twl4030_madc_battery *bat,
	76	int volt)
	77	{
	78	struct twl4030_madc_bat_calibration *calibration;
	79	int i, res = 0;
	80
	81	/* choose charging curve */
7e5e4389	82	if (twl4030_madc_bat_get_charging_status(bat))
da0a00eb MB	83	calibration = bat->pdata->charging;
	84	else
	85	calibration = bat->pdata->discharging;
	86
	87	if (volt > calibration[0].voltage) {
	88	res = calibration[0].level;
	89	} else {
	90	for (i = 0; calibration[i+1].voltage >= 0; i++) {
	91	if (volt <= calibration[i].voltage &&
	92	volt >= calibration[i+1].voltage) {
	93	/* interval found - interpolate within range */
	94	res = calibration[i].level -
	95	((calibration[i].voltage - volt) *
	96	(calibration[i].level -
	97	calibration[i+1].level)) /
	98	(calibration[i].voltage -
	99	calibration[i+1].voltage);
	100	break;
	101	}
	102	}
	103	}
	104	return res;
	105	}
	106
	107	static int twl4030_madc_bat_get_property(struct power_supply *psy,
	108	enum power_supply_property psp,
	109	union power_supply_propval *val)
	110	{
297d716f	111	struct twl4030_madc_battery *bat = power_supply_get_drvdata(psy);
da0a00eb MB	112
	113	switch (psp) {
	114	case POWER_SUPPLY_PROP_STATUS:
	115	if (twl4030_madc_bat_voltscale(bat,
7e5e4389	116	twl4030_madc_bat_get_voltage(bat)) > 95)
da0a00eb MB	117	val->intval = POWER_SUPPLY_STATUS_FULL;
da0a00eb MB	118	else {
7e5e4389	119	if (twl4030_madc_bat_get_charging_status(bat))
da0a00eb MB	120	val->intval = POWER_SUPPLY_STATUS_CHARGING;
	121	else
	122	val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
	123	}
	124	break;
	125	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
7e5e4389	126	val->intval = twl4030_madc_bat_get_voltage(bat) * 1000;
da0a00eb MB	127	break;
	128	case POWER_SUPPLY_PROP_TECHNOLOGY:
	129	val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
	130	break;
	131	case POWER_SUPPLY_PROP_CURRENT_NOW:
7e5e4389	132	val->intval = twl4030_madc_bat_get_current(bat);
da0a00eb MB	133	break;
	134	case POWER_SUPPLY_PROP_PRESENT:
	135	/* assume battery is always present */
	136	val->intval = 1;
	137	break;
	138	case POWER_SUPPLY_PROP_CHARGE_NOW: {
	139	int percent = twl4030_madc_bat_voltscale(bat,
7e5e4389	140	twl4030_madc_bat_get_voltage(bat));
da0a00eb MB	141	val->intval = (percent * bat->pdata->capacity) / 100;
	142	break;
	143	}
	144	case POWER_SUPPLY_PROP_CAPACITY:
	145	val->intval = twl4030_madc_bat_voltscale(bat,
7e5e4389	146	twl4030_madc_bat_get_voltage(bat));
da0a00eb MB	147	break;
	148	case POWER_SUPPLY_PROP_CHARGE_FULL:
	149	val->intval = bat->pdata->capacity;
	150	break;
	151	case POWER_SUPPLY_PROP_TEMP:
7e5e4389	152	val->intval = twl4030_madc_bat_get_temp(bat);
da0a00eb MB	153	break;
	154	case POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW: {
	155	int percent = twl4030_madc_bat_voltscale(bat,
7e5e4389	156	twl4030_madc_bat_get_voltage(bat));
da0a00eb MB	157	/* in mAh */
	158	int chg = (percent * (bat->pdata->capacity/1000))/100;
	159
	160	/* assume discharge with 400 mA (ca. 1.5W) */
	161	val->intval = (3600l * chg) / 400;
	162	break;
	163	}
	164	default:
	165	return -EINVAL;
	166	}
	167
	168	return 0;
	169	}
	170
	171	static void twl4030_madc_bat_ext_changed(struct power_supply *psy)
	172	{
297d716f	173	power_supply_changed(psy);
da0a00eb MB	174	}
da0a00eb MB	175
297d716f KK	176	static const struct power_supply_desc twl4030_madc_bat_desc = {
	177	.name = "twl4030_battery",
	178	.type = POWER_SUPPLY_TYPE_BATTERY,
	179	.properties = twl4030_madc_bat_props,
	180	.num_properties = ARRAY_SIZE(twl4030_madc_bat_props),
	181	.get_property = twl4030_madc_bat_get_property,
	182	.external_power_changed = twl4030_madc_bat_ext_changed,
	183
	184	};
	185
da0a00eb MB	186	static int twl4030_cmp(const void a, const void b)
	187	{
	188	return ((struct twl4030_madc_bat_calibration *)b)->voltage -
	189	((struct twl4030_madc_bat_calibration *)a)->voltage;
	190	}
	191
	192	static int twl4030_madc_battery_probe(struct platform_device *pdev)
	193	{
	194	struct twl4030_madc_battery *twl4030_madc_bat;
	195	struct twl4030_madc_bat_platform_data *pdata = pdev->dev.platform_data;
297d716f	196	struct power_supply_config psy_cfg = {};
68c3ed6f	197	int ret = 0;
da0a00eb	198
7e5e4389 MB	199	twl4030_madc_bat = devm_kzalloc(&pdev->dev, sizeof(*twl4030_madc_bat),
7e5e4389 MB	200	GFP_KERNEL);
da0a00eb MB	201	if (!twl4030_madc_bat)
	202	return -ENOMEM;
	203
7e5e4389 MB	204	twl4030_madc_bat->channel_temp = iio_channel_get(&pdev->dev, "temp");
	205	if (IS_ERR(twl4030_madc_bat->channel_temp)) {
	206	ret = PTR_ERR(twl4030_madc_bat->channel_temp);
	207	goto err;
	208	}
	209
	210	twl4030_madc_bat->channel_ichg = iio_channel_get(&pdev->dev, "ichg");
	211	if (IS_ERR(twl4030_madc_bat->channel_ichg)) {
	212	ret = PTR_ERR(twl4030_madc_bat->channel_ichg);
	213	goto err_temp;
	214	}
	215
	216	twl4030_madc_bat->channel_vbat = iio_channel_get(&pdev->dev, "vbat");
	217	if (IS_ERR(twl4030_madc_bat->channel_vbat)) {
	218	ret = PTR_ERR(twl4030_madc_bat->channel_vbat);
	219	goto err_ichg;
	220	}
	221
da0a00eb MB	222	/* sort charging and discharging calibration data */
	223	sort(pdata->charging, pdata->charging_size,
	224	sizeof(struct twl4030_madc_bat_calibration),
	225	twl4030_cmp, NULL);
	226	sort(pdata->discharging, pdata->discharging_size,
	227	sizeof(struct twl4030_madc_bat_calibration),
	228	twl4030_cmp, NULL);
	229
	230	twl4030_madc_bat->pdata = pdata;
	231	platform_set_drvdata(pdev, twl4030_madc_bat);
297d716f KK	232	psy_cfg.drv_data = twl4030_madc_bat;
	233	twl4030_madc_bat->psy = power_supply_register(&pdev->dev,
	234	&twl4030_madc_bat_desc,
	235	&psy_cfg);
	236	if (IS_ERR(twl4030_madc_bat->psy)) {
	237	ret = PTR_ERR(twl4030_madc_bat->psy);
7e5e4389	238	goto err_vbat;
297d716f	239	}
da0a00eb	240
7e5e4389 MB	241	return 0;
	242
	243	err_vbat:
	244	iio_channel_release(twl4030_madc_bat->channel_vbat);
	245	err_ichg:
	246	iio_channel_release(twl4030_madc_bat->channel_ichg);
	247	err_temp:
	248	iio_channel_release(twl4030_madc_bat->channel_temp);
	249	err:
68c3ed6f	250	return ret;
da0a00eb MB	251	}
	252
	253	static int twl4030_madc_battery_remove(struct platform_device *pdev)
	254	{
	255	struct twl4030_madc_battery *bat = platform_get_drvdata(pdev);
	256
297d716f	257	power_supply_unregister(bat->psy);
7e5e4389 MB	258
	259	iio_channel_release(bat->channel_vbat);
	260	iio_channel_release(bat->channel_ichg);
	261	iio_channel_release(bat->channel_temp);
da0a00eb MB	262
	263	return 0;
	264	}
	265
	266	static struct platform_driver twl4030_madc_battery_driver = {
	267	.driver = {
	268	.name = "twl4030_madc_battery",
	269	},
	270	.probe = twl4030_madc_battery_probe,
	271	.remove = twl4030_madc_battery_remove,
	272	};
	273	module_platform_driver(twl4030_madc_battery_driver);
	274
	275	MODULE_LICENSE("GPL");
	276	MODULE_AUTHOR("Lukas Märdian <lukas@goldelico.com>");
	277	MODULE_DESCRIPTION("twl4030_madc battery driver");
5939d9df	278	MODULE_ALIAS("platform:twl4030_madc_battery");