From: <mar...@us...> - 2007-06-24 18:01:21
|
Revision: 1070 http://svn.sourceforge.net/hackndev/?rev=1070&view=rev Author: marex_z71 Date: 2007-06-24 11:01:19 -0700 (Sun, 24 Jun 2007) Log Message: ----------- PalmLD, PalmTX, PalmT5, PalmZ72: fix battery driver once more Modified Paths: -------------- linux4palm/linux/trunk/arch/arm/mach-pxa/palmld/palmld_battery.c linux4palm/linux/trunk/arch/arm/mach-pxa/palmt5/palmt5_battery.c linux4palm/linux/trunk/arch/arm/mach-pxa/palmtx/palmtx_battery.c linux4palm/linux/trunk/arch/arm/mach-pxa/palmz72/palmz72_battery.c Modified: linux4palm/linux/trunk/arch/arm/mach-pxa/palmld/palmld_battery.c =================================================================== --- linux4palm/linux/trunk/arch/arm/mach-pxa/palmld/palmld_battery.c 2007-06-24 13:47:32 UTC (rev 1069) +++ linux4palm/linux/trunk/arch/arm/mach-pxa/palmld/palmld_battery.c 2007-06-24 18:01:19 UTC (rev 1070) @@ -16,7 +16,7 @@ #include <linux/input.h> #include <linux/device.h> #include <linux/workqueue.h> -#include <linux/battery.h> +#include <linux/power_supply.h> #include <linux/apm-emulation.h> #include <linux/wm97xx.h> @@ -51,13 +51,13 @@ static void (*apm_get_power_status_orig)(struct apm_power_info *info); #endif -int palmld_battery_min_voltage(struct battery *b) +int palmld_battery_min_voltage(struct power_supply *b) { return PALMLD_BAT_MIN_VOLTAGE; } -int palmld_battery_max_voltage(struct battery *b) +int palmld_battery_max_voltage(struct power_supply *b) { return PALMLD_BAT_MAX_VOLTAGE; /* mV */ } @@ -67,7 +67,7 @@ V_batt = ADCSEL_BMON * 1,889 + 767,8 [mV] */ -int palmld_battery_get_voltage(struct battery *b) +int palmld_battery_get_voltage(struct power_supply *b) { if (bat.battery_registered){ bat.previous_voltage = bat.current_voltage; @@ -81,7 +81,7 @@ } } -int palmld_battery_get_capacity(struct battery *b) +int palmld_battery_get_capacity(struct power_supply *b) { if (bat.battery_registered){ return (((palmld_battery_get_voltage(b)-palmld_battery_min_voltage(b)) @@ -93,66 +93,65 @@ } } -int palmld_battery_get_status(struct battery *b) +int palmld_battery_get_status(struct power_supply *b) { int ac_connected = GET_PALMLD_GPIO(POWER_DETECT); int usb_connected = !GET_PALMLD_GPIO(USB_DETECT); - if (bat.current_voltage <= 0) - return BATTERY_STATUS_UNKNOWN; - - if (ac_connected || usb_connected){ - if ( ( bat.current_voltage > bat.previous_voltage ) || (bat.current_voltage <= PALMLD_BAT_MAX_VOLTAGE) ) - return BATTERY_STATUS_CHARGING; - return BATTERY_STATUS_NOT_CHARGING; - } + if ( (ac_connected || usb_connected) && + ( ( bat.current_voltage > bat.previous_voltage ) || + (bat.current_voltage <= PALMLD_BAT_MAX_VOLTAGE) ) ) + return POWER_SUPPLY_STATUS_CHARGING; else - return BATTERY_STATUS_DISCHARGING; + return POWER_SUPPLY_STATUS_NOT_CHARGING; } int tmp; -static void *palmld_battery_get_property(struct battery *b, enum battery_property bp) +static int palmld_battery_get_property(struct power_supply *b, + enum power_supply_property psp, + union power_supply_propval *val) { - switch (bp) { - case BATTERY_PROP_VOLTAGE_MAX_DESIGN: - tmp = palmld_battery_max_voltage(b); - return &tmp; - case BATTERY_PROP_VOLTAGE_MIN_DESIGN: - tmp = palmld_battery_min_voltage(b); - return &tmp; - case BATTERY_PROP_CHARGE_FULL_DESIGN: - tmp = 100; - return &tmp; - case BATTERY_PROP_CHARGE_EMPTY_DESIGN: - tmp = 0; - return &tmp; - case BATTERY_PROP_CHARGE_NOW: - tmp = palmld_battery_get_capacity(b); - return &tmp; - case BATTERY_PROP_VOLTAGE_NOW: - tmp = palmld_battery_get_voltage(b); - return &tmp; - case BATTERY_PROP_STATUS: - tmp = palmld_battery_get_status(b); - return &tmp; - default: break; + switch (psp) { + case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN: + val->intval = palmld_battery_max_voltage(b); + break; + case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN: + val->intval = palmld_battery_min_voltage(b); + break; + case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN: + val->intval = 100; + break; + case POWER_SUPPLY_PROP_CHARGE_EMPTY_DESIGN: + val->intval = 0; + break; + case POWER_SUPPLY_PROP_CHARGE_NOW: + val->intval = palmld_battery_get_capacity(b); + break; + case POWER_SUPPLY_PROP_VOLTAGE_NOW: + val->intval = palmld_battery_get_voltage(b); + break; + case POWER_SUPPLY_PROP_STATUS: + val->intval = palmld_battery_get_status(b); + break; + default: + break; }; - return NULL; + return 0; } -static enum battery_property palmld_battery_props[] = { - BATTERY_PROP_VOLTAGE_MAX_DESIGN, - BATTERY_PROP_VOLTAGE_MIN_DESIGN, - BATTERY_PROP_CHARGE_FULL_DESIGN, - BATTERY_PROP_CHARGE_EMPTY_DESIGN, - BATTERY_PROP_CHARGE_NOW, - BATTERY_PROP_VOLTAGE_NOW, - BATTERY_PROP_STATUS, +static enum power_supply_property palmld_battery_props[] = { + POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN, + POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN, + POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, + POWER_SUPPLY_PROP_CHARGE_EMPTY_DESIGN, + POWER_SUPPLY_PROP_CHARGE_NOW, + POWER_SUPPLY_PROP_VOLTAGE_NOW, + POWER_SUPPLY_PROP_STATUS, }; -struct battery palmld_battery = { +struct power_supply palmld_battery = { .name = "palmld_battery", .get_property = palmld_battery_get_property, .properties = palmld_battery_props, @@ -248,14 +247,15 @@ /* register battery to APM layer */ bat.battery_registered = 0; - - if(battery_register(NULL, &palmld_battery)) { +#ifdef CONFIG_POWER_SUPPLY + if(power_supply_register(NULL, &palmld_battery)) { printk(KERN_ERR "palmld_ac97_probe: could not register battery class\n"); } else { bat.battery_registered = 1; printk("Battery registered\n"); } +#endif #if defined(CONFIG_APM_EMULATION) || defined(CONFIG_APM_MODULE) apm_get_power_status_orig = apm_get_power_status; apm_get_power_status = palmld_apm_get_power_status; @@ -272,7 +272,9 @@ static void __exit palmld_wm97xx_exit(void) { /* TODO - recover APM callback to original state */ - battery_unregister(&palmld_battery); +#ifdef CONFIG_POWER_SUPPLY + power_supply_unregister(&palmld_battery); +#endif driver_unregister(&palmld_wm97xx_driver); } Modified: linux4palm/linux/trunk/arch/arm/mach-pxa/palmt5/palmt5_battery.c =================================================================== --- linux4palm/linux/trunk/arch/arm/mach-pxa/palmt5/palmt5_battery.c 2007-06-24 13:47:32 UTC (rev 1069) +++ linux4palm/linux/trunk/arch/arm/mach-pxa/palmt5/palmt5_battery.c 2007-06-24 18:01:19 UTC (rev 1070) @@ -15,7 +15,7 @@ #include <linux/input.h> #include <linux/device.h> #include <linux/workqueue.h> -#include <linux/battery.h> +#include <linux/power_supply.h> #include <linux/apm-emulation.h> #include <linux/wm97xx.h> @@ -50,13 +50,13 @@ static void (*apm_get_power_status_orig)(struct apm_power_info *info); #endif -int palmt5_battery_min_voltage(struct battery *b) +int palmt5_battery_min_voltage(struct power_supply *b) { return PALMT5_BAT_MIN_VOLTAGE; } -int palmt5_battery_max_voltage(struct battery *b) +int palmt5_battery_max_voltage(struct power_supply *b) { return PALMT5_BAT_MAX_VOLTAGE; /* mV */ } @@ -66,7 +66,7 @@ V_batt = ADCSEL_BMON * 1,889 + 767,8 [mV] */ -int palmt5_battery_get_voltage(struct battery *b) +int palmt5_battery_get_voltage(struct power_supply *b) { if (bat.battery_registered){ bat.previous_voltage = bat.current_voltage; @@ -80,7 +80,7 @@ } } -int palmt5_battery_get_capacity(struct battery *b) +int palmt5_battery_get_capacity(struct power_supply *b) { if (bat.battery_registered){ return (((palmt5_battery_get_voltage(b)-palmt5_battery_min_voltage(b)) @@ -92,66 +92,65 @@ } } -int palmt5_battery_get_status(struct battery *b) +int palmt5_battery_get_status(struct power_supply *b) { - int ac_connected = GET_GPIO(GPIO_NR_PALMT5_POWER_DETECT); - int usb_connected = !GET_GPIO(GPIO_NR_PALMT5_USB_DETECT); - - if (bat.current_voltage <= 0) - return BATTERY_STATUS_UNKNOWN; - - if (ac_connected || usb_connected){ - if ( ( bat.current_voltage > bat.previous_voltage ) || (bat.current_voltage <= PALMT5_BAT_MAX_VOLTAGE) ) - return BATTERY_STATUS_CHARGING; - return BATTERY_STATUS_NOT_CHARGING; - } - else - return BATTERY_STATUS_DISCHARGING; + int ac_connected = GET_PALMT5_GPIO(POWER_DETECT); + int usb_connected = !GET_PALMT5_GPIO(USB_DETECT); + + if ( (ac_connected || usb_connected) && + ( ( bat.current_voltage > bat.previous_voltage ) || + (bat.current_voltage <= PALMT5_BAT_MAX_VOLTAGE) ) ) + return POWER_SUPPLY_STATUS_CHARGING; + else + return POWER_SUPPLY_STATUS_NOT_CHARGING; } int tmp; -static void *palmt5_battery_get_property(struct battery *b, enum battery_property bp) +static int palmt5_battery_get_property(struct power_supply *b, + enum power_supply_property psp, + union power_supply_propval *val) { - switch (bp) { - case BATTERY_PROP_VOLTAGE_MAX_DESIGN: - tmp = palmt5_battery_max_voltage(b); - return &tmp; - case BATTERY_PROP_VOLTAGE_MIN_DESIGN: - tmp = palmt5_battery_min_voltage(b); - return &tmp; - case BATTERY_PROP_CHARGE_FULL_DESIGN: - tmp = 100; - return &tmp; - case BATTERY_PROP_CHARGE_EMPTY_DESIGN: - tmp = 0; - return &tmp; - case BATTERY_PROP_CHARGE_NOW: - tmp = palmt5_battery_get_capacity(b); - return &tmp; - case BATTERY_PROP_VOLTAGE_NOW: - tmp = palmt5_battery_get_voltage(b); - return &tmp; - case BATTERY_PROP_STATUS: - tmp = palmt5_battery_get_status(b); - return &tmp; - default: break; + switch (psp) { + case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN: + val->intval = palmt5_battery_max_voltage(b); + break; + case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN: + val->intval = palmt5_battery_min_voltage(b); + break; + case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN: + val->intval = 100; + break; + case POWER_SUPPLY_PROP_CHARGE_EMPTY_DESIGN: + val->intval = 0; + break; + case POWER_SUPPLY_PROP_CHARGE_NOW: + val->intval = palmt5_battery_get_capacity(b); + break; + case POWER_SUPPLY_PROP_VOLTAGE_NOW: + val->intval = palmt5_battery_get_voltage(b); + break; + case POWER_SUPPLY_PROP_STATUS: + val->intval = palmt5_battery_get_status(b); + break; + default: + break; }; - return NULL; + return 0; } -static enum battery_property palmt5_battery_props[] = { - BATTERY_PROP_VOLTAGE_MAX_DESIGN, - BATTERY_PROP_VOLTAGE_MIN_DESIGN, - BATTERY_PROP_CHARGE_FULL_DESIGN, - BATTERY_PROP_CHARGE_EMPTY_DESIGN, - BATTERY_PROP_CHARGE_NOW, - BATTERY_PROP_VOLTAGE_NOW, - BATTERY_PROP_STATUS, +static enum power_supply_property palmt5_battery_props[] = { + POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN, + POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN, + POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, + POWER_SUPPLY_PROP_CHARGE_EMPTY_DESIGN, + POWER_SUPPLY_PROP_CHARGE_NOW, + POWER_SUPPLY_PROP_VOLTAGE_NOW, + POWER_SUPPLY_PROP_STATUS, }; -struct battery palmt5_battery = { +struct power_supply palmt5_battery = { .name = "palmt5_battery", .get_property = palmt5_battery_get_property, .properties = palmt5_battery_props, @@ -258,13 +257,15 @@ /* register battery to APM layer */ bat.battery_registered = 0; - if(battery_register(NULL, &palmt5_battery)) { +#ifdef CONFIG_POWER_SUPPLY + if(power_supply_register(NULL, &palmt5_battery)) { printk(KERN_ERR "palmt5_ac97_probe: could not register battery class\n"); } else { bat.battery_registered = 1; printk("Battery registered\n"); } +#endif #if defined(CONFIG_APM_EMULATION) || defined(CONFIG_APM_MODULE) apm_get_power_status_orig = apm_get_power_status; apm_get_power_status = palmt5_apm_get_power_status; @@ -281,7 +282,9 @@ static void __exit palmt5_wm97xx_exit(void) { /* TODO - recover APM callback to original state */ - battery_unregister(&palmt5_battery); +#ifdef CONFIG_POWER_SUPPLY + power_supply_unregister(&palmt5_battery); +#endif driver_unregister(&palmt5_wm97xx_driver); } Modified: linux4palm/linux/trunk/arch/arm/mach-pxa/palmtx/palmtx_battery.c =================================================================== --- linux4palm/linux/trunk/arch/arm/mach-pxa/palmtx/palmtx_battery.c 2007-06-24 13:47:32 UTC (rev 1069) +++ linux4palm/linux/trunk/arch/arm/mach-pxa/palmtx/palmtx_battery.c 2007-06-24 18:01:19 UTC (rev 1070) @@ -20,7 +20,7 @@ #include <linux/input.h> #include <linux/device.h> #include <linux/workqueue.h> -#include <linux/battery.h> +#include <linux/power_supply.h> #include <linux/apm-emulation.h> #include <linux/wm97xx.h> @@ -55,13 +55,13 @@ static void (*apm_get_power_status_orig)(struct apm_power_info *info); #endif -int palmtx_battery_min_voltage(struct battery *b) +int palmtx_battery_min_voltage(struct power_supply *b) { return PALMTX_BAT_MIN_VOLTAGE; } -int palmtx_battery_max_voltage(struct battery *b) +int palmtx_battery_max_voltage(struct power_supply *b) { return PALMTX_BAT_MAX_VOLTAGE; /* mV */ } @@ -71,7 +71,7 @@ V_batt = ADCSEL_BMON * 1,889 + 767,8 [mV] */ -int palmtx_battery_get_voltage(struct battery *b) +int palmtx_battery_get_voltage(struct power_supply *b) { if (bat.battery_registered){ bat.previous_voltage = bat.current_voltage; @@ -85,7 +85,7 @@ } } -int palmtx_battery_get_capacity(struct battery *b) +int palmtx_battery_get_capacity(struct power_supply *b) { if (bat.battery_registered){ return (((palmtx_battery_get_voltage(b)-palmtx_battery_min_voltage(b)) @@ -97,66 +97,65 @@ } } -int palmtx_battery_get_status(struct battery *b) +int palmtx_battery_get_status(struct power_supply *b) { - int ac_connected = GET_GPIO(GPIO_NR_PALMTX_POWER_DETECT); - int usb_connected = !GET_GPIO(GPIO_NR_PALMTX_USB_DETECT); - - if (bat.current_voltage <= 0) - return BATTERY_STATUS_UNKNOWN; - - if (ac_connected || usb_connected){ - if ( ( bat.current_voltage > bat.previous_voltage ) || (bat.current_voltage <= PALMTX_BAT_MAX_VOLTAGE) ) - return BATTERY_STATUS_CHARGING; - return BATTERY_STATUS_NOT_CHARGING; - } - else - return BATTERY_STATUS_DISCHARGING; + int ac_connected = GET_PALMTX_GPIO(POWER_DETECT); + int usb_connected = !GET_PALMTX_GPIO(USB_DETECT); + + if ( (ac_connected || usb_connected) && + ( ( bat.current_voltage > bat.previous_voltage ) || + (bat.current_voltage <= PALMTX_BAT_MAX_VOLTAGE) ) ) + return POWER_SUPPLY_STATUS_CHARGING; + else + return POWER_SUPPLY_STATUS_NOT_CHARGING; } int tmp; -static void *palmtx_battery_get_property(struct battery *b, enum battery_property bp) +static int palmtx_battery_get_property(struct power_supply *b, + enum power_supply_property psp, + union power_supply_propval *val) { - switch (bp) { - case BATTERY_PROP_VOLTAGE_MAX_DESIGN: - tmp = palmtx_battery_max_voltage(b); - return &tmp; - case BATTERY_PROP_VOLTAGE_MIN_DESIGN: - tmp = palmtx_battery_min_voltage(b); - return &tmp; - case BATTERY_PROP_CHARGE_FULL_DESIGN: - tmp = 100; - return &tmp; - case BATTERY_PROP_CHARGE_EMPTY_DESIGN: - tmp = 0; - return &tmp; - case BATTERY_PROP_CHARGE_NOW: - tmp = palmtx_battery_get_capacity(b); - return &tmp; - case BATTERY_PROP_VOLTAGE_NOW: - tmp = palmtx_battery_get_voltage(b); - return &tmp; - case BATTERY_PROP_STATUS: - tmp = palmtx_battery_get_status(b); - return &tmp; - default: break; + switch (psp) { + case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN: + val->intval = palmtx_battery_max_voltage(b); + break; + case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN: + val->intval = palmtx_battery_min_voltage(b); + break; + case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN: + val->intval = 100; + break; + case POWER_SUPPLY_PROP_CHARGE_EMPTY_DESIGN: + val->intval = 0; + break; + case POWER_SUPPLY_PROP_CHARGE_NOW: + val->intval = palmtx_battery_get_capacity(b); + break; + case POWER_SUPPLY_PROP_VOLTAGE_NOW: + val->intval = palmtx_battery_get_voltage(b); + break; + case POWER_SUPPLY_PROP_STATUS: + val->intval = palmtx_battery_get_status(b); + break; + default: + break; }; - return NULL; + return 0; } -static enum battery_property palmtx_battery_props[] = { - BATTERY_PROP_VOLTAGE_MAX_DESIGN, - BATTERY_PROP_VOLTAGE_MIN_DESIGN, - BATTERY_PROP_CHARGE_FULL_DESIGN, - BATTERY_PROP_CHARGE_EMPTY_DESIGN, - BATTERY_PROP_CHARGE_NOW, - BATTERY_PROP_VOLTAGE_NOW, - BATTERY_PROP_STATUS, +static enum power_supply_property palmtx_battery_props[] = { + POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN, + POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN, + POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, + POWER_SUPPLY_PROP_CHARGE_EMPTY_DESIGN, + POWER_SUPPLY_PROP_CHARGE_NOW, + POWER_SUPPLY_PROP_VOLTAGE_NOW, + POWER_SUPPLY_PROP_STATUS, }; -struct battery palmtx_battery = { +struct power_supply palmtx_battery = { .name = "palmtx_battery", .get_property = palmtx_battery_get_property, .properties = palmtx_battery_props, @@ -263,13 +262,15 @@ /* register battery to APM layer */ bat.battery_registered = 0; - if(battery_register(NULL, &palmtx_battery)) { +#fidef CONFIG_POWER_SUPPLY + if(power_supply_register(NULL, &palmtx_battery)) { printk(KERN_ERR "palmtx_ac97_probe: could not register battery class\n"); } else { bat.battery_registered = 1; printk("Battery registered\n"); } +#endif #if defined(CONFIG_APM_EMULATION) || defined(CONFIG_APM_MODULE) apm_get_power_status_orig = apm_get_power_status; apm_get_power_status = palmtx_apm_get_power_status; @@ -286,7 +287,9 @@ static void __exit palmtx_wm97xx_exit(void) { /* TODO - recover APM callback to original state */ - battery_unregister(&palmtx_battery); +#fidef CONFIG_POWER_SUPPLY + power_supply_unregister(&palmtx_battery); +#endif driver_unregister(&palmtx_wm97xx_driver); } Modified: linux4palm/linux/trunk/arch/arm/mach-pxa/palmz72/palmz72_battery.c =================================================================== --- linux4palm/linux/trunk/arch/arm/mach-pxa/palmz72/palmz72_battery.c 2007-06-24 13:47:32 UTC (rev 1069) +++ linux4palm/linux/trunk/arch/arm/mach-pxa/palmz72/palmz72_battery.c 2007-06-24 18:01:19 UTC (rev 1070) @@ -16,7 +16,7 @@ #include <linux/input.h> #include <linux/device.h> #include <linux/workqueue.h> -#include <linux/battery.h> +#include <linux/power_supply.h> #include <linux/apm-emulation.h> #include <linux/wm97xx.h> @@ -55,13 +55,13 @@ static void (*apm_get_power_status_orig)(struct apm_power_info *info); #endif -int palmz72_battery_min_voltage(struct battery *b) +int palmz72_battery_min_voltage(struct power_supply *b) { return PALMZ72_BAT_MIN_VOLTAGE; } -int palmz72_battery_max_voltage(struct battery *b) +int palmz72_battery_max_voltage(struct power_supply *b) { return PALMZ72_BAT_MAX_VOLTAGE; /* mV */ } @@ -71,7 +71,7 @@ V_batt = ADCSEL_BMON * 1,889 + 767,8 [mV] */ -int palmz72_battery_get_voltage(struct battery *b) +int palmz72_battery_get_voltage(struct power_supply *b) { if (bat.battery_registered){ bat.previous_voltage = bat.current_voltage; @@ -85,7 +85,7 @@ } } -int palmz72_battery_get_capacity(struct battery *b) +int palmz72_battery_get_capacity(struct power_supply *b) { if (bat.battery_registered){ return (((palmz72_battery_get_voltage(b)-palmz72_battery_min_voltage(b)) @@ -97,66 +97,65 @@ } } -int palmz72_battery_get_status(struct battery *b) +int palmz72_battery_get_status(struct power_supply *b) { - int ac_connected = GET_GPIO(GPIO_NR_PALMZ72_POWER_DETECT); - int usb_connected = !GET_GPIO(GPIO_NR_PALMZ72_USB_DETECT); - - if (bat.current_voltage <= 0) - return BATTERY_STATUS_UNKNOWN; - - if (ac_connected || usb_connected){ - if ( ( bat.current_voltage > bat.previous_voltage ) || (bat.current_voltage <= PALMZ72_BAT_MAX_VOLTAGE) ) - return BATTERY_STATUS_CHARGING; - return BATTERY_STATUS_NOT_CHARGING; - } - else - return BATTERY_STATUS_DISCHARGING; + int ac_connected = GET_PALMZ72_GPIO(POWER_DETECT); + int usb_connected = !GET_PALMZ72_GPIO(USB_DETECT); + + if ( (ac_connected || usb_connected) && + ( ( bat.current_voltage > bat.previous_voltage ) || + (bat.current_voltage <= PALMZ72_BAT_MAX_VOLTAGE) ) ) + return POWER_SUPPLY_STATUS_CHARGING; + else + return POWER_SUPPLY_STATUS_NOT_CHARGING; } int tmp; -static void *palmz72_battery_get_property(struct battery *b, enum battery_property bp) +static int palmz72_battery_get_property(struct power_supply *b, + enum power_supply_property psp, + union power_supply_propval *val) { - switch (bp) { - case BATTERY_PROP_VOLTAGE_MAX_DESIGN: - tmp = palmz72_battery_max_voltage(b); - return &tmp; - case BATTERY_PROP_VOLTAGE_MIN_DESIGN: - tmp = palmz72_battery_min_voltage(b); - return &tmp; - case BATTERY_PROP_CHARGE_FULL_DESIGN: - tmp = 100; - return &tmp; - case BATTERY_PROP_CHARGE_EMPTY_DESIGN: - tmp = 0; - return &tmp; - case BATTERY_PROP_CHARGE_NOW: - tmp = palmz72_battery_get_capacity(b); - return &tmp; - case BATTERY_PROP_VOLTAGE_NOW: - tmp = palmz72_battery_get_voltage(b); - return &tmp; - case BATTERY_PROP_STATUS: - tmp = palmz72_battery_get_status(b); - return &tmp; - default: break; + switch (psp) { + case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN: + val->intval = palmz72_battery_max_voltage(b); + break; + case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN: + val->intval = palmz72_battery_min_voltage(b); + break; + case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN: + val->intval = 100; + break; + case POWER_SUPPLY_PROP_CHARGE_EMPTY_DESIGN: + val->intval = 0; + break; + case POWER_SUPPLY_PROP_CHARGE_NOW: + val->intval = palmz72_battery_get_capacity(b); + break; + case POWER_SUPPLY_PROP_VOLTAGE_NOW: + val->intval = palmz72_battery_get_voltage(b); + break; + case POWER_SUPPLY_PROP_STATUS: + val->intval = palmz72_battery_get_status(b); + break; + default: + break; }; - return NULL; + return 0; } -static enum battery_property palmz72_battery_props[] = { - BATTERY_PROP_VOLTAGE_MAX_DESIGN, - BATTERY_PROP_VOLTAGE_MIN_DESIGN, - BATTERY_PROP_CHARGE_FULL_DESIGN, - BATTERY_PROP_CHARGE_EMPTY_DESIGN, - BATTERY_PROP_CHARGE_NOW, - BATTERY_PROP_VOLTAGE_NOW, - BATTERY_PROP_STATUS, +static enum power_supply_property palmz72_battery_props[] = { + POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN, + POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN, + POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, + POWER_SUPPLY_PROP_CHARGE_EMPTY_DESIGN, + POWER_SUPPLY_PROP_CHARGE_NOW, + POWER_SUPPLY_PROP_VOLTAGE_NOW, + POWER_SUPPLY_PROP_STATUS, }; -struct battery palmz72_battery = { +struct power_supply palmz72_battery = { .name = "palmz72_battery", .get_property = palmz72_battery_get_property, .properties = palmz72_battery_props, @@ -263,13 +262,15 @@ /* register battery to APM layer */ bat.battery_registered = 0; - if(battery_register(NULL, &palmz72_battery)) { +#ifdef CONFIG_POWER_SUPPLY + if(power_supply_register(NULL, &palmz72_battery)) { printk(KERN_ERR "palmz72_ac97_probe: could not register battery class\n"); } else { bat.battery_registered = 1; printk("Battery registered\n"); } +#endif #if defined(CONFIG_APM_EMULATION) || defined(CONFIG_APM_MODULE) apm_get_power_status_orig = apm_get_power_status; apm_get_power_status = palmz72_apm_get_power_status; @@ -286,7 +287,9 @@ static void __exit palmz72_wm97xx_exit(void) { /* TODO - recover APM callback to original state */ - battery_unregister(&palmz72_battery); +#ifdef CONFIG_POWER_SUPPLY + power_supply_unregister(&palmz72_battery); +#endif driver_unregister(&palmz72_wm97xx_driver); } This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |