[net-next-2.6.git] / drivers / power / wm831x_power.c

/*
 * PMU 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/mfd/wm831x/core.h>
#include <linux/mfd/wm831x/auxadc.h>
#include <linux/mfd/wm831x/pmu.h>
#include <linux/mfd/wm831x/pdata.h>

struct wm831x_power {
	struct wm831x *wm831x;
	struct power_supply wall;
	struct power_supply usb;
	struct power_supply battery;
};

static int wm831x_power_check_online(struct wm831x *wm831x, int supply,
				     union power_supply_propval *val)
{
	int ret;

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

	if (ret & supply)
		val->intval = 1;
	else
		val->intval = 0;

	return 0;
}

static int wm831x_power_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;
}

/*********************************************************************
 *		WALL Power
 *********************************************************************/
static int wm831x_wall_get_prop(struct power_supply *psy,
				enum power_supply_property psp,
				union power_supply_propval *val)
{
	struct wm831x_power *wm831x_power = dev_get_drvdata(psy->dev->parent);
	struct wm831x *wm831x = wm831x_power->wm831x;
	int ret = 0;

	switch (psp) {
	case POWER_SUPPLY_PROP_ONLINE:
		ret = wm831x_power_check_online(wm831x, WM831X_PWR_WALL, val);
		break;
	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
		ret = wm831x_power_read_voltage(wm831x, WM831X_AUX_WALL, val);
		break;
	default:
		ret = -EINVAL;
		break;
	}

	return ret;
}

static enum power_supply_property wm831x_wall_props[] = {
	POWER_SUPPLY_PROP_ONLINE,
	POWER_SUPPLY_PROP_VOLTAGE_NOW,
};

/*********************************************************************
 *		USB Power
 *********************************************************************/
static int wm831x_usb_get_prop(struct power_supply *psy,
			       enum power_supply_property psp,
			       union power_supply_propval *val)
{
	struct wm831x_power *wm831x_power = dev_get_drvdata(psy->dev->parent);
	struct wm831x *wm831x = wm831x_power->wm831x;
	int ret = 0;

	switch (psp) {
	case POWER_SUPPLY_PROP_ONLINE:
		ret = wm831x_power_check_online(wm831x, WM831X_PWR_USB, val);
		break;
	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
		ret = wm831x_power_read_voltage(wm831x, WM831X_AUX_USB, val);
		break;
	default:
		ret = -EINVAL;
		break;
	}

	return ret;
}

static enum power_supply_property wm831x_usb_props[] = {
	POWER_SUPPLY_PROP_ONLINE,
	POWER_SUPPLY_PROP_VOLTAGE_NOW,
};

/*********************************************************************
 *		Battery properties
 *********************************************************************/

struct chg_map {
	int val;
	int reg_val;
};

static struct chg_map trickle_ilims[] = {
	{  50, 0 << WM831X_CHG_TRKL_ILIM_SHIFT },
	{ 100, 1 << WM831X_CHG_TRKL_ILIM_SHIFT },
	{ 150, 2 << WM831X_CHG_TRKL_ILIM_SHIFT },
	{ 200, 3 << WM831X_CHG_TRKL_ILIM_SHIFT },
};

static struct chg_map vsels[] = {
	{ 4050, 0 << WM831X_CHG_VSEL_SHIFT },
	{ 4100, 1 << WM831X_CHG_VSEL_SHIFT },
	{ 4150, 2 << WM831X_CHG_VSEL_SHIFT },
	{ 4200, 3 << WM831X_CHG_VSEL_SHIFT },
};

static struct chg_map fast_ilims[] = {
	{    0,  0 << WM831X_CHG_FAST_ILIM_SHIFT },
	{   50,  1 << WM831X_CHG_FAST_ILIM_SHIFT },
	{  100,  2 << WM831X_CHG_FAST_ILIM_SHIFT },
	{  150,  3 << WM831X_CHG_FAST_ILIM_SHIFT },
	{  200,  4 << WM831X_CHG_FAST_ILIM_SHIFT },
	{  250,  5 << WM831X_CHG_FAST_ILIM_SHIFT },
	{  300,  6 << WM831X_CHG_FAST_ILIM_SHIFT },
	{  350,  7 << WM831X_CHG_FAST_ILIM_SHIFT },
	{  400,  8 << WM831X_CHG_FAST_ILIM_SHIFT },
	{  450,  9 << WM831X_CHG_FAST_ILIM_SHIFT },
	{  500, 10 << WM831X_CHG_FAST_ILIM_SHIFT },
	{  600, 11 << WM831X_CHG_FAST_ILIM_SHIFT },
	{  700, 12 << WM831X_CHG_FAST_ILIM_SHIFT },
	{  800, 13 << WM831X_CHG_FAST_ILIM_SHIFT },
	{  900, 14 << WM831X_CHG_FAST_ILIM_SHIFT },
	{ 1000, 15 << WM831X_CHG_FAST_ILIM_SHIFT },
};

static struct chg_map eoc_iterms[] = {
	{ 20, 0 << WM831X_CHG_ITERM_SHIFT },
	{ 30, 1 << WM831X_CHG_ITERM_SHIFT },
	{ 40, 2 << WM831X_CHG_ITERM_SHIFT },
	{ 50, 3 << WM831X_CHG_ITERM_SHIFT },
	{ 60, 4 << WM831X_CHG_ITERM_SHIFT },
	{ 70, 5 << WM831X_CHG_ITERM_SHIFT },
	{ 80, 6 << WM831X_CHG_ITERM_SHIFT },
	{ 90, 7 << WM831X_CHG_ITERM_SHIFT },
};

