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

/*
 * Battery driver for wm8350 PMIC
 *
 * Copyright 2007, 2008 Wolfson Microelectronics PLC.
 *
 * Based on OLPC Battery Driver
 *
 * Copyright 2006  David Woodhouse <dwmw2@infradead.org>
 *
 * 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/wm8350/supply.h>
#include <linux/mfd/wm8350/core.h>
#include <linux/mfd/wm8350/comparator.h>

static int wm8350_read_battery_uvolts(struct wm8350 *wm8350)
{
	return wm8350_read_auxadc(wm8350, WM8350_AUXADC_BATT, 0, 0)
		* WM8350_AUX_COEFF;
}

static int wm8350_read_line_uvolts(struct wm8350 *wm8350)
{
	return wm8350_read_auxadc(wm8350, WM8350_AUXADC_LINE, 0, 0)
		* WM8350_AUX_COEFF;
}

static int wm8350_read_usb_uvolts(struct wm8350 *wm8350)
{
	return wm8350_read_auxadc(wm8350, WM8350_AUXADC_USB, 0, 0)
		* WM8350_AUX_COEFF;
}

#define WM8350_BATT_SUPPLY	1
#define WM8350_USB_SUPPLY	2
#define WM8350_LINE_SUPPLY	4

static inline int wm8350_charge_time_min(struct wm8350 *wm8350, int min)
{
	if (!wm8350->power.rev_g_coeff)
		return (((min - 30) / 15) & 0xf) << 8;
	else
		return (((min - 30) / 30) & 0xf) << 8;
}

static int wm8350_get_supplies(struct wm8350 *wm8350)
{
	u16 sm, ov, co, chrg;
	int supplies = 0;

	sm = wm8350_reg_read(wm8350, WM8350_STATE_MACHINE_STATUS);
	ov = wm8350_reg_read(wm8350, WM8350_MISC_OVERRIDES);
	co = wm8350_reg_read(wm8350, WM8350_COMPARATOR_OVERRIDES);
	chrg = wm8350_reg_read(wm8350, WM8350_BATTERY_CHARGER_CONTROL_2);

	/* USB_SM */
	sm = (sm & WM8350_USB_SM_MASK) >> WM8350_USB_SM_SHIFT;

	/* CHG_ISEL */
	chrg &= WM8350_CHG_ISEL_MASK;

	/* If the USB state machine is active then we're using that with or
	 * without battery, otherwise check for wall supply */
	if (((sm == WM8350_USB_SM_100_SLV) ||
	     (sm == WM8350_USB_SM_500_SLV) ||
	     (sm == WM8350_USB_SM_STDBY_SLV))
	    && !(ov & WM8350_USB_LIMIT_OVRDE))
		supplies = WM8350_USB_SUPPLY;
	else if (((sm == WM8350_USB_SM_100_SLV) ||
		  (sm == WM8350_USB_SM_500_SLV) ||
		  (sm == WM8350_USB_SM_STDBY_SLV))
		 && (ov & WM8350_USB_LIMIT_OVRDE) && (chrg == 0))
		supplies = WM8350_USB_SUPPLY | WM8350_BATT_SUPPLY;
	else if (co & WM8350_WALL_FB_OVRDE)
		supplies = WM8350_LINE_SUPPLY;
	else
		supplies = WM8350_BATT_SUPPLY;

	return supplies;
}

static int wm8350_charger_config(struct wm8350 *wm8350,
				 struct wm8350_charger_policy *policy)
{
	u16 reg, eoc_mA, fast_limit_mA;

	if (!policy) {
		dev_warn(wm8350->dev,
			 "No charger policy, charger not configured.\n");
		return -EINVAL;
	}

	/* make sure USB fast charge current is not > 500mA */
	if (policy->fast_limit_USB_mA > 500) {
		dev_err(wm8350->dev, "USB fast charge > 500mA\n");
		return -EINVAL;
	}

	eoc_mA = WM8350_CHG_EOC_mA(policy->eoc_mA);

	wm8350_reg_unlock(wm8350);

	reg = wm8350_reg_read(wm8350, WM8350_BATTERY_CHARGER_CONTROL_1)
		& WM8350_CHG_ENA_R168;
	wm8350_reg_write(wm8350, WM8350_BATTERY_CHARGER_CONTROL_1,
			 reg | eoc_mA | policy->trickle_start_mV |
			 WM8350_CHG_TRICKLE_TEMP_CHOKE |
			 WM8350_CHG_TRICKLE_USB_CHOKE |
			 WM8350_CHG_FAST_USB_THROTTLE);

	if (wm8350_get_supplies(wm8350) & WM8350_USB_SUPPLY) {
		fast_limit_mA =
			WM8350_CHG_FAST_LIMIT_mA(policy->fast_limit_USB_mA);
		wm8350_reg_write(wm8350, WM8350_BATTERY_CHARGER_CONTROL_2,
			    policy->charge_mV | policy->trickle_charge_USB_mA |
			    fast_limit_mA | wm8350_charge_time_min(wm8350,
						policy->charge_timeout));

	} else {
		fast_limit_mA =
			WM8350_CHG_FAST_LIMIT_mA(policy->fast_limit_mA);
		wm8350_reg_write(wm8350, WM8350_BATTERY_CHARGER_CONTROL_2,
			    policy->charge_mV | policy->trickle_charge_mA |
			    fast_limit_mA | wm8350_charge_time_min(wm8350,
						policy->charge_timeout));
	}

