[linux-block.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 void wm8350_charger_handler(struct wm8350 *wm8350, int irq, void *data)
{
	struct wm8350_power *power = &wm8350->power;
	struct wm8350_charger_policy *policy = power->policy;

	switch (irq) {
	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);
	}
}

/*********************************************************************
 *		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, NULL);
	wm8350_unmask_irq(wm8350, WM8350_IRQ_CHG_BAT_HOT);
	wm8350_register_irq(wm8350, WM8350_IRQ_CHG_BAT_COLD,
			    wm8350_charger_handler, NULL);
	wm8350_unmask_irq(wm8350, WM8350_IRQ_CHG_BAT_COLD);
	wm8350_register_irq(wm8350, WM8350_IRQ_CHG_BAT_FAIL,
			    wm8350_charger_handler, NULL);
	wm8350_unmask_irq(wm8350, WM8350_IRQ_CHG_BAT_FAIL);
	wm8350_register_irq(wm8350, WM8350_IRQ_CHG_TO,
			    wm8350_charger_handler, NULL);
	wm8350_unmask_irq(wm8350, WM8350_IRQ_CHG_TO);
	wm8350_register_irq(wm8350, WM8350_IRQ_CHG_END,
			    wm8350_charger_handler, NULL);
	wm8350_unmask_irq(wm8350, WM8350_IRQ_CHG_END);
	wm8350_register_irq(wm8350, WM8350_IRQ_CHG_START,
			    wm8350_charger_handler, NULL);
	wm8350_unmask_irq(wm8350, WM8350_IRQ_CHG_START);
	wm8350_register_irq(wm8350, WM8350_IRQ_CHG_FAST_RDY,
			    wm8350_charger_handler, NULL);
	wm8350_unmask_irq(wm8350, WM8350_IRQ_CHG_FAST_RDY);
	wm8350_register_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_3P9,
			    wm8350_charger_handler, NULL);
	wm8350_unmask_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_3P9);
	wm8350_register_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_3P1,
			    wm8350_charger_handler, NULL);
	wm8350_unmask_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_3P1);
	wm8350_register_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_2P85,
			    wm8350_charger_handler, NULL);
	wm8350_unmask_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_2P85);

	/* and supply change events */
	wm8350_register_irq(wm8350, WM8350_IRQ_EXT_USB_FB,
			    wm8350_charger_handler, NULL);
	wm8350_unmask_irq(wm8350, WM8350_IRQ_EXT_USB_FB);
	wm8350_register_irq(wm8350, WM8350_IRQ_EXT_WALL_FB,
			    wm8350_charger_handler, NULL);
	wm8350_unmask_irq(wm8350, WM8350_IRQ_EXT_WALL_FB);
	wm8350_register_irq(wm8350, WM8350_IRQ_EXT_BAT_FB,
			    wm8350_charger_handler, NULL);
	wm8350_unmask_irq(wm8350, WM8350_IRQ_EXT_BAT_FB);
}

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

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
187	static void wm8350_charger_handler(struct wm8350 wm8350, int irq, void data)
188	{
189	struct wm8350_power *power = &wm8350->power;
190	struct wm8350_charger_policy *policy = power->policy;
191
192	switch (irq) {
14431aa0 MB	193	case WM8350_IRQ_CHG_BAT_FAIL:
	194	dev_err(wm8350->dev, "battery failed\n");
	195	break;
	196	case WM8350_IRQ_CHG_TO:
	197	dev_err(wm8350->dev, "charger timeout\n");
14431aa0 MB	198	power_supply_changed(&power->battery);
14431aa0 MB	199	break;
4008e879 MB	200
	201	case WM8350_IRQ_CHG_BAT_HOT:
	202	case WM8350_IRQ_CHG_BAT_COLD:
14431aa0	203	case WM8350_IRQ_CHG_START:
4008e879	204	case WM8350_IRQ_CHG_END:
14431aa0 MB	205	power_supply_changed(&power->battery);
	206	break;
	207
	208	case WM8350_IRQ_CHG_FAST_RDY:
	209	dev_dbg(wm8350->dev, "fast charger ready\n");
	210	wm8350_charger_config(wm8350, policy);
	211	wm8350_reg_unlock(wm8350);
	212	wm8350_set_bits(wm8350, WM8350_BATTERY_CHARGER_CONTROL_1,
	213	WM8350_CHG_FAST);
	214	wm8350_reg_lock(wm8350);
	215	break;
	216
	217	case WM8350_IRQ_CHG_VBATT_LT_3P9:
	218	dev_warn(wm8350->dev, "battery < 3.9V\n");
	219	break;
	220	case WM8350_IRQ_CHG_VBATT_LT_3P1:
	221	dev_warn(wm8350->dev, "battery < 3.1V\n");
	222	break;
	223	case WM8350_IRQ_CHG_VBATT_LT_2P85:
	224	dev_warn(wm8350->dev, "battery < 2.85V\n");
	225	break;
	226
	227	/* Supply change. We will overnotify but it should do
	228	* no harm. */
	229	case WM8350_IRQ_EXT_USB_FB:
	230	case WM8350_IRQ_EXT_WALL_FB:
	231	wm8350_charger_config(wm8350, policy);
	232	case WM8350_IRQ_EXT_BAT_FB: /* Fall through */
	233	power_supply_changed(&power->battery);
	234	power_supply_changed(&power->usb);
	235	power_supply_changed(&power->ac);
	236	break;
	237
	238	default:
	239	dev_err(wm8350->dev, "Unknown interrupt %d\n", irq);
	240	}
	241	}
	242
	243	/*********************************************************************
	244	* AC Power
	245	*********************************************************************/
	246	static int wm8350_ac_get_prop(struct power_supply *psy,
	247	enum power_supply_property psp,
	248	union power_supply_propval *val)
	249	{
	250	struct wm8350 *wm8350 = dev_get_drvdata(psy->dev->parent);
	251	int ret = 0;
	252
	253	switch (psp) {
	254	case POWER_SUPPLY_PROP_ONLINE:
	255	val->intval = !!(wm8350_get_supplies(wm8350) &
	256	WM8350_LINE_SUPPLY);
	257	break;
	258	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
	259	val->intval = wm8350_read_line_uvolts(wm8350);
	260	break;
	261	default:
	262	ret = -EINVAL;
	263	break;
	264	}
	265	return ret;
	266	}
	267
	268	static enum power_supply_property wm8350_ac_props[] = {
269	POWER_SUPPLY_PROP_ONLINE,
270	POWER_SUPPLY_PROP_VOLTAGE_NOW,
271	};
272
273	/*********************************************************************
274	* USB Power
275	*********************************************************************/
276	static int wm8350_usb_get_prop(struct power_supply *psy,
277	enum power_supply_property psp,
278	union power_supply_propval *val)
279	{
280	struct wm8350 *wm8350 = dev_get_drvdata(psy->dev->parent);
281	int ret = 0;
282
283	switch (psp) {
284	case POWER_SUPPLY_PROP_ONLINE:
285	val->intval = !!(wm8350_get_supplies(wm8350) &
286	WM8350_USB_SUPPLY);
287	break;
288	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
289	val->intval = wm8350_read_usb_uvolts(wm8350);
290	break;
291	default:
292	ret = -EINVAL;
293	break;
294	}
295	return ret;
296	}
297
298	static enum power_supply_property wm8350_usb_props[] = {
299	POWER_SUPPLY_PROP_ONLINE,
300	POWER_SUPPLY_PROP_VOLTAGE_NOW,
301	};
302
303	/*********************************************************************
304	* Battery properties
305	*********************************************************************/
306
4008e879 MB	307	static int wm8350_bat_check_health(struct wm8350 *wm8350)
	308	{
	309	u16 reg;
	310
	311	if (wm8350_read_battery_uvolts(wm8350) < 2850000)
	312	return POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
	313
	314	reg = wm8350_reg_read(wm8350, WM8350_CHARGER_OVERRIDES);
	315	if (reg & WM8350_CHG_BATT_HOT_OVRDE)
	316	return POWER_SUPPLY_HEALTH_OVERHEAT;
	317
	318	if (reg & WM8350_CHG_BATT_COLD_OVRDE)
	319	return POWER_SUPPLY_HEALTH_COLD;
	320
	321	return POWER_SUPPLY_HEALTH_GOOD;
	322	}
	323