static struct chg_map chg_times[] = {
	{  60,  0 << WM831X_CHG_TIME_SHIFT },
	{  90,  1 << WM831X_CHG_TIME_SHIFT },
	{ 120,  2 << WM831X_CHG_TIME_SHIFT },
	{ 150,  3 << WM831X_CHG_TIME_SHIFT },
	{ 180,  4 << WM831X_CHG_TIME_SHIFT },
	{ 210,  5 << WM831X_CHG_TIME_SHIFT },
	{ 240,  6 << WM831X_CHG_TIME_SHIFT },
	{ 270,  7 << WM831X_CHG_TIME_SHIFT },
	{ 300,  8 << WM831X_CHG_TIME_SHIFT },
	{ 330,  9 << WM831X_CHG_TIME_SHIFT },
	{ 360, 10 << WM831X_CHG_TIME_SHIFT },
	{ 390, 11 << WM831X_CHG_TIME_SHIFT },
	{ 420, 12 << WM831X_CHG_TIME_SHIFT },
	{ 450, 13 << WM831X_CHG_TIME_SHIFT },
	{ 480, 14 << WM831X_CHG_TIME_SHIFT },
	{ 510, 15 << WM831X_CHG_TIME_SHIFT },
};

static void wm831x_battey_apply_config(struct wm831x *wm831x,
				       struct chg_map *map, int count, int val,
				       int *reg, const char *name,
				       const char *units)
{
	int i;

	for (i = 0; i < count; i++)
		if (val == map[i].val)
			break;
	if (i == count) {
		dev_err(wm831x->dev, "Invalid %s %d%s\n",
			name, val, units);
	} else {
		*reg |= map[i].reg_val;
		dev_dbg(wm831x->dev, "Set %s of %d%s\n", name, val, units);
	}
}

static void wm831x_config_battery(struct wm831x *wm831x)
{
	struct wm831x_pdata *wm831x_pdata = wm831x->dev->platform_data;
	struct wm831x_battery_pdata *pdata;
	int ret, reg1, reg2;

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

	pdata = wm831x_pdata->battery;

	reg1 = 0;
	reg2 = 0;

	if (!pdata->enable) {
		dev_info(wm831x->dev, "Battery charger disabled\n");
		return;
	}

	reg1 |= WM831X_CHG_ENA;
	if (pdata->off_mask)
		reg2 |= WM831X_CHG_OFF_MSK;
	if (pdata->fast_enable)
		reg1 |= WM831X_CHG_FAST;

	wm831x_battey_apply_config(wm831x, trickle_ilims,
				   ARRAY_SIZE(trickle_ilims),
				   pdata->trickle_ilim, &reg2,
				   "trickle charge current limit", "mA");

	wm831x_battey_apply_config(wm831x, vsels, ARRAY_SIZE(vsels),
				   pdata->vsel, &reg2,
				   "target voltage", "mV");

	wm831x_battey_apply_config(wm831x, fast_ilims, ARRAY_SIZE(fast_ilims),
				   pdata->fast_ilim, &reg2,
				   "fast charge current limit", "mA");

	wm831x_battey_apply_config(wm831x, eoc_iterms, ARRAY_SIZE(eoc_iterms),
				   pdata->eoc_iterm, &reg1,
				   "end of charge current threshold", "mA");

	wm831x_battey_apply_config(wm831x, chg_times, ARRAY_SIZE(chg_times),
				   pdata->timeout, &reg2,
				   "charger timeout", "min");

	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_CHARGER_CONTROL_1,
			      WM831X_CHG_ENA_MASK |
			      WM831X_CHG_FAST_MASK |
			      WM831X_CHG_ITERM_MASK |
			      WM831X_CHG_ITERM_MASK,
			      reg1);
	if (ret != 0)
		dev_err(wm831x->dev, "Failed to set charger control 1: %d\n",
			ret);

	ret = wm831x_set_bits(wm831x, WM831X_CHARGER_CONTROL_2,
			      WM831X_CHG_OFF_MSK |
			      WM831X_CHG_TIME_MASK |
			      WM831X_CHG_FAST_ILIM_MASK |
			      WM831X_CHG_TRKL_ILIM_MASK |
			      WM831X_CHG_VSEL_MASK,
			      reg2);
	if (ret != 0)
		dev_err(wm831x->dev, "Failed to set charger control 2: %d\n",
			ret);

	wm831x_reg_lock(wm831x);
}

static int wm831x_bat_check_status(struct wm831x *wm831x, int *status)
{
	int ret;

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

	if (ret & WM831X_PWR_SRC_BATT) {
		*status = POWER_SUPPLY_STATUS_DISCHARGING;
		return 0;
	}

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

	switch (ret & WM831X_CHG_STATE_MASK) {
	case WM831X_CHG_STATE_OFF:
		*status = POWER_SUPPLY_STATUS_NOT_CHARGING;
		break;
	case WM831X_CHG_STATE_TRICKLE:
	case WM831X_CHG_STATE_FAST:
		*status = POWER_SUPPLY_STATUS_CHARGING;
		break;

	default:
		*status = POWER_SUPPLY_STATUS_UNKNOWN;
		break;
	}

	return 0;
}

static int wm831x_bat_check_type(struct wm831x *wm831x, int *type)
{
	int ret;

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

	switch (ret & WM831X_CHG_STATE_MASK) {
	case WM831X_CHG_STATE_TRICKLE:
	case WM831X_CHG_STATE_TRICKLE_OT:
		*type = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
		break;
	case WM831X_CHG_STATE_FAST:
	case WM831X_CHG_STATE_FAST_OT:
		*type = POWER_SUPPLY_CHARGE_TYPE_FAST;
		break;
	default:
		*type = POWER_SUPPLY_CHARGE_TYPE_NONE;
		break;
	}

	return 0;
}