	wm8350_reg_lock(wm8350);
	return 0;
}

static int wm8350_batt_status(struct wm8350 *wm8350)
{
	u16 state;

	state = wm8350_reg_read(wm8350, WM8350_BATTERY_CHARGER_CONTROL_2);
	state &= WM8350_CHG_STS_MASK;

	switch (state) {
	case WM8350_CHG_STS_OFF:
		return POWER_SUPPLY_STATUS_DISCHARGING;

	case WM8350_CHG_STS_TRICKLE:
	case WM8350_CHG_STS_FAST:
		return POWER_SUPPLY_STATUS_CHARGING;

	default:
		return POWER_SUPPLY_STATUS_UNKNOWN;
	}
}

static ssize_t charger_state_show(struct device *dev,
				 struct device_attribute *attr, char *buf)
{
	struct wm8350 *wm8350 = dev_get_drvdata(dev);
	char *charge;
	int state;

	state = wm8350_reg_read(wm8350, WM8350_BATTERY_CHARGER_CONTROL_2) &
	    WM8350_CHG_STS_MASK;
	switch (state) {
	case WM8350_CHG_STS_OFF:
		charge = "Charger Off";
		break;
	case WM8350_CHG_STS_TRICKLE:
		charge = "Trickle Charging";
		break;
	case WM8350_CHG_STS_FAST:
		charge = "Fast Charging";
		break;
	default:
		return 0;
	}

	return sprintf(buf, "%s\n", charge);
}

static DEVICE_ATTR(charger_state, 0444, charger_state_show, NULL);

static irqreturn_t wm8350_charger_handler(int irq, void *data)
{
	struct wm8350 *wm8350 = data;
	struct wm8350_power *power = &wm8350->power;
	struct wm8350_charger_policy *policy = power->policy;

	switch (irq - wm8350->irq_base) {
	case WM8350_IRQ_CHG_BAT_FAIL:
		dev_err(wm8350->dev, "battery failed\n");
		break;
	case WM8350_IRQ_CHG_TO:
		dev_err(wm8350->dev, "charger timeout\n");
		power_supply_changed(&power->battery);
		break;

	case WM8350_IRQ_CHG_BAT_HOT:
	case WM8350_IRQ_CHG_BAT_COLD:
	case WM8350_IRQ_CHG_START:
	case WM8350_IRQ_CHG_END:
		power_supply_changed(&power->battery);
		break;

	case WM8350_IRQ_CHG_FAST_RDY:
		dev_dbg(wm8350->dev, "fast charger ready\n");
		wm8350_charger_config(wm8350, policy);
		wm8350_reg_unlock(wm8350);
		wm8350_set_bits(wm8350, WM8350_BATTERY_CHARGER_CONTROL_1,
				WM8350_CHG_FAST);
		wm8350_reg_lock(wm8350);
		break;

	case WM8350_IRQ_CHG_VBATT_LT_3P9:
		dev_warn(wm8350->dev, "battery < 3.9V\n");
		break;
	case WM8350_IRQ_CHG_VBATT_LT_3P1:
		dev_warn(wm8350->dev, "battery < 3.1V\n");
		break;
	case WM8350_IRQ_CHG_VBATT_LT_2P85:
		dev_warn(wm8350->dev, "battery < 2.85V\n");
		break;

		/* Supply change.  We will overnotify but it should do
		 * no harm. */
	case WM8350_IRQ_EXT_USB_FB:
	case WM8350_IRQ_EXT_WALL_FB:
		wm8350_charger_config(wm8350, policy);
	case WM8350_IRQ_EXT_BAT_FB:   /* Fall through */
		power_supply_changed(&power->battery);
		power_supply_changed(&power->usb);
		power_supply_changed(&power->ac);
		break;

	default:
		dev_err(wm8350->dev, "Unknown interrupt %d\n", irq);
	}

	return IRQ_HANDLED;
}

/*********************************************************************
 *		AC Power
 *********************************************************************/
static int wm8350_ac_get_prop(struct power_supply *psy,
			      enum power_supply_property psp,
			      union power_supply_propval *val)
{
	struct wm8350 *wm8350 = dev_get_drvdata(psy->dev->parent);
	int ret = 0;

	switch (psp) {
	case POWER_SUPPLY_PROP_ONLINE:
		val->intval = !!(wm8350_get_supplies(wm8350) &
				 WM8350_LINE_SUPPLY);
		break;
	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
		val->intval = wm8350_read_line_uvolts(wm8350);
		break;
	default:
		ret = -EINVAL;
		break;
	}
	return ret;
}

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

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

	switch (psp) {
	case POWER_SUPPLY_PROP_ONLINE:
		val->intval = !!(wm8350_get_supplies(wm8350) &
				 WM8350_USB_SUPPLY);
		break;
	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
		val->intval = wm8350_read_usb_uvolts(wm8350);
		break;
	default:
		ret = -EINVAL;
		break;
	}
	return ret;
}

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

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

static int wm8350_bat_check_health(struct wm8350 *wm8350)
{
	u16 reg;

	if (wm8350_read_battery_uvolts(wm8350) < 2850000)
		return POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;

	reg = wm8350_reg_read(wm8350, WM8350_CHARGER_OVERRIDES);
	if (reg & WM8350_CHG_BATT_HOT_OVRDE)
		return POWER_SUPPLY_HEALTH_OVERHEAT;

	if (reg & WM8350_CHG_BATT_COLD_OVRDE)
		return POWER_SUPPLY_HEALTH_COLD;

	return POWER_SUPPLY_HEALTH_GOOD;
}