4aed03ae MB	324	static int wm8350_bat_get_charge_type(struct wm8350 *wm8350)
	325	{
	326	int state;
	327
	328	state = wm8350_reg_read(wm8350, WM8350_BATTERY_CHARGER_CONTROL_2) &
	329	WM8350_CHG_STS_MASK;
	330	switch (state) {
	331	case WM8350_CHG_STS_OFF:
	332	return POWER_SUPPLY_CHARGE_TYPE_NONE;
	333	case WM8350_CHG_STS_TRICKLE:
	334	return POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
	335	case WM8350_CHG_STS_FAST:
	336	return POWER_SUPPLY_CHARGE_TYPE_FAST;
	337	default:
	338	return POWER_SUPPLY_CHARGE_TYPE_UNKNOWN;
	339	}
	340	}
	341
14431aa0 MB	342	static int wm8350_bat_get_property(struct power_supply *psy,
	343	enum power_supply_property psp,
	344	union power_supply_propval *val)
	345	{
	346	struct wm8350 *wm8350 = dev_get_drvdata(psy->dev->parent);
	347	int ret = 0;
	348
	349	switch (psp) {
	350	case POWER_SUPPLY_PROP_STATUS:
	351	val->intval = wm8350_batt_status(wm8350);
	352	break;
	353	case POWER_SUPPLY_PROP_ONLINE:
	354	val->intval = !!(wm8350_get_supplies(wm8350) &
	355	WM8350_BATT_SUPPLY);
	356	break;
	357	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
	358	val->intval = wm8350_read_battery_uvolts(wm8350);
	359	break;
4008e879 MB	360	case POWER_SUPPLY_PROP_HEALTH:
	361	val->intval = wm8350_bat_check_health(wm8350);
	362	break;
4aed03ae MB	363	case POWER_SUPPLY_PROP_CHARGE_TYPE:
	364	val->intval = wm8350_bat_get_charge_type(wm8350);
	365	break;
14431aa0 MB	366	default:
	367	ret = -EINVAL;
	368	break;
	369	}
	370
	371	return ret;
	372	}
	373
	374	static enum power_supply_property wm8350_bat_props[] = {
	375	POWER_SUPPLY_PROP_STATUS,
	376	POWER_SUPPLY_PROP_ONLINE,
	377	POWER_SUPPLY_PROP_VOLTAGE_NOW,
4008e879	378	POWER_SUPPLY_PROP_HEALTH,
4aed03ae	379	POWER_SUPPLY_PROP_CHARGE_TYPE,
14431aa0 MB	380	};
	381
	382	/*********************************************************************
	383	* Initialisation
	384	*********************************************************************/
	385
	386	static void wm8350_init_charger(struct wm8350 *wm8350)
	387	{
	388	/* register our interest in charger events */
	389	wm8350_register_irq(wm8350, WM8350_IRQ_CHG_BAT_HOT,
	390	wm8350_charger_handler, NULL);
	391	wm8350_unmask_irq(wm8350, WM8350_IRQ_CHG_BAT_HOT);
	392	wm8350_register_irq(wm8350, WM8350_IRQ_CHG_BAT_COLD,
	393	wm8350_charger_handler, NULL);
	394	wm8350_unmask_irq(wm8350, WM8350_IRQ_CHG_BAT_COLD);
	395	wm8350_register_irq(wm8350, WM8350_IRQ_CHG_BAT_FAIL,
	396	wm8350_charger_handler, NULL);
	397	wm8350_unmask_irq(wm8350, WM8350_IRQ_CHG_BAT_FAIL);
	398	wm8350_register_irq(wm8350, WM8350_IRQ_CHG_TO,
	399	wm8350_charger_handler, NULL);
	400	wm8350_unmask_irq(wm8350, WM8350_IRQ_CHG_TO);
	401	wm8350_register_irq(wm8350, WM8350_IRQ_CHG_END,
	402	wm8350_charger_handler, NULL);
	403	wm8350_unmask_irq(wm8350, WM8350_IRQ_CHG_END);
	404	wm8350_register_irq(wm8350, WM8350_IRQ_CHG_START,
	405	wm8350_charger_handler, NULL);
	406	wm8350_unmask_irq(wm8350, WM8350_IRQ_CHG_START);
	407	wm8350_register_irq(wm8350, WM8350_IRQ_CHG_FAST_RDY,
	408	wm8350_charger_handler, NULL);
	409	wm8350_unmask_irq(wm8350, WM8350_IRQ_CHG_FAST_RDY);
	410	wm8350_register_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_3P9,
	411	wm8350_charger_handler, NULL);
	412	wm8350_unmask_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_3P9);
	413	wm8350_register_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_3P1,
	414	wm8350_charger_handler, NULL);
	415	wm8350_unmask_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_3P1);
	416	wm8350_register_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_2P85,
	417	wm8350_charger_handler, NULL);
	418	wm8350_unmask_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_2P85);
	419
	420	/* and supply change events */
	421	wm8350_register_irq(wm8350, WM8350_IRQ_EXT_USB_FB,
	422	wm8350_charger_handler, NULL);
	423	wm8350_unmask_irq(wm8350, WM8350_IRQ_EXT_USB_FB);
	424	wm8350_register_irq(wm8350, WM8350_IRQ_EXT_WALL_FB,
	425	wm8350_charger_handler, NULL);
	426	wm8350_unmask_irq(wm8350, WM8350_IRQ_EXT_WALL_FB);
	427	wm8350_register_irq(wm8350, WM8350_IRQ_EXT_BAT_FB,
	428	wm8350_charger_handler, NULL);
	429	wm8350_unmask_irq(wm8350, WM8350_IRQ_EXT_BAT_FB);
	430	}
	431
	432	static void free_charger_irq(struct wm8350 *wm8350)
	433	{
	434	wm8350_mask_irq(wm8350, WM8350_IRQ_CHG_BAT_HOT);
	435	wm8350_free_irq(wm8350, WM8350_IRQ_CHG_BAT_HOT);
	436	wm8350_mask_irq(wm8350, WM8350_IRQ_CHG_BAT_COLD);
	437	wm8350_free_irq(wm8350, WM8350_IRQ_CHG_BAT_COLD);
	438	wm8350_mask_irq(wm8350, WM8350_IRQ_CHG_BAT_FAIL);
	439	wm8350_free_irq(wm8350, WM8350_IRQ_CHG_BAT_FAIL);
	440	wm8350_mask_irq(wm8350, WM8350_IRQ_CHG_TO);
	441	wm8350_free_irq(wm8350, WM8350_IRQ_CHG_TO);
	442	wm8350_mask_irq(wm8350, WM8350_IRQ_CHG_END);
	443	wm8350_free_irq(wm8350, WM8350_IRQ_CHG_END);
444	wm8350_mask_irq(wm8350, WM8350_IRQ_CHG_START);
445	wm8350_free_irq(wm8350, WM8350_IRQ_CHG_START);
446	wm8350_mask_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_3P9);
447	wm8350_free_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_3P9);
448	wm8350_mask_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_3P1);
449	wm8350_free_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_3P1);
450	wm8350_mask_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_2P85);
451	wm8350_free_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_2P85);
452	wm8350_mask_irq(wm8350, WM8350_IRQ_EXT_USB_FB);
453	wm8350_free_irq(wm8350, WM8350_IRQ_EXT_USB_FB);
454	wm8350_mask_irq(wm8350, WM8350_IRQ_EXT_WALL_FB);
455	wm8350_free_irq(wm8350, WM8350_IRQ_EXT_WALL_FB);
456	wm8350_mask_irq(wm8350, WM8350_IRQ_EXT_BAT_FB);
457	wm8350_free_irq(wm8350, WM8350_IRQ_EXT_BAT_FB);
458	}
459
460	static __devinit int wm8350_power_probe(struct platform_device *pdev)
461	{
462	struct wm8350 *wm8350 = platform_get_drvdata(pdev);
463	struct wm8350_power *power = &wm8350->power;
464	struct wm8350_charger_policy *policy = power->policy;
465	struct power_supply *usb = &power->usb;
466	struct power_supply *battery = &power->battery;
467	struct power_supply *ac = &power->ac;
468	int ret;
469
470	ac->name = "wm8350-ac";
471	ac->type = POWER_SUPPLY_TYPE_MAINS;
472	ac->properties = wm8350_ac_props;
473	ac->num_properties = ARRAY_SIZE(wm8350_ac_props);
474	ac->get_property = wm8350_ac_get_prop;
475	ret = power_supply_register(&pdev->dev, ac);
476	if (ret)
477	return ret;
478
479	battery->name = "wm8350-battery";
480	battery->properties = wm8350_bat_props;
481	battery->num_properties = ARRAY_SIZE(wm8350_bat_props);
482	battery->get_property = wm8350_bat_get_property;
483	battery->use_for_apm = 1;
484	ret = power_supply_register(&pdev->dev, battery);
485	if (ret)
486	goto battery_failed;
487
488	usb->name = "wm8350-usb",
489	usb->type = POWER_SUPPLY_TYPE_USB;
490	usb->properties = wm8350_usb_props;
491	usb->num_properties = ARRAY_SIZE(wm8350_usb_props);
492	usb->get_property = wm8350_usb_get_prop;
493	ret = power_supply_register(&pdev->dev, usb);
494	if (ret)
495	goto usb_failed;
496
497	ret = device_create_file(&pdev->dev, &dev_attr_charger_state);
498	if (ret < 0)
499	dev_warn(wm8350->dev, "failed to add charge sysfs: %d\n", ret);
500	ret = 0;
501
502	wm8350_init_charger(wm8350);
503	if (wm8350_charger_config(wm8350, policy) == 0) {
504	wm8350_reg_unlock(wm8350);
505	wm8350_set_bits(wm8350, WM8350_POWER_MGMT_5, WM8350_CHG_ENA);
506	wm8350_reg_lock(wm8350);
507	}
508
509	return ret;
510
511	usb_failed:
512	power_supply_unregister(battery);
513	battery_failed:
514	power_supply_unregister(ac);
515
516	return ret;
517	}
518
519	static __devexit int wm8350_power_remove(struct platform_device *pdev)
520	{
521	struct wm8350 *wm8350 = platform_get_drvdata(pdev);
522	struct wm8350_power *power = &wm8350->power;
523
524	free_charger_irq(wm8350);
525	device_remove_file(&pdev->dev, &dev_attr_charger_state);
526	power_supply_unregister(&power->battery);
527	power_supply_unregister(&power->ac);
528	power_supply_unregister(&power->usb);
529	return 0;
530	}
531
532	static struct platform_driver wm8350_power_driver = {
533	.probe = wm8350_power_probe,
534	.remove = __devexit_p(wm8350_power_remove),
535	.driver = {
536	.name = "wm8350-power",
537	},
538	};
539
540	static int __init wm8350_power_init(void)
541	{
542	return platform_driver_register(&wm8350_power_driver);
543	}
544	module_init(wm8350_power_init);
545
546	static void __exit wm8350_power_exit(void)
547	{
548	platform_driver_unregister(&wm8350_power_driver);
549	}
550	module_exit(wm8350_power_exit);
551
552	MODULE_LICENSE("GPL");
553	MODULE_DESCRIPTION("Power supply driver for WM8350");
554	MODULE_ALIAS("platform:wm8350-power");