static int wm831x_bat_check_health(struct wm831x *wm831x, int *health)
{
	int ret;

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

	if (ret & WM831X_BATT_HOT_STS) {
		*health = POWER_SUPPLY_HEALTH_OVERHEAT;
		return 0;
	}

	if (ret & WM831X_BATT_COLD_STS) {
		*health = POWER_SUPPLY_HEALTH_COLD;
		return 0;
	}

	if (ret & WM831X_BATT_OV_STS) {
		*health = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
		return 0;
	}

	switch (ret & WM831X_CHG_STATE_MASK) {
	case WM831X_CHG_STATE_TRICKLE_OT:
	case WM831X_CHG_STATE_FAST_OT:
		*health = POWER_SUPPLY_HEALTH_OVERHEAT;
		break;
	case WM831X_CHG_STATE_DEFECTIVE:
		*health = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
		break;
	default:
		*health = POWER_SUPPLY_HEALTH_GOOD;
		break;
	}

	return 0;
}

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

	switch (psp) {
	case POWER_SUPPLY_PROP_STATUS:
		ret = wm831x_bat_check_status(wm831x, &val->intval);
		break;
	case POWER_SUPPLY_PROP_ONLINE:
		ret = wm831x_power_check_online(wm831x, WM831X_PWR_SRC_BATT,
						val);
		break;
	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
		ret = wm831x_power_read_voltage(wm831x, WM831X_AUX_BATT, val);
		break;
	case POWER_SUPPLY_PROP_HEALTH:
		ret = wm831x_bat_check_health(wm831x, &val->intval);
		break;
	case POWER_SUPPLY_PROP_CHARGE_TYPE:
		ret = wm831x_bat_check_type(wm831x, &val->intval);
		break;
	default:
		ret = -EINVAL;
		break;
	}

	return ret;
}

static enum power_supply_property wm831x_bat_props[] = {
	POWER_SUPPLY_PROP_STATUS,
	POWER_SUPPLY_PROP_ONLINE,
	POWER_SUPPLY_PROP_VOLTAGE_NOW,
	POWER_SUPPLY_PROP_HEALTH,
	POWER_SUPPLY_PROP_CHARGE_TYPE,
};

static const char *wm831x_bat_irqs[] = {
	"BATT HOT",
	"BATT COLD",
	"BATT FAIL",
	"OV",
	"END",
	"TO",
	"MODE",
	"START",
};

static irqreturn_t wm831x_bat_irq(int irq, void *data)
{
	struct wm831x_power *wm831x_power = data;
	struct wm831x *wm831x = wm831x_power->wm831x;

	dev_dbg(wm831x->dev, "Battery status changed: %d\n", irq);

	/* The battery charger is autonomous so we don't need to do
	 * anything except kick user space */
	power_supply_changed(&wm831x_power->battery);

	return IRQ_HANDLED;
}


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

static irqreturn_t wm831x_syslo_irq(int irq, void *data)
{
	struct wm831x_power *wm831x_power = data;
	struct wm831x *wm831x = wm831x_power->wm831x;

	/* Not much we can actually *do* but tell people for
	 * posterity, we're probably about to run out of power. */
	dev_crit(wm831x->dev, "SYSVDD under voltage\n");

	return IRQ_HANDLED;
}

static irqreturn_t wm831x_pwr_src_irq(int irq, void *data)
{
	struct wm831x_power *wm831x_power = data;
	struct wm831x *wm831x = wm831x_power->wm831x;

	dev_dbg(wm831x->dev, "Power source changed\n");

	/* Just notify for everything - little harm in overnotifying. */
	power_supply_changed(&wm831x_power->battery);
	power_supply_changed(&wm831x_power->usb);
	power_supply_changed(&wm831x_power->wall);

	return IRQ_HANDLED;
}

static __devinit int wm831x_power_probe(struct platform_device *pdev)
{
	struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
	struct wm831x_power *power;
	struct power_supply *usb;
	struct power_supply *battery;
	struct power_supply *wall;
	int ret, irq, i;

	power = kzalloc(sizeof(struct wm831x_power), GFP_KERNEL);
	if (power == NULL)
		return -ENOMEM;

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

	usb = &power->usb;
	battery = &power->battery;
	wall = &power->wall;

	/* We ignore configuration failures since we can still read back
	 * the status without enabling the charger.
	 */
	wm831x_config_battery(wm831x);

	wall->name = "wm831x-wall";
	wall->type = POWER_SUPPLY_TYPE_MAINS;
	wall->properties = wm831x_wall_props;
	wall->num_properties = ARRAY_SIZE(wm831x_wall_props);
	wall->get_property = wm831x_wall_get_prop;
	ret = power_supply_register(&pdev->dev, wall);
	if (ret)
		goto err_kmalloc;

	battery->name = "wm831x-battery";
	battery->properties = wm831x_bat_props;
	battery->num_properties = ARRAY_SIZE(wm831x_bat_props);
	battery->get_property = wm831x_bat_get_prop;
	battery->use_for_apm = 1;
	ret = power_supply_register(&pdev->dev, battery);
	if (ret)
		goto err_wall;

	usb->name = "wm831x-usb",
	usb->type = POWER_SUPPLY_TYPE_USB;
	usb->properties = wm831x_usb_props;
	usb->num_properties = ARRAY_SIZE(wm831x_usb_props);
	usb->get_property = wm831x_usb_get_prop;
	ret = power_supply_register(&pdev->dev, usb);
	if (ret)
		goto err_battery;

	irq = platform_get_irq_byname(pdev, "SYSLO");
	ret = request_threaded_irq(irq, NULL, wm831x_syslo_irq,
				   IRQF_TRIGGER_RISING, "System power low",
				   power);
	if (ret != 0) {
		dev_err(&pdev->dev, "Failed to request SYSLO IRQ %d: %d\n",
			irq, ret);
		goto err_usb;
	}

	irq = platform_get_irq_byname(pdev, "PWR SRC");
	ret = request_threaded_irq(irq, NULL, wm831x_pwr_src_irq,
				   IRQF_TRIGGER_RISING, "Power source",
				   power);
	if (ret != 0) {
		dev_err(&pdev->dev, "Failed to request PWR SRC IRQ %d: %d\n",
			irq, ret);
		goto err_syslo;
	}

	for (i = 0; i < ARRAY_SIZE(wm831x_bat_irqs); i++) {
		irq = platform_get_irq_byname(pdev, wm831x_bat_irqs[i]);
		ret = request_threaded_irq(irq, NULL, wm831x_bat_irq,
					   IRQF_TRIGGER_RISING,
					   wm831x_bat_irqs[i],
					   power);
		if (ret != 0) {
			dev_err(&pdev->dev,
				"Failed to request %s IRQ %d: %d\n",
				wm831x_bat_irqs[i], irq, ret);
			goto err_bat_irq;
		}
	}

	return ret;

err_bat_irq:
	for (; i >= 0; i--) {
		irq = platform_get_irq_byname(pdev, wm831x_bat_irqs[i]);
		free_irq(irq, power);
	}
	irq = platform_get_irq_byname(pdev, "PWR SRC");
	free_irq(irq, power);
err_syslo:
	irq = platform_get_irq_byname(pdev, "SYSLO");
	free_irq(irq, power);
err_usb:
	power_supply_unregister(usb);
err_battery:
	power_supply_unregister(battery);
err_wall:
	power_supply_unregister(wall);
err_kmalloc:
	kfree(power);
	return ret;
}