static int wm8350_bat_get_charge_type(struct wm8350 *wm8350)
{
	int state;

	state = wm8350_reg_read(wm8350, WM8350_BATTERY_CHARGER_CONTROL_2) &
	    WM8350_CHG_STS_MASK;
	switch (state) {
	case WM8350_CHG_STS_OFF:
		return POWER_SUPPLY_CHARGE_TYPE_NONE;
	case WM8350_CHG_STS_TRICKLE:
		return POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
	case WM8350_CHG_STS_FAST:
		return POWER_SUPPLY_CHARGE_TYPE_FAST;
	default:
		return POWER_SUPPLY_CHARGE_TYPE_UNKNOWN;
	}
}

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

	switch (psp) {
	case POWER_SUPPLY_PROP_STATUS:
		val->intval = wm8350_batt_status(wm8350);
		break;
	case POWER_SUPPLY_PROP_ONLINE:
		val->intval = !!(wm8350_get_supplies(wm8350) &
				 WM8350_BATT_SUPPLY);
		break;
	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
		val->intval = wm8350_read_battery_uvolts(wm8350);
		break;
	case POWER_SUPPLY_PROP_HEALTH:
		val->intval = wm8350_bat_check_health(wm8350);
		break;
	case POWER_SUPPLY_PROP_CHARGE_TYPE:
		val->intval = wm8350_bat_get_charge_type(wm8350);
		break;
	default:
		ret = -EINVAL;
		break;
	}

	return ret;
}

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

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

static void wm8350_init_charger(struct wm8350 *wm8350)
{
	/* register our interest in charger events */
	wm8350_register_irq(wm8350, WM8350_IRQ_CHG_BAT_HOT,
			    wm8350_charger_handler, 0, "Battery hot", wm8350);
	wm8350_register_irq(wm8350, WM8350_IRQ_CHG_BAT_COLD,
			    wm8350_charger_handler, 0, "Battery cold", wm8350);
	wm8350_register_irq(wm8350, WM8350_IRQ_CHG_BAT_FAIL,
			    wm8350_charger_handler, 0, "Battery fail", wm8350);
	wm8350_register_irq(wm8350, WM8350_IRQ_CHG_TO,
			    wm8350_charger_handler, 0,
			    "Charger timeout", wm8350);
	wm8350_register_irq(wm8350, WM8350_IRQ_CHG_END,
			    wm8350_charger_handler, 0,
			    "Charge end", wm8350);
	wm8350_register_irq(wm8350, WM8350_IRQ_CHG_START,
			    wm8350_charger_handler, 0,
			    "Charge start", wm8350);
	wm8350_register_irq(wm8350, WM8350_IRQ_CHG_FAST_RDY,
			    wm8350_charger_handler, 0,
			    "Fast charge ready", wm8350);
	wm8350_register_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_3P9,
			    wm8350_charger_handler, 0,
			    "Battery <3.9V", wm8350);
	wm8350_register_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_3P1,
			    wm8350_charger_handler, 0,
			    "Battery <3.1V", wm8350);
	wm8350_register_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_2P85,
			    wm8350_charger_handler, 0,
			    "Battery <2.85V", wm8350);

	/* and supply change events */
	wm8350_register_irq(wm8350, WM8350_IRQ_EXT_USB_FB,
			    wm8350_charger_handler, 0, "USB", wm8350);
	wm8350_register_irq(wm8350, WM8350_IRQ_EXT_WALL_FB,
			    wm8350_charger_handler, 0, "Wall", wm8350);
	wm8350_register_irq(wm8350, WM8350_IRQ_EXT_BAT_FB,
			    wm8350_charger_handler, 0, "Battery", wm8350);
}

static void free_charger_irq(struct wm8350 *wm8350)
{
	wm8350_free_irq(wm8350, WM8350_IRQ_CHG_BAT_HOT, wm8350);
	wm8350_free_irq(wm8350, WM8350_IRQ_CHG_BAT_COLD, wm8350);
	wm8350_free_irq(wm8350, WM8350_IRQ_CHG_BAT_FAIL, wm8350);
	wm8350_free_irq(wm8350, WM8350_IRQ_CHG_TO, wm8350);
	wm8350_free_irq(wm8350, WM8350_IRQ_CHG_END, wm8350);
	wm8350_free_irq(wm8350, WM8350_IRQ_CHG_START, wm8350);
	wm8350_free_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_3P9, wm8350);
	wm8350_free_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_3P1, wm8350);
	wm8350_free_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_2P85, wm8350);
	wm8350_free_irq(wm8350, WM8350_IRQ_EXT_USB_FB, wm8350);
	wm8350_free_irq(wm8350, WM8350_IRQ_EXT_WALL_FB, wm8350);
	wm8350_free_irq(wm8350, WM8350_IRQ_EXT_BAT_FB, wm8350);
}

