[ARM] 5248/1: wm97xx generic battery driver

This patch adds generic battery driver for wm97xx chips. Signed-off-by: Marek Vasut <marek.vasut@gmail.com> Acked-by: Anton Vorontsov <cbouatmailru@gmail.com> Acked-by: Mark Brown <broonie@opensource.wolfsonmicro.com> Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
author: Marek Vašut <marek.vasut@gmail.com> 2008-09-11 14:37:32 -0400
committer: Russell King <rmk+kernel@arm.linux.org.uk> 2008-10-02 17:48:34 -0400
commit: 4e9687d9c843dc34d368358a36f5f1610e4fbab3 (patch)
tree: 54ee159fff8a1b6064cbc1f4e97f8c4d918c5d02
parent: c49e1e63a9c7893d9ff9be4258d86ddc5485d712 (diff)
6 files changed, 323 insertions, 203 deletions
diff --git a/arch/arm/mach-pxa/palmtx.c b/arch/arm/mach-pxa/palmtx.c
index fe924a23debe..4447711c9fc6 100644
--- a/arch/arm/mach-pxa/palmtx.c
+++ b/arch/arm/mach-pxa/palmtx.c
@@ -25,6 +25,8 @@
 #include <linux/pda_power.h>
 #include <linux/pwm_backlight.h>
 #include <linux/gpio.h>
+#include <linux/wm97xx_batt.h>
+#include <linux/power_supply.h>
 #include <asm/mach-types.h>
 #include <asm/mach/arch.h>
@@ -340,6 +342,23 @@ static struct platform_device power_supply = {
 };
 /******************************************************************************
+ * WM97xx battery
+ ******************************************************************************/
+static struct wm97xx_batt_info wm97xx_batt_pdata = {
+        .batt_aux       = WM97XX_AUX_ID3,
+        .temp_aux       = WM97XX_AUX_ID2,
+        .charge_gpio    = -1,
+        .max_voltage    = PALMTX_BAT_MAX_VOLTAGE,
+        .min_voltage    = PALMTX_BAT_MIN_VOLTAGE,
+        .batt_mult      = 1000,
+        .batt_div       = 414,
+        .temp_mult      = 1,
+        .temp_div       = 1,
+        .batt_tech      = POWER_SUPPLY_TECHNOLOGY_LIPO,
+        .batt_name      = "main-batt",
+};
+/******************************************************************************
 * Framebuffer
 ******************************************************************************/
 static struct pxafb_mode_info palmtx_lcd_modes[] = {
@@ -401,6 +420,7 @@ static void __init palmtx_init(void)
        pxa_set_ac97_info(NULL);
        pxa_set_ficp_info(&palmtx_ficp_platform_data);
        pxa_set_keypad_info(&palmtx_keypad_platform_data);
+        wm97xx_bat_set_pdata(&wm97xx_batt_pdata);
        platform_add_devices(devices, ARRAY_SIZE(devices));
 }
diff --git a/drivers/power/Kconfig b/drivers/power/Kconfig
index 9ce55850271a..1982f8b42782 100644
--- a/drivers/power/Kconfig
+++ b/drivers/power/Kconfig
@@ -56,10 +56,10 @@ config BATTERY_TOSA
          Say Y to enable support for the battery on the Sharp Zaurus
          SL-6000 (tosa) models.
-config BATTERY_PALMTX
+config BATTERY_WM97XX
-        tristate "Palm T|X battery"
+        bool "WM97xx generic battery driver"
-        depends on MACH_PALMTX
+        depends on TOUCHSCREEN_WM97XX
        help
-          Say Y to enable support for the battery in Palm T|X.
+          Say Y to enable support for battery measured by WM97xx aux port.
 endif # POWER_SUPPLY
diff --git a/drivers/power/Makefile b/drivers/power/Makefile
index 4706bf8ff459..4e20026cc45a 100644
--- a/drivers/power/Makefile
+++ b/drivers/power/Makefile
@@ -21,4 +21,4 @@ obj-$(CONFIG_BATTERY_DS2760)	+= ds2760_battery.o
 obj-$(CONFIG_BATTERY_PMU)       += pmu_battery.o
 obj-$(CONFIG_BATTERY_OLPC)      += olpc_battery.o
 obj-$(CONFIG_BATTERY_TOSA)      += tosa_battery.o
