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

/*
 * Backup battery driver for Wolfson Microelectronics wm831x PMICs
 *
 * Copyright 2009 Wolfson Microelectronics PLC.
 *
 * 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/module.h>
#include <linux/err.h>
#include <linux/platform_device.h>
#include <linux/power_supply.h>
#include <linux/slab.h>

#include <linux/mfd/wm831x/core.h>
#include <linux/mfd/wm831x/auxadc.h>
#include <linux/mfd/wm831x/pmu.h>
#include <linux/mfd/wm831x/pdata.h>

struct wm831x_backup {
	struct wm831x *wm831x;
	struct power_supply *backup;
	struct power_supply_desc backup_desc;
	char name[20];
};

static int wm831x_backup_read_voltage(struct wm831x *wm831x,
				     enum wm831x_auxadc src,
				     union power_supply_propval *val)
{
	int ret;

	ret = wm831x_auxadc_read_uv(wm831x, src);
	if (ret >= 0)
		val->intval = ret;

	return ret;
}

/*********************************************************************
 *		Backup supply properties
 *********************************************************************/

static void wm831x_config_backup(struct wm831x *wm831x)
{
	struct wm831x_pdata *wm831x_pdata = wm831x->dev->platform_data;
	struct wm831x_backup_pdata *pdata;
	int ret, reg;

	if (!wm831x_pdata || !wm831x_pdata->backup) {
		dev_warn(wm831x->dev,
			 "No backup battery charger configuration\n");
		return;
	}

	pdata = wm831x_pdata->backup;

	reg = 0;

	if (pdata->charger_enable)
		reg |= WM831X_BKUP_CHG_ENA | WM831X_BKUP_BATT_DET_ENA;
	if (pdata->no_constant_voltage)
		reg |= WM831X_BKUP_CHG_MODE;

	switch (pdata->vlim) {
	case 2500:
		break;
	case 3100:
		reg |= WM831X_BKUP_CHG_VLIM;
		break;
	default:
		dev_err(wm831x->dev, "Invalid backup voltage limit %dmV\n",
			pdata->vlim);
	}

	switch (pdata->ilim) {
	case 100:
		break;
	case 200:
		reg |= 1;
		break;
	case 300:
		reg |= 2;
		break;
	case 400:
		reg |= 3;
		break;
	default:
		dev_err(wm831x->dev, "Invalid backup current limit %duA\n",
			pdata->ilim);
	}

	ret = wm831x_reg_unlock(wm831x);
	if (ret != 0) {
		dev_err(wm831x->dev, "Failed to unlock registers: %d\n", ret);
		return;
	}

	ret = wm831x_set_bits(wm831x, WM831X_BACKUP_CHARGER_CONTROL,
			      WM831X_BKUP_CHG_ENA_MASK |
			      WM831X_BKUP_CHG_MODE_MASK |
			      WM831X_BKUP_BATT_DET_ENA_MASK |
			      WM831X_BKUP_CHG_VLIM_MASK |
			      WM831X_BKUP_CHG_ILIM_MASK,
			      reg);
	if (ret != 0)
		dev_err(wm831x->dev,
			"Failed to set backup charger config: %d\n", ret);

	wm831x_reg_lock(wm831x);
}

static int wm831x_backup_get_prop(struct power_supply *psy,
				  enum power_supply_property psp,
				  union power_supply_propval *val)
{
	struct wm831x_backup *devdata = dev_get_drvdata(psy->dev.parent);
	struct wm831x *wm831x = devdata->wm831x;
	int ret = 0;

	ret = wm831x_reg_read(wm831x, WM831X_BACKUP_CHARGER_CONTROL);
	if (ret < 0)
		return ret;

	switch (psp) {
	case POWER_SUPPLY_PROP_STATUS:
		if (ret & WM831X_BKUP_CHG_STS)
			val->intval = POWER_SUPPLY_STATUS_CHARGING;
		else
			val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
		break;

	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
		ret = wm831x_backup_read_voltage(wm831x, WM831X_AUX_BKUP_BATT,
						val);
		break;

	case POWER_SUPPLY_PROP_PRESENT:
		if (ret & WM831X_BKUP_CHG_STS)
			val->intval = 1;
		else
			val->intval = 0;
		break;

	default:
		ret = -EINVAL;
		break;
	}

	return ret;
}

static enum power_supply_property wm831x_backup_props[] = {
	POWER_SUPPLY_PROP_STATUS,
	POWER_SUPPLY_PROP_VOLTAGE_NOW,
	POWER_SUPPLY_PROP_PRESENT,
};

/*********************************************************************
 *		Initialisation
 *********************************************************************/