static __devinit int wm8350_power_probe(struct platform_device *pdev)
{
	struct wm8350 *wm8350 = platform_get_drvdata(pdev);
	struct wm8350_power *power = &wm8350->power;
	struct wm8350_charger_policy *policy = power->policy;
	struct power_supply *usb = &power->usb;
	struct power_supply *battery = &power->battery;
	struct power_supply *ac = &power->ac;
	int ret;

	ac->name = "wm8350-ac";
	ac->type = POWER_SUPPLY_TYPE_MAINS;
	ac->properties = wm8350_ac_props;
	ac->num_properties = ARRAY_SIZE(wm8350_ac_props);
	ac->get_property = wm8350_ac_get_prop;
	ret = power_supply_register(&pdev->dev, ac);
	if (ret)
		return ret;

	battery->name = "wm8350-battery";
	battery->properties = wm8350_bat_props;
	battery->num_properties = ARRAY_SIZE(wm8350_bat_props);
	battery->get_property = wm8350_bat_get_property;
	battery->use_for_apm = 1;
	ret = power_supply_register(&pdev->dev, battery);
	if (ret)
		goto battery_failed;

	usb->name = "wm8350-usb",
	usb->type = POWER_SUPPLY_TYPE_USB;
	usb->properties = wm8350_usb_props;
	usb->num_properties = ARRAY_SIZE(wm8350_usb_props);
	usb->get_property = wm8350_usb_get_prop;
	ret = power_supply_register(&pdev->dev, usb);
	if (ret)
		goto usb_failed;

	ret = device_create_file(&pdev->dev, &dev_attr_charger_state);
	if (ret < 0)
		dev_warn(wm8350->dev, "failed to add charge sysfs: %d\n", ret);
	ret = 0;

	wm8350_init_charger(wm8350);
	if (wm8350_charger_config(wm8350, policy) == 0) {
		wm8350_reg_unlock(wm8350);
		wm8350_set_bits(wm8350, WM8350_POWER_MGMT_5, WM8350_CHG_ENA);
		wm8350_reg_lock(wm8350);
	}

	return ret;

usb_failed:
	power_supply_unregister(battery);
battery_failed:
	power_supply_unregister(ac);

	return ret;
}

static __devexit int wm8350_power_remove(struct platform_device *pdev)
{
	struct wm8350 *wm8350 = platform_get_drvdata(pdev);
	struct wm8350_power *power = &wm8350->power;

	free_charger_irq(wm8350);
	device_remove_file(&pdev->dev, &dev_attr_charger_state);
	power_supply_unregister(&power->battery);
	power_supply_unregister(&power->ac);
	power_supply_unregister(&power->usb);
	return 0;
}

static struct platform_driver wm8350_power_driver = {
	.probe = wm8350_power_probe,
	.remove = __devexit_p(wm8350_power_remove),
	.driver = {
		.name = "wm8350-power",
	},
};

static int __init wm8350_power_init(void)
{
	return platform_driver_register(&wm8350_power_driver);
}
module_init(wm8350_power_init);