-obj-$(CONFIG_BATTERY_PALMTX)    += palmtx_battery.o
+obj-$(CONFIG_BATTERY_WM97XX)    += wm97xx_battery.o
+\ No newline at end of file
diff --git a/drivers/power/palmtx_battery.c b/drivers/power/palmtx_battery.c
deleted file mode 100644
index 7035bfa41c62..000000000000
--- a/drivers/power/palmtx_battery.c
+++ /dev/null
@@ -1,198 +0,0 @@
-/*
- * linux/drivers/power/palmtx_battery.c
- *
- * Battery measurement code for Palm T|X Handheld computer
- *
- * based on tosa_battery.c
- *
- * Copyright (C) 2008 Marek Vasut <marek.vasut@gmail.com>
- *
- * 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/kernel.h>
-#include <linux/module.h>
-#include <linux/power_supply.h>
-#include <linux/wm97xx.h>
-#include <linux/delay.h>
-#include <linux/spinlock.h>
-#include <linux/interrupt.h>
-#include <linux/gpio.h>
-#include <asm/mach-types.h>
-#include <mach/palmtx.h>
-static DEFINE_MUTEX(bat_lock);
-static struct work_struct bat_work;
-struct mutex work_lock;
-int bat_status = POWER_SUPPLY_STATUS_DISCHARGING;
-static unsigned long palmtx_read_bat(struct power_supply *bat_ps)
-{
-        return wm97xx_read_aux_adc(bat_ps->dev->parent->driver_data,
-                                    WM97XX_AUX_ID3) * 1000 / 414;
-}
-static unsigned long palmtx_read_temp(struct power_supply *bat_ps)
-{
-        return wm97xx_read_aux_adc(bat_ps->dev->parent->driver_data,
-                                    WM97XX_AUX_ID2);
-}
-static int palmtx_bat_get_property(struct power_supply *bat_ps,
-                            enum power_supply_property psp,
-                            union power_supply_propval *val)
-{
-        switch (psp) {
-        case POWER_SUPPLY_PROP_STATUS:
-                val->intval = bat_status;
-                break;
-        case POWER_SUPPLY_PROP_TECHNOLOGY:
-                val->intval = POWER_SUPPLY_TECHNOLOGY_LIPO;
-                break;
-        case POWER_SUPPLY_PROP_VOLTAGE_NOW:
-                val->intval = palmtx_read_bat(bat_ps);
-                break;
-        case POWER_SUPPLY_PROP_VOLTAGE_MAX:
-        case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
-                val->intval = PALMTX_BAT_MAX_VOLTAGE;
-                break;
-        case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
-                val->intval = PALMTX_BAT_MIN_VOLTAGE;
-                break;
-        case POWER_SUPPLY_PROP_TEMP:
-                val->intval = palmtx_read_temp(bat_ps);
-                break;
-        case POWER_SUPPLY_PROP_PRESENT:
-                val->intval = 1;
-                break;
-        default:
-                return -EINVAL;
-        }
-        return 0;
-}
-static void palmtx_bat_external_power_changed(struct power_supply *bat_ps)
-{
-        schedule_work(&bat_work);
-}
-static char *status_text[] = {
-        [POWER_SUPPLY_STATUS_UNKNOWN] =         "Unknown",
-        [POWER_SUPPLY_STATUS_CHARGING] =        "Charging",
-        [POWER_SUPPLY_STATUS_DISCHARGING] =     "Discharging",
-};
-static void palmtx_bat_update(struct power_supply *bat_ps)
-{
-        int old_status = bat_status;
-        mutex_lock(&work_lock);
-        bat_status = gpio_get_value(GPIO_NR_PALMTX_POWER_DETECT) ?
-                                    POWER_SUPPLY_STATUS_CHARGING :
-                                    POWER_SUPPLY_STATUS_DISCHARGING;
-        if (old_status != bat_status) {
-                pr_debug("%s %s -> %s\n", bat_ps->name,
-                                status_text[old_status],
-                                status_text[bat_status]);
-                power_supply_changed(bat_ps);
-        }
-        mutex_unlock(&work_lock);
-}
-static enum power_supply_property palmtx_bat_main_props[] = {
-        POWER_SUPPLY_PROP_STATUS,
-        POWER_SUPPLY_PROP_TECHNOLOGY,
-        POWER_SUPPLY_PROP_VOLTAGE_NOW,
-        POWER_SUPPLY_PROP_VOLTAGE_MAX,
-        POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
-        POWER_SUPPLY_PROP_TEMP,
-        POWER_SUPPLY_PROP_PRESENT,
-};
-struct power_supply bat_ps = {
-        .name                   = "main-battery",
-        .type                   = POWER_SUPPLY_TYPE_BATTERY,
-        .properties             = palmtx_bat_main_props,
-        .num_properties         = ARRAY_SIZE(palmtx_bat_main_props),
-        .get_property           = palmtx_bat_get_property,
-        .external_power_changed = palmtx_bat_external_power_changed,
-        .use_for_apm            = 1,
-};
-static void palmtx_bat_work(struct work_struct *work)
-{
-        palmtx_bat_update(&bat_ps);
-}
-#ifdef CONFIG_PM
-static int palmtx_bat_suspend(struct platform_device *dev, pm_message_t state)
-{
-        flush_scheduled_work();
-        return 0;
-}
-static int palmtx_bat_resume(struct platform_device *dev)
-{
-        schedule_work(&bat_work);
-        return 0;
-}
-#else
-#define palmtx_bat_suspend NULL
-#define palmtx_bat_resume NULL
-#endif
-static int __devinit palmtx_bat_probe(struct platform_device *dev)
-{
-        int ret = 0;
-        if (!machine_is_palmtx())
-                return -ENODEV;
-        mutex_init(&work_lock);
-        INIT_WORK(&bat_work, palmtx_bat_work);
-        ret = power_supply_register(&dev->dev, &bat_ps);
-        if (!ret)
-                schedule_work(&bat_work);
-        return ret;
-}
-static int __devexit palmtx_bat_remove(struct platform_device *dev)
-{
-        power_supply_unregister(&bat_ps);
-        return 0;
-}
-static struct platform_driver palmtx_bat_driver = {
-        .driver.name    = "wm97xx-battery",
-        .driver.owner   = THIS_MODULE,
-        .probe          = palmtx_bat_probe,
-        .remove         = __devexit_p(palmtx_bat_remove),
-        .suspend        = palmtx_bat_suspend,
-        .resume         = palmtx_bat_resume,
-};
-static int __init palmtx_bat_init(void)
-{
-        return platform_driver_register(&palmtx_bat_driver);
-}
-static void __exit palmtx_bat_exit(void)
-{
-        platform_driver_unregister(&palmtx_bat_driver);
-}
-module_init(palmtx_bat_init);
-module_exit(palmtx_bat_exit);
-MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Marek Vasut <marek.vasut@gmail.com>");
-MODULE_DESCRIPTION("Palm T|X battery driver");
diff --git a/drivers/power/wm97xx_battery.c b/drivers/power/wm97xx_battery.c
new file mode 100644
index 000000000000..8bde92126d34
--- /dev/null
+++ b/drivers/power/wm97xx_battery.c
@@ -0,0 +1,272 @@
+/*
+ * linux/drivers/power/wm97xx_battery.c
+ *
+ * Battery measurement code for WM97xx
+ *
+ * based on tosa_battery.c
+ *
+ * Copyright (C) 2008 Marek Vasut <marek.vasut@gmail.com>
+ *
+ * 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/init.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/power_supply.h>
+#include <linux/wm97xx.h>
+#include <linux/spinlock.h>
+#include <linux/interrupt.h>
+#include <linux/gpio.h>
+#include <linux/wm97xx_batt.h>
+static DEFINE_MUTEX(bat_lock);
+static struct work_struct bat_work;
+struct mutex work_lock;
+static int bat_status = POWER_SUPPLY_STATUS_UNKNOWN;
+static struct wm97xx_batt_info *pdata;
+static enum power_supply_property *prop;
+static unsigned long wm97xx_read_bat(struct power_supply *bat_ps)
+{
+        return wm97xx_read_aux_adc(bat_ps->dev->parent->driver_data,
+                                        pdata->batt_aux) * pdata->batt_mult /
+                                        pdata->batt_div;
+}
+static unsigned long wm97xx_read_temp(struct power_supply *bat_ps)
+{
+        return wm97xx_read_aux_adc(bat_ps->dev->parent->driver_data,
+                                        pdata->temp_aux) * pdata->temp_mult /
+                                        pdata->temp_div;
+}
+static int wm97xx_bat_get_property(struct power_supply *bat_ps,
+                            enum power_supply_property psp,
+                            union power_supply_propval *val)
+{
+        switch (psp) {
+        case POWER_SUPPLY_PROP_STATUS:
+                val->intval = bat_status;
+                break;
+        case POWER_SUPPLY_PROP_TECHNOLOGY:
+                val->intval = pdata->batt_tech;
+                break;
+        case POWER_SUPPLY_PROP_VOLTAGE_NOW:
+                if (pdata->batt_aux >= 0)
+                        val->intval = wm97xx_read_bat(bat_ps);
+                else
+                        return -EINVAL;
+                break;
+        case POWER_SUPPLY_PROP_TEMP:
+                if (pdata->temp_aux >= 0)
+                        val->intval = wm97xx_read_temp(bat_ps);
+                else
+                        return -EINVAL;
+                break;
+        case POWER_SUPPLY_PROP_VOLTAGE_MAX:
+                if (pdata->max_voltage >= 0)
+                        val->intval = pdata->max_voltage;
+                else
+                        return -EINVAL;
+                break;
+        case POWER_SUPPLY_PROP_VOLTAGE_MIN:
+                if (pdata->min_voltage >= 0)
+                        val->intval = pdata->min_voltage;
+                else
+                        return -EINVAL;
+                break;
+        case POWER_SUPPLY_PROP_PRESENT:
+                val->intval = 1;
+                break;
+        default:
+                return -EINVAL;
+        }
+        return 0;
+}
+static void wm97xx_bat_external_power_changed(struct power_supply *bat_ps)
+{
+        schedule_work(&bat_work);
+}
+static void wm97xx_bat_update(struct power_supply *bat_ps)
+{
+        int old_status = bat_status;
+        mutex_lock(&work_lock);
+        bat_status = (pdata->charge_gpio >= 0) ?
+                        (gpio_get_value(pdata->charge_gpio) ?
+                        POWER_SUPPLY_STATUS_DISCHARGING :
+                        POWER_SUPPLY_STATUS_CHARGING) :
+                        POWER_SUPPLY_STATUS_UNKNOWN;
+        if (old_status != bat_status) {
+                pr_debug("%s: %i -> %i\n", bat_ps->name, old_status,
+                                        bat_status);
+                power_supply_changed(bat_ps);
+        }
+        mutex_unlock(&work_lock);
+}
+static struct power_supply bat_ps = {
+        .type                   = POWER_SUPPLY_TYPE_BATTERY,
+        .get_property           = wm97xx_bat_get_property,
+        .external_power_changed = wm97xx_bat_external_power_changed,
+        .use_for_apm            = 1,
+};
+static void wm97xx_bat_work(struct work_struct *work)
+{
+        wm97xx_bat_update(&bat_ps);
+}
+#ifdef CONFIG_PM
+static int wm97xx_bat_suspend(struct platform_device *dev, pm_message_t state)
+{
+        flush_scheduled_work();
+        return 0;
+}
+static int wm97xx_bat_resume(struct platform_device *dev)
+{
+        schedule_work(&bat_work);
+        return 0;
+}
+#else
+#define wm97xx_bat_suspend NULL
+#define wm97xx_bat_resume NULL
+#endif
+static int __devinit wm97xx_bat_probe(struct platform_device *dev)
+{
+        int ret = 0;
+        int props = 1;  /* POWER_SUPPLY_PROP_PRESENT */
+        int i = 0;
+        if (dev->id != -1)
+                return -EINVAL;
+        mutex_init(&work_lock);
+        if (!pdata) {
+                dev_err(&dev->dev, "Please use wm97xx_bat_set_pdata\n");
+                return -EINVAL;
+        }
+        if (pdata->charge_gpio >= 0 && gpio_is_valid(pdata->charge_gpio)) {
+                ret = gpio_request(pdata->charge_gpio, "BATT CHRG");
+                if (ret)
+                        goto err;
+                ret = gpio_direction_input(pdata->charge_gpio);
+                if (ret)
+                        goto err2;
+                props++;        /* POWER_SUPPLY_PROP_STATUS */
+        }
+        if (pdata->batt_tech >= 0)
+                props++;        /* POWER_SUPPLY_PROP_TECHNOLOGY */
+        if (pdata->temp_aux >= 0)
+                props++;        /* POWER_SUPPLY_PROP_TEMP */
+        if (pdata->batt_aux >= 0)
+                props++;        /* POWER_SUPPLY_PROP_VOLTAGE_NOW */
+        if (pdata->max_voltage >= 0)
+                props++;        /* POWER_SUPPLY_PROP_VOLTAGE_MAX */
+        if (pdata->min_voltage >= 0)
+                props++;        /* POWER_SUPPLY_PROP_VOLTAGE_MIN */
+        prop = kzalloc(props * sizeof(*prop), GFP_KERNEL);
+        if (!prop)
+                goto err2;
+        prop[i++] = POWER_SUPPLY_PROP_PRESENT;
+        if (pdata->charge_gpio >= 0)
+                prop[i++] = POWER_SUPPLY_PROP_STATUS;
+        if (pdata->batt_tech >= 0)
+                prop[i++] = POWER_SUPPLY_PROP_TECHNOLOGY;
+        if (pdata->temp_aux >= 0)
+                prop[i++] = POWER_SUPPLY_PROP_TEMP;
+        if (pdata->batt_aux >= 0)
+                prop[i++] = POWER_SUPPLY_PROP_VOLTAGE_NOW;
+        if (pdata->max_voltage >= 0)
+                prop[i++] = POWER_SUPPLY_PROP_VOLTAGE_MAX;
+        if (pdata->min_voltage >= 0)
+                prop[i++] = POWER_SUPPLY_PROP_VOLTAGE_MIN;
+        INIT_WORK(&bat_work, wm97xx_bat_work);
+        if (!pdata->batt_name) {
+                dev_info(&dev->dev, "Please consider setting proper battery "
+                                "name in platform definition file, falling "
+                                "back to name \"wm97xx-batt\"\n");
+                bat_ps.name = "wm97xx-batt";
+        } else
+                bat_ps.name = pdata->batt_name;
+        bat_ps.properties = prop;
+        bat_ps.num_properties = props;
+        ret = power_supply_register(&dev->dev, &bat_ps);
+        if (!ret)
+                schedule_work(&bat_work);
+        else
+                goto err3;
+        return 0;
+err3:
+        kfree(prop);
+err2:
+        gpio_free(pdata->charge_gpio);
+err:
+        return ret;
+}
+static int __devexit wm97xx_bat_remove(struct platform_device *dev)
+{
+        if (pdata && pdata->charge_gpio && pdata->charge_gpio >= 0)
+                gpio_free(pdata->charge_gpio);
+        flush_scheduled_work();
+        power_supply_unregister(&bat_ps);
+        kfree(prop);
+        return 0;
+}
+static struct platform_driver wm97xx_bat_driver = {
+        .driver = {
+                .name   = "wm97xx-battery",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = wm97xx_bat_probe,
+        .remove         = __devexit_p(wm97xx_bat_remove),
+        .suspend        = wm97xx_bat_suspend,
+        .resume         = wm97xx_bat_resume,
+};
+static int __init wm97xx_bat_init(void)
+{
+        return platform_driver_register(&wm97xx_bat_driver);
+}
+static void __exit wm97xx_bat_exit(void)
+{
+        platform_driver_unregister(&wm97xx_bat_driver);
+}
+void __init wm97xx_bat_set_pdata(struct wm97xx_batt_info *data)
+{
+        pdata = data;
+}
+EXPORT_SYMBOL_GPL(wm97xx_bat_set_pdata);
+module_init(wm97xx_bat_init);
+module_exit(wm97xx_bat_exit);
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Marek Vasut <marek.vasut@gmail.com>");
+MODULE_DESCRIPTION("WM97xx battery driver");
diff --git a/include/linux/wm97xx_batt.h b/include/linux/wm97xx_batt.h
new file mode 100644
index 000000000000..9681d1ab0e4f
--- /dev/null
+++ b/include/linux/wm97xx_batt.h
@@ -0,0 +1,26 @@
+#ifndef _LINUX_WM97XX_BAT_H
+#define _LINUX_WM97XX_BAT_H
+#include <linux/wm97xx.h>
+struct wm97xx_batt_info {
+        int     batt_aux;
+        int     temp_aux;
+        int     charge_gpio;
+        int     min_voltage;
+        int     max_voltage;
+        int     batt_div;
+        int     batt_mult;
+        int     temp_div;
+        int     temp_mult;
+        int     batt_tech;
+        char    *batt_name;
+};
+#ifdef CONFIG_BATTERY_WM97XX
+void __init wm97xx_bat_set_pdata(struct wm97xx_batt_info *data);
+#else
+static inline void wm97xx_bat_set_pdata(struct wm97xx_batt_info *data) {}
+#endif
+#endif
author	Marek Vašut <marek.vasut@gmail.com>	2008-09-11 14:37:32 -0400
committer	Russell King <rmk+kernel@arm.linux.org.uk>	2008-10-02 17:48:34 -0400
commit	4e9687d9c843dc34d368358a36f5f1610e4fbab3 (patch)
tree	54ee159fff8a1b6064cbc1f4e97f8c4d918c5d02
parent	c49e1e63a9c7893d9ff9be4258d86ddc5485d712 (diff)

diff --git a/arch/arm/mach-pxa/palmtx.c b/arch/arm/mach-pxa/palmtx.c index fe924a23debe..4447711c9fc6 100644 --- a/arch/arm/mach-pxa/palmtx.c +++ b/arch/arm/mach-pxa/palmtx.c
@@ -25,6 +25,8 @@
25	#include <linux/pda_power.h>	25	#include <linux/pda_power.h>
26	#include <linux/pwm_backlight.h>	26	#include <linux/pwm_backlight.h>
27	#include <linux/gpio.h>	27	#include <linux/gpio.h>
		28	#include <linux/wm97xx_batt.h>
		29	#include <linux/power_supply.h>
28		30
29	#include <asm/mach-types.h>	31	#include <asm/mach-types.h>
30	#include <asm/mach/arch.h>	32	#include <asm/mach/arch.h>
@@ -340,6 +342,23 @@ static struct platform_device power_supply = {
340	};	342	};
341		343
342	/******************************************************************************	344	/******************************************************************************
		345	* WM97xx battery
		346	******************************************************************************/
		347	static struct wm97xx_batt_info wm97xx_batt_pdata = {
		348	.batt_aux = WM97XX_AUX_ID3,
		349	.temp_aux = WM97XX_AUX_ID2,
		350	.charge_gpio = -1,
		351	.max_voltage = PALMTX_BAT_MAX_VOLTAGE,
		352	.min_voltage = PALMTX_BAT_MIN_VOLTAGE,
		353	.batt_mult = 1000,
		354	.batt_div = 414,
		355	.temp_mult = 1,
		356	.temp_div = 1,
		357	.batt_tech = POWER_SUPPLY_TECHNOLOGY_LIPO,
		358	.batt_name = "main-batt",
		359	};
		360
		361	/******************************************************************************
343	* Framebuffer	362	* Framebuffer
344	******************************************************************************/	363	******************************************************************************/
345	static struct pxafb_mode_info palmtx_lcd_modes[] = {	364	static struct pxafb_mode_info palmtx_lcd_modes[] = {
@@ -401,6 +420,7 @@ static void __init palmtx_init(void)
401	pxa_set_ac97_info(NULL);	420	pxa_set_ac97_info(NULL);
402	pxa_set_ficp_info(&palmtx_ficp_platform_data);	421	pxa_set_ficp_info(&palmtx_ficp_platform_data);
403	pxa_set_keypad_info(&palmtx_keypad_platform_data);	422	pxa_set_keypad_info(&palmtx_keypad_platform_data);
		423	wm97xx_bat_set_pdata(&wm97xx_batt_pdata);
404		424
405	platform_add_devices(devices, ARRAY_SIZE(devices));	425	platform_add_devices(devices, ARRAY_SIZE(devices));
406	}	426	}


