Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752575AbYKLQo6 (ORCPT ); Wed, 12 Nov 2008 11:44:58 -0500 Received: (majordomo@vger.kernel.org) by vger.kernel.org id S1751381AbYKLQos (ORCPT ); Wed, 12 Nov 2008 11:44:48 -0500 Received: from 3a.49.1343.static.theplanet.com ([67.19.73.58]:55160 "EHLO pug.o-hand.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1750763AbYKLQoq (ORCPT ); Wed, 12 Nov 2008 11:44:46 -0500 Date: Wed, 12 Nov 2008 17:47:23 +0100 From: Samuel Ortiz To: Mark Brown Cc: Anton Vorontsov , Andrew Morton , linux-kernel@vger.kernel.org Subject: Re: [PATCH] power_supply: Add support for WM8350 PMU Message-ID: <20081112164722.GB3882@sortiz.org> Reply-To: Samuel Ortiz References: <1226416083-12875-1-git-send-email-broonie@opensource.wolfsonmicro.com> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <1226416083-12875-1-git-send-email-broonie@opensource.wolfsonmicro.com> User-Agent: Mutt/1.5.18 (2008-05-17) Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Length: 22351 Lines: 683 On Tue, Nov 11, 2008 at 03:08:03PM +0000, Mark Brown wrote: > This patch adds support for the PMU provided by the WM8350 which > implements battery, line and USB supplies including a battery charger. > The hardware functions largely autonomously, with minimal software > control required to initiate fast charging. > > Support for configuration of the USB supply is not yet implemented. > This means that the hardware will remain in the mode configured at > startup, by default limiting the current drawn from USB to 100mA. > > This driver was originally written by Liam Girdwood with subsequent > updates for submission by Mark Brown. The MFD part looks good to me: > Signed-off-by: Mark Brown Acked-by: Samuel Ortiz > --- > > Modified to: > - Notify core of status changes in the battery charger. > - Remove the WM8350-specific supply state sysfs file. > > following feedback from Andrew. > > drivers/power/Kconfig | 7 + > drivers/power/Makefile | 1 + > drivers/power/wm8350_power.c | 515 +++++++++++++++++++++++++++++++++++++ > include/linux/mfd/wm8350/core.h | 26 ++ > include/linux/mfd/wm8350/supply.h | 23 ++- > 5 files changed, 571 insertions(+), 1 deletions(-) > create mode 100644 drivers/power/wm8350_power.c > > diff --git a/drivers/power/Kconfig b/drivers/power/Kconfig > index 8e0c2b4..52f8676 100644 > --- a/drivers/power/Kconfig > +++ b/drivers/power/Kconfig > @@ -29,6 +29,13 @@ config APM_POWER > Say Y here to enable support APM status emulation using > battery class devices. > > +config WM8350_POWER > + tristate "WM8350 PMU support" > + depends on MFD_WM8350 > + help > + Say Y here to enable support for the power management unit > + provided by the Wolfson Microelectronics WM8350 PMIC. > + > config BATTERY_DS2760 > tristate "DS2760 battery driver (HP iPAQ & others)" > select W1 > diff --git a/drivers/power/Makefile b/drivers/power/Makefile > index e8f1ece..e6f6865 100644 > --- a/drivers/power/Makefile > +++ b/drivers/power/Makefile > @@ -16,6 +16,7 @@ obj-$(CONFIG_POWER_SUPPLY) += power_supply.o > > obj-$(CONFIG_PDA_POWER) += pda_power.o > obj-$(CONFIG_APM_POWER) += apm_power.o > +obj-$(CONFIG_WM8350_POWER) += wm8350_power.o > > obj-$(CONFIG_BATTERY_DS2760) += ds2760_battery.o > obj-$(CONFIG_BATTERY_PMU) += pmu_battery.o > diff --git a/drivers/power/wm8350_power.c b/drivers/power/wm8350_power.c > new file mode 100644 > index 0000000..9c0a847 > --- /dev/null > +++ b/drivers/power/wm8350_power.c > @@ -0,0 +1,515 @@ > +/* > + * Battery driver for wm8350 PMIC > + * > + * Copyright 2007, 2008 Wolfson Microelectronics PLC. > + * > + * Based on OLPC Battery Driver > + * > + * Copyright 2006 David Woodhouse > + * > + * 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 > +#include > +#include > +#include > +#include > +#include > +#include > + > +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->rev < WM8350_REV_G) > + 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_HOT: > + dev_err(wm8350->dev, "battery too hot\n"); > + break; > + case WM8350_IRQ_CHG_BAT_COLD: > + dev_err(wm8350->dev, "battery too cold\n"); > + break; > + 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"); > + break; > + case WM8350_IRQ_CHG_END: > + power_supply_changed(&power->battery); > + break; > + case WM8350_IRQ_CHG_START: > + 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_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; > + 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, > +}; > + > +/********************************************************************* > + * 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"); > diff --git a/include/linux/mfd/wm8350/core.h b/include/linux/mfd/wm8350/core.h > index cc19005..d2614df 100644 > --- a/include/linux/mfd/wm8350/core.h > +++ b/include/linux/mfd/wm8350/core.h > @@ -57,6 +57,9 @@ > #define WM8350_OVER_CURRENT_INT_STATUS_MASK 0x25 > #define WM8350_GPIO_INT_STATUS_MASK 0x26 > #define WM8350_COMPARATOR_INT_STATUS_MASK 0x27 > +#define WM8350_MISC_OVERRIDES 0xE3 > +#define WM8350_COMPARATOR_OVERRIDES 0xE7 > +#define WM8350_STATE_MACHINE_STATUS 0xE9 > > #define WM8350_MAX_REGISTER 0xFF > > @@ -523,6 +526,29 @@ > #define WM8350_DC2_STS 0x0002 > #define WM8350_DC1_STS 0x0001 > > +/* > + * R227 (0xE3) - Misc Overrides > + */ > +#define WM8350_USB_LIMIT_OVRDE 0x0400 > + > +/* > + * R227 (0xE7) - Comparator Overrides > + */ > +#define WM8350_USB_FB_OVRDE 0x8000 > +#define WM8350_WALL_FB_OVRDE 0x4000 > +#define WM8350_BATT_FB_OVRDE 0x2000 > + > + > +/* > + * R233 (0xE9) - State Machinine Status > + */ > +#define WM8350_USB_SM_MASK 0x0700 > +#define WM8350_USB_SM_SHIFT 8 > + > +#define WM8350_USB_SM_100_SLV 1 > +#define WM8350_USB_SM_500_SLV 5 > +#define WM8350_USB_SM_STDBY_SLV 7 > + > /* WM8350 wake up conditions */ > #define WM8350_IRQ_WKUP_OFF_STATE 43 > #define WM8350_IRQ_WKUP_HIB_STATE 44 > diff --git a/include/linux/mfd/wm8350/supply.h b/include/linux/mfd/wm8350/supply.h > index 1c8f3cd..7972151 100644 > --- a/include/linux/mfd/wm8350/supply.h > +++ b/include/linux/mfd/wm8350/supply.h > @@ -13,7 +13,8 @@ > #ifndef __LINUX_MFD_WM8350_SUPPLY_H_ > #define __LINUX_MFD_WM8350_SUPPLY_H_ > > -#include > +#include > +#include > > /* > * Charger registers > @@ -104,8 +105,28 @@ > #define WM8350_IRQ_EXT_WALL_FB 37 > #define WM8350_IRQ_EXT_BAT_FB 38 > > +/* > + * Policy to control charger state machine. > + */ > +struct wm8350_charger_policy { > + > + /* charger state machine policy - set in machine driver */ > + int eoc_mA; /* end of charge current (mA) */ > + int charge_mV; /* charge voltage */ > + int fast_limit_mA; /* fast charge current limit */ > + int fast_limit_USB_mA; /* USB fast charge current limit */ > + int charge_timeout; /* charge timeout (mins) */ > + int trickle_start_mV; /* trickle charge starts at mV */ > + int trickle_charge_mA; /* trickle charge current */ > + int trickle_charge_USB_mA; /* USB trickle charge current */ > +}; > + > struct wm8350_power { > struct platform_device *pdev; > + struct power_supply battery; > + struct power_supply usb; > + struct power_supply ac; > + struct wm8350_charger_policy *policy; > }; > > #endif > -- > 1.5.6.5 > -- Intel Open Source Technology Centre http://oss.intel.com/ -- To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html Please read the FAQ at http://www.tux.org/lkml/