static void __exit wm8350_power_exit(void)
{
	platform_driver_unregister(&wm8350_power_driver);
}
module_exit(wm8350_power_exit);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Power supply driver for WM8350");
MODULE_ALIAS("platform:wm8350-power");
Commit	Line	Data
14431aa0 MB	1	/*
	2	* Battery driver for wm8350 PMIC
	3	*
	4	* Copyright 2007, 2008 Wolfson Microelectronics PLC.
	5	*
	6	* Based on OLPC Battery Driver
	7	*
	8	* Copyright 2006 David Woodhouse <dwmw2@infradead.org>
	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	#include <linux/module.h>
	16	#include <linux/err.h>
	17	#include <linux/platform_device.h>
	18	#include <linux/power_supply.h>
	19	#include <linux/mfd/wm8350/supply.h>
	20	#include <linux/mfd/wm8350/core.h>
	21	#include <linux/mfd/wm8350/comparator.h>
	22
	23	static int wm8350_read_battery_uvolts(struct wm8350 *wm8350)
	24	{
	25	return wm8350_read_auxadc(wm8350, WM8350_AUXADC_BATT, 0, 0)
	26	* WM8350_AUX_COEFF;
	27	}
	28
	29	static int wm8350_read_line_uvolts(struct wm8350 *wm8350)
	30	{
	31	return wm8350_read_auxadc(wm8350, WM8350_AUXADC_LINE, 0, 0)
	32	* WM8350_AUX_COEFF;
	33	}
	34
	35	static int wm8350_read_usb_uvolts(struct wm8350 *wm8350)
	36	{
	37	return wm8350_read_auxadc(wm8350, WM8350_AUXADC_USB, 0, 0)
	38	* WM8350_AUX_COEFF;
	39	}
	40
	41	#define WM8350_BATT_SUPPLY 1
	42	#define WM8350_USB_SUPPLY 2
	43	#define WM8350_LINE_SUPPLY 4
	44
	45	static inline int wm8350_charge_time_min(struct wm8350 *wm8350, int min)
	46	{
d756f4a4	47	if (!wm8350->power.rev_g_coeff)
14431aa0 MB	48	return (((min - 30) / 15) & 0xf) << 8;
	49	else
	50	return (((min - 30) / 30) & 0xf) << 8;
	51	}
	52
	53	static int wm8350_get_supplies(struct wm8350 *wm8350)
	54	{
	55	u16 sm, ov, co, chrg;
	56	int supplies = 0;
	57
	58	sm = wm8350_reg_read(wm8350, WM8350_STATE_MACHINE_STATUS);
	59	ov = wm8350_reg_read(wm8350, WM8350_MISC_OVERRIDES);
	60	co = wm8350_reg_read(wm8350, WM8350_COMPARATOR_OVERRIDES);
	61	chrg = wm8350_reg_read(wm8350, WM8350_BATTERY_CHARGER_CONTROL_2);
	62
	63	/* USB_SM */
	64	sm = (sm & WM8350_USB_SM_MASK) >> WM8350_USB_SM_SHIFT;
	65
	66	/* CHG_ISEL */
	67	chrg &= WM8350_CHG_ISEL_MASK;
	68
	69	/* If the USB state machine is active then we're using that with or
	70	* without battery, otherwise check for wall supply */
	71	if (((sm == WM8350_USB_SM_100_SLV) \|\|
	72	(sm == WM8350_USB_SM_500_SLV) \|\|
	73	(sm == WM8350_USB_SM_STDBY_SLV))
	74	&& !(ov & WM8350_USB_LIMIT_OVRDE))
	75	supplies = WM8350_USB_SUPPLY;
	76	else if (((sm == WM8350_USB_SM_100_SLV) \|\|
	77	(sm == WM8350_USB_SM_500_SLV) \|\|
	78	(sm == WM8350_USB_SM_STDBY_SLV))
	79	&& (ov & WM8350_USB_LIMIT_OVRDE) && (chrg == 0))
	80	supplies = WM8350_USB_SUPPLY \| WM8350_BATT_SUPPLY;
	81	else if (co & WM8350_WALL_FB_OVRDE)
	82	supplies = WM8350_LINE_SUPPLY;
	83	else
	84	supplies = WM8350_BATT_SUPPLY;
	85
	86	return supplies;
	87	}
	88
	89	static int wm8350_charger_config(struct wm8350 *wm8350,
	90	struct wm8350_charger_policy *policy)
	91	{
	92	u16 reg, eoc_mA, fast_limit_mA;
	93
	94	if (!policy) {
	95	dev_warn(wm8350->dev,
	96	"No charger policy, charger not configured.\n");
	97	return -EINVAL;
	98	}
	99
	100	/* make sure USB fast charge current is not > 500mA */
	101	if (policy->fast_limit_USB_mA > 500) {
	102	dev_err(wm8350->dev, "USB fast charge > 500mA\n");
	103	return -EINVAL;
	104	}
	105
	106	eoc_mA = WM8350_CHG_EOC_mA(policy->eoc_mA);
	107
	108	wm8350_reg_unlock(wm8350);
	109
	110	reg = wm8350_reg_read(wm8350, WM8350_BATTERY_CHARGER_CONTROL_1)
	111	& WM8350_CHG_ENA_R168;
112	wm8350_reg_write(wm8350, WM8350_BATTERY_CHARGER_CONTROL_1,
113	reg \| eoc_mA \| policy->trickle_start_mV \|
114	WM8350_CHG_TRICKLE_TEMP_CHOKE \|
115	WM8350_CHG_TRICKLE_USB_CHOKE \|
116	WM8350_CHG_FAST_USB_THROTTLE);
117
118	if (wm8350_get_supplies(wm8350) & WM8350_USB_SUPPLY) {
119	fast_limit_mA =
120	WM8350_CHG_FAST_LIMIT_mA(policy->fast_limit_USB_mA);
121	wm8350_reg_write(wm8350, WM8350_BATTERY_CHARGER_CONTROL_2,
122	policy->charge_mV \| policy->trickle_charge_USB_mA \|
123	fast_limit_mA \| wm8350_charge_time_min(wm8350,
124	policy->charge_timeout));
125
126	} else {
127	fast_limit_mA =
128	WM8350_CHG_FAST_LIMIT_mA(policy->fast_limit_mA);
129	wm8350_reg_write(wm8350, WM8350_BATTERY_CHARGER_CONTROL_2,
130	policy->charge_mV \| policy->trickle_charge_mA \|
131	fast_limit_mA \| wm8350_charge_time_min(wm8350,
132	policy->charge_timeout));
133	}
134
135	wm8350_reg_lock(wm8350);
136	return 0;
137	}
138
139	static int wm8350_batt_status(struct wm8350 *wm8350)
140	{
141	u16 state;
142
143	state = wm8350_reg_read(wm8350, WM8350_BATTERY_CHARGER_CONTROL_2);
144	state &= WM8350_CHG_STS_MASK;
145
146	switch (state) {
147	case WM8350_CHG_STS_OFF:
148	return POWER_SUPPLY_STATUS_DISCHARGING;
149
150	case WM8350_CHG_STS_TRICKLE:
151	case WM8350_CHG_STS_FAST:
152	return POWER_SUPPLY_STATUS_CHARGING;
153
154	default:
155	return POWER_SUPPLY_STATUS_UNKNOWN;
156	}
157	}
158
159	static ssize_t charger_state_show(struct device *dev,
160	struct device_attribute attr, char buf)
161	{
162	struct wm8350 *wm8350 = dev_get_drvdata(dev);
163	char *charge;
164	int state;
165
166	state = wm8350_reg_read(wm8350, WM8350_BATTERY_CHARGER_CONTROL_2) &
167	WM8350_CHG_STS_MASK;
168	switch (state) {
169	case WM8350_CHG_STS_OFF:
170	charge = "Charger Off";
171	break;
172	case WM8350_CHG_STS_TRICKLE:
173	charge = "Trickle Charging";
174	break;
175	case WM8350_CHG_STS_FAST:
176	charge = "Fast Charging";
177	break;
178	default:
179	return 0;
180	}
181
182	return sprintf(buf, "%s\n", charge);
183	}
184
185	static DEVICE_ATTR(charger_state, 0444, charger_state_show, NULL);
186
5a65edbc	187	static irqreturn_t wm8350_charger_handler(int irq, void *data)
14431aa0	188	{
5a65edbc	189	struct wm8350 *wm8350 = data;
14431aa0 MB	190	struct wm8350_power *power = &wm8350->power;
	191	struct wm8350_charger_policy *policy = power->policy;
	192
59f25070	193	switch (irq - wm8350->irq_base) {
14431aa0 MB	194	case WM8350_IRQ_CHG_BAT_FAIL:
	195	dev_err(wm8350->dev, "battery failed\n");
	196	break;
	197	case WM8350_IRQ_CHG_TO:
	198	dev_err(wm8350->dev, "charger timeout\n");
14431aa0 MB	199	power_supply_changed(&power->battery);
14431aa0 MB	200	break;
4008e879 MB	201
	202	case WM8350_IRQ_CHG_BAT_HOT:
	203	case WM8350_IRQ_CHG_BAT_COLD:
14431aa0	204	case WM8350_IRQ_CHG_START:
4008e879	205	case WM8350_IRQ_CHG_END:
14431aa0 MB	206	power_supply_changed(&power->battery);
	207	break;
	208
	209	case WM8350_IRQ_CHG_FAST_RDY:
	210	dev_dbg(wm8350->dev, "fast charger ready\n");
	211	wm8350_charger_config(wm8350, policy);
	212	wm8350_reg_unlock(wm8350);
	213	wm8350_set_bits(wm8350, WM8350_BATTERY_CHARGER_CONTROL_1,
	214	WM8350_CHG_FAST);
	215	wm8350_reg_lock(wm8350);
	216	break;
	217
	218	case WM8350_IRQ_CHG_VBATT_LT_3P9:
	219	dev_warn(wm8350->dev, "battery < 3.9V\n");
	220	break;
	221	case WM8350_IRQ_CHG_VBATT_LT_3P1:
	222	dev_warn(wm8350->dev, "battery < 3.1V\n");
	223	break;
	224	case WM8350_IRQ_CHG_VBATT_LT_2P85:
	225	dev_warn(wm8350->dev, "battery < 2.85V\n");
	226	break;
	227
	228	/* Supply change. We will overnotify but it should do
	229	* no harm. */
	230	case WM8350_IRQ_EXT_USB_FB:
	231	case WM8350_IRQ_EXT_WALL_FB:
	232	wm8350_charger_config(wm8350, policy);
	233	case WM8350_IRQ_EXT_BAT_FB: /* Fall through */
	234	power_supply_changed(&power->battery);
	235	power_supply_changed(&power->usb);
	236	power_supply_changed(&power->ac);
	237	break;
	238
	239	default:
	240	dev_err(wm8350->dev, "Unknown interrupt %d\n", irq);
	241	}
5a65edbc MB	242
5a65edbc MB	243	return IRQ_HANDLED;
14431aa0 MB	244	}
	245
	246	/*********************************************************************
	247	* AC Power
	248	*********************************************************************/
	249	static int wm8350_ac_get_prop(struct power_supply *psy,
	250	enum power_supply_property psp,
	251	union power_supply_propval *val)
	252	{
	253	struct wm8350 *wm8350 = dev_get_drvdata(psy->dev->parent);
	254	int ret = 0;
	255
	256	switch (psp) {
	257	case POWER_SUPPLY_PROP_ONLINE:
	258	val->intval = !!(wm8350_get_supplies(wm8350) &
	259	WM8350_LINE_SUPPLY);
	260	break;
	261	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
	262	val->intval = wm8350_read_line_uvolts(wm8350);
	263	break;
	264	default:
	265	ret = -EINVAL;
	266	break;
	267	}
	268	return ret;
	269	}
	270
	271	static enum power_supply_property wm8350_ac_props[] = {
	272	POWER_SUPPLY_PROP_ONLINE,
	273	POWER_SUPPLY_PROP_VOLTAGE_NOW,
	274	};
	275
	276	/*********************************************************************
	277	* USB Power
	278	*********************************************************************/
	279	static int wm8350_usb_get_prop(struct power_supply *psy,
	280	enum power_supply_property psp,
	281	union power_supply_propval *val)
	282	{
	283	struct wm8350 *wm8350 = dev_get_drvdata(psy->dev->parent);
	284	int ret = 0;
	285
	286	switch (psp) {
	287	case POWER_SUPPLY_PROP_ONLINE:
	288	val->intval = !!(wm8350_get_supplies(wm8350) &
	289	WM8350_USB_SUPPLY);
	290	break;
	291	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
	292	val->intval = wm8350_read_usb_uvolts(wm8350);
	293	break;
	294	default:
	295	ret = -EINVAL;
	296	break;
	297	}
	298	return ret;
	299	}
	300
	301	static enum power_supply_property wm8350_usb_props[] = {
	302	POWER_SUPPLY_PROP_ONLINE,
	303	POWER_SUPPLY_PROP_VOLTAGE_NOW,
	304	};
	305
	306	/*********************************************************************
	307	* Battery properties
308	*********************************************************************/
309
4008e879 MB	310	static int wm8350_bat_check_health(struct wm8350 *wm8350)
	311	{
	312	u16 reg;
	313
	314	if (wm8350_read_battery_uvolts(wm8350) < 2850000)
	315	return POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
	316
	317	reg = wm8350_reg_read(wm8350, WM8350_CHARGER_OVERRIDES);
	318	if (reg & WM8350_CHG_BATT_HOT_OVRDE)
	319	return POWER_SUPPLY_HEALTH_OVERHEAT;
	320
	321	if (reg & WM8350_CHG_BATT_COLD_OVRDE)
	322	return POWER_SUPPLY_HEALTH_COLD;
	323
	324	return POWER_SUPPLY_HEALTH_GOOD;
	325	}
	326