static __devexit int wm831x_power_remove(struct platform_device *pdev)
{
	struct wm831x_power *wm831x_power = platform_get_drvdata(pdev);
	int irq, i;

	for (i = 0; i < ARRAY_SIZE(wm831x_bat_irqs); i++) {
		irq = platform_get_irq_byname(pdev, wm831x_bat_irqs[i]);
		free_irq(irq, wm831x_power);
	}

	irq = platform_get_irq_byname(pdev, "PWR SRC");
	free_irq(irq, wm831x_power);

	irq = platform_get_irq_byname(pdev, "SYSLO");
	free_irq(irq, wm831x_power);

	power_supply_unregister(&wm831x_power->battery);
	power_supply_unregister(&wm831x_power->wall);
	power_supply_unregister(&wm831x_power->usb);
	return 0;
}

static struct platform_driver wm831x_power_driver = {
	.probe = wm831x_power_probe,
	.remove = __devexit_p(wm831x_power_remove),
	.driver = {
		.name = "wm831x-power",
	},
};

static int __init wm831x_power_init(void)
{
	return platform_driver_register(&wm831x_power_driver);
}
module_init(wm831x_power_init);

static void __exit wm831x_power_exit(void)
{
	platform_driver_unregister(&wm831x_power_driver);
}
module_exit(wm831x_power_exit);

MODULE_DESCRIPTION("Power supply driver for WM831x PMICs");
MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:wm831x-power");
Commit	Line	Data
3961f7c3 MB	1	/*
	2	* PMU 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>
	15
	16	#include <linux/mfd/wm831x/core.h>
	17	#include <linux/mfd/wm831x/auxadc.h>
	18	#include <linux/mfd/wm831x/pmu.h>
	19	#include <linux/mfd/wm831x/pdata.h>
	20
	21	struct wm831x_power {
	22	struct wm831x *wm831x;
	23	struct power_supply wall;
3961f7c3 MB	24	struct power_supply usb;
	25	struct power_supply battery;
	26	};
	27
	28	static int wm831x_power_check_online(struct wm831x *wm831x, int supply,
	29	union power_supply_propval *val)
	30	{
	31	int ret;
	32
	33	ret = wm831x_reg_read(wm831x, WM831X_SYSTEM_STATUS);
	34	if (ret < 0)
	35	return ret;
	36
	37	if (ret & supply)
	38	val->intval = 1;
	39	else
	40	val->intval = 0;
	41
	42	return 0;
	43	}
	44
	45	static int wm831x_power_read_voltage(struct wm831x *wm831x,
	46	enum wm831x_auxadc src,
	47	union power_supply_propval *val)
	48	{
	49	int ret;
	50
	51	ret = wm831x_auxadc_read_uv(wm831x, src);
	52	if (ret >= 0)
	53	val->intval = ret;
	54
	55	return ret;
	56	}
	57
	58	/*********************************************************************
	59	* WALL Power
	60	*********************************************************************/
	61	static int wm831x_wall_get_prop(struct power_supply *psy,
	62	enum power_supply_property psp,
	63	union power_supply_propval *val)
	64	{
	65	struct wm831x_power *wm831x_power = dev_get_drvdata(psy->dev->parent);
	66	struct wm831x *wm831x = wm831x_power->wm831x;
	67	int ret = 0;
	68
	69	switch (psp) {
	70	case POWER_SUPPLY_PROP_ONLINE:
	71	ret = wm831x_power_check_online(wm831x, WM831X_PWR_WALL, val);
	72	break;
	73	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
	74	ret = wm831x_power_read_voltage(wm831x, WM831X_AUX_WALL, val);
	75	break;
	76	default:
	77	ret = -EINVAL;
	78	break;
	79	}
	80
	81	return ret;
	82	}
	83
	84	static enum power_supply_property wm831x_wall_props[] = {
	85	POWER_SUPPLY_PROP_ONLINE,
	86	POWER_SUPPLY_PROP_VOLTAGE_NOW,
	87	};