diff --git a/drivers/power/Kconfig b/drivers/power/Kconfig index 9ce55850271a..1982f8b42782 100644 --- a/drivers/power/Kconfig +++ b/drivers/power/Kconfig
@@ -56,10 +56,10 @@ config BATTERY_TOSA
56	Say Y to enable support for the battery on the Sharp Zaurus	56	Say Y to enable support for the battery on the Sharp Zaurus
57	SL-6000 (tosa) models.	57	SL-6000 (tosa) models.
58		58
59	config BATTERY_PALMTX	59	config BATTERY_WM97XX
60	tristate "Palm T\|X battery"	60	bool "WM97xx generic battery driver"
61	depends on MACH_PALMTX	61	depends on TOUCHSCREEN_WM97XX
62	help	62	help
63	Say Y to enable support for the battery in Palm T\|X.	63	Say Y to enable support for battery measured by WM97xx aux port.
64		64
65	endif # POWER_SUPPLY	65	endif # POWER_SUPPLY


diff --git a/drivers/power/Makefile b/drivers/power/Makefile index 4706bf8ff459..4e20026cc45a 100644 --- a/drivers/power/Makefile +++ b/drivers/power/Makefile
@@ -21,4 +21,4 @@ obj-$(CONFIG_BATTERY_DS2760) += ds2760_battery.o
21	obj-$(CONFIG_BATTERY_PMU) += pmu_battery.o	21	obj-$(CONFIG_BATTERY_PMU) += pmu_battery.o
22	obj-$(CONFIG_BATTERY_OLPC) += olpc_battery.o	22	obj-$(CONFIG_BATTERY_OLPC) += olpc_battery.o
23	obj-$(CONFIG_BATTERY_TOSA) += tosa_battery.o	23	obj-$(CONFIG_BATTERY_TOSA) += tosa_battery.o
24	obj-$(CONFIG_BATTERY_PALMTX) += palmtx_battery.o	24	obj-$(CONFIG_BATTERY_WM97XX) += wm97xx_battery.o \ No newline at end of file


