blob: 7efaeaa53b88a5c8db7f9b2f624e65a432b3283a [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +04002 * battery.c - ACPI Battery Driver (Revision: 2.0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 *
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +04004 * Copyright (C) 2007 Alexey Starikovskiy <astarikovskiy@suse.de>
5 * Copyright (C) 2004-2007 Vladimir Lebedev <vladimir.p.lebedev@intel.com>
Linus Torvalds1da177e2005-04-16 15:20:36 -07006 * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
7 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
8 *
9 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or (at
14 * your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful, but
17 * WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License along
22 * with this program; if not, write to the Free Software Foundation, Inc.,
23 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
24 *
25 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
26 */
27
28#include <linux/kernel.h>
29#include <linux/module.h>
30#include <linux/init.h>
31#include <linux/types.h>
Alexey Starikovskiyf1d46612007-09-26 19:42:52 +040032#include <linux/jiffies.h>
Arjan van de Ven0f66af52009-01-10 14:19:05 -050033#include <linux/async.h>
Hector Martinbc76f902009-08-06 15:57:48 -070034#include <linux/dmi.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090035#include <linux/slab.h>
Kyle McMartin25be5822011-03-22 16:19:50 -040036#include <linux/suspend.h>
Kamil Iskra4000e622012-11-16 22:28:58 +010037#include <asm/unaligned.h>
Alexey Starikovskiyd7380962007-09-26 19:43:04 +040038
Alexey Starikovskiyfdcedbb2007-11-19 16:33:45 +030039#ifdef CONFIG_ACPI_PROCFS_POWER
Linus Torvalds1da177e2005-04-16 15:20:36 -070040#include <linux/proc_fs.h>
41#include <linux/seq_file.h>
42#include <asm/uaccess.h>
Alexey Starikovskiyd7380962007-09-26 19:43:04 +040043#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070044
45#include <acpi/acpi_bus.h>
46#include <acpi/acpi_drivers.h>
Alexey Starikovskiyd7380962007-09-26 19:43:04 +040047#include <linux/power_supply.h>
48
Len Browna192a952009-07-28 16:45:54 -040049#define PREFIX "ACPI: "
50
Linus Torvalds1da177e2005-04-16 15:20:36 -070051#define ACPI_BATTERY_VALUE_UNKNOWN 0xFFFFFFFF
52
Linus Torvalds1da177e2005-04-16 15:20:36 -070053#define ACPI_BATTERY_CLASS "battery"
Linus Torvalds1da177e2005-04-16 15:20:36 -070054#define ACPI_BATTERY_DEVICE_NAME "Battery"
Linus Torvalds1da177e2005-04-16 15:20:36 -070055#define ACPI_BATTERY_NOTIFY_STATUS 0x80
56#define ACPI_BATTERY_NOTIFY_INFO 0x81
Alexey Starikovskiyc67fcd62009-10-15 14:31:44 +040057#define ACPI_BATTERY_NOTIFY_THRESHOLD 0x82
Linus Torvalds1da177e2005-04-16 15:20:36 -070058
Lan Tianyuae6f6182011-06-30 11:32:40 +080059/* Battery power unit: 0 means mW, 1 means mA */
60#define ACPI_BATTERY_POWER_UNIT_MA 1
61
Linus Torvalds1da177e2005-04-16 15:20:36 -070062#define _COMPONENT ACPI_BATTERY_COMPONENT
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +030063
Len Brownf52fd662007-02-12 22:42:12 -050064ACPI_MODULE_NAME("battery");
Linus Torvalds1da177e2005-04-16 15:20:36 -070065
Len Brownf52fd662007-02-12 22:42:12 -050066MODULE_AUTHOR("Paul Diefenbaugh");
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +040067MODULE_AUTHOR("Alexey Starikovskiy <astarikovskiy@suse.de>");
Len Brown7cda93e2007-02-12 23:50:02 -050068MODULE_DESCRIPTION("ACPI Battery Driver");
Linus Torvalds1da177e2005-04-16 15:20:36 -070069MODULE_LICENSE("GPL");
70
Alexey Starikovskiyf1d46612007-09-26 19:42:52 +040071static unsigned int cache_time = 1000;
72module_param(cache_time, uint, 0644);
73MODULE_PARM_DESC(cache_time, "cache time in milliseconds");
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +030074
Alexey Starikovskiyfdcedbb2007-11-19 16:33:45 +030075#ifdef CONFIG_ACPI_PROCFS_POWER
Rich Townsend3f86b832006-07-01 11:36:54 -040076extern struct proc_dir_entry *acpi_lock_battery_dir(void);
77extern void *acpi_unlock_battery_dir(struct proc_dir_entry *acpi_battery_dir);
78
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +040079enum acpi_battery_files {
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +040080 info_tag = 0,
81 state_tag,
82 alarm_tag,
Alexey Starikovskiy78490d82007-05-11 13:18:55 -040083 ACPI_BATTERY_NUMFILES,
84};
85
Alexey Starikovskiyd7380962007-09-26 19:43:04 +040086#endif
87
88static const struct acpi_device_id battery_device_ids[] = {
89 {"PNP0C0A", 0},
90 {"", 0},
91};
92
93MODULE_DEVICE_TABLE(acpi, battery_device_ids);
94
Alexey Starikovskiy7b3bcc42009-10-15 14:31:24 +040095enum {
96 ACPI_BATTERY_ALARM_PRESENT,
Alexey Starikovskiyc67fcd62009-10-15 14:31:44 +040097 ACPI_BATTERY_XINFO_PRESENT,
Zhang Rui557d5862010-10-22 10:02:06 +080098 ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY,
Kamil Iskra4000e622012-11-16 22:28:58 +010099 /* On Lenovo Thinkpad models from 2010 and 2011, the power unit
100 switches between mWh and mAh depending on whether the system
101 is running on battery or not. When mAh is the unit, most
102 reported values are incorrect and need to be adjusted by
103 10000/design_voltage. Verified on x201, t410, t410s, and x220.
104 Pre-2010 and 2012 models appear to always report in mWh and
105 are thus unaffected (tested with t42, t61, t500, x200, x300,
106 and x230). Also, in mid-2012 Lenovo issued a BIOS update for
107 the 2011 models that fixes the issue (tested on x220 with a
108 post-1.29 BIOS), but as of Nov. 2012, no such update is
109 available for the 2010 models. */
110 ACPI_BATTERY_QUIRK_THINKPAD_MAH,
Alexey Starikovskiy7b3bcc42009-10-15 14:31:24 +0400111};
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400112
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400113struct acpi_battery {
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400114 struct mutex lock;
Sergey Senozhatsky69d94ec2011-08-06 01:34:08 +0300115 struct mutex sysfs_lock;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400116 struct power_supply bat;
Alexey Starikovskiyf1d46612007-09-26 19:42:52 +0400117 struct acpi_device *device;
Kyle McMartin25be5822011-03-22 16:19:50 -0400118 struct notifier_block pm_nb;
Alexey Starikovskiyf1d46612007-09-26 19:42:52 +0400119 unsigned long update_time;
Alexey Starikovskiy7faa1442009-03-27 22:23:52 -0400120 int rate_now;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400121 int capacity_now;
122 int voltage_now;
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400123 int design_capacity;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400124 int full_charge_capacity;
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400125 int technology;
126 int design_voltage;
127 int design_capacity_warning;
128 int design_capacity_low;
Alexey Starikovskiyc67fcd62009-10-15 14:31:44 +0400129 int cycle_count;
130 int measurement_accuracy;
131 int max_sampling_time;
132 int min_sampling_time;
133 int max_averaging_interval;
134 int min_averaging_interval;
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400135 int capacity_granularity_1;
136 int capacity_granularity_2;
Alexey Starikovskiyf1d46612007-09-26 19:42:52 +0400137 int alarm;
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400138 char model_number[32];
139 char serial_number[32];
140 char type[32];
141 char oem_info[32];
Alexey Starikovskiyf1d46612007-09-26 19:42:52 +0400142 int state;
143 int power_unit;
Alexey Starikovskiy7b3bcc42009-10-15 14:31:24 +0400144 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145};
146
Phil Carmody497888c2011-07-14 15:07:13 +0300147#define to_acpi_battery(x) container_of(x, struct acpi_battery, bat)
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400148
Alexey Starikovskiy78490d82007-05-11 13:18:55 -0400149inline int acpi_battery_present(struct acpi_battery *battery)
150{
151 return battery->device->status.battery_present;
152}
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400153
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400154static int acpi_battery_technology(struct acpi_battery *battery)
155{
156 if (!strcasecmp("NiCd", battery->type))
157 return POWER_SUPPLY_TECHNOLOGY_NiCd;
158 if (!strcasecmp("NiMH", battery->type))
159 return POWER_SUPPLY_TECHNOLOGY_NiMH;
160 if (!strcasecmp("LION", battery->type))
161 return POWER_SUPPLY_TECHNOLOGY_LION;
Andrey Borzenkovad40e682007-11-10 20:02:49 +0300162 if (!strncasecmp("LI-ION", battery->type, 6))
Alexey Starikovskiy0bde7ee2007-10-28 15:33:10 +0300163 return POWER_SUPPLY_TECHNOLOGY_LION;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400164 if (!strcasecmp("LiP", battery->type))
165 return POWER_SUPPLY_TECHNOLOGY_LIPO;
166 return POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
167}
168
Alexey Starikovskiy91044762007-11-13 12:23:06 +0300169static int acpi_battery_get_state(struct acpi_battery *battery);
Alexey Starikovskiyb19073a2007-10-25 17:10:47 -0400170
Richard Hughes56f382a2009-01-25 15:05:50 +0000171static int acpi_battery_is_charged(struct acpi_battery *battery)
172{
173 /* either charging or discharging */
174 if (battery->state != 0)
175 return 0;
176
177 /* battery not reporting charge */
178 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN ||
179 battery->capacity_now == 0)
180 return 0;
181
182 /* good batteries update full_charge as the batteries degrade */
183 if (battery->full_charge_capacity == battery->capacity_now)
184 return 1;
185
186 /* fallback to using design values for broken batteries */
187 if (battery->design_capacity == battery->capacity_now)
188 return 1;
189
190 /* we don't do any sort of metric based on percentages */
191 return 0;
192}
193
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400194static int acpi_battery_get_property(struct power_supply *psy,
195 enum power_supply_property psp,
196 union power_supply_propval *val)
197{
Rafael J. Wysockia1b4bd62010-10-23 19:35:15 +0200198 int ret = 0;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400199 struct acpi_battery *battery = to_acpi_battery(psy);
200
Alexey Starikovskiy91044762007-11-13 12:23:06 +0300201 if (acpi_battery_present(battery)) {
202 /* run battery update only if it is present */
203 acpi_battery_get_state(battery);
204 } else if (psp != POWER_SUPPLY_PROP_PRESENT)
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400205 return -ENODEV;
206 switch (psp) {
207 case POWER_SUPPLY_PROP_STATUS:
208 if (battery->state & 0x01)
209 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
210 else if (battery->state & 0x02)
211 val->intval = POWER_SUPPLY_STATUS_CHARGING;
Richard Hughes56f382a2009-01-25 15:05:50 +0000212 else if (acpi_battery_is_charged(battery))
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400213 val->intval = POWER_SUPPLY_STATUS_FULL;
Roland Dreier4c41d3a2007-11-07 15:09:09 -0800214 else
215 val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400216 break;
217 case POWER_SUPPLY_PROP_PRESENT:
218 val->intval = acpi_battery_present(battery);
219 break;
220 case POWER_SUPPLY_PROP_TECHNOLOGY:
221 val->intval = acpi_battery_technology(battery);
222 break;
Alexey Starikovskiyc67fcd62009-10-15 14:31:44 +0400223 case POWER_SUPPLY_PROP_CYCLE_COUNT:
224 val->intval = battery->cycle_count;
225 break;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400226 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
Rafael J. Wysockia1b4bd62010-10-23 19:35:15 +0200227 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
228 ret = -ENODEV;
229 else
230 val->intval = battery->design_voltage * 1000;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400231 break;
232 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
Rafael J. Wysockia1b4bd62010-10-23 19:35:15 +0200233 if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
234 ret = -ENODEV;
235 else
236 val->intval = battery->voltage_now * 1000;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400237 break;
238 case POWER_SUPPLY_PROP_CURRENT_NOW:
Alexey Starikovskiy7faa1442009-03-27 22:23:52 -0400239 case POWER_SUPPLY_PROP_POWER_NOW:
Rafael J. Wysockia1b4bd62010-10-23 19:35:15 +0200240 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
241 ret = -ENODEV;
242 else
243 val->intval = battery->rate_now * 1000;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400244 break;
245 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
246 case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
Rafael J. Wysockia1b4bd62010-10-23 19:35:15 +0200247 if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
248 ret = -ENODEV;
249 else
250 val->intval = battery->design_capacity * 1000;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400251 break;
252 case POWER_SUPPLY_PROP_CHARGE_FULL:
253 case POWER_SUPPLY_PROP_ENERGY_FULL:
Rafael J. Wysockia1b4bd62010-10-23 19:35:15 +0200254 if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
255 ret = -ENODEV;
256 else
257 val->intval = battery->full_charge_capacity * 1000;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400258 break;
259 case POWER_SUPPLY_PROP_CHARGE_NOW:
260 case POWER_SUPPLY_PROP_ENERGY_NOW:
Rafael J. Wysockia1b4bd62010-10-23 19:35:15 +0200261 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
262 ret = -ENODEV;
263 else
264 val->intval = battery->capacity_now * 1000;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400265 break;
srinivas pandruvadaa58e1152012-04-05 17:38:54 -0700266 case POWER_SUPPLY_PROP_CAPACITY:
267 if (battery->capacity_now && battery->full_charge_capacity)
268 val->intval = battery->capacity_now * 100/
269 battery->full_charge_capacity;
270 else
271 val->intval = 0;
272 break;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400273 case POWER_SUPPLY_PROP_MODEL_NAME:
274 val->strval = battery->model_number;
275 break;
276 case POWER_SUPPLY_PROP_MANUFACTURER:
277 val->strval = battery->oem_info;
278 break;
maximilian attems7c2670b2008-01-22 18:46:50 +0100279 case POWER_SUPPLY_PROP_SERIAL_NUMBER:
280 val->strval = battery->serial_number;
281 break;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400282 default:
Rafael J. Wysockia1b4bd62010-10-23 19:35:15 +0200283 ret = -EINVAL;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400284 }
Rafael J. Wysockia1b4bd62010-10-23 19:35:15 +0200285 return ret;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400286}
287
288static enum power_supply_property charge_battery_props[] = {
289 POWER_SUPPLY_PROP_STATUS,
290 POWER_SUPPLY_PROP_PRESENT,
291 POWER_SUPPLY_PROP_TECHNOLOGY,
Alexey Starikovskiyc67fcd62009-10-15 14:31:44 +0400292 POWER_SUPPLY_PROP_CYCLE_COUNT,
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400293 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
294 POWER_SUPPLY_PROP_VOLTAGE_NOW,
295 POWER_SUPPLY_PROP_CURRENT_NOW,
296 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
297 POWER_SUPPLY_PROP_CHARGE_FULL,
298 POWER_SUPPLY_PROP_CHARGE_NOW,
srinivas pandruvadaa58e1152012-04-05 17:38:54 -0700299 POWER_SUPPLY_PROP_CAPACITY,
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400300 POWER_SUPPLY_PROP_MODEL_NAME,
301 POWER_SUPPLY_PROP_MANUFACTURER,
maximilian attems7c2670b2008-01-22 18:46:50 +0100302 POWER_SUPPLY_PROP_SERIAL_NUMBER,
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400303};
304
305static enum power_supply_property energy_battery_props[] = {
306 POWER_SUPPLY_PROP_STATUS,
307 POWER_SUPPLY_PROP_PRESENT,
308 POWER_SUPPLY_PROP_TECHNOLOGY,
Alexey Starikovskiyc67fcd62009-10-15 14:31:44 +0400309 POWER_SUPPLY_PROP_CYCLE_COUNT,
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400310 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
311 POWER_SUPPLY_PROP_VOLTAGE_NOW,
Alexey Starikovskiy7faa1442009-03-27 22:23:52 -0400312 POWER_SUPPLY_PROP_POWER_NOW,
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400313 POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
314 POWER_SUPPLY_PROP_ENERGY_FULL,
315 POWER_SUPPLY_PROP_ENERGY_NOW,
srinivas pandruvadaa58e1152012-04-05 17:38:54 -0700316 POWER_SUPPLY_PROP_CAPACITY,
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400317 POWER_SUPPLY_PROP_MODEL_NAME,
318 POWER_SUPPLY_PROP_MANUFACTURER,
maximilian attems7c2670b2008-01-22 18:46:50 +0100319 POWER_SUPPLY_PROP_SERIAL_NUMBER,
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400320};
321
Alexey Starikovskiyfdcedbb2007-11-19 16:33:45 +0300322#ifdef CONFIG_ACPI_PROCFS_POWER
Alexey Starikovskiyf1d46612007-09-26 19:42:52 +0400323inline char *acpi_battery_units(struct acpi_battery *battery)
Alexey Starikovskiy78490d82007-05-11 13:18:55 -0400324{
Lan Tianyuae6f6182011-06-30 11:32:40 +0800325 return (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) ?
326 "mA" : "mW";
Alexey Starikovskiy78490d82007-05-11 13:18:55 -0400327}
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400328#endif
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300329
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330/* --------------------------------------------------------------------------
331 Battery Management
332 -------------------------------------------------------------------------- */
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400333struct acpi_offsets {
334 size_t offset; /* offset inside struct acpi_sbs_battery */
335 u8 mode; /* int or string? */
336};
337
338static struct acpi_offsets state_offsets[] = {
339 {offsetof(struct acpi_battery, state), 0},
Alexey Starikovskiy7faa1442009-03-27 22:23:52 -0400340 {offsetof(struct acpi_battery, rate_now), 0},
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400341 {offsetof(struct acpi_battery, capacity_now), 0},
342 {offsetof(struct acpi_battery, voltage_now), 0},
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400343};
344
345static struct acpi_offsets info_offsets[] = {
346 {offsetof(struct acpi_battery, power_unit), 0},
347 {offsetof(struct acpi_battery, design_capacity), 0},
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400348 {offsetof(struct acpi_battery, full_charge_capacity), 0},
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400349 {offsetof(struct acpi_battery, technology), 0},
350 {offsetof(struct acpi_battery, design_voltage), 0},
351 {offsetof(struct acpi_battery, design_capacity_warning), 0},
352 {offsetof(struct acpi_battery, design_capacity_low), 0},
353 {offsetof(struct acpi_battery, capacity_granularity_1), 0},
354 {offsetof(struct acpi_battery, capacity_granularity_2), 0},
355 {offsetof(struct acpi_battery, model_number), 1},
356 {offsetof(struct acpi_battery, serial_number), 1},
357 {offsetof(struct acpi_battery, type), 1},
358 {offsetof(struct acpi_battery, oem_info), 1},
359};
360
Alexey Starikovskiyc67fcd62009-10-15 14:31:44 +0400361static struct acpi_offsets extended_info_offsets[] = {
362 {offsetof(struct acpi_battery, power_unit), 0},
363 {offsetof(struct acpi_battery, design_capacity), 0},
364 {offsetof(struct acpi_battery, full_charge_capacity), 0},
365 {offsetof(struct acpi_battery, technology), 0},
366 {offsetof(struct acpi_battery, design_voltage), 0},
367 {offsetof(struct acpi_battery, design_capacity_warning), 0},
368 {offsetof(struct acpi_battery, design_capacity_low), 0},
369 {offsetof(struct acpi_battery, cycle_count), 0},
370 {offsetof(struct acpi_battery, measurement_accuracy), 0},
371 {offsetof(struct acpi_battery, max_sampling_time), 0},
372 {offsetof(struct acpi_battery, min_sampling_time), 0},
373 {offsetof(struct acpi_battery, max_averaging_interval), 0},
374 {offsetof(struct acpi_battery, min_averaging_interval), 0},
375 {offsetof(struct acpi_battery, capacity_granularity_1), 0},
376 {offsetof(struct acpi_battery, capacity_granularity_2), 0},
377 {offsetof(struct acpi_battery, model_number), 1},
378 {offsetof(struct acpi_battery, serial_number), 1},
379 {offsetof(struct acpi_battery, type), 1},
380 {offsetof(struct acpi_battery, oem_info), 1},
381};
382
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400383static int extract_package(struct acpi_battery *battery,
384 union acpi_object *package,
385 struct acpi_offsets *offsets, int num)
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300386{
Alexey Starikovskiy106449e2007-10-29 23:29:40 +0300387 int i;
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400388 union acpi_object *element;
389 if (package->type != ACPI_TYPE_PACKAGE)
390 return -EFAULT;
391 for (i = 0; i < num; ++i) {
392 if (package->package.count <= i)
393 return -EFAULT;
394 element = &package->package.elements[i];
395 if (offsets[i].mode) {
Alexey Starikovskiy106449e2007-10-29 23:29:40 +0300396 u8 *ptr = (u8 *)battery + offsets[i].offset;
397 if (element->type == ACPI_TYPE_STRING ||
398 element->type == ACPI_TYPE_BUFFER)
399 strncpy(ptr, element->string.pointer, 32);
400 else if (element->type == ACPI_TYPE_INTEGER) {
401 strncpy(ptr, (u8 *)&element->integer.value,
Lin Ming439913f2010-01-28 10:53:19 +0800402 sizeof(u64));
403 ptr[sizeof(u64)] = 0;
Alexey Starikovskiyb8a1bdb2008-03-17 22:37:42 -0400404 } else
405 *ptr = 0; /* don't have value */
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400406 } else {
Alexey Starikovskiyb8a1bdb2008-03-17 22:37:42 -0400407 int *x = (int *)((u8 *)battery + offsets[i].offset);
408 *x = (element->type == ACPI_TYPE_INTEGER) ?
409 element->integer.value : -1;
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300410 }
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300411 }
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300412 return 0;
413}
414
415static int acpi_battery_get_status(struct acpi_battery *battery)
416{
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400417 if (acpi_bus_get_status(battery->device)) {
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300418 ACPI_EXCEPTION((AE_INFO, AE_ERROR, "Evaluating _STA"));
419 return -ENODEV;
420 }
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400421 return 0;
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300422}
423
424static int acpi_battery_get_info(struct acpi_battery *battery)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425{
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400426 int result = -EFAULT;
Len Brown4be44fc2005-08-05 00:44:28 -0400427 acpi_status status = 0;
Alexey Starikovskiyc67fcd62009-10-15 14:31:44 +0400428 char *name = test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags)?
429 "_BIX" : "_BIF";
430
Len Brown4be44fc2005-08-05 00:44:28 -0400431 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300433 if (!acpi_battery_present(battery))
434 return 0;
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400435 mutex_lock(&battery->lock);
Alexey Starikovskiyc67fcd62009-10-15 14:31:44 +0400436 status = acpi_evaluate_object(battery->device->handle, name,
437 NULL, &buffer);
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400438 mutex_unlock(&battery->lock);
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400439
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 if (ACPI_FAILURE(status)) {
Alexey Starikovskiyc67fcd62009-10-15 14:31:44 +0400441 ACPI_EXCEPTION((AE_INFO, status, "Evaluating %s", name));
Patrick Mocheld550d982006-06-27 00:41:40 -0400442 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443 }
Alexey Starikovskiyc67fcd62009-10-15 14:31:44 +0400444 if (test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags))
445 result = extract_package(battery, buffer.pointer,
446 extended_info_offsets,
447 ARRAY_SIZE(extended_info_offsets));
448 else
449 result = extract_package(battery, buffer.pointer,
450 info_offsets, ARRAY_SIZE(info_offsets));
Alexey Starikovskiy78490d82007-05-11 13:18:55 -0400451 kfree(buffer.pointer);
Zhang Rui557d5862010-10-22 10:02:06 +0800452 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
453 battery->full_charge_capacity = battery->design_capacity;
Kamil Iskra4000e622012-11-16 22:28:58 +0100454 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
455 battery->power_unit && battery->design_voltage) {
456 battery->design_capacity = battery->design_capacity *
457 10000 / battery->design_voltage;
458 battery->full_charge_capacity = battery->full_charge_capacity *
459 10000 / battery->design_voltage;
460 battery->design_capacity_warning =
461 battery->design_capacity_warning *
462 10000 / battery->design_voltage;
463 /* Curiously, design_capacity_low, unlike the rest of them,
464 is correct. */
465 /* capacity_granularity_* equal 1 on the systems tested, so
466 it's impossible to tell if they would need an adjustment
467 or not if their values were higher. */
468 }
Patrick Mocheld550d982006-06-27 00:41:40 -0400469 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470}
471
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300472static int acpi_battery_get_state(struct acpi_battery *battery)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473{
Len Brown4be44fc2005-08-05 00:44:28 -0400474 int result = 0;
475 acpi_status status = 0;
476 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300478 if (!acpi_battery_present(battery))
479 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480
Alexey Starikovskiyf1d46612007-09-26 19:42:52 +0400481 if (battery->update_time &&
482 time_before(jiffies, battery->update_time +
483 msecs_to_jiffies(cache_time)))
484 return 0;
485
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400486 mutex_lock(&battery->lock);
Alexey Starikovskiyf1d46612007-09-26 19:42:52 +0400487 status = acpi_evaluate_object(battery->device->handle, "_BST",
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400488 NULL, &buffer);
489 mutex_unlock(&battery->lock);
Len Brown5b31d892007-08-15 00:19:26 -0400490
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491 if (ACPI_FAILURE(status)) {
Thomas Renningera6fc6722006-06-26 23:58:43 -0400492 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BST"));
Patrick Mocheld550d982006-06-27 00:41:40 -0400493 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 }
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400495
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400496 result = extract_package(battery, buffer.pointer,
497 state_offsets, ARRAY_SIZE(state_offsets));
Alexey Starikovskiyf1d46612007-09-26 19:42:52 +0400498 battery->update_time = jiffies;
Alexey Starikovskiy78490d82007-05-11 13:18:55 -0400499 kfree(buffer.pointer);
Hector Martinbc76f902009-08-06 15:57:48 -0700500
Lan Tianyu55003b22011-06-30 11:33:12 +0800501 /* For buggy DSDTs that report negative 16-bit values for either
502 * charging or discharging current and/or report 0 as 65536
503 * due to bad math.
504 */
505 if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA &&
506 battery->rate_now != ACPI_BATTERY_VALUE_UNKNOWN &&
507 (s16)(battery->rate_now) < 0) {
Hector Martinbc76f902009-08-06 15:57:48 -0700508 battery->rate_now = abs((s16)battery->rate_now);
Lan Tianyu55003b22011-06-30 11:33:12 +0800509 printk_once(KERN_WARNING FW_BUG "battery: (dis)charge rate"
510 " invalid.\n");
511 }
Hector Martinbc76f902009-08-06 15:57:48 -0700512
Zhang Rui557d5862010-10-22 10:02:06 +0800513 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags)
514 && battery->capacity_now >= 0 && battery->capacity_now <= 100)
515 battery->capacity_now = (battery->capacity_now *
516 battery->full_charge_capacity) / 100;
Kamil Iskra4000e622012-11-16 22:28:58 +0100517 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
518 battery->power_unit && battery->design_voltage) {
519 battery->capacity_now = battery->capacity_now *
520 10000 / battery->design_voltage;
521 }
Patrick Mocheld550d982006-06-27 00:41:40 -0400522 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523}
524
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400525static int acpi_battery_set_alarm(struct acpi_battery *battery)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526{
Len Brown4be44fc2005-08-05 00:44:28 -0400527 acpi_status status = 0;
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400528 union acpi_object arg0 = { .type = ACPI_TYPE_INTEGER };
Len Brown4be44fc2005-08-05 00:44:28 -0400529 struct acpi_object_list arg_list = { 1, &arg0 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530
Alexey Starikovskiyc67fcd62009-10-15 14:31:44 +0400531 if (!acpi_battery_present(battery) ||
Alexey Starikovskiy7b3bcc42009-10-15 14:31:24 +0400532 !test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags))
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300533 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400535 arg0.integer.value = battery->alarm;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400537 mutex_lock(&battery->lock);
Alexey Starikovskiyf1d46612007-09-26 19:42:52 +0400538 status = acpi_evaluate_object(battery->device->handle, "_BTP",
539 &arg_list, NULL);
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400540 mutex_unlock(&battery->lock);
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400541
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 if (ACPI_FAILURE(status))
Patrick Mocheld550d982006-06-27 00:41:40 -0400543 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400545 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Alarm set to %d\n", battery->alarm));
Patrick Mocheld550d982006-06-27 00:41:40 -0400546 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547}
548
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300549static int acpi_battery_init_alarm(struct acpi_battery *battery)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550{
Len Brown4be44fc2005-08-05 00:44:28 -0400551 acpi_status status = AE_OK;
552 acpi_handle handle = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300554 /* See if alarms are supported, and if so, set default */
Alexey Starikovskiyf1d46612007-09-26 19:42:52 +0400555 status = acpi_get_handle(battery->device->handle, "_BTP", &handle);
556 if (ACPI_FAILURE(status)) {
Alexey Starikovskiy7b3bcc42009-10-15 14:31:24 +0400557 clear_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
Alexey Starikovskiyf1d46612007-09-26 19:42:52 +0400558 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559 }
Alexey Starikovskiy7b3bcc42009-10-15 14:31:24 +0400560 set_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
Alexey Starikovskiyf1d46612007-09-26 19:42:52 +0400561 if (!battery->alarm)
562 battery->alarm = battery->design_capacity_warning;
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400563 return acpi_battery_set_alarm(battery);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564}
565
Andrey Borzenkov508df922007-10-28 12:50:09 +0300566static ssize_t acpi_battery_alarm_show(struct device *dev,
567 struct device_attribute *attr,
568 char *buf)
569{
570 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
571 return sprintf(buf, "%d\n", battery->alarm * 1000);
572}
573
574static ssize_t acpi_battery_alarm_store(struct device *dev,
575 struct device_attribute *attr,
576 const char *buf, size_t count)
577{
578 unsigned long x;
579 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
580 if (sscanf(buf, "%ld\n", &x) == 1)
581 battery->alarm = x/1000;
582 if (acpi_battery_present(battery))
583 acpi_battery_set_alarm(battery);
584 return count;
585}
586
587static struct device_attribute alarm_attr = {
Parag Warudkar01e8ef12008-10-18 20:28:50 -0700588 .attr = {.name = "alarm", .mode = 0644},
Andrey Borzenkov508df922007-10-28 12:50:09 +0300589 .show = acpi_battery_alarm_show,
590 .store = acpi_battery_alarm_store,
591};
592
593static int sysfs_add_battery(struct acpi_battery *battery)
594{
595 int result;
596
Lan Tianyuae6f6182011-06-30 11:32:40 +0800597 if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) {
Andrey Borzenkov508df922007-10-28 12:50:09 +0300598 battery->bat.properties = charge_battery_props;
599 battery->bat.num_properties =
600 ARRAY_SIZE(charge_battery_props);
601 } else {
602 battery->bat.properties = energy_battery_props;
603 battery->bat.num_properties =
604 ARRAY_SIZE(energy_battery_props);
605 }
606
607 battery->bat.name = acpi_device_bid(battery->device);
608 battery->bat.type = POWER_SUPPLY_TYPE_BATTERY;
609 battery->bat.get_property = acpi_battery_get_property;
610
611 result = power_supply_register(&battery->device->dev, &battery->bat);
612 if (result)
613 return result;
614 return device_create_file(battery->bat.dev, &alarm_attr);
615}
616
617static void sysfs_remove_battery(struct acpi_battery *battery)
618{
Sergey Senozhatsky69d94ec2011-08-06 01:34:08 +0300619 mutex_lock(&battery->sysfs_lock);
Lan Tianyu9c921c222011-06-30 11:34:12 +0800620 if (!battery->bat.dev) {
Sergey Senozhatsky69d94ec2011-08-06 01:34:08 +0300621 mutex_unlock(&battery->sysfs_lock);
Andrey Borzenkov508df922007-10-28 12:50:09 +0300622 return;
Lan Tianyu9c921c222011-06-30 11:34:12 +0800623 }
624
Andrey Borzenkov508df922007-10-28 12:50:09 +0300625 device_remove_file(battery->bat.dev, &alarm_attr);
626 power_supply_unregister(&battery->bat);
Alexey Starikovskiy91044762007-11-13 12:23:06 +0300627 battery->bat.dev = NULL;
Sergey Senozhatsky69d94ec2011-08-06 01:34:08 +0300628 mutex_unlock(&battery->sysfs_lock);
Hector Martinbc76f902009-08-06 15:57:48 -0700629}
630
Kamil Iskra4000e622012-11-16 22:28:58 +0100631static void find_battery(const struct dmi_header *dm, void *private)
632{
633 struct acpi_battery *battery = (struct acpi_battery *)private;
634 /* Note: the hardcoded offsets below have been extracted from
635 the source code of dmidecode. */
636 if (dm->type == DMI_ENTRY_PORTABLE_BATTERY && dm->length >= 8) {
637 const u8 *dmi_data = (const u8 *)(dm + 1);
638 int dmi_capacity = get_unaligned((const u16 *)(dmi_data + 6));
639 if (dm->length >= 18)
640 dmi_capacity *= dmi_data[17];
641 if (battery->design_capacity * battery->design_voltage / 1000
642 != dmi_capacity &&
643 battery->design_capacity * 10 == dmi_capacity)
644 set_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
645 &battery->flags);
646 }
647}
648
Zhang Rui557d5862010-10-22 10:02:06 +0800649/*
650 * According to the ACPI spec, some kinds of primary batteries can
651 * report percentage battery remaining capacity directly to OS.
652 * In this case, it reports the Last Full Charged Capacity == 100
653 * and BatteryPresentRate == 0xFFFFFFFF.
654 *
655 * Now we found some battery reports percentage remaining capacity
656 * even if it's rechargeable.
657 * https://bugzilla.kernel.org/show_bug.cgi?id=15979
658 *
659 * Handle this correctly so that they won't break userspace.
660 */
Lan Tianyu7b786222011-06-30 11:33:27 +0800661static void acpi_battery_quirks(struct acpi_battery *battery)
Zhang Rui557d5862010-10-22 10:02:06 +0800662{
663 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
664 return ;
665
666 if (battery->full_charge_capacity == 100 &&
667 battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN &&
668 battery->capacity_now >=0 && battery->capacity_now <= 100) {
669 set_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags);
670 battery->full_charge_capacity = battery->design_capacity;
671 battery->capacity_now = (battery->capacity_now *
672 battery->full_charge_capacity) / 100;
673 }
Kamil Iskra4000e622012-11-16 22:28:58 +0100674
675 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags))
676 return ;
677
678 if (battery->power_unit && dmi_name_in_vendors("LENOVO")) {
679 const char *s;
680 s = dmi_get_system_info(DMI_PRODUCT_VERSION);
681 if (s && !strnicmp(s, "ThinkPad", 8)) {
682 dmi_walk(find_battery, battery);
683 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
684 &battery->flags) &&
685 battery->design_voltage) {
686 battery->design_capacity =
687 battery->design_capacity *
688 10000 / battery->design_voltage;
689 battery->full_charge_capacity =
690 battery->full_charge_capacity *
691 10000 / battery->design_voltage;
692 battery->design_capacity_warning =
693 battery->design_capacity_warning *
694 10000 / battery->design_voltage;
695 battery->capacity_now = battery->capacity_now *
696 10000 / battery->design_voltage;
697 }
698 }
699 }
Zhang Rui557d5862010-10-22 10:02:06 +0800700}
701
Alexey Starikovskiyf1d46612007-09-26 19:42:52 +0400702static int acpi_battery_update(struct acpi_battery *battery)
Vladimir Lebedev4bd35cd2007-02-10 01:43:48 -0500703{
Alexey Starikovskiy50b17852008-12-23 02:44:54 +0300704 int result, old_present = acpi_battery_present(battery);
Alexey Starikovskiy97749cd2008-01-01 14:27:24 -0500705 result = acpi_battery_get_status(battery);
Andrey Borzenkov508df922007-10-28 12:50:09 +0300706 if (result)
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300707 return result;
Andrey Borzenkov508df922007-10-28 12:50:09 +0300708 if (!acpi_battery_present(battery)) {
709 sysfs_remove_battery(battery);
Alexey Starikovskiy97749cd2008-01-01 14:27:24 -0500710 battery->update_time = 0;
Andrey Borzenkov508df922007-10-28 12:50:09 +0300711 return 0;
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300712 }
Alexey Starikovskiy50b17852008-12-23 02:44:54 +0300713 if (!battery->update_time ||
714 old_present != acpi_battery_present(battery)) {
Alexey Starikovskiy97749cd2008-01-01 14:27:24 -0500715 result = acpi_battery_get_info(battery);
716 if (result)
717 return result;
718 acpi_battery_init_alarm(battery);
719 }
Stefan Hajnoczieb03cb02011-07-12 09:03:29 +0100720 if (!battery->bat.dev) {
721 result = sysfs_add_battery(battery);
722 if (result)
723 return result;
724 }
Zhang Rui557d5862010-10-22 10:02:06 +0800725 result = acpi_battery_get_state(battery);
Lan Tianyu7b786222011-06-30 11:33:27 +0800726 acpi_battery_quirks(battery);
Zhang Rui557d5862010-10-22 10:02:06 +0800727 return result;
Vladimir Lebedev4bd35cd2007-02-10 01:43:48 -0500728}
729
Rafael J. Wysockida8aeb92011-01-06 23:42:27 +0100730static void acpi_battery_refresh(struct acpi_battery *battery)
731{
Andy Whitcroftc5971452012-05-03 14:48:26 +0100732 int power_unit;
733
Rafael J. Wysockida8aeb92011-01-06 23:42:27 +0100734 if (!battery->bat.dev)
735 return;
736
Andy Whitcroftc5971452012-05-03 14:48:26 +0100737 power_unit = battery->power_unit;
738
Rafael J. Wysockida8aeb92011-01-06 23:42:27 +0100739 acpi_battery_get_info(battery);
Andy Whitcroftc5971452012-05-03 14:48:26 +0100740
741 if (power_unit == battery->power_unit)
742 return;
743
744 /* The battery has changed its reporting units. */
Rafael J. Wysockida8aeb92011-01-06 23:42:27 +0100745 sysfs_remove_battery(battery);
746 sysfs_add_battery(battery);
747}
748
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749/* --------------------------------------------------------------------------
750 FS Interface (/proc)
751 -------------------------------------------------------------------------- */
752
Alexey Starikovskiyfdcedbb2007-11-19 16:33:45 +0300753#ifdef CONFIG_ACPI_PROCFS_POWER
Len Brown4be44fc2005-08-05 00:44:28 -0400754static struct proc_dir_entry *acpi_battery_dir;
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300755
Alexey Starikovskiy78490d82007-05-11 13:18:55 -0400756static int acpi_battery_print_info(struct seq_file *seq, int result)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757{
Jan Engelhardt50dd0962006-10-01 00:28:50 +0200758 struct acpi_battery *battery = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300760 if (result)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761 goto end;
762
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400763 seq_printf(seq, "present: %s\n",
764 acpi_battery_present(battery)?"yes":"no");
765 if (!acpi_battery_present(battery))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766 goto end;
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400767 if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768 seq_printf(seq, "design capacity: unknown\n");
769 else
770 seq_printf(seq, "design capacity: %d %sh\n",
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400771 battery->design_capacity,
772 acpi_battery_units(battery));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400774 if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775 seq_printf(seq, "last full capacity: unknown\n");
776 else
777 seq_printf(seq, "last full capacity: %d %sh\n",
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400778 battery->full_charge_capacity,
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400779 acpi_battery_units(battery));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400781 seq_printf(seq, "battery technology: %srechargeable\n",
782 (!battery->technology)?"non-":"");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400784 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785 seq_printf(seq, "design voltage: unknown\n");
786 else
787 seq_printf(seq, "design voltage: %d mV\n",
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400788 battery->design_voltage);
Len Brown4be44fc2005-08-05 00:44:28 -0400789 seq_printf(seq, "design capacity warning: %d %sh\n",
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400790 battery->design_capacity_warning,
791 acpi_battery_units(battery));
Len Brown4be44fc2005-08-05 00:44:28 -0400792 seq_printf(seq, "design capacity low: %d %sh\n",
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400793 battery->design_capacity_low,
794 acpi_battery_units(battery));
Alexey Starikovskiyc67fcd62009-10-15 14:31:44 +0400795 seq_printf(seq, "cycle count: %i\n", battery->cycle_count);
Len Brown4be44fc2005-08-05 00:44:28 -0400796 seq_printf(seq, "capacity granularity 1: %d %sh\n",
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400797 battery->capacity_granularity_1,
798 acpi_battery_units(battery));
Len Brown4be44fc2005-08-05 00:44:28 -0400799 seq_printf(seq, "capacity granularity 2: %d %sh\n",
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400800 battery->capacity_granularity_2,
801 acpi_battery_units(battery));
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400802 seq_printf(seq, "model number: %s\n", battery->model_number);
803 seq_printf(seq, "serial number: %s\n", battery->serial_number);
804 seq_printf(seq, "battery type: %s\n", battery->type);
805 seq_printf(seq, "OEM info: %s\n", battery->oem_info);
Len Brown4be44fc2005-08-05 00:44:28 -0400806 end:
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300807 if (result)
808 seq_printf(seq, "ERROR: Unable to read battery info\n");
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300809 return result;
810}
811
Alexey Starikovskiy78490d82007-05-11 13:18:55 -0400812static int acpi_battery_print_state(struct seq_file *seq, int result)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813{
Jan Engelhardt50dd0962006-10-01 00:28:50 +0200814 struct acpi_battery *battery = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300816 if (result)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817 goto end;
818
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400819 seq_printf(seq, "present: %s\n",
820 acpi_battery_present(battery)?"yes":"no");
821 if (!acpi_battery_present(battery))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822 goto end;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400824 seq_printf(seq, "capacity state: %s\n",
825 (battery->state & 0x04)?"critical":"ok");
826 if ((battery->state & 0x01) && (battery->state & 0x02))
Len Brown4be44fc2005-08-05 00:44:28 -0400827 seq_printf(seq,
828 "charging state: charging/discharging\n");
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400829 else if (battery->state & 0x01)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830 seq_printf(seq, "charging state: discharging\n");
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400831 else if (battery->state & 0x02)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832 seq_printf(seq, "charging state: charging\n");
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400833 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 seq_printf(seq, "charging state: charged\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835
Alexey Starikovskiy7faa1442009-03-27 22:23:52 -0400836 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837 seq_printf(seq, "present rate: unknown\n");
838 else
839 seq_printf(seq, "present rate: %d %s\n",
Alexey Starikovskiy7faa1442009-03-27 22:23:52 -0400840 battery->rate_now, acpi_battery_units(battery));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400842 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843 seq_printf(seq, "remaining capacity: unknown\n");
844 else
845 seq_printf(seq, "remaining capacity: %d %sh\n",
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400846 battery->capacity_now, acpi_battery_units(battery));
847 if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 seq_printf(seq, "present voltage: unknown\n");
849 else
850 seq_printf(seq, "present voltage: %d mV\n",
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400851 battery->voltage_now);
Len Brown4be44fc2005-08-05 00:44:28 -0400852 end:
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400853 if (result)
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300854 seq_printf(seq, "ERROR: Unable to read battery state\n");
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300855
856 return result;
857}
858
Alexey Starikovskiy78490d82007-05-11 13:18:55 -0400859static int acpi_battery_print_alarm(struct seq_file *seq, int result)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860{
Jan Engelhardt50dd0962006-10-01 00:28:50 +0200861 struct acpi_battery *battery = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300863 if (result)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864 goto end;
865
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300866 if (!acpi_battery_present(battery)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867 seq_printf(seq, "present: no\n");
868 goto end;
869 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870 seq_printf(seq, "alarm: ");
871 if (!battery->alarm)
872 seq_printf(seq, "unsupported\n");
873 else
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400874 seq_printf(seq, "%u %sh\n", battery->alarm,
875 acpi_battery_units(battery));
Len Brown4be44fc2005-08-05 00:44:28 -0400876 end:
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300877 if (result)
878 seq_printf(seq, "ERROR: Unable to read battery alarm\n");
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300879 return result;
880}
881
Alexey Starikovskiyf1d46612007-09-26 19:42:52 +0400882static ssize_t acpi_battery_write_alarm(struct file *file,
883 const char __user * buffer,
884 size_t count, loff_t * ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885{
Len Brown4be44fc2005-08-05 00:44:28 -0400886 int result = 0;
887 char alarm_string[12] = { '\0' };
Jan Engelhardt50dd0962006-10-01 00:28:50 +0200888 struct seq_file *m = file->private_data;
889 struct acpi_battery *battery = m->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891 if (!battery || (count > sizeof(alarm_string) - 1))
Patrick Mocheld550d982006-06-27 00:41:40 -0400892 return -EINVAL;
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300893 if (!acpi_battery_present(battery)) {
894 result = -ENODEV;
895 goto end;
896 }
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300897 if (copy_from_user(alarm_string, buffer, count)) {
898 result = -EFAULT;
899 goto end;
900 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901 alarm_string[count] = '\0';
Alexey Starikovskiyf1d46612007-09-26 19:42:52 +0400902 battery->alarm = simple_strtol(alarm_string, NULL, 0);
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400903 result = acpi_battery_set_alarm(battery);
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300904 end:
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300905 if (!result)
Alexey Starikovskiyf1d46612007-09-26 19:42:52 +0400906 return count;
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300907 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908}
909
Alexey Starikovskiy78490d82007-05-11 13:18:55 -0400910typedef int(*print_func)(struct seq_file *seq, int result);
Alexey Starikovskiy78490d82007-05-11 13:18:55 -0400911
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400912static print_func acpi_print_funcs[ACPI_BATTERY_NUMFILES] = {
913 acpi_battery_print_info,
914 acpi_battery_print_state,
915 acpi_battery_print_alarm,
Alexey Starikovskiy78490d82007-05-11 13:18:55 -0400916};
917
918static int acpi_battery_read(int fid, struct seq_file *seq)
919{
920 struct acpi_battery *battery = seq->private;
Alexey Starikovskiyf1d46612007-09-26 19:42:52 +0400921 int result = acpi_battery_update(battery);
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400922 return acpi_print_funcs[fid](seq, result);
Alexey Starikovskiy78490d82007-05-11 13:18:55 -0400923}
924
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400925#define DECLARE_FILE_FUNCTIONS(_name) \
926static int acpi_battery_read_##_name(struct seq_file *seq, void *offset) \
927{ \
928 return acpi_battery_read(_name##_tag, seq); \
929} \
930static int acpi_battery_##_name##_open_fs(struct inode *inode, struct file *file) \
931{ \
932 return single_open(file, acpi_battery_read_##_name, PDE(inode)->data); \
Alexey Starikovskiy78490d82007-05-11 13:18:55 -0400933}
934
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400935DECLARE_FILE_FUNCTIONS(info);
936DECLARE_FILE_FUNCTIONS(state);
937DECLARE_FILE_FUNCTIONS(alarm);
Alexey Starikovskiy78490d82007-05-11 13:18:55 -0400938
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400939#undef DECLARE_FILE_FUNCTIONS
Alexey Starikovskiy78490d82007-05-11 13:18:55 -0400940
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400941#define FILE_DESCRIPTION_RO(_name) \
942 { \
943 .name = __stringify(_name), \
944 .mode = S_IRUGO, \
945 .ops = { \
946 .open = acpi_battery_##_name##_open_fs, \
947 .read = seq_read, \
948 .llseek = seq_lseek, \
949 .release = single_release, \
950 .owner = THIS_MODULE, \
951 }, \
952 }
Alexey Starikovskiy78490d82007-05-11 13:18:55 -0400953
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400954#define FILE_DESCRIPTION_RW(_name) \
955 { \
956 .name = __stringify(_name), \
957 .mode = S_IFREG | S_IRUGO | S_IWUSR, \
958 .ops = { \
959 .open = acpi_battery_##_name##_open_fs, \
960 .read = seq_read, \
961 .llseek = seq_lseek, \
962 .write = acpi_battery_write_##_name, \
963 .release = single_release, \
964 .owner = THIS_MODULE, \
965 }, \
966 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967
Vasiliy Kulikov9c8b04b2011-06-25 21:07:52 +0400968static const struct battery_file {
Alexey Starikovskiy78490d82007-05-11 13:18:55 -0400969 struct file_operations ops;
Al Virod161a132011-07-24 03:36:29 -0400970 umode_t mode;
Jan Engelhardt070d8eb2009-01-12 00:07:55 +0100971 const char *name;
Alexey Starikovskiy78490d82007-05-11 13:18:55 -0400972} acpi_battery_file[] = {
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400973 FILE_DESCRIPTION_RO(info),
974 FILE_DESCRIPTION_RO(state),
975 FILE_DESCRIPTION_RW(alarm),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976};
977
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400978#undef FILE_DESCRIPTION_RO
979#undef FILE_DESCRIPTION_RW
980
Len Brown4be44fc2005-08-05 00:44:28 -0400981static int acpi_battery_add_fs(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700982{
Len Brown4be44fc2005-08-05 00:44:28 -0400983 struct proc_dir_entry *entry = NULL;
Alexey Starikovskiy78490d82007-05-11 13:18:55 -0400984 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985
Zhang Rui6d855fc2011-01-10 11:16:30 +0800986 printk(KERN_WARNING PREFIX "Deprecated procfs I/F for battery is loaded,"
987 " please retry with CONFIG_ACPI_PROCFS_POWER cleared\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988 if (!acpi_device_dir(device)) {
989 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
Len Brown4be44fc2005-08-05 00:44:28 -0400990 acpi_battery_dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991 if (!acpi_device_dir(device))
Patrick Mocheld550d982006-06-27 00:41:40 -0400992 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993 }
994
Alexey Starikovskiy78490d82007-05-11 13:18:55 -0400995 for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i) {
Denis V. Lunevcf7acfa2008-04-29 01:02:27 -0700996 entry = proc_create_data(acpi_battery_file[i].name,
997 acpi_battery_file[i].mode,
998 acpi_device_dir(device),
999 &acpi_battery_file[i].ops,
1000 acpi_driver_data(device));
Alexey Starikovskiy78490d82007-05-11 13:18:55 -04001001 if (!entry)
1002 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003 }
Patrick Mocheld550d982006-06-27 00:41:40 -04001004 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005}
1006
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +04001007static void acpi_battery_remove_fs(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008{
Alexey Starikovskiy78490d82007-05-11 13:18:55 -04001009 int i;
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +04001010 if (!acpi_device_dir(device))
1011 return;
1012 for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i)
1013 remove_proc_entry(acpi_battery_file[i].name,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014 acpi_device_dir(device));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +04001016 remove_proc_entry(acpi_device_bid(device), acpi_battery_dir);
1017 acpi_device_dir(device) = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018}
1019
Alexey Starikovskiyd7380962007-09-26 19:43:04 +04001020#endif
Alexey Starikovskiy3e58ea02007-09-26 19:43:11 +04001021
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022/* --------------------------------------------------------------------------
1023 Driver Interface
1024 -------------------------------------------------------------------------- */
1025
Bjorn Helgaasd9406692009-04-30 09:35:47 -06001026static void acpi_battery_notify(struct acpi_device *device, u32 event)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027{
Bjorn Helgaasd9406692009-04-30 09:35:47 -06001028 struct acpi_battery *battery = acpi_driver_data(device);
Zhang Rui153e5002010-07-07 09:11:57 +08001029 struct device *old;
Bjorn Helgaasd9406692009-04-30 09:35:47 -06001030
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031 if (!battery)
Patrick Mocheld550d982006-06-27 00:41:40 -04001032 return;
Zhang Rui153e5002010-07-07 09:11:57 +08001033 old = battery->bat.dev;
Rafael J. Wysockida8aeb92011-01-06 23:42:27 +01001034 if (event == ACPI_BATTERY_NOTIFY_INFO)
1035 acpi_battery_refresh(battery);
Alexey Starikovskiyf1d46612007-09-26 19:42:52 +04001036 acpi_battery_update(battery);
1037 acpi_bus_generate_proc_event(device, event,
1038 acpi_battery_present(battery));
1039 acpi_bus_generate_netlink_event(device->pnp.device_class,
Kay Sievers07944692008-10-30 01:18:59 +01001040 dev_name(&device->dev), event,
Vladimir Lebedev9ea7d572007-02-20 15:48:06 +03001041 acpi_battery_present(battery));
Justin P. Mattock2345baf2009-12-13 14:42:36 -08001042 /* acpi_battery_update could remove power_supply object */
Zhang Rui153e5002010-07-07 09:11:57 +08001043 if (old && battery->bat.dev)
Alan Jenkinsf79e1ce2009-06-30 14:36:16 +00001044 power_supply_changed(&battery->bat);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045}
1046
Kyle McMartin25be5822011-03-22 16:19:50 -04001047static int battery_notify(struct notifier_block *nb,
1048 unsigned long mode, void *_unused)
1049{
1050 struct acpi_battery *battery = container_of(nb, struct acpi_battery,
1051 pm_nb);
1052 switch (mode) {
Lan Tianyud5a59112011-06-30 11:33:40 +08001053 case PM_POST_HIBERNATION:
Kyle McMartin25be5822011-03-22 16:19:50 -04001054 case PM_POST_SUSPEND:
Lan Tianyu6e17fb62011-06-30 11:33:58 +08001055 if (battery->bat.dev) {
1056 sysfs_remove_battery(battery);
1057 sysfs_add_battery(battery);
1058 }
Kyle McMartin25be5822011-03-22 16:19:50 -04001059 break;
1060 }
1061
1062 return 0;
1063}
1064
Len Brown4be44fc2005-08-05 00:44:28 -04001065static int acpi_battery_add(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066{
Len Brown4be44fc2005-08-05 00:44:28 -04001067 int result = 0;
Len Brown4be44fc2005-08-05 00:44:28 -04001068 struct acpi_battery *battery = NULL;
Alexey Starikovskiyc67fcd62009-10-15 14:31:44 +04001069 acpi_handle handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070 if (!device)
Patrick Mocheld550d982006-06-27 00:41:40 -04001071 return -EINVAL;
Burman Yan36bcbec2006-12-19 12:56:11 -08001072 battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073 if (!battery)
Patrick Mocheld550d982006-06-27 00:41:40 -04001074 return -ENOMEM;
Patrick Mochel145def82006-05-19 16:54:39 -04001075 battery->device = device;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001076 strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME);
1077 strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS);
Pavel Machekdb89b4f2008-09-22 14:37:34 -07001078 device->driver_data = battery;
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +04001079 mutex_init(&battery->lock);
Sergey Senozhatsky69d94ec2011-08-06 01:34:08 +03001080 mutex_init(&battery->sysfs_lock);
Alexey Starikovskiyc67fcd62009-10-15 14:31:44 +04001081 if (ACPI_SUCCESS(acpi_get_handle(battery->device->handle,
1082 "_BIX", &handle)))
1083 set_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags);
Stefan Hajnoczieb03cb02011-07-12 09:03:29 +01001084 result = acpi_battery_update(battery);
1085 if (result)
1086 goto fail;
Alexey Starikovskiyfdcedbb2007-11-19 16:33:45 +03001087#ifdef CONFIG_ACPI_PROCFS_POWER
Linus Torvalds1da177e2005-04-16 15:20:36 -07001088 result = acpi_battery_add_fs(device);
Alexey Starikovskiyd7380962007-09-26 19:43:04 +04001089#endif
Stefan Hajnoczie80bba42011-07-12 09:03:28 +01001090 if (result) {
Alexey Starikovskiyfdcedbb2007-11-19 16:33:45 +03001091#ifdef CONFIG_ACPI_PROCFS_POWER
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092 acpi_battery_remove_fs(device);
Alexey Starikovskiyd7380962007-09-26 19:43:04 +04001093#endif
Stefan Hajnoczie80bba42011-07-12 09:03:28 +01001094 goto fail;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001095 }
Kyle McMartin25be5822011-03-22 16:19:50 -04001096
Stefan Hajnoczie80bba42011-07-12 09:03:28 +01001097 printk(KERN_INFO PREFIX "%s Slot [%s] (battery %s)\n",
1098 ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device),
1099 device->status.battery_present ? "present" : "absent");
1100
Kyle McMartin25be5822011-03-22 16:19:50 -04001101 battery->pm_nb.notifier_call = battery_notify;
1102 register_pm_notifier(&battery->pm_nb);
1103
Patrick Mocheld550d982006-06-27 00:41:40 -04001104 return result;
Stefan Hajnoczie80bba42011-07-12 09:03:28 +01001105
1106fail:
1107 sysfs_remove_battery(battery);
1108 mutex_destroy(&battery->lock);
Sergey Senozhatsky69d94ec2011-08-06 01:34:08 +03001109 mutex_destroy(&battery->sysfs_lock);
Stefan Hajnoczie80bba42011-07-12 09:03:28 +01001110 kfree(battery);
1111 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112}
1113
Len Brown4be44fc2005-08-05 00:44:28 -04001114static int acpi_battery_remove(struct acpi_device *device, int type)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115{
Len Brown4be44fc2005-08-05 00:44:28 -04001116 struct acpi_battery *battery = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118 if (!device || !acpi_driver_data(device))
Patrick Mocheld550d982006-06-27 00:41:40 -04001119 return -EINVAL;
Jan Engelhardt50dd0962006-10-01 00:28:50 +02001120 battery = acpi_driver_data(device);
Kyle McMartin25be5822011-03-22 16:19:50 -04001121 unregister_pm_notifier(&battery->pm_nb);
Alexey Starikovskiyfdcedbb2007-11-19 16:33:45 +03001122#ifdef CONFIG_ACPI_PROCFS_POWER
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123 acpi_battery_remove_fs(device);
Alexey Starikovskiyd7380962007-09-26 19:43:04 +04001124#endif
Andrey Borzenkov508df922007-10-28 12:50:09 +03001125 sysfs_remove_battery(battery);
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +04001126 mutex_destroy(&battery->lock);
Sergey Senozhatsky69d94ec2011-08-06 01:34:08 +03001127 mutex_destroy(&battery->sysfs_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001128 kfree(battery);
Patrick Mocheld550d982006-06-27 00:41:40 -04001129 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130}
1131
Rafael J. Wysocki90692402012-08-09 23:00:02 +02001132#ifdef CONFIG_PM_SLEEP
Jiri Kosina34c44152006-10-10 14:20:41 -07001133/* this is needed to learn about changes made in suspended state */
Rafael J. Wysockia6f50dc2012-06-27 23:26:43 +02001134static int acpi_battery_resume(struct device *dev)
Jiri Kosina34c44152006-10-10 14:20:41 -07001135{
1136 struct acpi_battery *battery;
Rafael J. Wysockia6f50dc2012-06-27 23:26:43 +02001137
1138 if (!dev)
Jiri Kosina34c44152006-10-10 14:20:41 -07001139 return -EINVAL;
Rafael J. Wysockia6f50dc2012-06-27 23:26:43 +02001140
1141 battery = acpi_driver_data(to_acpi_device(dev));
1142 if (!battery)
1143 return -EINVAL;
1144
Alexey Starikovskiyf1d46612007-09-26 19:42:52 +04001145 battery->update_time = 0;
Andrey Borzenkov508df922007-10-28 12:50:09 +03001146 acpi_battery_update(battery);
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +03001147 return 0;
Jiri Kosina34c44152006-10-10 14:20:41 -07001148}
Rafael J. Wysocki90692402012-08-09 23:00:02 +02001149#endif
Jiri Kosina34c44152006-10-10 14:20:41 -07001150
Rafael J. Wysockia6f50dc2012-06-27 23:26:43 +02001151static SIMPLE_DEV_PM_OPS(acpi_battery_pm, NULL, acpi_battery_resume);
1152
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +04001153static struct acpi_driver acpi_battery_driver = {
1154 .name = "battery",
1155 .class = ACPI_BATTERY_CLASS,
1156 .ids = battery_device_ids,
Bjorn Helgaasd9406692009-04-30 09:35:47 -06001157 .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +04001158 .ops = {
1159 .add = acpi_battery_add,
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +04001160 .remove = acpi_battery_remove,
Bjorn Helgaasd9406692009-04-30 09:35:47 -06001161 .notify = acpi_battery_notify,
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +04001162 },
Rafael J. Wysockia6f50dc2012-06-27 23:26:43 +02001163 .drv.pm = &acpi_battery_pm,
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +04001164};
1165
Linus Torvaldsb0cbc862009-04-11 12:45:20 -07001166static void __init acpi_battery_init_async(void *unused, async_cookie_t cookie)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167{
Pavel Machek4d8316d2006-08-14 22:37:22 -07001168 if (acpi_disabled)
Arjan van de Ven0f66af52009-01-10 14:19:05 -05001169 return;
Alexey Starikovskiyfdcedbb2007-11-19 16:33:45 +03001170#ifdef CONFIG_ACPI_PROCFS_POWER
Rich Townsend3f86b832006-07-01 11:36:54 -04001171 acpi_battery_dir = acpi_lock_battery_dir();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001172 if (!acpi_battery_dir)
Arjan van de Ven0f66af52009-01-10 14:19:05 -05001173 return;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +04001174#endif
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +04001175 if (acpi_bus_register_driver(&acpi_battery_driver) < 0) {
Alexey Starikovskiyfdcedbb2007-11-19 16:33:45 +03001176#ifdef CONFIG_ACPI_PROCFS_POWER
Rich Townsend3f86b832006-07-01 11:36:54 -04001177 acpi_unlock_battery_dir(acpi_battery_dir);
Alexey Starikovskiyd7380962007-09-26 19:43:04 +04001178#endif
Arjan van de Ven0f66af52009-01-10 14:19:05 -05001179 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180 }
Arjan van de Ven0f66af52009-01-10 14:19:05 -05001181 return;
1182}
1183
1184static int __init acpi_battery_init(void)
1185{
1186 async_schedule(acpi_battery_init_async, NULL);
Patrick Mocheld550d982006-06-27 00:41:40 -04001187 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188}
1189
Len Brown4be44fc2005-08-05 00:44:28 -04001190static void __exit acpi_battery_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001191{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192 acpi_bus_unregister_driver(&acpi_battery_driver);
Alexey Starikovskiyfdcedbb2007-11-19 16:33:45 +03001193#ifdef CONFIG_ACPI_PROCFS_POWER
Rich Townsend3f86b832006-07-01 11:36:54 -04001194 acpi_unlock_battery_dir(acpi_battery_dir);
Alexey Starikovskiyd7380962007-09-26 19:43:04 +04001195#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196}
1197
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198module_init(acpi_battery_init);
1199module_exit(acpi_battery_exit);