88
89	/*********************************************************************
90	* USB Power
91	*********************************************************************/
92	static int wm831x_usb_get_prop(struct power_supply *psy,
93	enum power_supply_property psp,
94	union power_supply_propval *val)
95	{
96	struct wm831x_power *wm831x_power = dev_get_drvdata(psy->dev->parent);
97	struct wm831x *wm831x = wm831x_power->wm831x;
98	int ret = 0;
99
100	switch (psp) {
101	case POWER_SUPPLY_PROP_ONLINE:
102	ret = wm831x_power_check_online(wm831x, WM831X_PWR_USB, val);
103	break;
104	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
105	ret = wm831x_power_read_voltage(wm831x, WM831X_AUX_USB, val);
106	break;
107	default:
108	ret = -EINVAL;
109	break;
110	}
111
112	return ret;
113	}
114
115	static enum power_supply_property wm831x_usb_props[] = {
116	POWER_SUPPLY_PROP_ONLINE,
117	POWER_SUPPLY_PROP_VOLTAGE_NOW,
118	};
119
120	/*********************************************************************
121	* Battery properties
122	*********************************************************************/
123
124	struct chg_map {
125	int val;
126	int reg_val;
127	};
128
129	static struct chg_map trickle_ilims[] = {
130	{ 50, 0 << WM831X_CHG_TRKL_ILIM_SHIFT },
131	{ 100, 1 << WM831X_CHG_TRKL_ILIM_SHIFT },
132	{ 150, 2 << WM831X_CHG_TRKL_ILIM_SHIFT },
133	{ 200, 3 << WM831X_CHG_TRKL_ILIM_SHIFT },
134	};
135
136	static struct chg_map vsels[] = {
137	{ 4050, 0 << WM831X_CHG_VSEL_SHIFT },
138	{ 4100, 1 << WM831X_CHG_VSEL_SHIFT },
139	{ 4150, 2 << WM831X_CHG_VSEL_SHIFT },
140	{ 4200, 3 << WM831X_CHG_VSEL_SHIFT },
141	};
142
143	static struct chg_map fast_ilims[] = {
144	{ 0, 0 << WM831X_CHG_FAST_ILIM_SHIFT },
145	{ 50, 1 << WM831X_CHG_FAST_ILIM_SHIFT },
146	{ 100, 2 << WM831X_CHG_FAST_ILIM_SHIFT },
147	{ 150, 3 << WM831X_CHG_FAST_ILIM_SHIFT },
148	{ 200, 4 << WM831X_CHG_FAST_ILIM_SHIFT },
149	{ 250, 5 << WM831X_CHG_FAST_ILIM_SHIFT },
150	{ 300, 6 << WM831X_CHG_FAST_ILIM_SHIFT },
151	{ 350, 7 << WM831X_CHG_FAST_ILIM_SHIFT },
152	{ 400, 8 << WM831X_CHG_FAST_ILIM_SHIFT },
153	{ 450, 9 << WM831X_CHG_FAST_ILIM_SHIFT },
154	{ 500, 10 << WM831X_CHG_FAST_ILIM_SHIFT },
155	{ 600, 11 << WM831X_CHG_FAST_ILIM_SHIFT },
156	{ 700, 12 << WM831X_CHG_FAST_ILIM_SHIFT },
157	{ 800, 13 << WM831X_CHG_FAST_ILIM_SHIFT },
158	{ 900, 14 << WM831X_CHG_FAST_ILIM_SHIFT },
159	{ 1000, 15 << WM831X_CHG_FAST_ILIM_SHIFT },
160	};
161
162	static struct chg_map eoc_iterms[] = {
163	{ 20, 0 << WM831X_CHG_ITERM_SHIFT },
164	{ 30, 1 << WM831X_CHG_ITERM_SHIFT },
165	{ 40, 2 << WM831X_CHG_ITERM_SHIFT },
166	{ 50, 3 << WM831X_CHG_ITERM_SHIFT },
167	{ 60, 4 << WM831X_CHG_ITERM_SHIFT },
168	{ 70, 5 << WM831X_CHG_ITERM_SHIFT },
169	{ 80, 6 << WM831X_CHG_ITERM_SHIFT },
170	{ 90, 7 << WM831X_CHG_ITERM_SHIFT },
171	};
172
173	static struct chg_map chg_times[] = {
174	{ 60, 0 << WM831X_CHG_TIME_SHIFT },
175	{ 90, 1 << WM831X_CHG_TIME_SHIFT },
176	{ 120, 2 << WM831X_CHG_TIME_SHIFT },
177	{ 150, 3 << WM831X_CHG_TIME_SHIFT },
178	{ 180, 4 << WM831X_CHG_TIME_SHIFT },
179	{ 210, 5 << WM831X_CHG_TIME_SHIFT },
180	{ 240, 6 << WM831X_CHG_TIME_SHIFT },
181	{ 270, 7 << WM831X_CHG_TIME_SHIFT },
182	{ 300, 8 << WM831X_CHG_TIME_SHIFT },
183	{ 330, 9 << WM831X_CHG_TIME_SHIFT },
184	{ 360, 10 << WM831X_CHG_TIME_SHIFT },
185	{ 390, 11 << WM831X_CHG_TIME_SHIFT },
186	{ 420, 12 << WM831X_CHG_TIME_SHIFT },
187	{ 450, 13 << WM831X_CHG_TIME_SHIFT },
188	{ 480, 14 << WM831X_CHG_TIME_SHIFT },
189	{ 510, 15 << WM831X_CHG_TIME_SHIFT },
190	};
191
192	static void wm831x_battey_apply_config(struct wm831x *wm831x,
193	struct chg_map *map, int count, int val,
194	int reg, const char name,
195	const char *units)
196	{
197	int i;
198
199	for (i = 0; i < count; i++)
200	if (val == map[i].val)
201	break;
202	if (i == count) {
203	dev_err(wm831x->dev, "Invalid %s %d%s\n",
204	name, val, units);
205	} else {
206	*reg \|= map[i].reg_val;
207	dev_dbg(wm831x->dev, "Set %s of %d%s\n", name, val, units);
208	}
209	}
210
211	static void wm831x_config_battery(struct wm831x *wm831x)
212	{
213	struct wm831x_pdata *wm831x_pdata = wm831x->dev->platform_data;
214	struct wm831x_battery_pdata *pdata;
215	int ret, reg1, reg2;
216
217	if (!wm831x_pdata \|\| !wm831x_pdata->battery) {
218	dev_warn(wm831x->dev,
219	"No battery charger configuration\n");
220	return;
221	}
222
223	pdata = wm831x_pdata->battery;
224
225	reg1 = 0;
226	reg2 = 0;
227
228	if (!pdata->enable) {
229	dev_info(wm831x->dev, "Battery charger disabled\n");
230	return;
231	}
232
233	reg1 \|= WM831X_CHG_ENA;
234	if (pdata->off_mask)
235	reg2 \|= WM831X_CHG_OFF_MSK;
236	if (pdata->fast_enable)
237	reg1 \|= WM831X_CHG_FAST;
238
239	wm831x_battey_apply_config(wm831x, trickle_ilims,
240	ARRAY_SIZE(trickle_ilims),
241	pdata->trickle_ilim, &reg2,
242	"trickle charge current limit", "mA");
243
244	wm831x_battey_apply_config(wm831x, vsels, ARRAY_SIZE(vsels),
245	pdata->vsel, &reg2,
246	"target voltage", "mV");
247
248	wm831x_battey_apply_config(wm831x, fast_ilims, ARRAY_SIZE(fast_ilims),
249	pdata->fast_ilim, &reg2,
250	"fast charge current limit", "mA");
251
252	wm831x_battey_apply_config(wm831x, eoc_iterms, ARRAY_SIZE(eoc_iterms),
253	pdata->eoc_iterm, &reg1,
254	"end of charge current threshold", "mA");
255
256	wm831x_battey_apply_config(wm831x, chg_times, ARRAY_SIZE(chg_times),
257	pdata->timeout, &reg2,
258	"charger timeout", "min");
259
260	ret = wm831x_reg_unlock(wm831x);
261	if (ret != 0) {
262	dev_err(wm831x->dev, "Failed to unlock registers: %d\n", ret);
263	return;
264	}
265
266	ret = wm831x_set_bits(wm831x, WM831X_CHARGER_CONTROL_1,
267	WM831X_CHG_ENA_MASK \|
268	WM831X_CHG_FAST_MASK \|
269	WM831X_CHG_ITERM_MASK \|
270	WM831X_CHG_ITERM_MASK,
271	reg1);
272	if (ret != 0)
273	dev_err(wm831x->dev, "Failed to set charger control 1: %d\n",
274	ret);
275
276	ret = wm831x_set_bits(wm831x, WM831X_CHARGER_CONTROL_2,
277	WM831X_CHG_OFF_MSK \|
278	WM831X_CHG_TIME_MASK \|
279	WM831X_CHG_FAST_ILIM_MASK \|
280	WM831X_CHG_TRKL_ILIM_MASK \|
281	WM831X_CHG_VSEL_MASK,
282	reg2);
283	if (ret != 0)
284	dev_err(wm831x->dev, "Failed to set charger control 2: %d\n",
285	ret);
286
287	wm831x_reg_lock(wm831x);
288	}
289
290	static int wm831x_bat_check_status(struct wm831x wm831x, int status)
291	{
292	int ret;
293
294	ret = wm831x_reg_read(wm831x, WM831X_SYSTEM_STATUS);
295	if (ret < 0)
296	return ret;
297
298	if (ret & WM831X_PWR_SRC_BATT) {
299	*status = POWER_SUPPLY_STATUS_DISCHARGING;
300	return 0;
301	}
302
303	ret = wm831x_reg_read(wm831x, WM831X_CHARGER_STATUS);
304	if (ret < 0)
305	return ret;
306
307	switch (ret & WM831X_CHG_STATE_MASK) {
308	case WM831X_CHG_STATE_OFF:
309	*status = POWER_SUPPLY_STATUS_NOT_CHARGING;
310	break;
311	case WM831X_CHG_STATE_TRICKLE:
312	case WM831X_CHG_STATE_FAST:
313	*status = POWER_SUPPLY_STATUS_CHARGING;
314	break;
315
316	default:
317	*status = POWER_SUPPLY_STATUS_UNKNOWN;
318	break;
319	}
320
321	return 0;
322	}
323
324	static int wm831x_bat_check_type(struct wm831x wm831x, int type)
325	{
326	int ret;
327
328	ret = wm831x_reg_read(wm831x, WM831X_CHARGER_STATUS);
329	if (ret < 0)
330	return ret;
331
332	switch (ret & WM831X_CHG_STATE_MASK) {
333	case WM831X_CHG_STATE_TRICKLE:
334	case WM831X_CHG_STATE_TRICKLE_OT:
335	*type = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
336	break;
337	case WM831X_CHG_STATE_FAST:
338	case WM831X_CHG_STATE_FAST_OT:
339	*type = POWER_SUPPLY_CHARGE_TYPE_FAST;
340	break;
341	default:
342	*type = POWER_SUPPLY_CHARGE_TYPE_NONE;
343	break;
344	}
345
346	return 0;
347	}
348
349	static int wm831x_bat_check_health(struct wm831x wm831x, int health)
350	{
351	int ret;
352
353	ret = wm831x_reg_read(wm831x, WM831X_CHARGER_STATUS);
354	if (ret < 0)
355	return ret;
356
357	if (ret & WM831X_BATT_HOT_STS) {
358	*health = POWER_SUPPLY_HEALTH_OVERHEAT;
359	return 0;
360	}
361
362	if (ret & WM831X_BATT_COLD_STS) {
363	*health = POWER_SUPPLY_HEALTH_COLD;
364	return 0;
365	}
366
367	if (ret & WM831X_BATT_OV_STS) {
368	*health = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
369	return 0;
370	}
371
372	switch (ret & WM831X_CHG_STATE_MASK) {
373	case WM831X_CHG_STATE_TRICKLE_OT:
374	case WM831X_CHG_STATE_FAST_OT:
375	*health = POWER_SUPPLY_HEALTH_OVERHEAT;
376	break;
377	case WM831X_CHG_STATE_DEFECTIVE:
378	*health = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
379	break;
380	default:
381	*health = POWER_SUPPLY_HEALTH_GOOD;
382	break;
383	}
384
385	return 0;
386	}
387
388	static int wm831x_bat_get_prop(struct power_supply *psy,
389	enum power_supply_property psp,
390	union power_supply_propval *val)
391	{
392	struct wm831x_power *wm831x_power = dev_get_drvdata(psy->dev->parent);
393	struct wm831x *wm831x = wm831x_power->wm831x;
394	int ret = 0;
395
396	switch (psp) {
397	case POWER_SUPPLY_PROP_STATUS:
398	ret = wm831x_bat_check_status(wm831x, &val->intval);
399	break;
400	case POWER_SUPPLY_PROP_ONLINE:
401	ret = wm831x_power_check_online(wm831x, WM831X_PWR_SRC_BATT,
402	val);
403	break;
404	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
405	ret = wm831x_power_read_voltage(wm831x, WM831X_AUX_BATT, val);
406	break;
407	case POWER_SUPPLY_PROP_HEALTH:
408	ret = wm831x_bat_check_health(wm831x, &val->intval);
409	break;
410	case POWER_SUPPLY_PROP_CHARGE_TYPE:
411	ret = wm831x_bat_check_type(wm831x, &val->intval);
412	break;
413	default:
414	ret = -EINVAL;
415	break;
416	}
417
418	return ret;
419	}
420
421	static enum power_supply_property wm831x_bat_props[] = {
422	POWER_SUPPLY_PROP_STATUS,
423	POWER_SUPPLY_PROP_ONLINE,
424	POWER_SUPPLY_PROP_VOLTAGE_NOW,
425	POWER_SUPPLY_PROP_HEALTH,
426	POWER_SUPPLY_PROP_CHARGE_TYPE,
427	};
428
429	static const char *wm831x_bat_irqs[] = {
430	"BATT HOT",
431	"BATT COLD",
432	"BATT FAIL",
433	"OV",
434	"END",
435	"TO",
436	"MODE",
437	"START",
438	};
439
440	static irqreturn_t wm831x_bat_irq(int irq, void *data)
441	{
442	struct wm831x_power *wm831x_power = data;
443	struct wm831x *wm831x = wm831x_power->wm831x;
444
445	dev_dbg(wm831x->dev, "Battery status changed: %d\n", irq);
446
447	/* The battery charger is autonomous so we don't need to do
448	* anything except kick user space */
449	power_supply_changed(&wm831x_power->battery);
450
451	return IRQ_HANDLED;
452	}
453
454
3961f7c3 MB	455	/*********************************************************************
	456	* Initialisation
	457	*********************************************************************/
	458
	459	static irqreturn_t wm831x_syslo_irq(int irq, void *data)
	460	{
	461	struct wm831x_power *wm831x_power = data;
	462	struct wm831x *wm831x = wm831x_power->wm831x;
	463
	464	/* Not much we can actually do but tell people for
	465	* posterity, we're probably about to run out of power. */
	466	dev_crit(wm831x->dev, "SYSVDD under voltage\n");
	467
	468	return IRQ_HANDLED;
	469	}
	470
	471	static irqreturn_t wm831x_pwr_src_irq(int irq, void *data)
	472	{
	473	struct wm831x_power *wm831x_power = data;
	474	struct wm831x *wm831x = wm831x_power->wm831x;
	475
	476	dev_dbg(wm831x->dev, "Power source changed\n");
	477
c26964ea	478	/* Just notify for everything - little harm in overnotifying. */
3961f7c3 MB	479	power_supply_changed(&wm831x_power->battery);
	480	power_supply_changed(&wm831x_power->usb);
	481	power_supply_changed(&wm831x_power->wall);
	482
	483	return IRQ_HANDLED;
	484	}
	485
	486	static __devinit int wm831x_power_probe(struct platform_device *pdev)
	487	{
	488	struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
	489	struct wm831x_power *power;
	490	struct power_supply *usb;
	491	struct power_supply *battery;
	492	struct power_supply *wall;
3961f7c3 MB	493	int ret, irq, i;
	494
	495	power = kzalloc(sizeof(struct wm831x_power), GFP_KERNEL);
	496	if (power == NULL)
	497	return -ENOMEM;
	498
	499	power->wm831x = wm831x;
	500	platform_set_drvdata(pdev, power);
	501
	502	usb = &power->usb;
	503	battery = &power->battery;
	504	wall = &power->wall;
3961f7c3 MB	505
3961f7c3 MB	506	/* We ignore configuration failures since we can still read back
c26964ea	507	* the status without enabling the charger.
3961f7c3 MB	508	*/
3961f7c3 MB	509	wm831x_config_battery(wm831x);
3961f7c3 MB	510
	511	wall->name = "wm831x-wall";
	512	wall->type = POWER_SUPPLY_TYPE_MAINS;
	513	wall->properties = wm831x_wall_props;
	514	wall->num_properties = ARRAY_SIZE(wm831x_wall_props);
	515	wall->get_property = wm831x_wall_get_prop;
	516	ret = power_supply_register(&pdev->dev, wall);
	517	if (ret)
	518	goto err_kmalloc;
	519
	520	battery->name = "wm831x-battery";
	521	battery->properties = wm831x_bat_props;
	522	battery->num_properties = ARRAY_SIZE(wm831x_bat_props);
	523	battery->get_property = wm831x_bat_get_prop;
	524	battery->use_for_apm = 1;
	525	ret = power_supply_register(&pdev->dev, battery);
	526	if (ret)
	527	goto err_wall;
	528
	529	usb->name = "wm831x-usb",
	530	usb->type = POWER_SUPPLY_TYPE_USB;
	531	usb->properties = wm831x_usb_props;
	532	usb->num_properties = ARRAY_SIZE(wm831x_usb_props);
	533	usb->get_property = wm831x_usb_get_prop;
	534	ret = power_supply_register(&pdev->dev, usb);
	535	if (ret)
	536	goto err_battery;
	537
3961f7c3	538	irq = platform_get_irq_byname(pdev, "SYSLO");
b5874f33 MB	539	ret = request_threaded_irq(irq, NULL, wm831x_syslo_irq,
	540	IRQF_TRIGGER_RISING, "System power low",
	541	power);
3961f7c3 MB	542	if (ret != 0) {
	543	dev_err(&pdev->dev, "Failed to request SYSLO IRQ %d: %d\n",
	544	irq, ret);
c26964ea	545	goto err_usb;
3961f7c3 MB	546	}
	547
	548	irq = platform_get_irq_byname(pdev, "PWR SRC");
b5874f33 MB	549	ret = request_threaded_irq(irq, NULL, wm831x_pwr_src_irq,
	550	IRQF_TRIGGER_RISING, "Power source",
	551	power);
3961f7c3 MB	552	if (ret != 0) {
	553	dev_err(&pdev->dev, "Failed to request PWR SRC IRQ %d: %d\n",
	554	irq, ret);
	555	goto err_syslo;
	556	}
	557
	558	for (i = 0; i < ARRAY_SIZE(wm831x_bat_irqs); i++) {
	559	irq = platform_get_irq_byname(pdev, wm831x_bat_irqs[i]);
b5874f33 MB	560	ret = request_threaded_irq(irq, NULL, wm831x_bat_irq,
	561	IRQF_TRIGGER_RISING,
	562	wm831x_bat_irqs[i],
	563	power);
3961f7c3 MB	564	if (ret != 0) {
	565	dev_err(&pdev->dev,
	566	"Failed to request %s IRQ %d: %d\n",
	567	wm831x_bat_irqs[i], irq, ret);
	568	goto err_bat_irq;
	569	}
	570	}
	571
	572	return ret;
	573
	574	err_bat_irq:
	575	for (; i >= 0; i--) {
	576	irq = platform_get_irq_byname(pdev, wm831x_bat_irqs[i]);
b5874f33	577	free_irq(irq, power);
3961f7c3 MB	578	}
3961f7c3 MB	579	irq = platform_get_irq_byname(pdev, "PWR SRC");
b5874f33	580	free_irq(irq, power);
3961f7c3 MB	581	err_syslo:
3961f7c3 MB	582	irq = platform_get_irq_byname(pdev, "SYSLO");
b5874f33	583	free_irq(irq, power);
3961f7c3 MB	584	err_usb:
	585	power_supply_unregister(usb);
	586	err_battery:
	587	power_supply_unregister(battery);
	588	err_wall:
	589	power_supply_unregister(wall);
	590	err_kmalloc:
	591	kfree(power);
	592	return ret;
	593	}
	594
	595	static __devexit int wm831x_power_remove(struct platform_device *pdev)
	596	{
	597	struct wm831x_power *wm831x_power = platform_get_drvdata(pdev);
3961f7c3 MB	598	int irq, i;
	599
	600	for (i = 0; i < ARRAY_SIZE(wm831x_bat_irqs); i++) {
	601	irq = platform_get_irq_byname(pdev, wm831x_bat_irqs[i]);
b5874f33	602	free_irq(irq, wm831x_power);
3961f7c3 MB	603	}
	604
	605	irq = platform_get_irq_byname(pdev, "PWR SRC");
b5874f33	606	free_irq(irq, wm831x_power);
3961f7c3 MB	607
3961f7c3 MB	608	irq = platform_get_irq_byname(pdev, "SYSLO");
b5874f33	609	free_irq(irq, wm831x_power);
3961f7c3	610
3961f7c3 MB	611	power_supply_unregister(&wm831x_power->battery);
	612	power_supply_unregister(&wm831x_power->wall);
	613	power_supply_unregister(&wm831x_power->usb);
	614	return 0;
	615	}
	616
	617	static struct platform_driver wm831x_power_driver = {
	618	.probe = wm831x_power_probe,
	619	.remove = __devexit_p(wm831x_power_remove),
	620	.driver = {
	621	.name = "wm831x-power",
	622	},
	623	};
	624
	625	static int __init wm831x_power_init(void)
	626	{
	627	return platform_driver_register(&wm831x_power_driver);
	628	}
	629	module_init(wm831x_power_init);
	630
	631	static void __exit wm831x_power_exit(void)
	632	{
	633	platform_driver_unregister(&wm831x_power_driver);
	634	}
	635	module_exit(wm831x_power_exit);
	636
	637	MODULE_DESCRIPTION("Power supply driver for WM831x PMICs");
	638	MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
	639	MODULE_LICENSE("GPL");
	640	MODULE_ALIAS("platform:wm831x-power");