diff --git a/drivers/power/palmtx_battery.c b/drivers/power/palmtx_battery.c deleted file mode 100644 index 7035bfa41c62..000000000000 --- a/drivers/power/palmtx_battery.c +++ /dev/null
@@ -1,198 +0,0 @@
1	/*
2	* linux/drivers/power/palmtx_battery.c
3	*
4	* Battery measurement code for Palm T\|X Handheld computer
5	*
6	* based on tosa_battery.c
7	*
8	* Copyright (C) 2008 Marek Vasut <marek.vasut@gmail.com>
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/kernel.h>
16	#include <linux/module.h>
17	#include <linux/power_supply.h>
18	#include <linux/wm97xx.h>
19	#include <linux/delay.h>
20	#include <linux/spinlock.h>
21	#include <linux/interrupt.h>
22	#include <linux/gpio.h>
23
24	#include <asm/mach-types.h>
25	#include <mach/palmtx.h>
26
27	static DEFINE_MUTEX(bat_lock);
28	static struct work_struct bat_work;
29	struct mutex work_lock;
30	int bat_status = POWER_SUPPLY_STATUS_DISCHARGING;
31
32	static unsigned long palmtx_read_bat(struct power_supply *bat_ps)
33	{
34	return wm97xx_read_aux_adc(bat_ps->dev->parent->driver_data,
35	WM97XX_AUX_ID3) * 1000 / 414;
36	}
37
38	static unsigned long palmtx_read_temp(struct power_supply *bat_ps)
39	{
40	return wm97xx_read_aux_adc(bat_ps->dev->parent->driver_data,
41	WM97XX_AUX_ID2);
42	}
43
44	static int palmtx_bat_get_property(struct power_supply *bat_ps,
45	enum power_supply_property psp,
46	union power_supply_propval *val)
47	{
48	switch (psp) {
49	case POWER_SUPPLY_PROP_STATUS:
50	val->intval = bat_status;
51	break;
52	case POWER_SUPPLY_PROP_TECHNOLOGY:
53	val->intval = POWER_SUPPLY_TECHNOLOGY_LIPO;
54	break;
55	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
56	val->intval = palmtx_read_bat(bat_ps);
57	break;
58	case POWER_SUPPLY_PROP_VOLTAGE_MAX:
59	case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
60	val->intval = PALMTX_BAT_MAX_VOLTAGE;
61	break;
62	case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
63	val->intval = PALMTX_BAT_MIN_VOLTAGE;
64	break;
65	case POWER_SUPPLY_PROP_TEMP:
66	val->intval = palmtx_read_temp(bat_ps);
67	break;
68	case POWER_SUPPLY_PROP_PRESENT:
69	val->intval = 1;
70	break;
71	default:
72	return -EINVAL;
73	}
74	return 0;
75	}
76
77	static void palmtx_bat_external_power_changed(struct power_supply *bat_ps)
78	{
79	schedule_work(&bat_work);
80	}
81
82	static char *status_text[] = {
83	[POWER_SUPPLY_STATUS_UNKNOWN] = "Unknown",
84	[POWER_SUPPLY_STATUS_CHARGING] = "Charging",
85	[POWER_SUPPLY_STATUS_DISCHARGING] = "Discharging",
86	};
87
88	static void palmtx_bat_update(struct power_supply *bat_ps)
89	{
90	int old_status = bat_status;
91
92	mutex_lock(&work_lock);
93
94	bat_status = gpio_get_value(GPIO_NR_PALMTX_POWER_DETECT) ?
95	POWER_SUPPLY_STATUS_CHARGING :
96	POWER_SUPPLY_STATUS_DISCHARGING;
97
98	if (old_status != bat_status) {
99	pr_debug("%s %s -> %s\n", bat_ps->name,
100	status_text[old_status],
101	status_text[bat_status]);
102	power_supply_changed(bat_ps);
103	}
104
105	mutex_unlock(&work_lock);
106	}
107
108	static enum power_supply_property palmtx_bat_main_props[] = {
109	POWER_SUPPLY_PROP_STATUS,
110	POWER_SUPPLY_PROP_TECHNOLOGY,
111	POWER_SUPPLY_PROP_VOLTAGE_NOW,
112	POWER_SUPPLY_PROP_VOLTAGE_MAX,
113	POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
114	POWER_SUPPLY_PROP_TEMP,
115	POWER_SUPPLY_PROP_PRESENT,
116	};
117
118	struct power_supply bat_ps = {
119	.name = "main-battery",
120	.type = POWER_SUPPLY_TYPE_BATTERY,
121	.properties = palmtx_bat_main_props,
122	.num_properties = ARRAY_SIZE(palmtx_bat_main_props),
123	.get_property = palmtx_bat_get_property,
124	.external_power_changed = palmtx_bat_external_power_changed,
125	.use_for_apm = 1,
126	};
127
128	static void palmtx_bat_work(struct work_struct *work)
129	{
130	palmtx_bat_update(&bat_ps);
131	}
132
133	#ifdef CONFIG_PM
134	static int palmtx_bat_suspend(struct platform_device *dev, pm_message_t state)
135	{
136	flush_scheduled_work();
137	return 0;
138	}
139
140	static int palmtx_bat_resume(struct platform_device *dev)
141	{
142	schedule_work(&bat_work);
143	return 0;
144	}
145	#else
146	#define palmtx_bat_suspend NULL
147	#define palmtx_bat_resume NULL
148	#endif
149
150	static int __devinit palmtx_bat_probe(struct platform_device *dev)
151	{
152	int ret = 0;
153
154	if (!machine_is_palmtx())
155	return -ENODEV;
156
157	mutex_init(&work_lock);
158
159	INIT_WORK(&bat_work, palmtx_bat_work);
160
161	ret = power_supply_register(&dev->dev, &bat_ps);
162	if (!ret)
163	schedule_work(&bat_work);
164
165	return ret;
166	}
167
168	static int __devexit palmtx_bat_remove(struct platform_device *dev)
169	{
170	power_supply_unregister(&bat_ps);
171	return 0;
172	}
173
174	static struct platform_driver palmtx_bat_driver = {
175	.driver.name = "wm97xx-battery",
176	.driver.owner = THIS_MODULE,
177	.probe = palmtx_bat_probe,
178	.remove = __devexit_p(palmtx_bat_remove),
179	.suspend = palmtx_bat_suspend,
180	.resume = palmtx_bat_resume,
181	};
182
183	static int __init palmtx_bat_init(void)
184	{
185	return platform_driver_register(&palmtx_bat_driver);
186	}
187
188	static void __exit palmtx_bat_exit(void)
189	{
190	platform_driver_unregister(&palmtx_bat_driver);
191	}
192
193	module_init(palmtx_bat_init);
194	module_exit(palmtx_bat_exit);
195
196	MODULE_LICENSE("GPL");
197	MODULE_AUTHOR("Marek Vasut <marek.vasut@gmail.com>");
198	MODULE_DESCRIPTION("Palm T\|X battery driver");


diff --git a/drivers/power/wm97xx_battery.c b/drivers/power/wm97xx_battery.c new file mode 100644 index 000000000000..8bde92126d34 --- /dev/null +++ b/drivers/power/wm97xx_battery.c
@@ -0,0 +1,272 @@
		1	/*
		2	* linux/drivers/power/wm97xx_battery.c
		3	*
		4	* Battery measurement code for WM97xx
		5	*
		6	* based on tosa_battery.c
		7	*
		8	* Copyright (C) 2008 Marek Vasut <marek.vasut@gmail.com>
		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
		16	#include <linux/init.h>
		17	#include <linux/kernel.h>
		18	#include <linux/module.h>
		19	#include <linux/platform_device.h>
		20	#include <linux/power_supply.h>
		21	#include <linux/wm97xx.h>
		22	#include <linux/spinlock.h>
		23	#include <linux/interrupt.h>
		24	#include <linux/gpio.h>
		25	#include <linux/wm97xx_batt.h>
		26
		27	static DEFINE_MUTEX(bat_lock);
		28	static struct work_struct bat_work;
		29	struct mutex work_lock;
		30	static int bat_status = POWER_SUPPLY_STATUS_UNKNOWN;
		31	static struct wm97xx_batt_info *pdata;
		32	static enum power_supply_property *prop;
		33
		34	static unsigned long wm97xx_read_bat(struct power_supply *bat_ps)
		35	{
		36	return wm97xx_read_aux_adc(bat_ps->dev->parent->driver_data,
		37	pdata->batt_aux) * pdata->batt_mult /
		38	pdata->batt_div;
		39	}
		40
		41	static unsigned long wm97xx_read_temp(struct power_supply *bat_ps)
		42	{
		43	return wm97xx_read_aux_adc(bat_ps->dev->parent->driver_data,
		44	pdata->temp_aux) * pdata->temp_mult /
		45	pdata->temp_div;
		46	}
		47
		48	static int wm97xx_bat_get_property(struct power_supply *bat_ps,
		49	enum power_supply_property psp,
		50	union power_supply_propval *val)
		51	{
		52	switch (psp) {
		53	case POWER_SUPPLY_PROP_STATUS:
		54	val->intval = bat_status;
		55	break;
		56	case POWER_SUPPLY_PROP_TECHNOLOGY:
		57	val->intval = pdata->batt_tech;
		58	break;
		59	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
		60	if (pdata->batt_aux >= 0)
		61	val->intval = wm97xx_read_bat(bat_ps);
		62	else
		63	return -EINVAL;
		64	break;
		65	case POWER_SUPPLY_PROP_TEMP:
		66	if (pdata->temp_aux >= 0)
		67	val->intval = wm97xx_read_temp(bat_ps);
		68	else
		69	return -EINVAL;
		70	break;
		71	case POWER_SUPPLY_PROP_VOLTAGE_MAX:
		72	if (pdata->max_voltage >= 0)
		73	val->intval = pdata->max_voltage;
		74	else
		75	return -EINVAL;
		76	break;
		77	case POWER_SUPPLY_PROP_VOLTAGE_MIN:
		78	if (pdata->min_voltage >= 0)
		79	val->intval = pdata->min_voltage;
		80	else
		81	return -EINVAL;
		82	break;
		83	case POWER_SUPPLY_PROP_PRESENT:
		84	val->intval = 1;
		85	break;
		86	default:
		87	return -EINVAL;
		88	}
		89	return 0;
		90	}
		91
		92	static void wm97xx_bat_external_power_changed(struct power_supply *bat_ps)
		93	{
		94	schedule_work(&bat_work);
		95	}
		96
		97	static void wm97xx_bat_update(struct power_supply *bat_ps)
		98	{
		99	int old_status = bat_status;
		100
		101	mutex_lock(&work_lock);
		102
		103	bat_status = (pdata->charge_gpio >= 0) ?
		104	(gpio_get_value(pdata->charge_gpio) ?
		105	POWER_SUPPLY_STATUS_DISCHARGING :
		106	POWER_SUPPLY_STATUS_CHARGING) :
		107	POWER_SUPPLY_STATUS_UNKNOWN;
		108
		109	if (old_status != bat_status) {
		110	pr_debug("%s: %i -> %i\n", bat_ps->name, old_status,
		111	bat_status);
		112	power_supply_changed(bat_ps);
		113	}
		114
		115	mutex_unlock(&work_lock);
		116	}
		117
		118	static struct power_supply bat_ps = {
		119	.type = POWER_SUPPLY_TYPE_BATTERY,
		120	.get_property = wm97xx_bat_get_property,
		121	.external_power_changed = wm97xx_bat_external_power_changed,
		122	.use_for_apm = 1,
		123	};
		124
		125	static void wm97xx_bat_work(struct work_struct *work)
		126	{
		127	wm97xx_bat_update(&bat_ps);
		128	}
		129
		130	#ifdef CONFIG_PM
		131	static int wm97xx_bat_suspend(struct platform_device *dev, pm_message_t state)
		132	{
		133	flush_scheduled_work();
		134	return 0;
		135	}
		136
		137	static int wm97xx_bat_resume(struct platform_device *dev)
		138	{
		139	schedule_work(&bat_work);
		140	return 0;
		141	}
		142	#else
		143	#define wm97xx_bat_suspend NULL
		144	#define wm97xx_bat_resume NULL
		145	#endif
		146
		147	static int __devinit wm97xx_bat_probe(struct platform_device *dev)
		148	{
		149	int ret = 0;
		150	int props = 1; /* POWER_SUPPLY_PROP_PRESENT */
		151	int i = 0;
		152
		153	if (dev->id != -1)
		154	return -EINVAL;
		155
		156	mutex_init(&work_lock);
		157
		158	if (!pdata) {
		159	dev_err(&dev->dev, "Please use wm97xx_bat_set_pdata\n");
		160	return -EINVAL;
		161	}
		162
		163	if (pdata->charge_gpio >= 0 && gpio_is_valid(pdata->charge_gpio)) {
		164	ret = gpio_request(pdata->charge_gpio, "BATT CHRG");
		165	if (ret)
		166	goto err;
		167	ret = gpio_direction_input(pdata->charge_gpio);
		168	if (ret)
		169	goto err2;
		170	props++; /* POWER_SUPPLY_PROP_STATUS */
		171	}
		172
		173	if (pdata->batt_tech >= 0)
		174	props++; /* POWER_SUPPLY_PROP_TECHNOLOGY */
		175	if (pdata->temp_aux >= 0)
		176	props++; /* POWER_SUPPLY_PROP_TEMP */
		177	if (pdata->batt_aux >= 0)
		178	props++; /* POWER_SUPPLY_PROP_VOLTAGE_NOW */
		179	if (pdata->max_voltage >= 0)
		180	props++; /* POWER_SUPPLY_PROP_VOLTAGE_MAX */
		181	if (pdata->min_voltage >= 0)
		182	props++; /* POWER_SUPPLY_PROP_VOLTAGE_MIN */
		183
		184	prop = kzalloc(props * sizeof(*prop), GFP_KERNEL);
		185	if (!prop)
		186	goto err2;
		187
		188	prop[i++] = POWER_SUPPLY_PROP_PRESENT;
		189	if (pdata->charge_gpio >= 0)
		190	prop[i++] = POWER_SUPPLY_PROP_STATUS;
		191	if (pdata->batt_tech >= 0)
		192	prop[i++] = POWER_SUPPLY_PROP_TECHNOLOGY;
		193	if (pdata->temp_aux >= 0)
		194	prop[i++] = POWER_SUPPLY_PROP_TEMP;
		195	if (pdata->batt_aux >= 0)
		196	prop[i++] = POWER_SUPPLY_PROP_VOLTAGE_NOW;
		197	if (pdata->max_voltage >= 0)
		198	prop[i++] = POWER_SUPPLY_PROP_VOLTAGE_MAX;
		199	if (pdata->min_voltage >= 0)
		200	prop[i++] = POWER_SUPPLY_PROP_VOLTAGE_MIN;
		201
		202	INIT_WORK(&bat_work, wm97xx_bat_work);
		203
		204	if (!pdata->batt_name) {
		205	dev_info(&dev->dev, "Please consider setting proper battery "
		206	"name in platform definition file, falling "
		207	"back to name \"wm97xx-batt\"\n");
		208	bat_ps.name = "wm97xx-batt";
		209	} else
		210	bat_ps.name = pdata->batt_name;
		211
		212	bat_ps.properties = prop;
		213	bat_ps.num_properties = props;
		214
		215	ret = power_supply_register(&dev->dev, &bat_ps);
		216	if (!ret)
		217	schedule_work(&bat_work);
		218	else
		219	goto err3;
		220
		221	return 0;
		222	err3:
		223	kfree(prop);
		224	err2:
		225	gpio_free(pdata->charge_gpio);
		226	err:
		227	return ret;
		228	}
		229
		230	static int __devexit wm97xx_bat_remove(struct platform_device *dev)
		231	{
		232	if (pdata && pdata->charge_gpio && pdata->charge_gpio >= 0)
		233	gpio_free(pdata->charge_gpio);
		234	flush_scheduled_work();
		235	power_supply_unregister(&bat_ps);
		236	kfree(prop);
		237	return 0;
		238	}
		239
		240	static struct platform_driver wm97xx_bat_driver = {
		241	.driver = {
		242	.name = "wm97xx-battery",
		243	.owner = THIS_MODULE,
		244	},
		245	.probe = wm97xx_bat_probe,
		246	.remove = __devexit_p(wm97xx_bat_remove),
		247	.suspend = wm97xx_bat_suspend,
		248	.resume = wm97xx_bat_resume,
		249	};
		250
		251	static int __init wm97xx_bat_init(void)
		252	{
		253	return platform_driver_register(&wm97xx_bat_driver);
		254	}
		255
		256	static void __exit wm97xx_bat_exit(void)
		257	{
		258	platform_driver_unregister(&wm97xx_bat_driver);
		259	}
		260
		261	void __init wm97xx_bat_set_pdata(struct wm97xx_batt_info *data)
		262	{
		263	pdata = data;
		264	}
		265	EXPORT_SYMBOL_GPL(wm97xx_bat_set_pdata);
		266
		267	module_init(wm97xx_bat_init);
		268	module_exit(wm97xx_bat_exit);
		269
		270	MODULE_LICENSE("GPL");
		271	MODULE_AUTHOR("Marek Vasut <marek.vasut@gmail.com>");
		272	MODULE_DESCRIPTION("WM97xx battery driver");


diff --git a/include/linux/wm97xx_batt.h b/include/linux/wm97xx_batt.h new file mode 100644 index 000000000000..9681d1ab0e4f --- /dev/null +++ b/include/linux/wm97xx_batt.h
@@ -0,0 +1,26 @@
		1	#ifndef _LINUX_WM97XX_BAT_H
		2	#define _LINUX_WM97XX_BAT_H
		3
		4	#include <linux/wm97xx.h>
		5
		6	struct wm97xx_batt_info {
		7	int batt_aux;
		8	int temp_aux;
		9	int charge_gpio;
		10	int min_voltage;
		11	int max_voltage;
		12	int batt_div;
		13	int batt_mult;
		14	int temp_div;
		15	int temp_mult;
		16	int batt_tech;
		17	char *batt_name;
		18	};
		19
		20	#ifdef CONFIG_BATTERY_WM97XX
		21	void __init wm97xx_bat_set_pdata(struct wm97xx_batt_info *data);
		22	#else
		23	static inline void wm97xx_bat_set_pdata(struct wm97xx_batt_info *data) {}
		24	#endif
		25
		26	#endif