4aed03ae MB	327	static int wm8350_bat_get_charge_type(struct wm8350 *wm8350)
	328	{
	329	int state;
	330
	331	state = wm8350_reg_read(wm8350, WM8350_BATTERY_CHARGER_CONTROL_2) &
	332	WM8350_CHG_STS_MASK;
	333	switch (state) {
	334	case WM8350_CHG_STS_OFF:
	335	return POWER_SUPPLY_CHARGE_TYPE_NONE;
	336	case WM8350_CHG_STS_TRICKLE:
	337	return POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
	338	case WM8350_CHG_STS_FAST:
	339	return POWER_SUPPLY_CHARGE_TYPE_FAST;
	340	default:
	341	return POWER_SUPPLY_CHARGE_TYPE_UNKNOWN;
	342	}
	343	}
	344
14431aa0 MB	345	static int wm8350_bat_get_property(struct power_supply *psy,
	346	enum power_supply_property psp,
	347	union power_supply_propval *val)
	348	{
	349	struct wm8350 *wm8350 = dev_get_drvdata(psy->dev->parent);
	350	int ret = 0;
	351
	352	switch (psp) {
	353	case POWER_SUPPLY_PROP_STATUS:
	354	val->intval = wm8350_batt_status(wm8350);
	355	break;
	356	case POWER_SUPPLY_PROP_ONLINE:
	357	val->intval = !!(wm8350_get_supplies(wm8350) &
	358	WM8350_BATT_SUPPLY);
	359	break;
	360	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
	361	val->intval = wm8350_read_battery_uvolts(wm8350);
	362	break;
4008e879 MB	363	case POWER_SUPPLY_PROP_HEALTH:
	364	val->intval = wm8350_bat_check_health(wm8350);
	365	break;
4aed03ae MB	366	case POWER_SUPPLY_PROP_CHARGE_TYPE:
	367	val->intval = wm8350_bat_get_charge_type(wm8350);
	368	break;
14431aa0 MB	369	default:
	370	ret = -EINVAL;
	371	break;
	372	}
	373
	374	return ret;
	375	}
	376
	377	static enum power_supply_property wm8350_bat_props[] = {
	378	POWER_SUPPLY_PROP_STATUS,
	379	POWER_SUPPLY_PROP_ONLINE,
	380	POWER_SUPPLY_PROP_VOLTAGE_NOW,
4008e879	381	POWER_SUPPLY_PROP_HEALTH,
4aed03ae	382	POWER_SUPPLY_PROP_CHARGE_TYPE,
14431aa0 MB	383	};
	384
	385	/*********************************************************************
	386	* Initialisation
	387	*********************************************************************/
	388
	389	static void wm8350_init_charger(struct wm8350 *wm8350)
	390	{
	391	/* register our interest in charger events */
	392	wm8350_register_irq(wm8350, WM8350_IRQ_CHG_BAT_HOT,
5a65edbc	393	wm8350_charger_handler, 0, "Battery hot", wm8350);
14431aa0	394	wm8350_register_irq(wm8350, WM8350_IRQ_CHG_BAT_COLD,
5a65edbc	395	wm8350_charger_handler, 0, "Battery cold", wm8350);
14431aa0	396	wm8350_register_irq(wm8350, WM8350_IRQ_CHG_BAT_FAIL,
5a65edbc	397	wm8350_charger_handler, 0, "Battery fail", wm8350);
14431aa0	398	wm8350_register_irq(wm8350, WM8350_IRQ_CHG_TO,
5a65edbc MB	399	wm8350_charger_handler, 0,
5a65edbc MB	400	"Charger timeout", wm8350);
14431aa0	401	wm8350_register_irq(wm8350, WM8350_IRQ_CHG_END,
5a65edbc MB	402	wm8350_charger_handler, 0,
5a65edbc MB	403	"Charge end", wm8350);
14431aa0	404	wm8350_register_irq(wm8350, WM8350_IRQ_CHG_START,
5a65edbc MB	405	wm8350_charger_handler, 0,
5a65edbc MB	406	"Charge start", wm8350);
14431aa0	407	wm8350_register_irq(wm8350, WM8350_IRQ_CHG_FAST_RDY,
5a65edbc MB	408	wm8350_charger_handler, 0,
5a65edbc MB	409	"Fast charge ready", wm8350);
14431aa0	410	wm8350_register_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_3P9,
5a65edbc MB	411	wm8350_charger_handler, 0,
5a65edbc MB	412	"Battery <3.9V", wm8350);
14431aa0	413	wm8350_register_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_3P1,
5a65edbc MB	414	wm8350_charger_handler, 0,
5a65edbc MB	415	"Battery <3.1V", wm8350);
14431aa0	416	wm8350_register_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_2P85,
5a65edbc MB	417	wm8350_charger_handler, 0,
	418	"Battery <2.85V", wm8350);
	419
