2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2007-09-26 09:42:58 -06:00
|
|
|
* battery.c - ACPI Battery Driver (Revision: 2.0)
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2007-09-26 09:42:58 -06:00
|
|
|
* Copyright (C) 2007 Alexey Starikovskiy <astarikovskiy@suse.de>
|
|
|
|
* Copyright (C) 2004-2007 Vladimir Lebedev <vladimir.p.lebedev@intel.com>
|
2005-04-16 16:20:36 -06:00
|
|
|
* Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
|
|
|
|
* Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
|
|
|
|
*
|
|
|
|
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or (at
|
|
|
|
* your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful, but
|
|
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License along
|
|
|
|
* with this program; if not, write to the Free Software Foundation, Inc.,
|
|
|
|
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
|
|
|
|
*
|
|
|
|
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/types.h>
|
2007-09-26 09:42:52 -06:00
|
|
|
#include <linux/jiffies.h>
|
2009-01-10 12:19:05 -07:00
|
|
|
#include <linux/async.h>
|
2009-08-06 16:57:48 -06:00
|
|
|
#include <linux/dmi.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2007-09-26 09:43:04 -06:00
|
|
|
|
2007-11-19 06:33:45 -07:00
|
|
|
#ifdef CONFIG_ACPI_PROCFS_POWER
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/proc_fs.h>
|
|
|
|
#include <linux/seq_file.h>
|
|
|
|
#include <asm/uaccess.h>
|
2007-09-26 09:43:04 -06:00
|
|
|
#endif
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#include <acpi/acpi_bus.h>
|
|
|
|
#include <acpi/acpi_drivers.h>
|
|
|
|
|
2008-01-01 12:27:24 -07:00
|
|
|
#ifdef CONFIG_ACPI_SYSFS_POWER
|
2007-09-26 09:43:04 -06:00
|
|
|
#include <linux/power_supply.h>
|
2008-01-01 12:27:24 -07:00
|
|
|
#endif
|
2007-09-26 09:43:04 -06:00
|
|
|
|
2009-07-28 14:45:54 -06:00
|
|
|
#define PREFIX "ACPI: "
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#define ACPI_BATTERY_VALUE_UNKNOWN 0xFFFFFFFF
|
|
|
|
|
|
|
|
#define ACPI_BATTERY_CLASS "battery"
|
|
|
|
#define ACPI_BATTERY_DEVICE_NAME "Battery"
|
|
|
|
#define ACPI_BATTERY_NOTIFY_STATUS 0x80
|
|
|
|
#define ACPI_BATTERY_NOTIFY_INFO 0x81
|
2009-10-15 04:31:44 -06:00
|
|
|
#define ACPI_BATTERY_NOTIFY_THRESHOLD 0x82
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#define _COMPONENT ACPI_BATTERY_COMPONENT
|
2007-02-20 05:48:06 -07:00
|
|
|
|
2007-02-12 20:42:12 -07:00
|
|
|
ACPI_MODULE_NAME("battery");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-02-12 20:42:12 -07:00
|
|
|
MODULE_AUTHOR("Paul Diefenbaugh");
|
2007-09-26 09:42:58 -06:00
|
|
|
MODULE_AUTHOR("Alexey Starikovskiy <astarikovskiy@suse.de>");
|
2007-02-12 21:50:02 -07:00
|
|
|
MODULE_DESCRIPTION("ACPI Battery Driver");
|
2005-04-16 16:20:36 -06:00
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
|
2007-09-26 09:42:52 -06:00
|
|
|
static unsigned int cache_time = 1000;
|
|
|
|
module_param(cache_time, uint, 0644);
|
|
|
|
MODULE_PARM_DESC(cache_time, "cache time in milliseconds");
|
2007-02-20 05:48:06 -07:00
|
|
|
|
2007-11-19 06:33:45 -07:00
|
|
|
#ifdef CONFIG_ACPI_PROCFS_POWER
|
2006-07-01 09:36:54 -06:00
|
|
|
extern struct proc_dir_entry *acpi_lock_battery_dir(void);
|
|
|
|
extern void *acpi_unlock_battery_dir(struct proc_dir_entry *acpi_battery_dir);
|
|
|
|
|
2007-09-26 09:43:04 -06:00
|
|
|
enum acpi_battery_files {
|
|
|
|
info_tag = 0,
|
|
|
|
state_tag,
|
|
|
|
alarm_tag,
|
|
|
|
ACPI_BATTERY_NUMFILES,
|
|
|
|
};
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2007-07-23 06:44:41 -06:00
|
|
|
static const struct acpi_device_id battery_device_ids[] = {
|
|
|
|
{"PNP0C0A", 0},
|
|
|
|
{"", 0},
|
|
|
|
};
|
|
|
|
|
2007-09-26 09:42:58 -06:00
|
|
|
MODULE_DEVICE_TABLE(acpi, battery_device_ids);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-10-15 04:31:24 -06:00
|
|
|
enum {
|
|
|
|
ACPI_BATTERY_ALARM_PRESENT,
|
2009-10-15 04:31:44 -06:00
|
|
|
ACPI_BATTERY_XINFO_PRESENT,
|
|
|
|
/* For buggy DSDTs that report negative 16-bit values for either
|
|
|
|
* charging or discharging current and/or report 0 as 65536
|
|
|
|
* due to bad math.
|
|
|
|
*/
|
2009-10-15 04:31:24 -06:00
|
|
|
ACPI_BATTERY_QUIRK_SIGNED16_CURRENT,
|
|
|
|
};
|
2007-05-11 11:18:55 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
struct acpi_battery {
|
2007-09-26 09:42:46 -06:00
|
|
|
struct mutex lock;
|
2008-01-01 12:27:24 -07:00
|
|
|
#ifdef CONFIG_ACPI_SYSFS_POWER
|
2007-09-26 09:43:04 -06:00
|
|
|
struct power_supply bat;
|
2008-01-01 12:27:24 -07:00
|
|
|
#endif
|
2007-09-26 09:42:52 -06:00
|
|
|
struct acpi_device *device;
|
|
|
|
unsigned long update_time;
|
2009-03-27 20:23:52 -06:00
|
|
|
int rate_now;
|
2007-09-26 09:43:04 -06:00
|
|
|
int capacity_now;
|
|
|
|
int voltage_now;
|
2007-09-26 09:42:46 -06:00
|
|
|
int design_capacity;
|
2007-09-26 09:43:04 -06:00
|
|
|
int full_charge_capacity;
|
2007-09-26 09:42:46 -06:00
|
|
|
int technology;
|
|
|
|
int design_voltage;
|
|
|
|
int design_capacity_warning;
|
|
|
|
int design_capacity_low;
|
2009-10-15 04:31:44 -06:00
|
|
|
int cycle_count;
|
|
|
|
int measurement_accuracy;
|
|
|
|
int max_sampling_time;
|
|
|
|
int min_sampling_time;
|
|
|
|
int max_averaging_interval;
|
|
|
|
int min_averaging_interval;
|
2007-09-26 09:42:46 -06:00
|
|
|
int capacity_granularity_1;
|
|
|
|
int capacity_granularity_2;
|
2007-09-26 09:42:52 -06:00
|
|
|
int alarm;
|
2007-09-26 09:42:46 -06:00
|
|
|
char model_number[32];
|
|
|
|
char serial_number[32];
|
|
|
|
char type[32];
|
|
|
|
char oem_info[32];
|
2007-09-26 09:42:52 -06:00
|
|
|
int state;
|
|
|
|
int power_unit;
|
2009-10-15 04:31:24 -06:00
|
|
|
unsigned long flags;
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2007-09-26 09:43:04 -06:00
|
|
|
#define to_acpi_battery(x) container_of(x, struct acpi_battery, bat);
|
|
|
|
|
2007-05-11 11:18:55 -06:00
|
|
|
inline int acpi_battery_present(struct acpi_battery *battery)
|
2007-02-20 05:48:06 -07:00
|
|
|
{
|
2007-05-11 11:18:55 -06:00
|
|
|
return battery->device->status.battery_present;
|
|
|
|
}
|
2007-09-26 09:42:46 -06:00
|
|
|
|
2008-01-01 12:27:24 -07:00
|
|
|
#ifdef CONFIG_ACPI_SYSFS_POWER
|
2007-09-26 09:43:04 -06:00
|
|
|
static int acpi_battery_technology(struct acpi_battery *battery)
|
|
|
|
{
|
|
|
|
if (!strcasecmp("NiCd", battery->type))
|
|
|
|
return POWER_SUPPLY_TECHNOLOGY_NiCd;
|
|
|
|
if (!strcasecmp("NiMH", battery->type))
|
|
|
|
return POWER_SUPPLY_TECHNOLOGY_NiMH;
|
|
|
|
if (!strcasecmp("LION", battery->type))
|
|
|
|
return POWER_SUPPLY_TECHNOLOGY_LION;
|
2007-11-10 10:02:49 -07:00
|
|
|
if (!strncasecmp("LI-ION", battery->type, 6))
|
2007-10-28 06:33:10 -06:00
|
|
|
return POWER_SUPPLY_TECHNOLOGY_LION;
|
2007-09-26 09:43:04 -06:00
|
|
|
if (!strcasecmp("LiP", battery->type))
|
|
|
|
return POWER_SUPPLY_TECHNOLOGY_LIPO;
|
|
|
|
return POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
|
|
|
|
}
|
|
|
|
|
2007-11-13 02:23:06 -07:00
|
|
|
static int acpi_battery_get_state(struct acpi_battery *battery);
|
2007-10-25 15:10:47 -06:00
|
|
|
|
2009-01-25 08:05:50 -07:00
|
|
|
static int acpi_battery_is_charged(struct acpi_battery *battery)
|
|
|
|
{
|
|
|
|
/* either charging or discharging */
|
|
|
|
if (battery->state != 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* battery not reporting charge */
|
|
|
|
if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN ||
|
|
|
|
battery->capacity_now == 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* good batteries update full_charge as the batteries degrade */
|
|
|
|
if (battery->full_charge_capacity == battery->capacity_now)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
/* fallback to using design values for broken batteries */
|
|
|
|
if (battery->design_capacity == battery->capacity_now)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
/* we don't do any sort of metric based on percentages */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-09-26 09:43:04 -06:00
|
|
|
static int acpi_battery_get_property(struct power_supply *psy,
|
|
|
|
enum power_supply_property psp,
|
|
|
|
union power_supply_propval *val)
|
|
|
|
{
|
|
|
|
struct acpi_battery *battery = to_acpi_battery(psy);
|
|
|
|
|
2007-11-13 02:23:06 -07:00
|
|
|
if (acpi_battery_present(battery)) {
|
|
|
|
/* run battery update only if it is present */
|
|
|
|
acpi_battery_get_state(battery);
|
|
|
|
} else if (psp != POWER_SUPPLY_PROP_PRESENT)
|
2007-09-26 09:43:04 -06:00
|
|
|
return -ENODEV;
|
|
|
|
switch (psp) {
|
|
|
|
case POWER_SUPPLY_PROP_STATUS:
|
|
|
|
if (battery->state & 0x01)
|
|
|
|
val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
|
|
|
|
else if (battery->state & 0x02)
|
|
|
|
val->intval = POWER_SUPPLY_STATUS_CHARGING;
|
2009-01-25 08:05:50 -07:00
|
|
|
else if (acpi_battery_is_charged(battery))
|
2007-09-26 09:43:04 -06:00
|
|
|
val->intval = POWER_SUPPLY_STATUS_FULL;
|
2007-11-07 16:09:09 -07:00
|
|
|
else
|
|
|
|
val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
|
2007-09-26 09:43:04 -06:00
|
|
|
break;
|
|
|
|
case POWER_SUPPLY_PROP_PRESENT:
|
|
|
|
val->intval = acpi_battery_present(battery);
|
|
|
|
break;
|
|
|
|
case POWER_SUPPLY_PROP_TECHNOLOGY:
|
|
|
|
val->intval = acpi_battery_technology(battery);
|
|
|
|
break;
|
2009-10-15 04:31:44 -06:00
|
|
|
case POWER_SUPPLY_PROP_CYCLE_COUNT:
|
|
|
|
val->intval = battery->cycle_count;
|
|
|
|
break;
|
2007-09-26 09:43:04 -06:00
|
|
|
case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
|
|
|
|
val->intval = battery->design_voltage * 1000;
|
|
|
|
break;
|
|
|
|
case POWER_SUPPLY_PROP_VOLTAGE_NOW:
|
|
|
|
val->intval = battery->voltage_now * 1000;
|
|
|
|
break;
|
|
|
|
case POWER_SUPPLY_PROP_CURRENT_NOW:
|
2009-03-27 20:23:52 -06:00
|
|
|
case POWER_SUPPLY_PROP_POWER_NOW:
|
|
|
|
val->intval = battery->rate_now * 1000;
|
2007-09-26 09:43:04 -06:00
|
|
|
break;
|
|
|
|
case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
|
|
|
|
case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
|
|
|
|
val->intval = battery->design_capacity * 1000;
|
|
|
|
break;
|
|
|
|
case POWER_SUPPLY_PROP_CHARGE_FULL:
|
|
|
|
case POWER_SUPPLY_PROP_ENERGY_FULL:
|
|
|
|
val->intval = battery->full_charge_capacity * 1000;
|
|
|
|
break;
|
|
|
|
case POWER_SUPPLY_PROP_CHARGE_NOW:
|
|
|
|
case POWER_SUPPLY_PROP_ENERGY_NOW:
|
|
|
|
val->intval = battery->capacity_now * 1000;
|
|
|
|
break;
|
|
|
|
case POWER_SUPPLY_PROP_MODEL_NAME:
|
|
|
|
val->strval = battery->model_number;
|
|
|
|
break;
|
|
|
|
case POWER_SUPPLY_PROP_MANUFACTURER:
|
|
|
|
val->strval = battery->oem_info;
|
|
|
|
break;
|
2008-01-22 10:46:50 -07:00
|
|
|
case POWER_SUPPLY_PROP_SERIAL_NUMBER:
|
|
|
|
val->strval = battery->serial_number;
|
|
|
|
break;
|
2007-09-26 09:43:04 -06:00
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static enum power_supply_property charge_battery_props[] = {
|
|
|
|
POWER_SUPPLY_PROP_STATUS,
|
|
|
|
POWER_SUPPLY_PROP_PRESENT,
|
|
|
|
POWER_SUPPLY_PROP_TECHNOLOGY,
|
2009-10-15 04:31:44 -06:00
|
|
|
POWER_SUPPLY_PROP_CYCLE_COUNT,
|
2007-09-26 09:43:04 -06:00
|
|
|
POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
|
|
|
|
POWER_SUPPLY_PROP_VOLTAGE_NOW,
|
|
|
|
POWER_SUPPLY_PROP_CURRENT_NOW,
|
|
|
|
POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
|
|
|
|
POWER_SUPPLY_PROP_CHARGE_FULL,
|
|
|
|
POWER_SUPPLY_PROP_CHARGE_NOW,
|
|
|
|
POWER_SUPPLY_PROP_MODEL_NAME,
|
|
|
|
POWER_SUPPLY_PROP_MANUFACTURER,
|
2008-01-22 10:46:50 -07:00
|
|
|
POWER_SUPPLY_PROP_SERIAL_NUMBER,
|
2007-09-26 09:43:04 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
static enum power_supply_property energy_battery_props[] = {
|
|
|
|
POWER_SUPPLY_PROP_STATUS,
|
|
|
|
POWER_SUPPLY_PROP_PRESENT,
|
|
|
|
POWER_SUPPLY_PROP_TECHNOLOGY,
|
2009-10-15 04:31:44 -06:00
|
|
|
POWER_SUPPLY_PROP_CYCLE_COUNT,
|
2007-09-26 09:43:04 -06:00
|
|
|
POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
|
|
|
|
POWER_SUPPLY_PROP_VOLTAGE_NOW,
|
|
|
|
POWER_SUPPLY_PROP_CURRENT_NOW,
|
2009-03-27 20:23:52 -06:00
|
|
|
POWER_SUPPLY_PROP_POWER_NOW,
|
2007-09-26 09:43:04 -06:00
|
|
|
POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
|
|
|
|
POWER_SUPPLY_PROP_ENERGY_FULL,
|
|
|
|
POWER_SUPPLY_PROP_ENERGY_NOW,
|
|
|
|
POWER_SUPPLY_PROP_MODEL_NAME,
|
|
|
|
POWER_SUPPLY_PROP_MANUFACTURER,
|
2008-01-22 10:46:50 -07:00
|
|
|
POWER_SUPPLY_PROP_SERIAL_NUMBER,
|
2007-09-26 09:43:04 -06:00
|
|
|
};
|
2008-01-01 12:27:24 -07:00
|
|
|
#endif
|
2007-09-26 09:43:04 -06:00
|
|
|
|
2007-11-19 06:33:45 -07:00
|
|
|
#ifdef CONFIG_ACPI_PROCFS_POWER
|
2007-09-26 09:42:52 -06:00
|
|
|
inline char *acpi_battery_units(struct acpi_battery *battery)
|
2007-05-11 11:18:55 -06:00
|
|
|
{
|
2007-09-26 09:42:52 -06:00
|
|
|
return (battery->power_unit)?"mA":"mW";
|
2007-02-20 05:48:06 -07:00
|
|
|
}
|
2007-09-26 09:43:04 -06:00
|
|
|
#endif
|
2007-02-20 05:48:06 -07:00
|
|
|
|
2007-05-11 11:18:55 -06:00
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
Battery Management
|
|
|
|
-------------------------------------------------------------------------- */
|
2007-09-26 09:42:46 -06:00
|
|
|
struct acpi_offsets {
|
|
|
|
size_t offset; /* offset inside struct acpi_sbs_battery */
|
|
|
|
u8 mode; /* int or string? */
|
|
|
|
};
|
2007-02-20 05:48:06 -07:00
|
|
|
|
2007-09-26 09:42:46 -06:00
|
|
|
static struct acpi_offsets state_offsets[] = {
|
|
|
|
{offsetof(struct acpi_battery, state), 0},
|
2009-03-27 20:23:52 -06:00
|
|
|
{offsetof(struct acpi_battery, rate_now), 0},
|
2007-09-26 09:43:04 -06:00
|
|
|
{offsetof(struct acpi_battery, capacity_now), 0},
|
|
|
|
{offsetof(struct acpi_battery, voltage_now), 0},
|
2007-09-26 09:42:46 -06:00
|
|
|
};
|
2007-02-20 05:48:06 -07:00
|
|
|
|
2007-09-26 09:42:46 -06:00
|
|
|
static struct acpi_offsets info_offsets[] = {
|
|
|
|
{offsetof(struct acpi_battery, power_unit), 0},
|
|
|
|
{offsetof(struct acpi_battery, design_capacity), 0},
|
2007-09-26 09:43:04 -06:00
|
|
|
{offsetof(struct acpi_battery, full_charge_capacity), 0},
|
2007-09-26 09:42:46 -06:00
|
|
|
{offsetof(struct acpi_battery, technology), 0},
|
|
|
|
{offsetof(struct acpi_battery, design_voltage), 0},
|
|
|
|
{offsetof(struct acpi_battery, design_capacity_warning), 0},
|
|
|
|
{offsetof(struct acpi_battery, design_capacity_low), 0},
|
|
|
|
{offsetof(struct acpi_battery, capacity_granularity_1), 0},
|
|
|
|
{offsetof(struct acpi_battery, capacity_granularity_2), 0},
|
|
|
|
{offsetof(struct acpi_battery, model_number), 1},
|
|
|
|
{offsetof(struct acpi_battery, serial_number), 1},
|
|
|
|
{offsetof(struct acpi_battery, type), 1},
|
|
|
|
{offsetof(struct acpi_battery, oem_info), 1},
|
|
|
|
};
|
2007-02-20 05:48:06 -07:00
|
|
|
|
2009-10-15 04:31:44 -06:00
|
|
|
static struct acpi_offsets extended_info_offsets[] = {
|
|
|
|
{offsetof(struct acpi_battery, power_unit), 0},
|
|
|
|
{offsetof(struct acpi_battery, design_capacity), 0},
|
|
|
|
{offsetof(struct acpi_battery, full_charge_capacity), 0},
|
|
|
|
{offsetof(struct acpi_battery, technology), 0},
|
|
|
|
{offsetof(struct acpi_battery, design_voltage), 0},
|
|
|
|
{offsetof(struct acpi_battery, design_capacity_warning), 0},
|
|
|
|
{offsetof(struct acpi_battery, design_capacity_low), 0},
|
|
|
|
{offsetof(struct acpi_battery, cycle_count), 0},
|
|
|
|
{offsetof(struct acpi_battery, measurement_accuracy), 0},
|
|
|
|
{offsetof(struct acpi_battery, max_sampling_time), 0},
|
|
|
|
{offsetof(struct acpi_battery, min_sampling_time), 0},
|
|
|
|
{offsetof(struct acpi_battery, max_averaging_interval), 0},
|
|
|
|
{offsetof(struct acpi_battery, min_averaging_interval), 0},
|
|
|
|
{offsetof(struct acpi_battery, capacity_granularity_1), 0},
|
|
|
|
{offsetof(struct acpi_battery, capacity_granularity_2), 0},
|
|
|
|
{offsetof(struct acpi_battery, model_number), 1},
|
|
|
|
{offsetof(struct acpi_battery, serial_number), 1},
|
|
|
|
{offsetof(struct acpi_battery, type), 1},
|
|
|
|
{offsetof(struct acpi_battery, oem_info), 1},
|
|
|
|
};
|
|
|
|
|
2007-09-26 09:42:46 -06:00
|
|
|
static int extract_package(struct acpi_battery *battery,
|
|
|
|
union acpi_object *package,
|
|
|
|
struct acpi_offsets *offsets, int num)
|
|
|
|
{
|
2007-10-29 14:29:40 -06:00
|
|
|
int i;
|
2007-09-26 09:42:46 -06:00
|
|
|
union acpi_object *element;
|
|
|
|
if (package->type != ACPI_TYPE_PACKAGE)
|
|
|
|
return -EFAULT;
|
|
|
|
for (i = 0; i < num; ++i) {
|
|
|
|
if (package->package.count <= i)
|
|
|
|
return -EFAULT;
|
|
|
|
element = &package->package.elements[i];
|
|
|
|
if (offsets[i].mode) {
|
2007-10-29 14:29:40 -06:00
|
|
|
u8 *ptr = (u8 *)battery + offsets[i].offset;
|
|
|
|
if (element->type == ACPI_TYPE_STRING ||
|
|
|
|
element->type == ACPI_TYPE_BUFFER)
|
|
|
|
strncpy(ptr, element->string.pointer, 32);
|
|
|
|
else if (element->type == ACPI_TYPE_INTEGER) {
|
|
|
|
strncpy(ptr, (u8 *)&element->integer.value,
|
2010-01-27 19:53:19 -07:00
|
|
|
sizeof(u64));
|
|
|
|
ptr[sizeof(u64)] = 0;
|
2008-03-17 20:37:42 -06:00
|
|
|
} else
|
|
|
|
*ptr = 0; /* don't have value */
|
2007-09-26 09:42:46 -06:00
|
|
|
} else {
|
2008-03-17 20:37:42 -06:00
|
|
|
int *x = (int *)((u8 *)battery + offsets[i].offset);
|
|
|
|
*x = (element->type == ACPI_TYPE_INTEGER) ?
|
|
|
|
element->integer.value : -1;
|
2007-09-26 09:42:46 -06:00
|
|
|
}
|
2007-02-20 05:48:06 -07:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int acpi_battery_get_status(struct acpi_battery *battery)
|
|
|
|
{
|
2007-09-26 09:42:58 -06:00
|
|
|
if (acpi_bus_get_status(battery->device)) {
|
2007-02-20 05:48:06 -07:00
|
|
|
ACPI_EXCEPTION((AE_INFO, AE_ERROR, "Evaluating _STA"));
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
2007-09-26 09:42:58 -06:00
|
|
|
return 0;
|
2007-02-20 05:48:06 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int acpi_battery_get_info(struct acpi_battery *battery)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-09-26 09:42:58 -06:00
|
|
|
int result = -EFAULT;
|
2005-08-04 22:44:28 -06:00
|
|
|
acpi_status status = 0;
|
2009-10-15 04:31:44 -06:00
|
|
|
char *name = test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags)?
|
|
|
|
"_BIX" : "_BIF";
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-02-20 05:48:06 -07:00
|
|
|
if (!acpi_battery_present(battery))
|
|
|
|
return 0;
|
2007-09-26 09:42:46 -06:00
|
|
|
mutex_lock(&battery->lock);
|
2009-10-15 04:31:44 -06:00
|
|
|
status = acpi_evaluate_object(battery->device->handle, name,
|
|
|
|
NULL, &buffer);
|
2007-09-26 09:42:46 -06:00
|
|
|
mutex_unlock(&battery->lock);
|
2007-09-26 09:42:58 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (ACPI_FAILURE(status)) {
|
2009-10-15 04:31:44 -06:00
|
|
|
ACPI_EXCEPTION((AE_INFO, status, "Evaluating %s", name));
|
2006-06-26 22:41:40 -06:00
|
|
|
return -ENODEV;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2009-10-15 04:31:44 -06:00
|
|
|
if (test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags))
|
|
|
|
result = extract_package(battery, buffer.pointer,
|
|
|
|
extended_info_offsets,
|
|
|
|
ARRAY_SIZE(extended_info_offsets));
|
|
|
|
else
|
|
|
|
result = extract_package(battery, buffer.pointer,
|
|
|
|
info_offsets, ARRAY_SIZE(info_offsets));
|
2007-05-11 11:18:55 -06:00
|
|
|
kfree(buffer.pointer);
|
2006-06-26 22:41:40 -06:00
|
|
|
return result;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-02-20 05:48:06 -07:00
|
|
|
static int acpi_battery_get_state(struct acpi_battery *battery)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-08-04 22:44:28 -06:00
|
|
|
int result = 0;
|
|
|
|
acpi_status status = 0;
|
|
|
|
struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-02-20 05:48:06 -07:00
|
|
|
if (!acpi_battery_present(battery))
|
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-09-26 09:42:52 -06:00
|
|
|
if (battery->update_time &&
|
|
|
|
time_before(jiffies, battery->update_time +
|
|
|
|
msecs_to_jiffies(cache_time)))
|
|
|
|
return 0;
|
|
|
|
|
2007-09-26 09:42:46 -06:00
|
|
|
mutex_lock(&battery->lock);
|
2007-09-26 09:42:52 -06:00
|
|
|
status = acpi_evaluate_object(battery->device->handle, "_BST",
|
2007-09-26 09:42:46 -06:00
|
|
|
NULL, &buffer);
|
|
|
|
mutex_unlock(&battery->lock);
|
2007-08-14 22:19:26 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (ACPI_FAILURE(status)) {
|
2006-06-26 21:58:43 -06:00
|
|
|
ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BST"));
|
2006-06-26 22:41:40 -06:00
|
|
|
return -ENODEV;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2007-09-26 09:42:58 -06:00
|
|
|
|
2007-09-26 09:42:46 -06:00
|
|
|
result = extract_package(battery, buffer.pointer,
|
|
|
|
state_offsets, ARRAY_SIZE(state_offsets));
|
2007-09-26 09:42:52 -06:00
|
|
|
battery->update_time = jiffies;
|
2007-05-11 11:18:55 -06:00
|
|
|
kfree(buffer.pointer);
|
2009-08-06 16:57:48 -06:00
|
|
|
|
2009-10-15 04:31:24 -06:00
|
|
|
if (test_bit(ACPI_BATTERY_QUIRK_SIGNED16_CURRENT, &battery->flags) &&
|
2009-08-06 16:57:48 -06:00
|
|
|
battery->rate_now != -1)
|
|
|
|
battery->rate_now = abs((s16)battery->rate_now);
|
|
|
|
|
2007-02-20 05:48:06 -07:00
|
|
|
return result;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-09-26 09:42:58 -06:00
|
|
|
static int acpi_battery_set_alarm(struct acpi_battery *battery)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-08-04 22:44:28 -06:00
|
|
|
acpi_status status = 0;
|
2007-09-26 09:42:58 -06:00
|
|
|
union acpi_object arg0 = { .type = ACPI_TYPE_INTEGER };
|
2005-08-04 22:44:28 -06:00
|
|
|
struct acpi_object_list arg_list = { 1, &arg0 };
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-10-15 04:31:44 -06:00
|
|
|
if (!acpi_battery_present(battery) ||
|
2009-10-15 04:31:24 -06:00
|
|
|
!test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags))
|
2006-06-26 22:41:40 -06:00
|
|
|
return -ENODEV;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-09-26 09:42:58 -06:00
|
|
|
arg0.integer.value = battery->alarm;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-09-26 09:42:46 -06:00
|
|
|
mutex_lock(&battery->lock);
|
2007-09-26 09:42:52 -06:00
|
|
|
status = acpi_evaluate_object(battery->device->handle, "_BTP",
|
|
|
|
&arg_list, NULL);
|
2007-09-26 09:42:46 -06:00
|
|
|
mutex_unlock(&battery->lock);
|
2007-09-26 09:42:58 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (ACPI_FAILURE(status))
|
2006-06-26 22:41:40 -06:00
|
|
|
return -ENODEV;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-09-26 09:42:58 -06:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Alarm set to %d\n", battery->alarm));
|
2006-06-26 22:41:40 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-02-20 05:48:06 -07:00
|
|
|
static int acpi_battery_init_alarm(struct acpi_battery *battery)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-08-04 22:44:28 -06:00
|
|
|
acpi_status status = AE_OK;
|
|
|
|
acpi_handle handle = NULL;
|
|
|
|
|
2007-02-20 05:48:06 -07:00
|
|
|
/* See if alarms are supported, and if so, set default */
|
2007-09-26 09:42:52 -06:00
|
|
|
status = acpi_get_handle(battery->device->handle, "_BTP", &handle);
|
|
|
|
if (ACPI_FAILURE(status)) {
|
2009-10-15 04:31:24 -06:00
|
|
|
clear_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
|
2007-09-26 09:42:52 -06:00
|
|
|
return 0;
|
2007-02-20 05:48:06 -07:00
|
|
|
}
|
2009-10-15 04:31:24 -06:00
|
|
|
set_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
|
2007-09-26 09:42:52 -06:00
|
|
|
if (!battery->alarm)
|
|
|
|
battery->alarm = battery->design_capacity_warning;
|
2007-09-26 09:42:58 -06:00
|
|
|
return acpi_battery_set_alarm(battery);
|
2007-02-20 05:48:06 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-01-01 12:27:24 -07:00
|
|
|
#ifdef CONFIG_ACPI_SYSFS_POWER
|
2007-10-28 03:50:09 -06:00
|
|
|
static ssize_t acpi_battery_alarm_show(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
|
|
|
|
return sprintf(buf, "%d\n", battery->alarm * 1000);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t acpi_battery_alarm_store(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
|
|
|
{
|
|
|
|
unsigned long x;
|
|
|
|
struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
|
|
|
|
if (sscanf(buf, "%ld\n", &x) == 1)
|
|
|
|
battery->alarm = x/1000;
|
|
|
|
if (acpi_battery_present(battery))
|
|
|
|
acpi_battery_set_alarm(battery);
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct device_attribute alarm_attr = {
|
2008-10-18 21:28:50 -06:00
|
|
|
.attr = {.name = "alarm", .mode = 0644},
|
2007-10-28 03:50:09 -06:00
|
|
|
.show = acpi_battery_alarm_show,
|
|
|
|
.store = acpi_battery_alarm_store,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int sysfs_add_battery(struct acpi_battery *battery)
|
|
|
|
{
|
|
|
|
int result;
|
|
|
|
|
|
|
|
if (battery->power_unit) {
|
|
|
|
battery->bat.properties = charge_battery_props;
|
|
|
|
battery->bat.num_properties =
|
|
|
|
ARRAY_SIZE(charge_battery_props);
|
|
|
|
} else {
|
|
|
|
battery->bat.properties = energy_battery_props;
|
|
|
|
battery->bat.num_properties =
|
|
|
|
ARRAY_SIZE(energy_battery_props);
|
|
|
|
}
|
|
|
|
|
|
|
|
battery->bat.name = acpi_device_bid(battery->device);
|
|
|
|
battery->bat.type = POWER_SUPPLY_TYPE_BATTERY;
|
|
|
|
battery->bat.get_property = acpi_battery_get_property;
|
|
|
|
|
|
|
|
result = power_supply_register(&battery->device->dev, &battery->bat);
|
|
|
|
if (result)
|
|
|
|
return result;
|
|
|
|
return device_create_file(battery->bat.dev, &alarm_attr);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void sysfs_remove_battery(struct acpi_battery *battery)
|
|
|
|
{
|
|
|
|
if (!battery->bat.dev)
|
|
|
|
return;
|
|
|
|
device_remove_file(battery->bat.dev, &alarm_attr);
|
|
|
|
power_supply_unregister(&battery->bat);
|
2007-11-13 02:23:06 -07:00
|
|
|
battery->bat.dev = NULL;
|
2007-10-28 03:50:09 -06:00
|
|
|
}
|
2008-01-01 12:27:24 -07:00
|
|
|
#endif
|
2007-10-28 03:50:09 -06:00
|
|
|
|
2009-08-06 16:57:48 -06:00
|
|
|
static void acpi_battery_quirks(struct acpi_battery *battery)
|
|
|
|
{
|
|
|
|
if (dmi_name_in_vendors("Acer") && battery->power_unit) {
|
2009-10-15 04:31:24 -06:00
|
|
|
set_bit(ACPI_BATTERY_QUIRK_SIGNED16_CURRENT, &battery->flags);
|
2009-08-06 16:57:48 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-09-26 09:42:52 -06:00
|
|
|
static int acpi_battery_update(struct acpi_battery *battery)
|
2007-02-20 05:48:06 -07:00
|
|
|
{
|
2008-12-22 16:44:54 -07:00
|
|
|
int result, old_present = acpi_battery_present(battery);
|
2008-01-01 12:27:24 -07:00
|
|
|
result = acpi_battery_get_status(battery);
|
2007-10-28 03:50:09 -06:00
|
|
|
if (result)
|
2007-02-20 05:48:06 -07:00
|
|
|
return result;
|
2007-10-28 03:50:09 -06:00
|
|
|
if (!acpi_battery_present(battery)) {
|
2009-06-30 08:35:05 -06:00
|
|
|
#ifdef CONFIG_ACPI_SYSFS_POWER
|
2007-10-28 03:50:09 -06:00
|
|
|
sysfs_remove_battery(battery);
|
2009-06-30 08:35:05 -06:00
|
|
|
#endif
|
2008-01-01 12:27:24 -07:00
|
|
|
battery->update_time = 0;
|
2007-10-28 03:50:09 -06:00
|
|
|
return 0;
|
2007-02-20 05:48:06 -07:00
|
|
|
}
|
2008-12-22 16:44:54 -07:00
|
|
|
if (!battery->update_time ||
|
|
|
|
old_present != acpi_battery_present(battery)) {
|
2008-01-01 12:27:24 -07:00
|
|
|
result = acpi_battery_get_info(battery);
|
|
|
|
if (result)
|
|
|
|
return result;
|
2009-08-06 16:57:48 -06:00
|
|
|
acpi_battery_quirks(battery);
|
2008-01-01 12:27:24 -07:00
|
|
|
acpi_battery_init_alarm(battery);
|
|
|
|
}
|
|
|
|
#ifdef CONFIG_ACPI_SYSFS_POWER
|
2007-10-28 03:50:09 -06:00
|
|
|
if (!battery->bat.dev)
|
|
|
|
sysfs_add_battery(battery);
|
2008-01-01 12:27:24 -07:00
|
|
|
#endif
|
2007-09-26 09:42:52 -06:00
|
|
|
return acpi_battery_get_state(battery);
|
2007-02-09 23:43:48 -07:00
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
FS Interface (/proc)
|
|
|
|
-------------------------------------------------------------------------- */
|
|
|
|
|
2007-11-19 06:33:45 -07:00
|
|
|
#ifdef CONFIG_ACPI_PROCFS_POWER
|
2005-08-04 22:44:28 -06:00
|
|
|
static struct proc_dir_entry *acpi_battery_dir;
|
2007-02-20 05:48:06 -07:00
|
|
|
|
2007-05-11 11:18:55 -06:00
|
|
|
static int acpi_battery_print_info(struct seq_file *seq, int result)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2006-09-30 16:28:50 -06:00
|
|
|
struct acpi_battery *battery = seq->private;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-02-20 05:48:06 -07:00
|
|
|
if (result)
|
2005-04-16 16:20:36 -06:00
|
|
|
goto end;
|
|
|
|
|
2007-09-26 09:42:58 -06:00
|
|
|
seq_printf(seq, "present: %s\n",
|
|
|
|
acpi_battery_present(battery)?"yes":"no");
|
|
|
|
if (!acpi_battery_present(battery))
|
2005-04-16 16:20:36 -06:00
|
|
|
goto end;
|
2007-09-26 09:42:46 -06:00
|
|
|
if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
|
2005-04-16 16:20:36 -06:00
|
|
|
seq_printf(seq, "design capacity: unknown\n");
|
|
|
|
else
|
|
|
|
seq_printf(seq, "design capacity: %d %sh\n",
|
2007-09-26 09:42:58 -06:00
|
|
|
battery->design_capacity,
|
|
|
|
acpi_battery_units(battery));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-09-26 09:43:04 -06:00
|
|
|
if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
|
2005-04-16 16:20:36 -06:00
|
|
|
seq_printf(seq, "last full capacity: unknown\n");
|
|
|
|
else
|
|
|
|
seq_printf(seq, "last full capacity: %d %sh\n",
|
2007-09-26 09:43:04 -06:00
|
|
|
battery->full_charge_capacity,
|
2007-09-26 09:42:58 -06:00
|
|
|
acpi_battery_units(battery));
|
|
|
|
|
|
|
|
seq_printf(seq, "battery technology: %srechargeable\n",
|
|
|
|
(!battery->technology)?"non-":"");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-09-26 09:42:46 -06:00
|
|
|
if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
|
2005-04-16 16:20:36 -06:00
|
|
|
seq_printf(seq, "design voltage: unknown\n");
|
|
|
|
else
|
|
|
|
seq_printf(seq, "design voltage: %d mV\n",
|
2007-09-26 09:42:58 -06:00
|
|
|
battery->design_voltage);
|
2005-04-16 16:20:36 -06:00
|
|
|
seq_printf(seq, "design capacity warning: %d %sh\n",
|
2007-09-26 09:42:58 -06:00
|
|
|
battery->design_capacity_warning,
|
|
|
|
acpi_battery_units(battery));
|
2005-04-16 16:20:36 -06:00
|
|
|
seq_printf(seq, "design capacity low: %d %sh\n",
|
2007-09-26 09:42:58 -06:00
|
|
|
battery->design_capacity_low,
|
|
|
|
acpi_battery_units(battery));
|
2009-10-15 04:31:44 -06:00
|
|
|
seq_printf(seq, "cycle count: %i\n", battery->cycle_count);
|
2005-04-16 16:20:36 -06:00
|
|
|
seq_printf(seq, "capacity granularity 1: %d %sh\n",
|
2007-09-26 09:42:58 -06:00
|
|
|
battery->capacity_granularity_1,
|
|
|
|
acpi_battery_units(battery));
|
2005-04-16 16:20:36 -06:00
|
|
|
seq_printf(seq, "capacity granularity 2: %d %sh\n",
|
2007-09-26 09:42:58 -06:00
|
|
|
battery->capacity_granularity_2,
|
|
|
|
acpi_battery_units(battery));
|
2007-09-26 09:42:46 -06:00
|
|
|
seq_printf(seq, "model number: %s\n", battery->model_number);
|
|
|
|
seq_printf(seq, "serial number: %s\n", battery->serial_number);
|
|
|
|
seq_printf(seq, "battery type: %s\n", battery->type);
|
|
|
|
seq_printf(seq, "OEM info: %s\n", battery->oem_info);
|
2005-08-04 22:44:28 -06:00
|
|
|
end:
|
2007-02-20 05:48:06 -07:00
|
|
|
if (result)
|
|
|
|
seq_printf(seq, "ERROR: Unable to read battery info\n");
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2007-05-11 11:18:55 -06:00
|
|
|
static int acpi_battery_print_state(struct seq_file *seq, int result)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2006-09-30 16:28:50 -06:00
|
|
|
struct acpi_battery *battery = seq->private;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-02-20 05:48:06 -07:00
|
|
|
if (result)
|
2005-04-16 16:20:36 -06:00
|
|
|
goto end;
|
|
|
|
|
2007-09-26 09:42:58 -06:00
|
|
|
seq_printf(seq, "present: %s\n",
|
|
|
|
acpi_battery_present(battery)?"yes":"no");
|
|
|
|
if (!acpi_battery_present(battery))
|
2005-04-16 16:20:36 -06:00
|
|
|
goto end;
|
2007-02-20 05:48:06 -07:00
|
|
|
|
2007-09-26 09:42:58 -06:00
|
|
|
seq_printf(seq, "capacity state: %s\n",
|
|
|
|
(battery->state & 0x04)?"critical":"ok");
|
|
|
|
if ((battery->state & 0x01) && (battery->state & 0x02))
|
2005-08-04 22:44:28 -06:00
|
|
|
seq_printf(seq,
|
|
|
|
"charging state: charging/discharging\n");
|
2007-09-26 09:42:58 -06:00
|
|
|
else if (battery->state & 0x01)
|
2005-04-16 16:20:36 -06:00
|
|
|
seq_printf(seq, "charging state: discharging\n");
|
2007-09-26 09:42:46 -06:00
|
|
|
else if (battery->state & 0x02)
|
2005-04-16 16:20:36 -06:00
|
|
|
seq_printf(seq, "charging state: charging\n");
|
2007-09-26 09:42:58 -06:00
|
|
|
else
|
2005-04-16 16:20:36 -06:00
|
|
|
seq_printf(seq, "charging state: charged\n");
|
|
|
|
|
2009-03-27 20:23:52 -06:00
|
|
|
if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
|
2005-04-16 16:20:36 -06:00
|
|
|
seq_printf(seq, "present rate: unknown\n");
|
|
|
|
else
|
|
|
|
seq_printf(seq, "present rate: %d %s\n",
|
2009-03-27 20:23:52 -06:00
|
|
|
battery->rate_now, acpi_battery_units(battery));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-09-26 09:43:04 -06:00
|
|
|
if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
|
2005-04-16 16:20:36 -06:00
|
|
|
seq_printf(seq, "remaining capacity: unknown\n");
|
|
|
|
else
|
|
|
|
seq_printf(seq, "remaining capacity: %d %sh\n",
|
2007-09-26 09:43:04 -06:00
|
|
|
battery->capacity_now, acpi_battery_units(battery));
|
|
|
|
if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
|
2005-04-16 16:20:36 -06:00
|
|
|
seq_printf(seq, "present voltage: unknown\n");
|
|
|
|
else
|
|
|
|
seq_printf(seq, "present voltage: %d mV\n",
|
2007-09-26 09:43:04 -06:00
|
|
|
battery->voltage_now);
|
2005-08-04 22:44:28 -06:00
|
|
|
end:
|
2007-09-26 09:42:58 -06:00
|
|
|
if (result)
|
2007-02-20 05:48:06 -07:00
|
|
|
seq_printf(seq, "ERROR: Unable to read battery state\n");
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2007-05-11 11:18:55 -06:00
|
|
|
static int acpi_battery_print_alarm(struct seq_file *seq, int result)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2006-09-30 16:28:50 -06:00
|
|
|
struct acpi_battery *battery = seq->private;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-02-20 05:48:06 -07:00
|
|
|
if (result)
|
2005-04-16 16:20:36 -06:00
|
|
|
goto end;
|
|
|
|
|
2007-02-20 05:48:06 -07:00
|
|
|
if (!acpi_battery_present(battery)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
seq_printf(seq, "present: no\n");
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
seq_printf(seq, "alarm: ");
|
|
|
|
if (!battery->alarm)
|
|
|
|
seq_printf(seq, "unsupported\n");
|
|
|
|
else
|
2007-09-26 09:42:58 -06:00
|
|
|
seq_printf(seq, "%u %sh\n", battery->alarm,
|
|
|
|
acpi_battery_units(battery));
|
2005-08-04 22:44:28 -06:00
|
|
|
end:
|
2007-02-20 05:48:06 -07:00
|
|
|
if (result)
|
|
|
|
seq_printf(seq, "ERROR: Unable to read battery alarm\n");
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2007-09-26 09:42:52 -06:00
|
|
|
static ssize_t acpi_battery_write_alarm(struct file *file,
|
|
|
|
const char __user * buffer,
|
|
|
|
size_t count, loff_t * ppos)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-08-04 22:44:28 -06:00
|
|
|
int result = 0;
|
|
|
|
char alarm_string[12] = { '\0' };
|
2006-09-30 16:28:50 -06:00
|
|
|
struct seq_file *m = file->private_data;
|
|
|
|
struct acpi_battery *battery = m->private;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (!battery || (count > sizeof(alarm_string) - 1))
|
2006-06-26 22:41:40 -06:00
|
|
|
return -EINVAL;
|
2007-02-20 05:48:06 -07:00
|
|
|
if (!acpi_battery_present(battery)) {
|
|
|
|
result = -ENODEV;
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
if (copy_from_user(alarm_string, buffer, count)) {
|
|
|
|
result = -EFAULT;
|
|
|
|
goto end;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
alarm_string[count] = '\0';
|
2007-09-26 09:42:52 -06:00
|
|
|
battery->alarm = simple_strtol(alarm_string, NULL, 0);
|
2007-09-26 09:42:58 -06:00
|
|
|
result = acpi_battery_set_alarm(battery);
|
2007-02-20 05:48:06 -07:00
|
|
|
end:
|
|
|
|
if (!result)
|
2007-09-26 09:42:52 -06:00
|
|
|
return count;
|
2007-05-11 11:18:55 -06:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
typedef int(*print_func)(struct seq_file *seq, int result);
|
2007-09-26 09:42:58 -06:00
|
|
|
|
|
|
|
static print_func acpi_print_funcs[ACPI_BATTERY_NUMFILES] = {
|
|
|
|
acpi_battery_print_info,
|
|
|
|
acpi_battery_print_state,
|
|
|
|
acpi_battery_print_alarm,
|
2007-05-11 11:18:55 -06:00
|
|
|
};
|
2007-02-20 05:48:06 -07:00
|
|
|
|
2007-05-11 11:18:55 -06:00
|
|
|
static int acpi_battery_read(int fid, struct seq_file *seq)
|
|
|
|
{
|
|
|
|
struct acpi_battery *battery = seq->private;
|
2007-09-26 09:42:52 -06:00
|
|
|
int result = acpi_battery_update(battery);
|
2007-09-26 09:42:58 -06:00
|
|
|
return acpi_print_funcs[fid](seq, result);
|
2007-05-11 11:18:55 -06:00
|
|
|
}
|
|
|
|
|
2007-09-26 09:42:58 -06:00
|
|
|
#define DECLARE_FILE_FUNCTIONS(_name) \
|
|
|
|
static int acpi_battery_read_##_name(struct seq_file *seq, void *offset) \
|
|
|
|
{ \
|
|
|
|
return acpi_battery_read(_name##_tag, seq); \
|
|
|
|
} \
|
|
|
|
static int acpi_battery_##_name##_open_fs(struct inode *inode, struct file *file) \
|
|
|
|
{ \
|
|
|
|
return single_open(file, acpi_battery_read_##_name, PDE(inode)->data); \
|
2007-05-11 11:18:55 -06:00
|
|
|
}
|
|
|
|
|
2007-09-26 09:42:58 -06:00
|
|
|
DECLARE_FILE_FUNCTIONS(info);
|
|
|
|
DECLARE_FILE_FUNCTIONS(state);
|
|
|
|
DECLARE_FILE_FUNCTIONS(alarm);
|
|
|
|
|
|
|
|
#undef DECLARE_FILE_FUNCTIONS
|
|
|
|
|
|
|
|
#define FILE_DESCRIPTION_RO(_name) \
|
|
|
|
{ \
|
|
|
|
.name = __stringify(_name), \
|
|
|
|
.mode = S_IRUGO, \
|
|
|
|
.ops = { \
|
|
|
|
.open = acpi_battery_##_name##_open_fs, \
|
|
|
|
.read = seq_read, \
|
|
|
|
.llseek = seq_lseek, \
|
|
|
|
.release = single_release, \
|
|
|
|
.owner = THIS_MODULE, \
|
|
|
|
}, \
|
|
|
|
}
|
2007-05-11 11:18:55 -06:00
|
|
|
|
2007-09-26 09:42:58 -06:00
|
|
|
#define FILE_DESCRIPTION_RW(_name) \
|
|
|
|
{ \
|
|
|
|
.name = __stringify(_name), \
|
|
|
|
.mode = S_IFREG | S_IRUGO | S_IWUSR, \
|
|
|
|
.ops = { \
|
|
|
|
.open = acpi_battery_##_name##_open_fs, \
|
|
|
|
.read = seq_read, \
|
|
|
|
.llseek = seq_lseek, \
|
|
|
|
.write = acpi_battery_write_##_name, \
|
|
|
|
.release = single_release, \
|
|
|
|
.owner = THIS_MODULE, \
|
|
|
|
}, \
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-05-11 11:18:55 -06:00
|
|
|
static struct battery_file {
|
|
|
|
struct file_operations ops;
|
|
|
|
mode_t mode;
|
2009-01-11 16:07:55 -07:00
|
|
|
const char *name;
|
2007-05-11 11:18:55 -06:00
|
|
|
} acpi_battery_file[] = {
|
2007-09-26 09:42:58 -06:00
|
|
|
FILE_DESCRIPTION_RO(info),
|
|
|
|
FILE_DESCRIPTION_RO(state),
|
|
|
|
FILE_DESCRIPTION_RW(alarm),
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2007-09-26 09:42:58 -06:00
|
|
|
#undef FILE_DESCRIPTION_RO
|
|
|
|
#undef FILE_DESCRIPTION_RW
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
static int acpi_battery_add_fs(struct acpi_device *device)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-08-04 22:44:28 -06:00
|
|
|
struct proc_dir_entry *entry = NULL;
|
2007-05-11 11:18:55 -06:00
|
|
|
int i;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (!acpi_device_dir(device)) {
|
|
|
|
acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
|
2005-08-04 22:44:28 -06:00
|
|
|
acpi_battery_dir);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!acpi_device_dir(device))
|
2006-06-26 22:41:40 -06:00
|
|
|
return -ENODEV;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-05-11 11:18:55 -06:00
|
|
|
for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i) {
|
2008-04-29 02:02:27 -06:00
|
|
|
entry = proc_create_data(acpi_battery_file[i].name,
|
|
|
|
acpi_battery_file[i].mode,
|
|
|
|
acpi_device_dir(device),
|
|
|
|
&acpi_battery_file[i].ops,
|
|
|
|
acpi_driver_data(device));
|
2007-05-11 11:18:55 -06:00
|
|
|
if (!entry)
|
|
|
|
return -ENODEV;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2006-06-26 22:41:40 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-09-26 09:42:58 -06:00
|
|
|
static void acpi_battery_remove_fs(struct acpi_device *device)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-05-11 11:18:55 -06:00
|
|
|
int i;
|
2007-09-26 09:42:58 -06:00
|
|
|
if (!acpi_device_dir(device))
|
|
|
|
return;
|
|
|
|
for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i)
|
|
|
|
remove_proc_entry(acpi_battery_file[i].name,
|
2005-04-16 16:20:36 -06:00
|
|
|
acpi_device_dir(device));
|
|
|
|
|
2007-09-26 09:42:58 -06:00
|
|
|
remove_proc_entry(acpi_device_bid(device), acpi_battery_dir);
|
|
|
|
acpi_device_dir(device) = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-09-26 09:43:04 -06:00
|
|
|
#endif
|
2007-09-26 09:43:11 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
Driver Interface
|
|
|
|
-------------------------------------------------------------------------- */
|
|
|
|
|
2009-04-30 09:35:47 -06:00
|
|
|
static void acpi_battery_notify(struct acpi_device *device, u32 event)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2009-04-30 09:35:47 -06:00
|
|
|
struct acpi_battery *battery = acpi_driver_data(device);
|
2010-07-06 19:11:57 -06:00
|
|
|
#ifdef CONFIG_ACPI_SYSFS_POWER
|
|
|
|
struct device *old;
|
|
|
|
#endif
|
2009-04-30 09:35:47 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!battery)
|
2006-06-26 22:41:40 -06:00
|
|
|
return;
|
2010-07-06 19:11:57 -06:00
|
|
|
#ifdef CONFIG_ACPI_SYSFS_POWER
|
|
|
|
old = battery->bat.dev;
|
|
|
|
#endif
|
2007-09-26 09:42:52 -06:00
|
|
|
acpi_battery_update(battery);
|
|
|
|
acpi_bus_generate_proc_event(device, event,
|
|
|
|
acpi_battery_present(battery));
|
|
|
|
acpi_bus_generate_netlink_event(device->pnp.device_class,
|
ACPI: struct device - replace bus_id with dev_name(), dev_set_name()
This patch is part of a larger patch series which will remove
the "char bus_id[20]" name string from struct device. The device
name is managed in the kobject anyway, and without any size
limitation, and just needlessly copied into "struct device".
To set and read the device name dev_name(dev) and dev_set_name(dev)
must be used. If your code uses static kobjects, which it shouldn't
do, "const char *init_name" can be used to statically provide the
name the registered device should have. At registration time, the
init_name field is cleared, to enforce the use of dev_name(dev) to
access the device name at a later time.
We need to get rid of all occurrences of bus_id in the entire tree
to be able to enable the new interface. Please apply this patch,
and possibly convert any remaining remaining occurrences of bus_id.
We want to submit a patch to -next, which will remove bus_id from
"struct device", to find the remaining pieces to convert, and finally
switch over to the new api, which will remove the 20 bytes array
and does no longer have a size limitation.
Acked-by: Greg Kroah-Hartman <gregkh@suse.de>
Signed-Off-By: Kay Sievers <kay.sievers@vrfy.org>
Signed-off-by: Len Brown <len.brown@intel.com>
2008-10-29 18:18:59 -06:00
|
|
|
dev_name(&device->dev), event,
|
2007-02-20 05:48:06 -07:00
|
|
|
acpi_battery_present(battery));
|
2008-01-01 12:27:24 -07:00
|
|
|
#ifdef CONFIG_ACPI_SYSFS_POWER
|
2009-12-13 15:42:36 -07:00
|
|
|
/* acpi_battery_update could remove power_supply object */
|
2010-07-06 19:11:57 -06:00
|
|
|
if (old && battery->bat.dev)
|
2009-06-30 08:36:16 -06:00
|
|
|
power_supply_changed(&battery->bat);
|
2008-01-01 12:27:24 -07:00
|
|
|
#endif
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
static int acpi_battery_add(struct acpi_device *device)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-08-04 22:44:28 -06:00
|
|
|
int result = 0;
|
|
|
|
struct acpi_battery *battery = NULL;
|
2009-10-15 04:31:44 -06:00
|
|
|
acpi_handle handle;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!device)
|
2006-06-26 22:41:40 -06:00
|
|
|
return -EINVAL;
|
2006-12-19 13:56:11 -07:00
|
|
|
battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!battery)
|
2006-06-26 22:41:40 -06:00
|
|
|
return -ENOMEM;
|
2006-05-19 14:54:39 -06:00
|
|
|
battery->device = device;
|
2005-04-16 16:20:36 -06:00
|
|
|
strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME);
|
|
|
|
strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS);
|
2008-09-22 15:37:34 -06:00
|
|
|
device->driver_data = battery;
|
2007-09-26 09:42:46 -06:00
|
|
|
mutex_init(&battery->lock);
|
2009-10-15 04:31:44 -06:00
|
|
|
if (ACPI_SUCCESS(acpi_get_handle(battery->device->handle,
|
|
|
|
"_BIX", &handle)))
|
|
|
|
set_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags);
|
2007-09-26 09:42:52 -06:00
|
|
|
acpi_battery_update(battery);
|
2007-11-19 06:33:45 -07:00
|
|
|
#ifdef CONFIG_ACPI_PROCFS_POWER
|
2005-04-16 16:20:36 -06:00
|
|
|
result = acpi_battery_add_fs(device);
|
2007-09-26 09:43:04 -06:00
|
|
|
#endif
|
2009-06-17 22:38:27 -06:00
|
|
|
if (!result) {
|
|
|
|
printk(KERN_INFO PREFIX "%s Slot [%s] (battery %s)\n",
|
|
|
|
ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device),
|
|
|
|
device->status.battery_present ? "present" : "absent");
|
|
|
|
} else {
|
2007-11-19 06:33:45 -07:00
|
|
|
#ifdef CONFIG_ACPI_PROCFS_POWER
|
2005-04-16 16:20:36 -06:00
|
|
|
acpi_battery_remove_fs(device);
|
2007-09-26 09:43:04 -06:00
|
|
|
#endif
|
2005-04-16 16:20:36 -06:00
|
|
|
kfree(battery);
|
|
|
|
}
|
2006-06-26 22:41:40 -06:00
|
|
|
return result;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
static int acpi_battery_remove(struct acpi_device *device, int type)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-08-04 22:44:28 -06:00
|
|
|
struct acpi_battery *battery = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (!device || !acpi_driver_data(device))
|
2006-06-26 22:41:40 -06:00
|
|
|
return -EINVAL;
|
2006-09-30 16:28:50 -06:00
|
|
|
battery = acpi_driver_data(device);
|
2007-11-19 06:33:45 -07:00
|
|
|
#ifdef CONFIG_ACPI_PROCFS_POWER
|
2005-04-16 16:20:36 -06:00
|
|
|
acpi_battery_remove_fs(device);
|
2007-09-26 09:43:04 -06:00
|
|
|
#endif
|
2008-01-01 12:27:24 -07:00
|
|
|
#ifdef CONFIG_ACPI_SYSFS_POWER
|
2007-10-28 03:50:09 -06:00
|
|
|
sysfs_remove_battery(battery);
|
2008-01-01 12:27:24 -07:00
|
|
|
#endif
|
2007-09-26 09:42:46 -06:00
|
|
|
mutex_destroy(&battery->lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
kfree(battery);
|
2006-06-26 22:41:40 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2006-10-10 15:20:41 -06:00
|
|
|
/* this is needed to learn about changes made in suspended state */
|
2006-12-07 05:56:27 -07:00
|
|
|
static int acpi_battery_resume(struct acpi_device *device)
|
2006-10-10 15:20:41 -06:00
|
|
|
{
|
|
|
|
struct acpi_battery *battery;
|
|
|
|
if (!device)
|
|
|
|
return -EINVAL;
|
2007-09-26 09:42:52 -06:00
|
|
|
battery = acpi_driver_data(device);
|
|
|
|
battery->update_time = 0;
|
2007-10-28 03:50:09 -06:00
|
|
|
acpi_battery_update(battery);
|
2007-02-20 05:48:06 -07:00
|
|
|
return 0;
|
2006-10-10 15:20:41 -06:00
|
|
|
}
|
|
|
|
|
2007-09-26 09:42:58 -06:00
|
|
|
static struct acpi_driver acpi_battery_driver = {
|
|
|
|
.name = "battery",
|
|
|
|
.class = ACPI_BATTERY_CLASS,
|
|
|
|
.ids = battery_device_ids,
|
2009-04-30 09:35:47 -06:00
|
|
|
.flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
|
2007-09-26 09:42:58 -06:00
|
|
|
.ops = {
|
|
|
|
.add = acpi_battery_add,
|
|
|
|
.resume = acpi_battery_resume,
|
|
|
|
.remove = acpi_battery_remove,
|
2009-04-30 09:35:47 -06:00
|
|
|
.notify = acpi_battery_notify,
|
2007-09-26 09:42:58 -06:00
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2009-04-11 13:45:20 -06:00
|
|
|
static void __init acpi_battery_init_async(void *unused, async_cookie_t cookie)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2006-08-14 23:37:22 -06:00
|
|
|
if (acpi_disabled)
|
2009-01-10 12:19:05 -07:00
|
|
|
return;
|
2007-11-19 06:33:45 -07:00
|
|
|
#ifdef CONFIG_ACPI_PROCFS_POWER
|
2006-07-01 09:36:54 -06:00
|
|
|
acpi_battery_dir = acpi_lock_battery_dir();
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!acpi_battery_dir)
|
2009-01-10 12:19:05 -07:00
|
|
|
return;
|
2007-09-26 09:43:04 -06:00
|
|
|
#endif
|
2007-09-26 09:42:58 -06:00
|
|
|
if (acpi_bus_register_driver(&acpi_battery_driver) < 0) {
|
2007-11-19 06:33:45 -07:00
|
|
|
#ifdef CONFIG_ACPI_PROCFS_POWER
|
2006-07-01 09:36:54 -06:00
|
|
|
acpi_unlock_battery_dir(acpi_battery_dir);
|
2007-09-26 09:43:04 -06:00
|
|
|
#endif
|
2009-01-10 12:19:05 -07:00
|
|
|
return;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2009-01-10 12:19:05 -07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __init acpi_battery_init(void)
|
|
|
|
{
|
|
|
|
async_schedule(acpi_battery_init_async, NULL);
|
2006-06-26 22:41:40 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
static void __exit acpi_battery_exit(void)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
acpi_bus_unregister_driver(&acpi_battery_driver);
|
2007-11-19 06:33:45 -07:00
|
|
|
#ifdef CONFIG_ACPI_PROCFS_POWER
|
2006-07-01 09:36:54 -06:00
|
|
|
acpi_unlock_battery_dir(acpi_battery_dir);
|
2007-09-26 09:43:04 -06:00
|
|
|
#endif
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
module_init(acpi_battery_init);
|
|
|
|
module_exit(acpi_battery_exit);
|