static int wm831x_backup_probe(struct platform_device *pdev)
{
	struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
	struct wm831x_pdata *wm831x_pdata = wm831x->dev->platform_data;
	struct wm831x_backup *devdata;

	devdata = devm_kzalloc(&pdev->dev, sizeof(struct wm831x_backup),
				GFP_KERNEL);
	if (devdata == NULL)
		return -ENOMEM;

	devdata->wm831x = wm831x;
	platform_set_drvdata(pdev, devdata);

	/* We ignore configuration failures since we can still read
	 * back the status without enabling the charger (which may
	 * already be enabled anyway).
	 */
	wm831x_config_backup(wm831x);

	if (wm831x_pdata && wm831x_pdata->wm831x_num)
		snprintf(devdata->name, sizeof(devdata->name),
			 "wm831x-backup.%d", wm831x_pdata->wm831x_num);
	else
		snprintf(devdata->name, sizeof(devdata->name),
			 "wm831x-backup");

	devdata->backup_desc.name = devdata->name;
	devdata->backup_desc.type = POWER_SUPPLY_TYPE_BATTERY;
	devdata->backup_desc.properties = wm831x_backup_props;
	devdata->backup_desc.num_properties = ARRAY_SIZE(wm831x_backup_props);
	devdata->backup_desc.get_property = wm831x_backup_get_prop;
	devdata->backup = power_supply_register(&pdev->dev,
						&devdata->backup_desc, NULL);

	return PTR_ERR_OR_ZERO(devdata->backup);
}

static int wm831x_backup_remove(struct platform_device *pdev)
{
	struct wm831x_backup *devdata = platform_get_drvdata(pdev);

	power_supply_unregister(devdata->backup);

	return 0;
}

static struct platform_driver wm831x_backup_driver = {
	.probe = wm831x_backup_probe,
	.remove = wm831x_backup_remove,
	.driver = {
		.name = "wm831x-backup",
	},
};

module_platform_driver(wm831x_backup_driver);

MODULE_DESCRIPTION("Backup battery charger driver for WM831x PMICs");
MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:wm831x-backup");
Commit	Line	Data
c26964ea MB	1	/*
	2	* Backup battery driver for Wolfson Microelectronics wm831x PMICs
	3	*
	4	* Copyright 2009 Wolfson Microelectronics PLC.
	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 version 2 as
	8	* published by the Free Software Foundation.
	9	*/
	10
	11	#include <linux/module.h>
	12	#include <linux/err.h>
	13	#include <linux/platform_device.h>
	14	#include <linux/power_supply.h>
5a0e3ad6	15	#include <linux/slab.h>
c26964ea MB	16
	17	#include <linux/mfd/wm831x/core.h>
	18	#include <linux/mfd/wm831x/auxadc.h>
	19	#include <linux/mfd/wm831x/pmu.h>
	20	#include <linux/mfd/wm831x/pdata.h>
	21
	22	struct wm831x_backup {
	23	struct wm831x *wm831x;
297d716f KK	24	struct power_supply *backup;
297d716f KK	25	struct power_supply_desc backup_desc;
d0376031	26	char name[20];
c26964ea MB	27	};
	28
	29	static int wm831x_backup_read_voltage(struct wm831x *wm831x,
	30	enum wm831x_auxadc src,
	31	union power_supply_propval *val)
	32	{
	33	int ret;
	34
	35	ret = wm831x_auxadc_read_uv(wm831x, src);
	36	if (ret >= 0)
	37	val->intval = ret;
	38
	39	return ret;
	40	}
	41
	42	/*********************************************************************
	43	* Backup supply properties
	44	*********************************************************************/
	45
	46	static void wm831x_config_backup(struct wm831x *wm831x)
	47	{
	48	struct wm831x_pdata *wm831x_pdata = wm831x->dev->platform_data;
	49	struct wm831x_backup_pdata *pdata;
	50	int ret, reg;
	51
	52	if (!wm831x_pdata \|\| !wm831x_pdata->backup) {
	53	dev_warn(wm831x->dev,
	54	"No backup battery charger configuration\n");
	55	return;
	56	}
	57
	58	pdata = wm831x_pdata->backup;
	59
	60	reg = 0;
	61
	62	if (pdata->charger_enable)
	63	reg \|= WM831X_BKUP_CHG_ENA \| WM831X_BKUP_BATT_DET_ENA;
	64	if (pdata->no_constant_voltage)
	65	reg \|= WM831X_BKUP_CHG_MODE;
	66
	67	switch (pdata->vlim) {
	68	case 2500:
	69	break;
	70	case 3100:
	71	reg \|= WM831X_BKUP_CHG_VLIM;
	72	break;
	73	default:
	74	dev_err(wm831x->dev, "Invalid backup voltage limit %dmV\n",
	75	pdata->vlim);
	76	}
	77
	78	switch (pdata->ilim) {
	79	case 100:
	80	break;
	81	case 200:
	82	reg \|= 1;
	83	break;
	84	case 300:
	85	reg \|= 2;
	86	break;
	87	case 400:
	88	reg \|= 3;
	89	break;
	90	default:
91	dev_err(wm831x->dev, "Invalid backup current limit %duA\n",
92	pdata->ilim);
93	}
94
95	ret = wm831x_reg_unlock(wm831x);
96	if (ret != 0) {
97	dev_err(wm831x->dev, "Failed to unlock registers: %d\n", ret);
98	return;
99	}
100
101	ret = wm831x_set_bits(wm831x, WM831X_BACKUP_CHARGER_CONTROL,
102	WM831X_BKUP_CHG_ENA_MASK \|
103	WM831X_BKUP_CHG_MODE_MASK \|
104	WM831X_BKUP_BATT_DET_ENA_MASK \|
105	WM831X_BKUP_CHG_VLIM_MASK \|
106	WM831X_BKUP_CHG_ILIM_MASK,
107	reg);
108	if (ret != 0)
109	dev_err(wm831x->dev,
110	"Failed to set backup charger config: %d\n", ret);
111
112	wm831x_reg_lock(wm831x);
113	}
114
115	static int wm831x_backup_get_prop(struct power_supply *psy,
116	enum power_supply_property psp,
117	union power_supply_propval *val)
118	{
297d716f	119	struct wm831x_backup *devdata = dev_get_drvdata(psy->dev.parent);
c26964ea MB	120	struct wm831x *wm831x = devdata->wm831x;
	121	int ret = 0;
	122
	123	ret = wm831x_reg_read(wm831x, WM831X_BACKUP_CHARGER_CONTROL);
	124	if (ret < 0)
	125	return ret;
	126
	127	switch (psp) {
	128	case POWER_SUPPLY_PROP_STATUS:
	129	if (ret & WM831X_BKUP_CHG_STS)
	130	val->intval = POWER_SUPPLY_STATUS_CHARGING;
	131	else
	132	val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
	133	break;
	134
	135	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
	136	ret = wm831x_backup_read_voltage(wm831x, WM831X_AUX_BKUP_BATT,
	137	val);
	138	break;
	139
	140	case POWER_SUPPLY_PROP_PRESENT:
	141	if (ret & WM831X_BKUP_CHG_STS)
	142	val->intval = 1;
	143	else
	144	val->intval = 0;
	145	break;
	146
	147	default:
	148	ret = -EINVAL;
	149	break;
	150	}
	151
	152	return ret;
	153	}
	154
	155	static enum power_supply_property wm831x_backup_props[] = {
	156	POWER_SUPPLY_PROP_STATUS,
	157	POWER_SUPPLY_PROP_VOLTAGE_NOW,
	158	POWER_SUPPLY_PROP_PRESENT,
	159	};
	160
	161	/*********************************************************************
	162	* Initialisation
	163	*********************************************************************/
	164
