Menu
▾
▴
[Hackndev-commit] SF.net SVN: hackndev: [1070] linux4palm/linux/trunk/arch/arm/mach-pxa
|
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.
|