14431aa0 MB	420	/* and supply change events */
14431aa0 MB	421	wm8350_register_irq(wm8350, WM8350_IRQ_EXT_USB_FB,
5a65edbc	422	wm8350_charger_handler, 0, "USB", wm8350);
14431aa0	423	wm8350_register_irq(wm8350, WM8350_IRQ_EXT_WALL_FB,
5a65edbc	424	wm8350_charger_handler, 0, "Wall", wm8350);
14431aa0	425	wm8350_register_irq(wm8350, WM8350_IRQ_EXT_BAT_FB,
5a65edbc	426	wm8350_charger_handler, 0, "Battery", wm8350);
14431aa0 MB	427	}
	428
	429	static void free_charger_irq(struct wm8350 *wm8350)
	430	{
f99344fc MB	431	wm8350_free_irq(wm8350, WM8350_IRQ_CHG_BAT_HOT, wm8350);
	432	wm8350_free_irq(wm8350, WM8350_IRQ_CHG_BAT_COLD, wm8350);
	433	wm8350_free_irq(wm8350, WM8350_IRQ_CHG_BAT_FAIL, wm8350);
	434	wm8350_free_irq(wm8350, WM8350_IRQ_CHG_TO, wm8350);
	435	wm8350_free_irq(wm8350, WM8350_IRQ_CHG_END, wm8350);
	436	wm8350_free_irq(wm8350, WM8350_IRQ_CHG_START, wm8350);
	437	wm8350_free_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_3P9, wm8350);
	438	wm8350_free_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_3P1, wm8350);
	439	wm8350_free_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_2P85, wm8350);
	440	wm8350_free_irq(wm8350, WM8350_IRQ_EXT_USB_FB, wm8350);
	441	wm8350_free_irq(wm8350, WM8350_IRQ_EXT_WALL_FB, wm8350);
	442	wm8350_free_irq(wm8350, WM8350_IRQ_EXT_BAT_FB, wm8350);
14431aa0 MB	443	}
	444
	445	static __devinit int wm8350_power_probe(struct platform_device *pdev)
	446	{
	447	struct wm8350 *wm8350 = platform_get_drvdata(pdev);
	448	struct wm8350_power *power = &wm8350->power;
	449	struct wm8350_charger_policy *policy = power->policy;
	450	struct power_supply *usb = &power->usb;
	451	struct power_supply *battery = &power->battery;
	452	struct power_supply *ac = &power->ac;
	453	int ret;
	454
	455	ac->name = "wm8350-ac";
	456	ac->type = POWER_SUPPLY_TYPE_MAINS;
	457	ac->properties = wm8350_ac_props;
	458	ac->num_properties = ARRAY_SIZE(wm8350_ac_props);
	459	ac->get_property = wm8350_ac_get_prop;
	460	ret = power_supply_register(&pdev->dev, ac);
	461	if (ret)
	462	return ret;
	463
	464	battery->name = "wm8350-battery";
	465	battery->properties = wm8350_bat_props;
	466	battery->num_properties = ARRAY_SIZE(wm8350_bat_props);
	467	battery->get_property = wm8350_bat_get_property;
	468	battery->use_for_apm = 1;
	469	ret = power_supply_register(&pdev->dev, battery);
	470	if (ret)
	471	goto battery_failed;
	472
	473	usb->name = "wm8350-usb",
	474	usb->type = POWER_SUPPLY_TYPE_USB;
	475	usb->properties = wm8350_usb_props;
	476	usb->num_properties = ARRAY_SIZE(wm8350_usb_props);
	477	usb->get_property = wm8350_usb_get_prop;
	478	ret = power_supply_register(&pdev->dev, usb);
	479	if (ret)
	480	goto usb_failed;
	481
	482	ret = device_create_file(&pdev->dev, &dev_attr_charger_state);
	483	if (ret < 0)
	484	dev_warn(wm8350->dev, "failed to add charge sysfs: %d\n", ret);
	485	ret = 0;
	486
	487	wm8350_init_charger(wm8350);
	488	if (wm8350_charger_config(wm8350, policy) == 0) {
	489	wm8350_reg_unlock(wm8350);
	490	wm8350_set_bits(wm8350, WM8350_POWER_MGMT_5, WM8350_CHG_ENA);
	491	wm8350_reg_lock(wm8350);
	492	}
	493
	494	return ret;
	495
	496	usb_failed:
	497	power_supply_unregister(battery);
	498	battery_failed:
	499	power_supply_unregister(ac);
	500
	501	return ret;
	502	}
	503
	504	static __devexit int wm8350_power_remove(struct platform_device *pdev)
	505	{
	506	struct wm8350 *wm8350 = platform_get_drvdata(pdev);
507	struct wm8350_power *power = &wm8350->power;
508
509	free_charger_irq(wm8350);
510	device_remove_file(&pdev->dev, &dev_attr_charger_state);
511	power_supply_unregister(&power->battery);
512	power_supply_unregister(&power->ac);
513	power_supply_unregister(&power->usb);
514	return 0;
515	}
516
517	static struct platform_driver wm8350_power_driver = {
518	.probe = wm8350_power_probe,
519	.remove = __devexit_p(wm8350_power_remove),
520	.driver = {
521	.name = "wm8350-power",
522	},
523	};
524
525	static int __init wm8350_power_init(void)
526	{
527	return platform_driver_register(&wm8350_power_driver);
528	}
529	module_init(wm8350_power_init);
530
531	static void __exit wm8350_power_exit(void)
532	{
533	platform_driver_unregister(&wm8350_power_driver);
534	}
535	module_exit(wm8350_power_exit);
536
537	MODULE_LICENSE("GPL");
538	MODULE_DESCRIPTION("Power supply driver for WM8350");
539	MODULE_ALIAS("platform:wm8350-power");