c8afa640	165	static int wm831x_backup_probe(struct platform_device *pdev)
c26964ea MB	166	{
c26964ea MB	167	struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
d0376031	168	struct wm831x_pdata *wm831x_pdata = wm831x->dev->platform_data;
c26964ea	169	struct wm831x_backup *devdata;
c26964ea	170
f11d018f JH	171	devdata = devm_kzalloc(&pdev->dev, sizeof(struct wm831x_backup),
f11d018f JH	172	GFP_KERNEL);
c26964ea MB	173	if (devdata == NULL)
	174	return -ENOMEM;
	175
	176	devdata->wm831x = wm831x;
	177	platform_set_drvdata(pdev, devdata);
	178
c26964ea MB	179	/* We ignore configuration failures since we can still read
	180	* back the status without enabling the charger (which may
	181	* already be enabled anyway).
	182	*/
	183	wm831x_config_backup(wm831x);
	184
d0376031 MB	185	if (wm831x_pdata && wm831x_pdata->wm831x_num)
	186	snprintf(devdata->name, sizeof(devdata->name),
	187	"wm831x-backup.%d", wm831x_pdata->wm831x_num);
	188	else
	189	snprintf(devdata->name, sizeof(devdata->name),
	190	"wm831x-backup");
	191
297d716f KK	192	devdata->backup_desc.name = devdata->name;
	193	devdata->backup_desc.type = POWER_SUPPLY_TYPE_BATTERY;
	194	devdata->backup_desc.properties = wm831x_backup_props;
	195	devdata->backup_desc.num_properties = ARRAY_SIZE(wm831x_backup_props);
	196	devdata->backup_desc.get_property = wm831x_backup_get_prop;
	197	devdata->backup = power_supply_register(&pdev->dev,
	198	&devdata->backup_desc, NULL);
c26964ea	199
297d716f	200	return PTR_ERR_OR_ZERO(devdata->backup);
c26964ea MB	201	}
c26964ea MB	202
415ec69f	203	static int wm831x_backup_remove(struct platform_device *pdev)
c26964ea MB	204	{
	205	struct wm831x_backup *devdata = platform_get_drvdata(pdev);
	206
297d716f	207	power_supply_unregister(devdata->backup);
c26964ea MB	208
	209	return 0;
	210	}
	211
	212	static struct platform_driver wm831x_backup_driver = {
	213	.probe = wm831x_backup_probe,
28ea73f4	214	.remove = wm831x_backup_remove,
c26964ea MB	215	.driver = {
	216	.name = "wm831x-backup",
	217	},
	218	};
	219
300bac7f	220	module_platform_driver(wm831x_backup_driver);
c26964ea MB	221
	222	MODULE_DESCRIPTION("Backup battery charger driver for WM831x PMICs");
	223	MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
	224	MODULE_LICENSE("GPL");
	225	MODULE_ALIAS("platform:wm831x-backup");