2006-07-01 09:36:54 -06:00
|
|
|
/*
|
2007-09-26 09:43:41 -06:00
|
|
|
* sbs.c - ACPI Smart Battery System Driver ($Revision: 2.0 $)
|
2006-07-01 09:36:54 -06:00
|
|
|
*
|
2007-09-26 09:43:41 -06:00
|
|
|
* Copyright (c) 2007 Alexey Starikovskiy <astarikovskiy@suse.de>
|
|
|
|
* Copyright (c) 2005-2007 Vladimir Lebedev <vladimir.p.lebedev@intel.com>
|
2006-07-01 09:36:54 -06:00
|
|
|
* Copyright (c) 2005 Rich Townsend <rhdt@bartol.udel.edu>
|
|
|
|
*
|
|
|
|
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
*
|
|
|
|
* 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/init.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>
|
2006-07-01 09:36:54 -06:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/moduleparam.h>
|
|
|
|
#include <linux/kernel.h>
|
2007-09-26 09:43:48 -06:00
|
|
|
|
2006-07-01 09:36:54 -06:00
|
|
|
#include <linux/acpi.h>
|
2007-03-19 08:45:50 -06:00
|
|
|
#include <linux/timer.h>
|
2007-03-19 08:45:50 -06:00
|
|
|
#include <linux/jiffies.h>
|
2006-07-01 09:36:54 -06:00
|
|
|
#include <linux/delay.h>
|
2007-09-26 09:43:48 -06:00
|
|
|
#include <linux/power_supply.h>
|
2014-09-20 05:19:46 -06:00
|
|
|
#include <linux/dmi.h>
|
2007-09-26 09:43:48 -06:00
|
|
|
|
2007-09-26 09:43:28 -06:00
|
|
|
#include "sbshc.h"
|
2014-03-11 11:58:46 -06:00
|
|
|
#include "battery.h"
|
2007-09-26 09:43:28 -06:00
|
|
|
|
2009-07-28 14:45:54 -06:00
|
|
|
#define PREFIX "ACPI: "
|
|
|
|
|
2006-07-01 09:36:54 -06:00
|
|
|
#define ACPI_SBS_CLASS "sbs"
|
|
|
|
#define ACPI_AC_CLASS "ac_adapter"
|
|
|
|
#define ACPI_SBS_DEVICE_NAME "Smart Battery System"
|
|
|
|
#define ACPI_SBS_FILE_INFO "info"
|
|
|
|
#define ACPI_SBS_FILE_STATE "state"
|
|
|
|
#define ACPI_SBS_FILE_ALARM "alarm"
|
|
|
|
#define ACPI_BATTERY_DIR_NAME "BAT%i"
|
|
|
|
#define ACPI_AC_DIR_NAME "AC0"
|
|
|
|
|
2007-09-26 09:43:41 -06:00
|
|
|
#define ACPI_SBS_NOTIFY_STATUS 0x80
|
|
|
|
#define ACPI_SBS_NOTIFY_INFO 0x81
|
2006-07-01 09:36:54 -06:00
|
|
|
|
2007-09-26 09:43:41 -06:00
|
|
|
MODULE_AUTHOR("Alexey Starikovskiy <astarikovskiy@suse.de>");
|
2006-07-01 09:36:54 -06:00
|
|
|
MODULE_DESCRIPTION("Smart Battery System ACPI interface driver");
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
|
2007-09-26 09:43:41 -06:00
|
|
|
static unsigned int cache_time = 1000;
|
|
|
|
module_param(cache_time, uint, 0644);
|
|
|
|
MODULE_PARM_DESC(cache_time, "cache time in milliseconds");
|
2007-03-19 08:45:50 -06:00
|
|
|
|
2014-09-20 05:19:46 -06:00
|
|
|
static bool sbs_manager_broken;
|
|
|
|
|
2007-09-26 09:43:41 -06:00
|
|
|
#define MAX_SBS_BAT 4
|
2007-03-19 08:45:50 -06:00
|
|
|
#define ACPI_SBS_BLOCK_MAX 32
|
|
|
|
|
2007-07-23 06:44:41 -06:00
|
|
|
static const struct acpi_device_id sbs_device_ids[] = {
|
2007-09-26 09:43:28 -06:00
|
|
|
{"ACPI0002", 0},
|
2007-07-23 06:44:41 -06:00
|
|
|
{"", 0},
|
|
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(acpi, sbs_device_ids);
|
|
|
|
|
2006-07-01 09:36:54 -06:00
|
|
|
struct acpi_battery {
|
2007-09-26 09:43:48 -06:00
|
|
|
struct power_supply bat;
|
2006-07-01 09:36:54 -06:00
|
|
|
struct acpi_sbs *sbs;
|
2007-09-26 09:43:41 -06:00
|
|
|
unsigned long update_time;
|
|
|
|
char name[8];
|
2007-09-26 09:43:35 -06:00
|
|
|
char manufacturer_name[ACPI_SBS_BLOCK_MAX];
|
|
|
|
char device_name[ACPI_SBS_BLOCK_MAX];
|
|
|
|
char device_chemistry[ACPI_SBS_BLOCK_MAX];
|
2007-09-26 09:43:48 -06:00
|
|
|
u16 alarm_capacity;
|
2007-09-26 09:43:35 -06:00
|
|
|
u16 full_charge_capacity;
|
|
|
|
u16 design_capacity;
|
|
|
|
u16 design_voltage;
|
|
|
|
u16 serial_number;
|
2007-09-26 09:43:41 -06:00
|
|
|
u16 cycle_count;
|
|
|
|
u16 temp_now;
|
2007-09-26 09:43:35 -06:00
|
|
|
u16 voltage_now;
|
2009-03-27 20:23:52 -06:00
|
|
|
s16 rate_now;
|
|
|
|
s16 rate_avg;
|
2007-09-26 09:43:35 -06:00
|
|
|
u16 capacity_now;
|
2007-09-26 09:43:41 -06:00
|
|
|
u16 state_of_charge;
|
2007-09-26 09:43:35 -06:00
|
|
|
u16 state;
|
|
|
|
u16 mode;
|
2007-09-26 09:43:41 -06:00
|
|
|
u16 spec;
|
2007-09-26 09:43:35 -06:00
|
|
|
u8 id;
|
|
|
|
u8 present:1;
|
2007-11-17 14:32:31 -07:00
|
|
|
u8 have_sysfs_alarm:1;
|
2006-07-01 09:36:54 -06:00
|
|
|
};
|
|
|
|
|
2011-07-14 06:07:13 -06:00
|
|
|
#define to_acpi_battery(x) container_of(x, struct acpi_battery, bat)
|
2007-09-26 09:43:48 -06:00
|
|
|
|
2006-07-01 09:36:54 -06:00
|
|
|
struct acpi_sbs {
|
2007-09-26 09:43:48 -06:00
|
|
|
struct power_supply charger;
|
2006-07-01 09:36:54 -06:00
|
|
|
struct acpi_device *device;
|
2007-09-26 09:43:28 -06:00
|
|
|
struct acpi_smb_hc *hc;
|
2007-09-26 09:43:41 -06:00
|
|
|
struct mutex lock;
|
2006-07-01 09:36:54 -06:00
|
|
|
struct acpi_battery battery[MAX_SBS_BAT];
|
2007-09-26 09:43:41 -06:00
|
|
|
u8 batteries_supported:4;
|
2007-09-26 09:43:35 -06:00
|
|
|
u8 manager_present:1;
|
|
|
|
u8 charger_present:1;
|
2014-09-20 05:19:45 -06:00
|
|
|
u8 charger_exists:1;
|
2006-07-01 09:36:54 -06:00
|
|
|
};
|
|
|
|
|
2007-09-26 09:43:48 -06:00
|
|
|
#define to_acpi_sbs(x) container_of(x, struct acpi_sbs, charger)
|
|
|
|
|
2013-01-23 16:24:48 -07:00
|
|
|
static int acpi_sbs_remove(struct acpi_device *device);
|
2011-07-01 02:03:15 -06:00
|
|
|
static int acpi_battery_get_state(struct acpi_battery *battery);
|
|
|
|
|
2007-09-26 09:43:41 -06:00
|
|
|
static inline int battery_scale(int log)
|
2007-03-19 08:45:50 -06:00
|
|
|
{
|
2007-09-26 09:43:41 -06:00
|
|
|
int scale = 1;
|
|
|
|
while (log--)
|
|
|
|
scale *= 10;
|
|
|
|
return scale;
|
2007-03-19 08:45:50 -06:00
|
|
|
}
|
|
|
|
|
2007-09-26 09:43:41 -06:00
|
|
|
static inline int acpi_battery_vscale(struct acpi_battery *battery)
|
2007-03-19 08:45:50 -06:00
|
|
|
{
|
2007-09-26 09:43:41 -06:00
|
|
|
return battery_scale((battery->spec & 0x0f00) >> 8);
|
2007-03-19 08:45:50 -06:00
|
|
|
}
|
|
|
|
|
2007-09-26 09:43:41 -06:00
|
|
|
static inline int acpi_battery_ipscale(struct acpi_battery *battery)
|
2007-03-19 08:45:50 -06:00
|
|
|
{
|
2007-09-26 09:43:41 -06:00
|
|
|
return battery_scale((battery->spec & 0xf000) >> 12);
|
2007-03-19 08:45:50 -06:00
|
|
|
}
|
|
|
|
|
2007-09-26 09:43:41 -06:00
|
|
|
static inline int acpi_battery_mode(struct acpi_battery *battery)
|
2007-03-19 08:45:50 -06:00
|
|
|
{
|
2007-09-26 09:43:41 -06:00
|
|
|
return (battery->mode & 0x8000);
|
2007-03-19 08:45:50 -06:00
|
|
|
}
|
2006-07-01 09:36:54 -06:00
|
|
|
|
2007-09-26 09:43:41 -06:00
|
|
|
static inline int acpi_battery_scale(struct acpi_battery *battery)
|
2006-07-01 09:36:54 -06:00
|
|
|
{
|
2007-09-26 09:43:41 -06:00
|
|
|
return (acpi_battery_mode(battery) ? 10 : 1) *
|
|
|
|
acpi_battery_ipscale(battery);
|
2006-07-01 09:36:54 -06:00
|
|
|
}
|
|
|
|
|
2007-09-26 09:43:48 -06:00
|
|
|
static int sbs_get_ac_property(struct power_supply *psy,
|
|
|
|
enum power_supply_property psp,
|
|
|
|
union power_supply_propval *val)
|
|
|
|
{
|
|
|
|
struct acpi_sbs *sbs = to_acpi_sbs(psy);
|
|
|
|
switch (psp) {
|
|
|
|
case POWER_SUPPLY_PROP_ONLINE:
|
|
|
|
val->intval = sbs->charger_present;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int acpi_battery_technology(struct acpi_battery *battery)
|
|
|
|
{
|
|
|
|
if (!strcasecmp("NiCd", battery->device_chemistry))
|
|
|
|
return POWER_SUPPLY_TECHNOLOGY_NiCd;
|
|
|
|
if (!strcasecmp("NiMH", battery->device_chemistry))
|
|
|
|
return POWER_SUPPLY_TECHNOLOGY_NiMH;
|
|
|
|
if (!strcasecmp("LION", battery->device_chemistry))
|
|
|
|
return POWER_SUPPLY_TECHNOLOGY_LION;
|
|
|
|
if (!strcasecmp("LiP", battery->device_chemistry))
|
|
|
|
return POWER_SUPPLY_TECHNOLOGY_LIPO;
|
|
|
|
return POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int acpi_sbs_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);
|
|
|
|
|
|
|
|
if ((!battery->present) && psp != POWER_SUPPLY_PROP_PRESENT)
|
|
|
|
return -ENODEV;
|
2011-07-01 02:03:15 -06:00
|
|
|
|
|
|
|
acpi_battery_get_state(battery);
|
2007-09-26 09:43:48 -06:00
|
|
|
switch (psp) {
|
|
|
|
case POWER_SUPPLY_PROP_STATUS:
|
2009-03-27 20:23:52 -06:00
|
|
|
if (battery->rate_now < 0)
|
2007-09-26 09:43:48 -06:00
|
|
|
val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
|
2009-03-27 20:23:52 -06:00
|
|
|
else if (battery->rate_now > 0)
|
2007-09-26 09:43:48 -06:00
|
|
|
val->intval = POWER_SUPPLY_STATUS_CHARGING;
|
|
|
|
else
|
|
|
|
val->intval = POWER_SUPPLY_STATUS_FULL;
|
|
|
|
break;
|
|
|
|
case POWER_SUPPLY_PROP_PRESENT:
|
|
|
|
val->intval = battery->present;
|
|
|
|
break;
|
|
|
|
case POWER_SUPPLY_PROP_TECHNOLOGY:
|
|
|
|
val->intval = acpi_battery_technology(battery);
|
|
|
|
break;
|
2009-10-15 04:31:37 -06:00
|
|
|
case POWER_SUPPLY_PROP_CYCLE_COUNT:
|
|
|
|
val->intval = battery->cycle_count;
|
|
|
|
break;
|
2007-09-26 09:43:48 -06:00
|
|
|
case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
|
|
|
|
val->intval = battery->design_voltage *
|
|
|
|
acpi_battery_vscale(battery) * 1000;
|
|
|
|
break;
|
|
|
|
case POWER_SUPPLY_PROP_VOLTAGE_NOW:
|
|
|
|
val->intval = battery->voltage_now *
|
|
|
|
acpi_battery_vscale(battery) * 1000;
|
|
|
|
break;
|
|
|
|
case POWER_SUPPLY_PROP_CURRENT_NOW:
|
2009-03-27 20:23:52 -06:00
|
|
|
case POWER_SUPPLY_PROP_POWER_NOW:
|
|
|
|
val->intval = abs(battery->rate_now) *
|
2007-09-26 09:43:48 -06:00
|
|
|
acpi_battery_ipscale(battery) * 1000;
|
2011-07-01 02:03:39 -06:00
|
|
|
val->intval *= (acpi_battery_mode(battery)) ?
|
|
|
|
(battery->voltage_now *
|
|
|
|
acpi_battery_vscale(battery) / 1000) : 1;
|
2007-09-26 09:43:48 -06:00
|
|
|
break;
|
|
|
|
case POWER_SUPPLY_PROP_CURRENT_AVG:
|
2009-03-27 20:23:52 -06:00
|
|
|
case POWER_SUPPLY_PROP_POWER_AVG:
|
|
|
|
val->intval = abs(battery->rate_avg) *
|
2007-09-26 09:43:48 -06:00
|
|
|
acpi_battery_ipscale(battery) * 1000;
|
2011-07-01 02:03:39 -06:00
|
|
|
val->intval *= (acpi_battery_mode(battery)) ?
|
|
|
|
(battery->voltage_now *
|
|
|
|
acpi_battery_vscale(battery) / 1000) : 1;
|
2007-09-26 09:43:48 -06:00
|
|
|
break;
|
|
|
|
case POWER_SUPPLY_PROP_CAPACITY:
|
|
|
|
val->intval = battery->state_of_charge;
|
|
|
|
break;
|
|
|
|
case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
|
|
|
|
case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
|
|
|
|
val->intval = battery->design_capacity *
|
|
|
|
acpi_battery_scale(battery) * 1000;
|
|
|
|
break;
|
|
|
|
case POWER_SUPPLY_PROP_CHARGE_FULL:
|
|
|
|
case POWER_SUPPLY_PROP_ENERGY_FULL:
|
|
|
|
val->intval = battery->full_charge_capacity *
|
|
|
|
acpi_battery_scale(battery) * 1000;
|
|
|
|
break;
|
|
|
|
case POWER_SUPPLY_PROP_CHARGE_NOW:
|
|
|
|
case POWER_SUPPLY_PROP_ENERGY_NOW:
|
|
|
|
val->intval = battery->capacity_now *
|
|
|
|
acpi_battery_scale(battery) * 1000;
|
|
|
|
break;
|
|
|
|
case POWER_SUPPLY_PROP_TEMP:
|
|
|
|
val->intval = battery->temp_now - 2730; // dK -> dC
|
|
|
|
break;
|
|
|
|
case POWER_SUPPLY_PROP_MODEL_NAME:
|
|
|
|
val->strval = battery->device_name;
|
|
|
|
break;
|
|
|
|
case POWER_SUPPLY_PROP_MANUFACTURER:
|
|
|
|
val->strval = battery->manufacturer_name;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static enum power_supply_property sbs_ac_props[] = {
|
|
|
|
POWER_SUPPLY_PROP_ONLINE,
|
|
|
|
};
|
|
|
|
|
|
|
|
static enum power_supply_property sbs_charge_battery_props[] = {
|
|
|
|
POWER_SUPPLY_PROP_STATUS,
|
|
|
|
POWER_SUPPLY_PROP_PRESENT,
|
|
|
|
POWER_SUPPLY_PROP_TECHNOLOGY,
|
2009-10-15 04:31:37 -06:00
|
|
|
POWER_SUPPLY_PROP_CYCLE_COUNT,
|
2007-09-26 09:43:48 -06:00
|
|
|
POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
|
|
|
|
POWER_SUPPLY_PROP_VOLTAGE_NOW,
|
|
|
|
POWER_SUPPLY_PROP_CURRENT_NOW,
|
|
|
|
POWER_SUPPLY_PROP_CURRENT_AVG,
|
|
|
|
POWER_SUPPLY_PROP_CAPACITY,
|
|
|
|
POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
|
|
|
|
POWER_SUPPLY_PROP_CHARGE_FULL,
|
|
|
|
POWER_SUPPLY_PROP_CHARGE_NOW,
|
|
|
|
POWER_SUPPLY_PROP_TEMP,
|
|
|
|
POWER_SUPPLY_PROP_MODEL_NAME,
|
|
|
|
POWER_SUPPLY_PROP_MANUFACTURER,
|
|
|
|
};
|
|
|
|
|
|
|
|
static enum power_supply_property sbs_energy_battery_props[] = {
|
|
|
|
POWER_SUPPLY_PROP_STATUS,
|
|
|
|
POWER_SUPPLY_PROP_PRESENT,
|
|
|
|
POWER_SUPPLY_PROP_TECHNOLOGY,
|
|
|
|
POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
|
|
|
|
POWER_SUPPLY_PROP_VOLTAGE_NOW,
|
|
|
|
POWER_SUPPLY_PROP_CURRENT_NOW,
|
|
|
|
POWER_SUPPLY_PROP_CURRENT_AVG,
|
2009-03-27 20:23:52 -06:00
|
|
|
POWER_SUPPLY_PROP_POWER_NOW,
|
|
|
|
POWER_SUPPLY_PROP_POWER_AVG,
|
2007-09-26 09:43:48 -06:00
|
|
|
POWER_SUPPLY_PROP_CAPACITY,
|
|
|
|
POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
|
|
|
|
POWER_SUPPLY_PROP_ENERGY_FULL,
|
|
|
|
POWER_SUPPLY_PROP_ENERGY_NOW,
|
|
|
|
POWER_SUPPLY_PROP_TEMP,
|
|
|
|
POWER_SUPPLY_PROP_MODEL_NAME,
|
|
|
|
POWER_SUPPLY_PROP_MANUFACTURER,
|
|
|
|
};
|
2009-03-27 20:23:52 -06:00
|
|
|
|
2007-09-26 09:43:48 -06:00
|
|
|
|
2007-09-26 09:43:41 -06:00
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
Smart Battery System Management
|
|
|
|
-------------------------------------------------------------------------- */
|
2006-07-01 09:36:54 -06:00
|
|
|
|
2007-09-26 09:43:41 -06:00
|
|
|
struct acpi_battery_reader {
|
|
|
|
u8 command; /* command for battery */
|
|
|
|
u8 mode; /* word or block? */
|
|
|
|
size_t offset; /* offset inside struct acpi_sbs_battery */
|
|
|
|
};
|
2006-07-01 09:36:54 -06:00
|
|
|
|
2007-09-26 09:43:41 -06:00
|
|
|
static struct acpi_battery_reader info_readers[] = {
|
|
|
|
{0x01, SMBUS_READ_WORD, offsetof(struct acpi_battery, alarm_capacity)},
|
|
|
|
{0x03, SMBUS_READ_WORD, offsetof(struct acpi_battery, mode)},
|
|
|
|
{0x10, SMBUS_READ_WORD, offsetof(struct acpi_battery, full_charge_capacity)},
|
|
|
|
{0x17, SMBUS_READ_WORD, offsetof(struct acpi_battery, cycle_count)},
|
|
|
|
{0x18, SMBUS_READ_WORD, offsetof(struct acpi_battery, design_capacity)},
|
|
|
|
{0x19, SMBUS_READ_WORD, offsetof(struct acpi_battery, design_voltage)},
|
|
|
|
{0x1a, SMBUS_READ_WORD, offsetof(struct acpi_battery, spec)},
|
|
|
|
{0x1c, SMBUS_READ_WORD, offsetof(struct acpi_battery, serial_number)},
|
|
|
|
{0x20, SMBUS_READ_BLOCK, offsetof(struct acpi_battery, manufacturer_name)},
|
|
|
|
{0x21, SMBUS_READ_BLOCK, offsetof(struct acpi_battery, device_name)},
|
|
|
|
{0x22, SMBUS_READ_BLOCK, offsetof(struct acpi_battery, device_chemistry)},
|
|
|
|
};
|
2006-07-01 09:36:54 -06:00
|
|
|
|
2007-09-26 09:43:41 -06:00
|
|
|
static struct acpi_battery_reader state_readers[] = {
|
|
|
|
{0x08, SMBUS_READ_WORD, offsetof(struct acpi_battery, temp_now)},
|
|
|
|
{0x09, SMBUS_READ_WORD, offsetof(struct acpi_battery, voltage_now)},
|
2009-03-27 20:23:52 -06:00
|
|
|
{0x0a, SMBUS_READ_WORD, offsetof(struct acpi_battery, rate_now)},
|
|
|
|
{0x0b, SMBUS_READ_WORD, offsetof(struct acpi_battery, rate_avg)},
|
2007-09-26 09:43:41 -06:00
|
|
|
{0x0f, SMBUS_READ_WORD, offsetof(struct acpi_battery, capacity_now)},
|
|
|
|
{0x0e, SMBUS_READ_WORD, offsetof(struct acpi_battery, state_of_charge)},
|
|
|
|
{0x16, SMBUS_READ_WORD, offsetof(struct acpi_battery, state)},
|
|
|
|
};
|
2006-07-01 09:36:54 -06:00
|
|
|
|
2007-09-26 09:43:41 -06:00
|
|
|
static int acpi_manager_get_info(struct acpi_sbs *sbs)
|
2006-07-01 09:36:54 -06:00
|
|
|
{
|
|
|
|
int result = 0;
|
2007-09-26 09:43:41 -06:00
|
|
|
u16 battery_system_info;
|
2006-07-01 09:36:54 -06:00
|
|
|
|
2007-09-26 09:43:41 -06:00
|
|
|
result = acpi_smbus_read(sbs->hc, SMBUS_READ_WORD, ACPI_SBS_MANAGER,
|
2007-09-26 09:43:48 -06:00
|
|
|
0x04, (u8 *)&battery_system_info);
|
2007-09-26 09:43:41 -06:00
|
|
|
if (!result)
|
|
|
|
sbs->batteries_supported = battery_system_info & 0x000f;
|
2006-07-01 14:48:23 -06:00
|
|
|
return result;
|
2006-07-01 09:36:54 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static int acpi_battery_get_info(struct acpi_battery *battery)
|
|
|
|
{
|
2007-09-26 09:43:41 -06:00
|
|
|
int i, result = 0;
|
2006-07-01 09:36:54 -06:00
|
|
|
|
2007-09-26 09:43:41 -06:00
|
|
|
for (i = 0; i < ARRAY_SIZE(info_readers); ++i) {
|
2007-09-26 09:43:48 -06:00
|
|
|
result = acpi_smbus_read(battery->sbs->hc,
|
|
|
|
info_readers[i].mode,
|
|
|
|
ACPI_SBS_BATTERY,
|
|
|
|
info_readers[i].command,
|
|
|
|
(u8 *) battery +
|
|
|
|
info_readers[i].offset);
|
2007-09-26 09:43:41 -06:00
|
|
|
if (result)
|
|
|
|
break;
|
2006-07-01 09:36:54 -06:00
|
|
|
}
|
2006-07-01 14:48:23 -06:00
|
|
|
return result;
|
2006-07-01 09:36:54 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static int acpi_battery_get_state(struct acpi_battery *battery)
|
|
|
|
{
|
2007-09-26 09:43:41 -06:00
|
|
|
int i, result = 0;
|
2006-07-01 09:36:54 -06:00
|
|
|
|
2007-09-26 09:43:48 -06:00
|
|
|
if (battery->update_time &&
|
|
|
|
time_before(jiffies, battery->update_time +
|
2007-09-26 09:43:41 -06:00
|
|
|
msecs_to_jiffies(cache_time)))
|
|
|
|
return 0;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(state_readers); ++i) {
|
|
|
|
result = acpi_smbus_read(battery->sbs->hc,
|
|
|
|
state_readers[i].mode,
|
|
|
|
ACPI_SBS_BATTERY,
|
|
|
|
state_readers[i].command,
|
|
|
|
(u8 *)battery +
|
|
|
|
state_readers[i].offset);
|
|
|
|
if (result)
|
2006-07-01 09:36:54 -06:00
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
end:
|
2007-09-26 09:43:41 -06:00
|
|
|
battery->update_time = jiffies;
|
2006-07-01 14:48:23 -06:00
|
|
|
return result;
|
2006-07-01 09:36:54 -06:00
|
|
|
}
|
|
|
|
|
2007-09-26 09:43:41 -06:00
|
|
|
static int acpi_battery_get_alarm(struct acpi_battery *battery)
|
2006-07-01 09:36:54 -06:00
|
|
|
{
|
2007-09-26 09:43:41 -06:00
|
|
|
return acpi_smbus_read(battery->sbs->hc, SMBUS_READ_WORD,
|
|
|
|
ACPI_SBS_BATTERY, 0x01,
|
2007-09-26 09:43:48 -06:00
|
|
|
(u8 *)&battery->alarm_capacity);
|
2006-07-01 09:36:54 -06:00
|
|
|
}
|
|
|
|
|
2007-09-26 09:43:41 -06:00
|
|
|
static int acpi_battery_set_alarm(struct acpi_battery *battery)
|
2006-07-01 09:36:54 -06:00
|
|
|
{
|
2007-09-26 09:43:41 -06:00
|
|
|
struct acpi_sbs *sbs = battery->sbs;
|
2007-09-26 09:43:48 -06:00
|
|
|
u16 value, sel = 1 << (battery->id + 12);
|
|
|
|
|
|
|
|
int ret;
|
|
|
|
|
2006-07-01 09:36:54 -06:00
|
|
|
|
2007-09-26 09:43:41 -06:00
|
|
|
if (sbs->manager_present) {
|
2007-09-26 09:43:48 -06:00
|
|
|
ret = acpi_smbus_read(sbs->hc, SMBUS_READ_WORD, ACPI_SBS_MANAGER,
|
2007-09-26 09:43:41 -06:00
|
|
|
0x01, (u8 *)&value);
|
2007-09-26 09:43:48 -06:00
|
|
|
if (ret)
|
|
|
|
goto end;
|
|
|
|
if ((value & 0xf000) != sel) {
|
|
|
|
value &= 0x0fff;
|
|
|
|
value |= sel;
|
|
|
|
ret = acpi_smbus_write(sbs->hc, SMBUS_WRITE_WORD,
|
|
|
|
ACPI_SBS_MANAGER,
|
|
|
|
0x01, (u8 *)&value, 2);
|
|
|
|
if (ret)
|
|
|
|
goto end;
|
|
|
|
}
|
2006-07-01 09:36:54 -06:00
|
|
|
}
|
2007-09-26 09:43:48 -06:00
|
|
|
ret = acpi_smbus_write(sbs->hc, SMBUS_WRITE_WORD, ACPI_SBS_BATTERY,
|
|
|
|
0x01, (u8 *)&battery->alarm_capacity, 2);
|
|
|
|
end:
|
|
|
|
return ret;
|
2006-07-01 09:36:54 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static int acpi_ac_get_present(struct acpi_sbs *sbs)
|
|
|
|
{
|
2007-09-26 09:43:41 -06:00
|
|
|
int result;
|
|
|
|
u16 status;
|
2006-07-01 09:36:54 -06:00
|
|
|
|
2007-09-26 09:43:41 -06:00
|
|
|
result = acpi_smbus_read(sbs->hc, SMBUS_READ_WORD, ACPI_SBS_CHARGER,
|
|
|
|
0x13, (u8 *) & status);
|
2014-09-20 05:19:45 -06:00
|
|
|
|
|
|
|
if (result)
|
|
|
|
return result;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The spec requires that bit 4 always be 1. If it's not set, assume
|
|
|
|
* that the implementation doesn't support an SBS charger
|
|
|
|
*/
|
2014-09-27 17:27:42 -06:00
|
|
|
if (!((status >> 4) & 0x1))
|
2014-09-20 05:19:45 -06:00
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
sbs->charger_present = (status >> 15) & 0x1;
|
|
|
|
return 0;
|
2006-07-01 09:36:54 -06:00
|
|
|
}
|
|
|
|
|
2007-09-26 09:44:00 -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));
|
|
|
|
acpi_battery_get_alarm(battery);
|
|
|
|
return sprintf(buf, "%d\n", battery->alarm_capacity *
|
|
|
|
acpi_battery_scale(battery) * 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));
|
2014-02-10 03:36:42 -07:00
|
|
|
if (sscanf(buf, "%lu\n", &x) == 1)
|
2007-09-26 09:44:00 -06:00
|
|
|
battery->alarm_capacity = x /
|
|
|
|
(1000 * acpi_battery_scale(battery));
|
|
|
|
if (battery->present)
|
|
|
|
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-09-26 09:44:00 -06:00
|
|
|
.show = acpi_battery_alarm_show,
|
|
|
|
.store = acpi_battery_alarm_store,
|
|
|
|
};
|
|
|
|
|
2006-07-01 09:36:54 -06:00
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
Driver Interface
|
|
|
|
-------------------------------------------------------------------------- */
|
2007-09-26 09:43:41 -06:00
|
|
|
static int acpi_battery_read(struct acpi_battery *battery)
|
2006-07-01 09:36:54 -06:00
|
|
|
{
|
2007-09-26 09:43:41 -06:00
|
|
|
int result = 0, saved_present = battery->present;
|
|
|
|
u16 state;
|
2006-07-01 09:36:54 -06:00
|
|
|
|
2007-09-26 09:43:41 -06:00
|
|
|
if (battery->sbs->manager_present) {
|
|
|
|
result = acpi_smbus_read(battery->sbs->hc, SMBUS_READ_WORD,
|
|
|
|
ACPI_SBS_MANAGER, 0x01, (u8 *)&state);
|
|
|
|
if (!result)
|
|
|
|
battery->present = state & (1 << battery->id);
|
|
|
|
state &= 0x0fff;
|
|
|
|
state |= 1 << (battery->id + 12);
|
|
|
|
acpi_smbus_write(battery->sbs->hc, SMBUS_WRITE_WORD,
|
|
|
|
ACPI_SBS_MANAGER, 0x01, (u8 *)&state, 2);
|
|
|
|
} else if (battery->id == 0)
|
|
|
|
battery->present = 1;
|
2014-09-20 05:19:46 -06:00
|
|
|
|
2007-09-26 09:43:41 -06:00
|
|
|
if (result || !battery->present)
|
|
|
|
return result;
|
2006-07-01 09:36:54 -06:00
|
|
|
|
2007-09-26 09:43:41 -06:00
|
|
|
if (saved_present != battery->present) {
|
|
|
|
battery->update_time = 0;
|
|
|
|
result = acpi_battery_get_info(battery);
|
2014-09-20 05:19:46 -06:00
|
|
|
if (result) {
|
|
|
|
battery->present = 0;
|
2007-09-26 09:43:41 -06:00
|
|
|
return result;
|
2014-09-20 05:19:46 -06:00
|
|
|
}
|
2007-09-26 09:43:41 -06:00
|
|
|
}
|
|
|
|
result = acpi_battery_get_state(battery);
|
2014-09-20 05:19:46 -06:00
|
|
|
if (result)
|
|
|
|
battery->present = 0;
|
2007-09-26 09:43:41 -06:00
|
|
|
return result;
|
|
|
|
}
|
2006-07-01 09:36:54 -06:00
|
|
|
|
2007-09-26 09:43:48 -06:00
|
|
|
/* Smart Battery */
|
2007-09-26 09:43:41 -06:00
|
|
|
static int acpi_battery_add(struct acpi_sbs *sbs, int id)
|
|
|
|
{
|
|
|
|
struct acpi_battery *battery = &sbs->battery[id];
|
2007-09-26 09:43:48 -06:00
|
|
|
int result;
|
|
|
|
|
2006-07-01 09:36:54 -06:00
|
|
|
battery->id = id;
|
|
|
|
battery->sbs = sbs;
|
2007-09-26 09:43:41 -06:00
|
|
|
result = acpi_battery_read(battery);
|
|
|
|
if (result)
|
|
|
|
return result;
|
2006-07-01 09:36:54 -06:00
|
|
|
|
2007-09-26 09:43:41 -06:00
|
|
|
sprintf(battery->name, ACPI_BATTERY_DIR_NAME, id);
|
2007-09-26 09:43:48 -06:00
|
|
|
battery->bat.name = battery->name;
|
|
|
|
battery->bat.type = POWER_SUPPLY_TYPE_BATTERY;
|
|
|
|
if (!acpi_battery_mode(battery)) {
|
|
|
|
battery->bat.properties = sbs_charge_battery_props;
|
|
|
|
battery->bat.num_properties =
|
|
|
|
ARRAY_SIZE(sbs_charge_battery_props);
|
|
|
|
} else {
|
|
|
|
battery->bat.properties = sbs_energy_battery_props;
|
|
|
|
battery->bat.num_properties =
|
|
|
|
ARRAY_SIZE(sbs_energy_battery_props);
|
|
|
|
}
|
|
|
|
battery->bat.get_property = acpi_sbs_battery_get_property;
|
|
|
|
result = power_supply_register(&sbs->device->dev, &battery->bat);
|
2007-11-17 14:32:31 -07:00
|
|
|
if (result)
|
|
|
|
goto end;
|
2014-09-20 05:19:46 -06:00
|
|
|
|
2007-11-17 14:32:31 -07:00
|
|
|
result = device_create_file(battery->bat.dev, &alarm_attr);
|
|
|
|
if (result)
|
|
|
|
goto end;
|
|
|
|
battery->have_sysfs_alarm = 1;
|
|
|
|
end:
|
2007-03-19 08:45:50 -06:00
|
|
|
printk(KERN_INFO PREFIX "%s [%s]: Battery Slot [%s] (battery %s)\n",
|
2007-09-26 09:43:41 -06:00
|
|
|
ACPI_SBS_DEVICE_NAME, acpi_device_bid(sbs->device),
|
2008-02-09 01:22:13 -07:00
|
|
|
battery->name, battery->present ? "present" : "absent");
|
2006-07-01 14:48:23 -06:00
|
|
|
return result;
|
2006-07-01 09:36:54 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static void acpi_battery_remove(struct acpi_sbs *sbs, int id)
|
|
|
|
{
|
2007-11-17 14:32:31 -07:00
|
|
|
struct acpi_battery *battery = &sbs->battery[id];
|
2010-01-03 06:27:56 -07:00
|
|
|
|
2007-11-17 14:32:31 -07:00
|
|
|
if (battery->bat.dev) {
|
|
|
|
if (battery->have_sysfs_alarm)
|
|
|
|
device_remove_file(battery->bat.dev, &alarm_attr);
|
|
|
|
power_supply_unregister(&battery->bat);
|
2006-07-01 09:36:54 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-09-26 09:43:41 -06:00
|
|
|
static int acpi_charger_add(struct acpi_sbs *sbs)
|
2006-07-01 09:36:54 -06:00
|
|
|
{
|
|
|
|
int result;
|
|
|
|
|
|
|
|
result = acpi_ac_get_present(sbs);
|
2007-09-26 09:43:41 -06:00
|
|
|
if (result)
|
2006-07-01 09:36:54 -06:00
|
|
|
goto end;
|
2013-10-10 19:54:09 -06:00
|
|
|
|
2014-09-20 05:19:45 -06:00
|
|
|
sbs->charger_exists = 1;
|
2007-09-26 09:43:48 -06:00
|
|
|
sbs->charger.name = "sbs-charger";
|
|
|
|
sbs->charger.type = POWER_SUPPLY_TYPE_MAINS;
|
|
|
|
sbs->charger.properties = sbs_ac_props;
|
|
|
|
sbs->charger.num_properties = ARRAY_SIZE(sbs_ac_props);
|
|
|
|
sbs->charger.get_property = sbs_get_ac_property;
|
|
|
|
power_supply_register(&sbs->device->dev, &sbs->charger);
|
2007-03-19 08:45:50 -06:00
|
|
|
printk(KERN_INFO PREFIX "%s [%s]: AC Adapter [%s] (%s)\n",
|
|
|
|
ACPI_SBS_DEVICE_NAME, acpi_device_bid(sbs->device),
|
2007-09-26 09:43:35 -06:00
|
|
|
ACPI_AC_DIR_NAME, sbs->charger_present ? "on-line" : "off-line");
|
2006-07-01 09:36:54 -06:00
|
|
|
end:
|
2006-07-01 14:48:23 -06:00
|
|
|
return result;
|
2006-07-01 09:36:54 -06:00
|
|
|
}
|
|
|
|
|
2007-09-26 09:43:41 -06:00
|
|
|
static void acpi_charger_remove(struct acpi_sbs *sbs)
|
2006-07-01 09:36:54 -06:00
|
|
|
{
|
2007-09-26 09:43:48 -06:00
|
|
|
if (sbs->charger.dev)
|
|
|
|
power_supply_unregister(&sbs->charger);
|
2006-07-01 09:36:54 -06:00
|
|
|
}
|
|
|
|
|
2007-10-24 10:24:42 -06:00
|
|
|
static void acpi_sbs_callback(void *context)
|
2006-07-01 09:36:54 -06:00
|
|
|
{
|
2007-09-26 09:43:41 -06:00
|
|
|
int id;
|
|
|
|
struct acpi_sbs *sbs = context;
|
|
|
|
struct acpi_battery *bat;
|
|
|
|
u8 saved_charger_state = sbs->charger_present;
|
|
|
|
u8 saved_battery_state;
|
2014-09-20 05:19:45 -06:00
|
|
|
|
|
|
|
if (sbs->charger_exists) {
|
|
|
|
acpi_ac_get_present(sbs);
|
|
|
|
if (sbs->charger_present != saved_charger_state)
|
|
|
|
kobject_uevent(&sbs->charger.dev->kobj, KOBJ_CHANGE);
|
|
|
|
}
|
2013-07-15 02:15:09 -06:00
|
|
|
|
2007-09-26 09:43:41 -06:00
|
|
|
if (sbs->manager_present) {
|
|
|
|
for (id = 0; id < MAX_SBS_BAT; ++id) {
|
|
|
|
if (!(sbs->batteries_supported & (1 << id)))
|
|
|
|
continue;
|
|
|
|
bat = &sbs->battery[id];
|
|
|
|
saved_battery_state = bat->present;
|
|
|
|
acpi_battery_read(bat);
|
|
|
|
if (saved_battery_state == bat->present)
|
|
|
|
continue;
|
2007-09-26 09:43:48 -06:00
|
|
|
kobject_uevent(&bat->bat.dev->kobj, KOBJ_CHANGE);
|
2006-07-01 09:36:54 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-09-20 05:19:46 -06:00
|
|
|
static int disable_sbs_manager(const struct dmi_system_id *d)
|
|
|
|
{
|
|
|
|
sbs_manager_broken = true;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct dmi_system_id acpi_sbs_dmi_table[] = {
|
|
|
|
{
|
|
|
|
.callback = disable_sbs_manager,
|
|
|
|
.ident = "Apple",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc.")
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{ },
|
|
|
|
};
|
|
|
|
|
2006-07-01 09:36:54 -06:00
|
|
|
static int acpi_sbs_add(struct acpi_device *device)
|
|
|
|
{
|
2007-09-26 09:43:41 -06:00
|
|
|
struct acpi_sbs *sbs;
|
|
|
|
int result = 0;
|
2007-03-19 08:45:50 -06:00
|
|
|
int id;
|
2006-07-01 09:36:54 -06:00
|
|
|
|
2014-09-20 05:19:46 -06:00
|
|
|
dmi_check_system(acpi_sbs_dmi_table);
|
|
|
|
|
2006-12-19 13:56:11 -07:00
|
|
|
sbs = kzalloc(sizeof(struct acpi_sbs), GFP_KERNEL);
|
2006-07-01 09:36:54 -06:00
|
|
|
if (!sbs) {
|
2007-03-19 08:45:50 -06:00
|
|
|
result = -ENOMEM;
|
|
|
|
goto end;
|
2006-07-01 09:36:54 -06:00
|
|
|
}
|
|
|
|
|
2007-09-26 09:43:41 -06:00
|
|
|
mutex_init(&sbs->lock);
|
2007-03-19 08:45:50 -06:00
|
|
|
|
2007-09-26 09:43:28 -06:00
|
|
|
sbs->hc = acpi_driver_data(device->parent);
|
2007-09-26 09:43:41 -06:00
|
|
|
sbs->device = device;
|
2006-07-01 09:36:54 -06:00
|
|
|
strcpy(acpi_device_name(device), ACPI_SBS_DEVICE_NAME);
|
|
|
|
strcpy(acpi_device_class(device), ACPI_SBS_CLASS);
|
2008-09-22 15:37:34 -06:00
|
|
|
device->driver_data = sbs;
|
2006-07-01 09:36:54 -06:00
|
|
|
|
2007-09-26 09:43:41 -06:00
|
|
|
result = acpi_charger_add(sbs);
|
2014-09-20 05:19:45 -06:00
|
|
|
if (result && result != -ENODEV)
|
2007-03-19 08:45:50 -06:00
|
|
|
goto end;
|
2006-07-01 09:36:54 -06:00
|
|
|
|
2014-09-20 05:19:46 -06:00
|
|
|
result = 0;
|
|
|
|
|
|
|
|
if (!sbs_manager_broken) {
|
|
|
|
result = acpi_manager_get_info(sbs);
|
|
|
|
if (!result) {
|
|
|
|
sbs->manager_present = 0;
|
|
|
|
for (id = 0; id < MAX_SBS_BAT; ++id)
|
|
|
|
if ((sbs->batteries_supported & (1 << id)))
|
|
|
|
acpi_battery_add(sbs, id);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!sbs->manager_present)
|
2007-09-26 09:43:41 -06:00
|
|
|
acpi_battery_add(sbs, 0);
|
2014-09-20 05:19:46 -06:00
|
|
|
|
2007-09-26 09:43:41 -06:00
|
|
|
acpi_smbus_register_callback(sbs->hc, acpi_sbs_callback, sbs);
|
2006-07-01 09:36:54 -06:00
|
|
|
end:
|
2007-09-26 09:43:41 -06:00
|
|
|
if (result)
|
2013-01-23 16:24:48 -07:00
|
|
|
acpi_sbs_remove(device);
|
2006-07-01 14:48:23 -06:00
|
|
|
return result;
|
2006-07-01 09:36:54 -06:00
|
|
|
}
|
|
|
|
|
2013-01-23 16:24:48 -07:00
|
|
|
static int acpi_sbs_remove(struct acpi_device *device)
|
2006-07-01 09:36:54 -06:00
|
|
|
{
|
2006-12-15 23:04:27 -07:00
|
|
|
struct acpi_sbs *sbs;
|
2006-07-01 09:36:54 -06:00
|
|
|
int id;
|
|
|
|
|
2007-09-26 09:43:41 -06:00
|
|
|
if (!device)
|
2006-09-05 09:49:13 -06:00
|
|
|
return -EINVAL;
|
2007-03-19 08:45:50 -06:00
|
|
|
sbs = acpi_driver_data(device);
|
2007-09-26 09:43:41 -06:00
|
|
|
if (!sbs)
|
2006-07-01 14:48:23 -06:00
|
|
|
return -EINVAL;
|
2007-09-26 09:43:41 -06:00
|
|
|
mutex_lock(&sbs->lock);
|
|
|
|
acpi_smbus_unregister_callback(sbs->hc);
|
|
|
|
for (id = 0; id < MAX_SBS_BAT; ++id)
|
2006-07-01 09:36:54 -06:00
|
|
|
acpi_battery_remove(sbs, id);
|
2007-09-26 09:43:41 -06:00
|
|
|
acpi_charger_remove(sbs);
|
|
|
|
mutex_unlock(&sbs->lock);
|
|
|
|
mutex_destroy(&sbs->lock);
|
2006-07-01 09:36:54 -06:00
|
|
|
kfree(sbs);
|
2006-07-01 14:48:23 -06:00
|
|
|
return 0;
|
2006-07-01 09:36:54 -06:00
|
|
|
}
|
|
|
|
|
2012-08-09 15:00:02 -06:00
|
|
|
#ifdef CONFIG_PM_SLEEP
|
2012-06-27 15:27:07 -06:00
|
|
|
static int acpi_sbs_resume(struct device *dev)
|
2007-03-19 08:45:50 -06:00
|
|
|
{
|
|
|
|
struct acpi_sbs *sbs;
|
2012-06-27 15:27:07 -06:00
|
|
|
if (!dev)
|
2007-03-19 08:45:50 -06:00
|
|
|
return -EINVAL;
|
2012-06-27 15:27:07 -06:00
|
|
|
sbs = to_acpi_device(dev)->driver_data;
|
2007-09-26 09:43:41 -06:00
|
|
|
acpi_sbs_callback(sbs);
|
2007-03-19 08:45:50 -06:00
|
|
|
return 0;
|
|
|
|
}
|
2014-02-12 20:19:09 -07:00
|
|
|
#else
|
|
|
|
#define acpi_sbs_resume NULL
|
2012-08-09 15:00:02 -06:00
|
|
|
#endif
|
2007-03-19 08:45:50 -06:00
|
|
|
|
2012-06-27 15:27:07 -06:00
|
|
|
static SIMPLE_DEV_PM_OPS(acpi_sbs_pm, NULL, acpi_sbs_resume);
|
|
|
|
|
2007-09-26 09:43:48 -06:00
|
|
|
static struct acpi_driver acpi_sbs_driver = {
|
|
|
|
.name = "sbs",
|
|
|
|
.class = ACPI_SBS_CLASS,
|
|
|
|
.ids = sbs_device_ids,
|
|
|
|
.ops = {
|
|
|
|
.add = acpi_sbs_add,
|
|
|
|
.remove = acpi_sbs_remove,
|
|
|
|
},
|
2012-06-27 15:27:07 -06:00
|
|
|
.drv.pm = &acpi_sbs_pm,
|
2007-09-26 09:43:48 -06:00
|
|
|
};
|
|
|
|
|
2006-07-01 09:36:54 -06:00
|
|
|
static int __init acpi_sbs_init(void)
|
|
|
|
{
|
|
|
|
int result = 0;
|
|
|
|
|
2006-08-15 21:21:37 -06:00
|
|
|
if (acpi_disabled)
|
|
|
|
return -ENODEV;
|
2013-10-10 19:54:09 -06:00
|
|
|
|
2006-07-01 09:36:54 -06:00
|
|
|
result = acpi_bus_register_driver(&acpi_sbs_driver);
|
2013-10-10 19:54:09 -06:00
|
|
|
if (result < 0)
|
2006-07-01 14:48:23 -06:00
|
|
|
return -ENODEV;
|
2013-10-10 19:54:09 -06:00
|
|
|
|
2006-07-01 14:48:23 -06:00
|
|
|
return 0;
|
2006-07-01 09:36:54 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit acpi_sbs_exit(void)
|
|
|
|
{
|
|
|
|
acpi_bus_unregister_driver(&acpi_sbs_driver);
|
2006-07-01 14:48:23 -06:00
|
|
|
return;
|
2006-07-01 09:36:54 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
module_init(acpi_sbs_init);
|
|
|
|
module_exit(acpi_sbs_exit);
|