]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blame - drivers/acpi/battery.c
projects / mirror_ubuntu-artful-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'acpi-proc' into acpi-battery
[mirror_ubuntu-artful-kernel.git] / drivers / acpi / battery.c
CommitLineData
1da177e4 1/*
aa650bbd 2 * battery.c - ACPI Battery Driver (Revision: 2.0)
1da177e4 3 *
aa650bbd
AS		 4 * Copyright (C) 2007 Alexey Starikovskiy <astarikovskiy@suse.de>
5 * Copyright (C) 2004-2007 Vladimir Lebedev <vladimir.p.lebedev@intel.com>
1da177e4
LT		 6 * 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>
f1d4661a 32#include <linux/jiffies.h>
0f66af53 33#include <linux/async.h>
bc76f90b 34#include <linux/dmi.h>
5a0e3ad6 35#include <linux/slab.h>
25be5821 36#include <linux/suspend.h>
4000e626 37#include <asm/unaligned.h>
d7380965 38
3a670cc7
LT		 39#ifdef CONFIG_ACPI_PROCFS_POWER
40#include <linux/proc_fs.h>
41#include <linux/seq_file.h>
42#include <asm/uaccess.h>
43#endif
44
8b48463f 45#include <linux/acpi.h>
d7380965
AS		 46#include <linux/power_supply.h>
47
f03be352
AM		 48#include "battery.h"
49
a192a958
LB		 50#define PREFIX "ACPI: "
51
1da177e4
LT		 52#define ACPI_BATTERY_VALUE_UNKNOWN 0xFFFFFFFF
53
1da177e4 54#define ACPI_BATTERY_DEVICE_NAME "Battery"
1da177e4 55
ae6f6187
LT		 56/* Battery power unit: 0 means mW, 1 means mA */
57#define ACPI_BATTERY_POWER_UNIT_MA 1
58
1da177e4 59#define _COMPONENT ACPI_BATTERY_COMPONENT
b6ce4083 60
f52fd66d 61ACPI_MODULE_NAME("battery");
1da177e4 62
f52fd66d 63MODULE_AUTHOR("Paul Diefenbaugh");
aa650bbd 64MODULE_AUTHOR("Alexey Starikovskiy <astarikovskiy@suse.de>");
7cda93e0 65MODULE_DESCRIPTION("ACPI Battery Driver");
1da177e4
LT		 66MODULE_LICENSE("GPL");
67
a90b4038 68static int battery_bix_broken_package;
f1d4661a
AS		 69static unsigned int cache_time = 1000;
70module_param(cache_time, uint, 0644);
71MODULE_PARM_DESC(cache_time, "cache time in milliseconds");
b6ce4083 72
3a670cc7
LT		 73#ifdef CONFIG_ACPI_PROCFS_POWER
74extern struct proc_dir_entry *acpi_lock_battery_dir(void);
75extern void *acpi_unlock_battery_dir(struct proc_dir_entry *acpi_battery_dir);
76
77enum acpi_battery_files {
78 info_tag = 0,
79 state_tag,
80 alarm_tag,
81 ACPI_BATTERY_NUMFILES,
82};
83
84#endif
85
1ba90e3a
TR		 86static const struct acpi_device_id battery_device_ids[] = {
87 {"PNP0C0A", 0},
88 {"", 0},
89};
1ba90e3a 90
aa650bbd 91MODULE_DEVICE_TABLE(acpi, battery_device_ids);
1da177e4 92
7b3bcc4a
AS		 93enum {
94 ACPI_BATTERY_ALARM_PRESENT,
c67fcd67 95 ACPI_BATTERY_XINFO_PRESENT,
557d5868 96 ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY,
4000e626
KI		 97 /* On Lenovo Thinkpad models from 2010 and 2011, the power unit
98 switches between mWh and mAh depending on whether the system
99 is running on battery or not. When mAh is the unit, most
100 reported values are incorrect and need to be adjusted by
101 10000/design_voltage. Verified on x201, t410, t410s, and x220.
102 Pre-2010 and 2012 models appear to always report in mWh and
103 are thus unaffected (tested with t42, t61, t500, x200, x300,
104 and x230). Also, in mid-2012 Lenovo issued a BIOS update for
105 the 2011 models that fixes the issue (tested on x220 with a
106 post-1.29 BIOS), but as of Nov. 2012, no such update is
107 available for the 2010 models. */
108 ACPI_BATTERY_QUIRK_THINKPAD_MAH,
7b3bcc4a 109};
78490d82 110
1da177e4 111struct acpi_battery {
038fdea2 112 struct mutex lock;
69d94ec6 113 struct mutex sysfs_lock;
d7380965 114 struct power_supply bat;
f1d4661a 115 struct acpi_device *device;
25be5821 116 struct notifier_block pm_nb;
f1d4661a 117 unsigned long update_time;
016d5baa 118 int revision;
7faa144a 119 int rate_now;
d7380965
AS		 120 int capacity_now;
121 int voltage_now;
038fdea2 122 int design_capacity;
d7380965 123 int full_charge_capacity;
038fdea2
AS		 124 int technology;
125 int design_voltage;
126 int design_capacity_warning;
127 int design_capacity_low;
c67fcd67
AS		 128 int cycle_count;
129 int measurement_accuracy;
130 int max_sampling_time;
131 int min_sampling_time;
132 int max_averaging_interval;
133 int min_averaging_interval;
038fdea2
AS		 134 int capacity_granularity_1;
135 int capacity_granularity_2;
f1d4661a 136 int alarm;
038fdea2
AS		 137 char model_number[32];
138 char serial_number[32];
139 char type[32];
140 char oem_info[32];
f1d4661a
AS		 141 int state;
142 int power_unit;
7b3bcc4a 143 unsigned long flags;
1da177e4
LT		 144};
145
497888cf 146#define to_acpi_battery(x) container_of(x, struct acpi_battery, bat)
d7380965 147
efd941f1 148static inline int acpi_battery_present(struct acpi_battery *battery)
b6ce4083 149{
78490d82
AS		 150 return battery->device->status.battery_present;
151}
038fdea2 152
d7380965
AS		 153static int acpi_battery_technology(struct acpi_battery *battery)
154{
155 if (!strcasecmp("NiCd", battery->type))
156 return POWER_SUPPLY_TECHNOLOGY_NiCd;
157 if (!strcasecmp("NiMH", battery->type))
158 return POWER_SUPPLY_TECHNOLOGY_NiMH;
159 if (!strcasecmp("LION", battery->type))
160 return POWER_SUPPLY_TECHNOLOGY_LION;
ad40e68b 161 if (!strncasecmp("LI-ION", battery->type, 6))
0bde7eee 162 return POWER_SUPPLY_TECHNOLOGY_LION;
d7380965
AS		 163 if (!strcasecmp("LiP", battery->type))
164 return POWER_SUPPLY_TECHNOLOGY_LIPO;
165 return POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
166}
167
9104476e 168static int acpi_battery_get_state(struct acpi_battery *battery);
b19073a0 169
56f382a0
RH		 170static int acpi_battery_is_charged(struct acpi_battery *battery)
171{
172 /* either charging or discharging */
173 if (battery->state != 0)
174 return 0;
175
176 /* battery not reporting charge */
177 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN ||
178 battery->capacity_now == 0)
179 return 0;
180
181 /* good batteries update full_charge as the batteries degrade */
182 if (battery->full_charge_capacity == battery->capacity_now)
183 return 1;
184
185 /* fallback to using design values for broken batteries */
186 if (battery->design_capacity == battery->capacity_now)
187 return 1;
188
189 /* we don't do any sort of metric based on percentages */
190 return 0;
191}
192
d7380965
AS		 193static int acpi_battery_get_property(struct power_supply *psy,
194 enum power_supply_property psp,
195 union power_supply_propval *val)
196{
a1b4bd69 197 int ret = 0;
d7380965
AS		 198 struct acpi_battery *battery = to_acpi_battery(psy);
199
9104476e
AS		 200 if (acpi_battery_present(battery)) {
201 /* run battery update only if it is present */
202 acpi_battery_get_state(battery);
203 } else if (psp != POWER_SUPPLY_PROP_PRESENT)
d7380965
AS		 204 return -ENODEV;
205 switch (psp) {
206 case POWER_SUPPLY_PROP_STATUS:
207 if (battery->state & 0x01)
208 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
209 else if (battery->state & 0x02)
210 val->intval = POWER_SUPPLY_STATUS_CHARGING;
56f382a0 211 else if (acpi_battery_is_charged(battery))
d7380965 212 val->intval = POWER_SUPPLY_STATUS_FULL;
4c41d3ad
RD		 213 else
214 val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
d7380965
AS		 215 break;
216 case POWER_SUPPLY_PROP_PRESENT:
217 val->intval = acpi_battery_present(battery);
218 break;
219 case POWER_SUPPLY_PROP_TECHNOLOGY:
220 val->intval = acpi_battery_technology(battery);
221 break;
c67fcd67
AS		 222 case POWER_SUPPLY_PROP_CYCLE_COUNT:
223 val->intval = battery->cycle_count;
224 break;
d7380965 225 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
a1b4bd69
RW		 226 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
227 ret = -ENODEV;
228 else
229 val->intval = battery->design_voltage * 1000;
d7380965
AS		 230 break;
231 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
a1b4bd69
RW		 232 if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
233 ret = -ENODEV;
234 else
235 val->intval = battery->voltage_now * 1000;
d7380965
AS		 236 break;
237 case POWER_SUPPLY_PROP_CURRENT_NOW:
7faa144a 238 case POWER_SUPPLY_PROP_POWER_NOW:
a1b4bd69
RW		 239 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
240 ret = -ENODEV;
241 else
242 val->intval = battery->rate_now * 1000;
d7380965
AS		 243 break;
244 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
245 case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
a1b4bd69
RW		 246 if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
247 ret = -ENODEV;
248 else
249 val->intval = battery->design_capacity * 1000;
d7380965
AS		 250 break;
251 case POWER_SUPPLY_PROP_CHARGE_FULL:
252 case POWER_SUPPLY_PROP_ENERGY_FULL:
a1b4bd69
RW		 253 if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
254 ret = -ENODEV;
255 else
256 val->intval = battery->full_charge_capacity * 1000;
d7380965
AS		 257 break;
258 case POWER_SUPPLY_PROP_CHARGE_NOW:
259 case POWER_SUPPLY_PROP_ENERGY_NOW:
a1b4bd69
RW		 260 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
261 ret = -ENODEV;
262 else
263 val->intval = battery->capacity_now * 1000;
d7380965 264 break;
a58e1150 265 case POWER_SUPPLY_PROP_CAPACITY:
266 if (battery->capacity_now && battery->full_charge_capacity)
267 val->intval = battery->capacity_now * 100/
268 battery->full_charge_capacity;
269 else
270 val->intval = 0;
271 break;
d7380965
AS		 272 case POWER_SUPPLY_PROP_MODEL_NAME:
273 val->strval = battery->model_number;
274 break;
275 case POWER_SUPPLY_PROP_MANUFACTURER:
276 val->strval = battery->oem_info;
277 break;
7c2670bb 278 case POWER_SUPPLY_PROP_SERIAL_NUMBER:
279 val->strval = battery->serial_number;
280 break;
d7380965 281 default:
a1b4bd69 282 ret = -EINVAL;
d7380965 283 }
a1b4bd69 284 return ret;
d7380965
AS		 285}
286
287static enum power_supply_property charge_battery_props[] = {
288 POWER_SUPPLY_PROP_STATUS,
289 POWER_SUPPLY_PROP_PRESENT,
290 POWER_SUPPLY_PROP_TECHNOLOGY,
c67fcd67 291 POWER_SUPPLY_PROP_CYCLE_COUNT,
d7380965
AS		 292 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
293 POWER_SUPPLY_PROP_VOLTAGE_NOW,
294 POWER_SUPPLY_PROP_CURRENT_NOW,
295 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
296 POWER_SUPPLY_PROP_CHARGE_FULL,
297 POWER_SUPPLY_PROP_CHARGE_NOW,
a58e1150 298 POWER_SUPPLY_PROP_CAPACITY,
d7380965
AS		 299 POWER_SUPPLY_PROP_MODEL_NAME,
300 POWER_SUPPLY_PROP_MANUFACTURER,
7c2670bb 301 POWER_SUPPLY_PROP_SERIAL_NUMBER,
d7380965
AS		 302};
303
304static enum power_supply_property energy_battery_props[] = {
305 POWER_SUPPLY_PROP_STATUS,
306 POWER_SUPPLY_PROP_PRESENT,
307 POWER_SUPPLY_PROP_TECHNOLOGY,
c67fcd67 308 POWER_SUPPLY_PROP_CYCLE_COUNT,
d7380965
AS		 309 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
310 POWER_SUPPLY_PROP_VOLTAGE_NOW,
7faa144a 311 POWER_SUPPLY_PROP_POWER_NOW,
d7380965
AS		 312 POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
313 POWER_SUPPLY_PROP_ENERGY_FULL,
314 POWER_SUPPLY_PROP_ENERGY_NOW,
a58e1150 315 POWER_SUPPLY_PROP_CAPACITY,
d7380965
AS		 316 POWER_SUPPLY_PROP_MODEL_NAME,
317 POWER_SUPPLY_PROP_MANUFACTURER,
7c2670bb 318 POWER_SUPPLY_PROP_SERIAL_NUMBER,
d7380965
AS		 319};
320
3a670cc7
LT		 321#ifdef CONFIG_ACPI_PROCFS_POWER
322inline char *acpi_battery_units(struct acpi_battery *battery)
323{
324 return (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) ?
325 "mA" : "mW";
326}
327#endif
328
78490d82
AS		 329/* --------------------------------------------------------------------------
330 Battery Management
331 -------------------------------------------------------------------------- */
038fdea2
AS		 332struct acpi_offsets {
333 size_t offset; /* offset inside struct acpi_sbs_battery */
334 u8 mode; /* int or string? */
335};
b6ce4083 336
038fdea2
AS		 337static struct acpi_offsets state_offsets[] = {
338 {offsetof(struct acpi_battery, state), 0},
7faa144a 339 {offsetof(struct acpi_battery, rate_now), 0},
d7380965
AS		 340 {offsetof(struct acpi_battery, capacity_now), 0},
341 {offsetof(struct acpi_battery, voltage_now), 0},
038fdea2 342};
b6ce4083 343
038fdea2
AS		 344static struct acpi_offsets info_offsets[] = {
345 {offsetof(struct acpi_battery, power_unit), 0},
346 {offsetof(struct acpi_battery, design_capacity), 0},
d7380965 347 {offsetof(struct acpi_battery, full_charge_capacity), 0},
038fdea2
AS		 348 {offsetof(struct acpi_battery, technology), 0},
349 {offsetof(struct acpi_battery, design_voltage), 0},
350 {offsetof(struct acpi_battery, design_capacity_warning), 0},
351 {offsetof(struct acpi_battery, design_capacity_low), 0},
352 {offsetof(struct acpi_battery, capacity_granularity_1), 0},
353 {offsetof(struct acpi_battery, capacity_granularity_2), 0},
354 {offsetof(struct acpi_battery, model_number), 1},
355 {offsetof(struct acpi_battery, serial_number), 1},
356 {offsetof(struct acpi_battery, type), 1},
357 {offsetof(struct acpi_battery, oem_info), 1},
358};
b6ce4083 359
c67fcd67 360static struct acpi_offsets extended_info_offsets[] = {
016d5baa 361 {offsetof(struct acpi_battery, revision), 0},
c67fcd67
AS		 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
038fdea2
AS		 383static int extract_package(struct acpi_battery *battery,
384 union acpi_object *package,
385 struct acpi_offsets *offsets, int num)
386{
106449e8 387 int i;
038fdea2
AS		 388 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) {
106449e8
AS		 396 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,
439913ff
LM		 402 sizeof(u64));
403 ptr[sizeof(u64)] = 0;
b8a1bdb1
AS		 404 } else
405 *ptr = 0; /* don't have value */
038fdea2 406 } else {
b8a1bdb1
AS		 407 int *x = (int *)((u8 *)battery + offsets[i].offset);
408 *x = (element->type == ACPI_TYPE_INTEGER) ?
409 element->integer.value : -1;
038fdea2 410 }
b6ce4083 411 }
b6ce4083
VL		 412 return 0;
413}
414
415static int acpi_battery_get_status(struct acpi_battery *battery)
416{
aa650bbd 417 if (acpi_bus_get_status(battery->device)) {
b6ce4083
VL		 418 ACPI_EXCEPTION((AE_INFO, AE_ERROR, "Evaluating _STA"));
419 return -ENODEV;
420 }
aa650bbd 421 return 0;
b6ce4083
VL		 422}
423
424static int acpi_battery_get_info(struct acpi_battery *battery)
1da177e4 425{
aa650bbd 426 int result = -EFAULT;
4be44fcd 427 acpi_status status = 0;
0f4c6547 428 char *name = test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags) ?
c67fcd67
AS		 429 "_BIX" : "_BIF";
430
4be44fcd 431 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
1da177e4 432
b6ce4083
VL		 433 if (!acpi_battery_present(battery))
434 return 0;
038fdea2 435 mutex_lock(&battery->lock);
c67fcd67
AS		 436 status = acpi_evaluate_object(battery->device->handle, name,
437 NULL, &buffer);
038fdea2 438 mutex_unlock(&battery->lock);
aa650bbd 439
1da177e4 440 if (ACPI_FAILURE(status)) {
c67fcd67 441 ACPI_EXCEPTION((AE_INFO, status, "Evaluating %s", name));
d550d98d 442 return -ENODEV;
1da177e4 443 }
a90b4038
LT		 444
445 if (battery_bix_broken_package)
446 result = extract_package(battery, buffer.pointer,
447 extended_info_offsets + 1,
448 ARRAY_SIZE(extended_info_offsets) - 1);
449 else if (test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags))
c67fcd67
AS		 450 result = extract_package(battery, buffer.pointer,
451 extended_info_offsets,
452 ARRAY_SIZE(extended_info_offsets));
453 else
454 result = extract_package(battery, buffer.pointer,
455 info_offsets, ARRAY_SIZE(info_offsets));
78490d82 456 kfree(buffer.pointer);
557d5868
ZR		 457 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
458 battery->full_charge_capacity = battery->design_capacity;
4000e626
KI		 459 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
460 battery->power_unit && battery->design_voltage) {
461 battery->design_capacity = battery->design_capacity *
462 10000 / battery->design_voltage;
463 battery->full_charge_capacity = battery->full_charge_capacity *
464 10000 / battery->design_voltage;
465 battery->design_capacity_warning =
466 battery->design_capacity_warning *
467 10000 / battery->design_voltage;
468 /* Curiously, design_capacity_low, unlike the rest of them,
469 is correct. */
470 /* capacity_granularity_* equal 1 on the systems tested, so
471 it's impossible to tell if they would need an adjustment
472 or not if their values were higher. */
473 }
d550d98d 474 return result;
1da177e4
LT		 475}
476
b6ce4083 477static int acpi_battery_get_state(struct acpi_battery *battery)
1da177e4 478{
4be44fcd
LB		 479 int result = 0;
480 acpi_status status = 0;
481 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
1da177e4 482
b6ce4083
VL		 483 if (!acpi_battery_present(battery))
484 return 0;
1da177e4 485
f1d4661a
AS		 486 if (battery->update_time &&
487 time_before(jiffies, battery->update_time +
488 msecs_to_jiffies(cache_time)))
489 return 0;
490
038fdea2 491 mutex_lock(&battery->lock);
f1d4661a 492 status = acpi_evaluate_object(battery->device->handle, "_BST",
038fdea2
AS		 493 NULL, &buffer);
494 mutex_unlock(&battery->lock);
5b31d895 495
1da177e4 496 if (ACPI_FAILURE(status)) {
a6fc6720 497 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BST"));
d550d98d 498 return -ENODEV;
1da177e4 499 }
aa650bbd 500
038fdea2
AS		 501 result = extract_package(battery, buffer.pointer,
502 state_offsets, ARRAY_SIZE(state_offsets));
f1d4661a 503 battery->update_time = jiffies;
78490d82 504 kfree(buffer.pointer);
bc76f90b 505
55003b21
LT		 506 /* For buggy DSDTs that report negative 16-bit values for either
507 * charging or discharging current and/or report 0 as 65536
508 * due to bad math.
509 */
510 if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA &&
511 battery->rate_now != ACPI_BATTERY_VALUE_UNKNOWN &&
512 (s16)(battery->rate_now) < 0) {
bc76f90b 513 battery->rate_now = abs((s16)battery->rate_now);
55003b21
LT		 514 printk_once(KERN_WARNING FW_BUG "battery: (dis)charge rate"
515 " invalid.\n");
516 }
bc76f90b 517
557d5868
ZR		 518 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags)
519 && battery->capacity_now >= 0 && battery->capacity_now <= 100)
520 battery->capacity_now = (battery->capacity_now *
521 battery->full_charge_capacity) / 100;
4000e626
KI		 522 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
523 battery->power_unit && battery->design_voltage) {
524 battery->capacity_now = battery->capacity_now *
525 10000 / battery->design_voltage;
526 }
b6ce4083
VL		 527 return result;
528}
1da177e4 529
aa650bbd 530static int acpi_battery_set_alarm(struct acpi_battery *battery)
1da177e4 531{
4be44fcd 532 acpi_status status = 0;
1da177e4 533
c67fcd67 534 if (!acpi_battery_present(battery) ||
7b3bcc4a 535 !test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags))
d550d98d 536 return -ENODEV;
1da177e4 537
038fdea2 538 mutex_lock(&battery->lock);
0db98202
JL		 539 status = acpi_execute_simple_method(battery->device->handle, "_BTP",
540 battery->alarm);
038fdea2 541 mutex_unlock(&battery->lock);
aa650bbd 542
1da177e4 543 if (ACPI_FAILURE(status))
d550d98d 544 return -ENODEV;
1da177e4 545
aa650bbd 546 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Alarm set to %d\n", battery->alarm));
d550d98d 547 return 0;
1da177e4
LT		 548}
549
b6ce4083 550static int acpi_battery_init_alarm(struct acpi_battery *battery)
1da177e4 551{
b6ce4083 552 /* See if alarms are supported, and if so, set default */
952c63e9 553 if (!acpi_has_method(battery->device->handle, "_BTP")) {
7b3bcc4a 554 clear_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
f1d4661a 555 return 0;
b6ce4083 556 }
7b3bcc4a 557 set_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
f1d4661a
AS		 558 if (!battery->alarm)
559 battery->alarm = battery->design_capacity_warning;
aa650bbd 560 return acpi_battery_set_alarm(battery);
b6ce4083 561}
1da177e4 562
508df92d
AB		 563static ssize_t acpi_battery_alarm_show(struct device *dev,
564 struct device_attribute *attr,
565 char *buf)
566{
567 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
568 return sprintf(buf, "%d\n", battery->alarm * 1000);
569}
570
571static ssize_t acpi_battery_alarm_store(struct device *dev,
572 struct device_attribute *attr,
573 const char *buf, size_t count)
574{
575 unsigned long x;
576 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
47a08c85 577 if (sscanf(buf, "%lu\n", &x) == 1)
508df92d
AB		 578 battery->alarm = x/1000;
579 if (acpi_battery_present(battery))
580 acpi_battery_set_alarm(battery);
581 return count;
582}
583
584static struct device_attribute alarm_attr = {
01e8ef11 585 .attr = {.name = "alarm", .mode = 0644},
508df92d
AB		 586 .show = acpi_battery_alarm_show,
587 .store = acpi_battery_alarm_store,
588};
589
590static int sysfs_add_battery(struct acpi_battery *battery)
591{
592 int result;
593
ae6f6187 594 if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) {
508df92d
AB		 595 battery->bat.properties = charge_battery_props;
596 battery->bat.num_properties =
597 ARRAY_SIZE(charge_battery_props);
598 } else {
599 battery->bat.properties = energy_battery_props;
600 battery->bat.num_properties =
601 ARRAY_SIZE(energy_battery_props);
602 }
603
604 battery->bat.name = acpi_device_bid(battery->device);
605 battery->bat.type = POWER_SUPPLY_TYPE_BATTERY;
606 battery->bat.get_property = acpi_battery_get_property;
607
608 result = power_supply_register(&battery->device->dev, &battery->bat);
609 if (result)
610 return result;
611 return device_create_file(battery->bat.dev, &alarm_attr);
612}
613
614static void sysfs_remove_battery(struct acpi_battery *battery)
615{
69d94ec6 616 mutex_lock(&battery->sysfs_lock);
9c921c22 617 if (!battery->bat.dev) {
69d94ec6 618 mutex_unlock(&battery->sysfs_lock);
508df92d 619 return;
9c921c22
LT		 620 }
621
508df92d
AB		 622 device_remove_file(battery->bat.dev, &alarm_attr);
623 power_supply_unregister(&battery->bat);
9104476e 624 battery->bat.dev = NULL;
69d94ec6 625 mutex_unlock(&battery->sysfs_lock);
bc76f90b
HM		 626}
627
4000e626
KI		 628static void find_battery(const struct dmi_header *dm, void *private)
629{
630 struct acpi_battery *battery = (struct acpi_battery *)private;
631 /* Note: the hardcoded offsets below have been extracted from
632 the source code of dmidecode. */
633 if (dm->type == DMI_ENTRY_PORTABLE_BATTERY && dm->length >= 8) {
634 const u8 *dmi_data = (const u8 *)(dm + 1);
635 int dmi_capacity = get_unaligned((const u16 *)(dmi_data + 6));
636 if (dm->length >= 18)
637 dmi_capacity *= dmi_data[17];
638 if (battery->design_capacity * battery->design_voltage / 1000
639 != dmi_capacity &&
640 battery->design_capacity * 10 == dmi_capacity)
641 set_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
642 &battery->flags);
643 }
644}
645
557d5868
ZR		 646/*
647 * According to the ACPI spec, some kinds of primary batteries can
648 * report percentage battery remaining capacity directly to OS.
649 * In this case, it reports the Last Full Charged Capacity == 100
650 * and BatteryPresentRate == 0xFFFFFFFF.
651 *
652 * Now we found some battery reports percentage remaining capacity
653 * even if it's rechargeable.
654 * https://bugzilla.kernel.org/show_bug.cgi?id=15979
655 *
656 * Handle this correctly so that they won't break userspace.
657 */
7b78622d 658static void acpi_battery_quirks(struct acpi_battery *battery)
557d5868
ZR		 659{
660 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
0f4c6547 661 return;
557d5868 662
0f4c6547
NM		 663 if (battery->full_charge_capacity == 100 &&
664 battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN &&
665 battery->capacity_now >= 0 && battery->capacity_now <= 100) {
557d5868
ZR		 666 set_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags);
667 battery->full_charge_capacity = battery->design_capacity;
668 battery->capacity_now = (battery->capacity_now *
669 battery->full_charge_capacity) / 100;
670 }
4000e626
KI		 671
672 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags))
0f4c6547 673 return;
4000e626
KI		 674
675 if (battery->power_unit && dmi_name_in_vendors("LENOVO")) {
676 const char *s;
677 s = dmi_get_system_info(DMI_PRODUCT_VERSION);
678 if (s && !strnicmp(s, "ThinkPad", 8)) {
679 dmi_walk(find_battery, battery);
680 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
681 &battery->flags) &&
682 battery->design_voltage) {
683 battery->design_capacity =
684 battery->design_capacity *
685 10000 / battery->design_voltage;
686 battery->full_charge_capacity =
687 battery->full_charge_capacity *
688 10000 / battery->design_voltage;
689 battery->design_capacity_warning =
690 battery->design_capacity_warning *
691 10000 / battery->design_voltage;
692 battery->capacity_now = battery->capacity_now *
693 10000 / battery->design_voltage;
694 }
695 }
696 }
557d5868
ZR		 697}
698
f1d4661a 699static int acpi_battery_update(struct acpi_battery *battery)
b6ce4083 700{
50b17851 701 int result, old_present = acpi_battery_present(battery);
97749cd9 702 result = acpi_battery_get_status(battery);
508df92d 703 if (result)
b6ce4083 704 return result;
508df92d
AB		 705 if (!acpi_battery_present(battery)) {
706 sysfs_remove_battery(battery);
97749cd9 707 battery->update_time = 0;
508df92d 708 return 0;
b6ce4083 709 }
50b17851
AS		 710 if (!battery->update_time ||
711 old_present != acpi_battery_present(battery)) {
97749cd9
AS		 712 result = acpi_battery_get_info(battery);
713 if (result)
714 return result;
715 acpi_battery_init_alarm(battery);
716 }
eb03cb02
SH		 717 if (!battery->bat.dev) {
718 result = sysfs_add_battery(battery);
719 if (result)
720 return result;
721 }
557d5868 722 result = acpi_battery_get_state(battery);
7b78622d 723 acpi_battery_quirks(battery);
557d5868 724 return result;
4bd35cdb
VL		 725}
726
da8aeb92
RW		 727static void acpi_battery_refresh(struct acpi_battery *battery)
728{
c5971456
AW		 729 int power_unit;
730
da8aeb92
RW		 731 if (!battery->bat.dev)
732 return;
733
c5971456
AW		 734 power_unit = battery->power_unit;
735
da8aeb92 736 acpi_battery_get_info(battery);
c5971456
AW		 737
738 if (power_unit == battery->power_unit)
739 return;
740
741 /* The battery has changed its reporting units. */
da8aeb92
RW		 742 sysfs_remove_battery(battery);
743 sysfs_add_battery(battery);
744}
745
3a670cc7
LT		 746/* --------------------------------------------------------------------------
747 FS Interface (/proc)
748 -------------------------------------------------------------------------- */
749
750#ifdef CONFIG_ACPI_PROCFS_POWER
751static struct proc_dir_entry *acpi_battery_dir;
752
753static int acpi_battery_print_info(struct seq_file *seq, int result)
754{
755 struct acpi_battery *battery = seq->private;
756
757 if (result)
758 goto end;
759
760 seq_printf(seq, "present: %s\n",
761 acpi_battery_present(battery) ? "yes" : "no");
762 if (!acpi_battery_present(battery))
763 goto end;
764 if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
765 seq_printf(seq, "design capacity: unknown\n");
766 else
767 seq_printf(seq, "design capacity: %d %sh\n",
768 battery->design_capacity,
769 acpi_battery_units(battery));
770
771 if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
772 seq_printf(seq, "last full capacity: unknown\n");
773 else
774 seq_printf(seq, "last full capacity: %d %sh\n",
775 battery->full_charge_capacity,
776 acpi_battery_units(battery));
777
778 seq_printf(seq, "battery technology: %srechargeable\n",
779 (!battery->technology)?"non-":"");
780
781 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
782 seq_printf(seq, "design voltage: unknown\n");
783 else
784 seq_printf(seq, "design voltage: %d mV\n",
785 battery->design_voltage);
786 seq_printf(seq, "design capacity warning: %d %sh\n",
787 battery->design_capacity_warning,
788 acpi_battery_units(battery));
789 seq_printf(seq, "design capacity low: %d %sh\n",
790 battery->design_capacity_low,
791 acpi_battery_units(battery));
792 seq_printf(seq, "cycle count: %i\n", battery->cycle_count);
793 seq_printf(seq, "capacity granularity 1: %d %sh\n",
794 battery->capacity_granularity_1,
795 acpi_battery_units(battery));
796 seq_printf(seq, "capacity granularity 2: %d %sh\n",
797 battery->capacity_granularity_2,
798 acpi_battery_units(battery));
799 seq_printf(seq, "model number: %s\n", battery->model_number);
800 seq_printf(seq, "serial number: %s\n", battery->serial_number);
801 seq_printf(seq, "battery type: %s\n", battery->type);
802 seq_printf(seq, "OEM info: %s\n", battery->oem_info);
803 end:
804 if (result)
805 seq_printf(seq, "ERROR: Unable to read battery info\n");
806 return result;
807}
808
809static int acpi_battery_print_state(struct seq_file *seq, int result)
810{
811 struct acpi_battery *battery = seq->private;
812
813 if (result)
814 goto end;
815
816 seq_printf(seq, "present: %s\n",
817 acpi_battery_present(battery) ? "yes" : "no");
818 if (!acpi_battery_present(battery))
819 goto end;
820
821 seq_printf(seq, "capacity state: %s\n",
822 (battery->state & 0x04) ? "critical" : "ok");
823 if ((battery->state & 0x01) && (battery->state & 0x02))
824 seq_printf(seq,
825 "charging state: charging/discharging\n");
826 else if (battery->state & 0x01)
827 seq_printf(seq, "charging state: discharging\n");
828 else if (battery->state & 0x02)
829 seq_printf(seq, "charging state: charging\n");
830 else
831 seq_printf(seq, "charging state: charged\n");
832
833 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
834 seq_printf(seq, "present rate: unknown\n");
835 else
836 seq_printf(seq, "present rate: %d %s\n",
837 battery->rate_now, acpi_battery_units(battery));
838
839 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
840 seq_printf(seq, "remaining capacity: unknown\n");
841 else
842 seq_printf(seq, "remaining capacity: %d %sh\n",
843 battery->capacity_now, acpi_battery_units(battery));
844 if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
845 seq_printf(seq, "present voltage: unknown\n");
846 else
847 seq_printf(seq, "present voltage: %d mV\n",
848 battery->voltage_now);
849 end:
850 if (result)
851 seq_printf(seq, "ERROR: Unable to read battery state\n");
852
853 return result;
854}
855
856static int acpi_battery_print_alarm(struct seq_file *seq, int result)
857{
858 struct acpi_battery *battery = seq->private;
859
860 if (result)
861 goto end;
862
863 if (!acpi_battery_present(battery)) {
864 seq_printf(seq, "present: no\n");
865 goto end;
866 }
867 seq_printf(seq, "alarm: ");
868 if (!battery->alarm)
869 seq_printf(seq, "unsupported\n");
870 else
871 seq_printf(seq, "%u %sh\n", battery->alarm,
872 acpi_battery_units(battery));
873 end:
874 if (result)
875 seq_printf(seq, "ERROR: Unable to read battery alarm\n");
876 return result;
877}
878
879static ssize_t acpi_battery_write_alarm(struct file *file,
880 const char __user * buffer,
881 size_t count, loff_t * ppos)
882{
883 int result = 0;
884 char alarm_string[12] = { '\0' };
885 struct seq_file *m = file->private_data;
886 struct acpi_battery *battery = m->private;
887
888 if (!battery || (count > sizeof(alarm_string) - 1))
889 return -EINVAL;
890 if (!acpi_battery_present(battery)) {
891 result = -ENODEV;
892 goto end;
893 }
894 if (copy_from_user(alarm_string, buffer, count)) {
895 result = -EFAULT;
896 goto end;
897 }
898 alarm_string[count] = '\0';
899 battery->alarm = simple_strtol(alarm_string, NULL, 0);
900 result = acpi_battery_set_alarm(battery);
901 end:
902 if (!result)
903 return count;
904 return result;
905}
906
907typedef int(*print_func)(struct seq_file *seq, int result);
908
909static print_func acpi_print_funcs[ACPI_BATTERY_NUMFILES] = {
910 acpi_battery_print_info,
911 acpi_battery_print_state,
912 acpi_battery_print_alarm,
913};
914
915static int acpi_battery_read(int fid, struct seq_file *seq)
916{
917 struct acpi_battery *battery = seq->private;
918 int result = acpi_battery_update(battery);
919 return acpi_print_funcs[fid](seq, result);
920}
921
922#define DECLARE_FILE_FUNCTIONS(_name) \
923static int acpi_battery_read_##_name(struct seq_file *seq, void *offset) \
924{ \
925 return acpi_battery_read(_name##_tag, seq); \
926} \
927static int acpi_battery_##_name##_open_fs(struct inode *inode, struct file *file) \
928{ \
929 return single_open(file, acpi_battery_read_##_name, PDE_DATA(inode)); \
930}
931
932DECLARE_FILE_FUNCTIONS(info);
933DECLARE_FILE_FUNCTIONS(state);
934DECLARE_FILE_FUNCTIONS(alarm);
935
936#undef DECLARE_FILE_FUNCTIONS
937
938#define FILE_DESCRIPTION_RO(_name) \
939 { \
940 .name = __stringify(_name), \
941 .mode = S_IRUGO, \
942 .ops = { \
943 .open = acpi_battery_##_name##_open_fs, \
944 .read = seq_read, \
945 .llseek = seq_lseek, \
946 .release = single_release, \
947 .owner = THIS_MODULE, \
948 }, \
949 }
950
951#define FILE_DESCRIPTION_RW(_name) \
952 { \
953 .name = __stringify(_name), \
954 .mode = S_IFREG | S_IRUGO | S_IWUSR, \
955 .ops = { \
956 .open = acpi_battery_##_name##_open_fs, \
957 .read = seq_read, \
958 .llseek = seq_lseek, \
959 .write = acpi_battery_write_##_name, \
960 .release = single_release, \
961 .owner = THIS_MODULE, \
962 }, \
963 }
964
965static const struct battery_file {
966 struct file_operations ops;
967 umode_t mode;
968 const char *name;
969} acpi_battery_file[] = {
970 FILE_DESCRIPTION_RO(info),
971 FILE_DESCRIPTION_RO(state),
972 FILE_DESCRIPTION_RW(alarm),
973};
974
975#undef FILE_DESCRIPTION_RO
976#undef FILE_DESCRIPTION_RW
977
978static int acpi_battery_add_fs(struct acpi_device *device)
979{
980 struct proc_dir_entry *entry = NULL;
981 int i;
982
983 printk(KERN_WARNING PREFIX "Deprecated procfs I/F for battery is loaded,"
984 " please retry with CONFIG_ACPI_PROCFS_POWER cleared\n");
985 if (!acpi_device_dir(device)) {
986 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
987 acpi_battery_dir);
988 if (!acpi_device_dir(device))
989 return -ENODEV;
990 }
991
992 for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i) {
993 entry = proc_create_data(acpi_battery_file[i].name,
994 acpi_battery_file[i].mode,
995 acpi_device_dir(device),
996 &acpi_battery_file[i].ops,
997 acpi_driver_data(device));
998 if (!entry)
999 return -ENODEV;
1000 }
1001 return 0;
1002}
1003
1004static void acpi_battery_remove_fs(struct acpi_device *device)
1005{
1006 int i;
1007 if (!acpi_device_dir(device))
1008 return;
1009 for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i)
1010 remove_proc_entry(acpi_battery_file[i].name,
1011 acpi_device_dir(device));
1012
1013 remove_proc_entry(acpi_device_bid(device), acpi_battery_dir);
1014 acpi_device_dir(device) = NULL;
1015}
1016
1017#endif
1018
1da177e4
LT		 1019/* --------------------------------------------------------------------------
1020 Driver Interface
1021 -------------------------------------------------------------------------- */
1022
d9406691 1023static void acpi_battery_notify(struct acpi_device *device, u32 event)
1da177e4 1024{
d9406691 1025 struct acpi_battery *battery = acpi_driver_data(device);
153e500f 1026 struct device *old;
d9406691 1027
1da177e4 1028 if (!battery)
d550d98d 1029 return;
153e500f 1030 old = battery->bat.dev;
da8aeb92
RW		 1031 if (event == ACPI_BATTERY_NOTIFY_INFO)
1032 acpi_battery_refresh(battery);
f1d4661a 1033 acpi_battery_update(battery);
f1d4661a 1034 acpi_bus_generate_netlink_event(device->pnp.device_class,
0794469d 1035 dev_name(&device->dev), event,
9ea7d575 1036 acpi_battery_present(battery));
411e0f77 1037 acpi_notifier_call_chain(device, event, acpi_battery_present(battery));
2345baf4 1038 /* acpi_battery_update could remove power_supply object */
153e500f 1039 if (old && battery->bat.dev)
f79e1cec 1040 power_supply_changed(&battery->bat);
1da177e4
LT		 1041}
1042
25be5821
KM		 1043static int battery_notify(struct notifier_block *nb,
1044 unsigned long mode, void *_unused)
1045{
1046 struct acpi_battery *battery = container_of(nb, struct acpi_battery,
1047 pm_nb);
1048 switch (mode) {
d5a5911b 1049 case PM_POST_HIBERNATION:
25be5821 1050 case PM_POST_SUSPEND:
6e17fb6a
LT		 1051 if (battery->bat.dev) {
1052 sysfs_remove_battery(battery);
1053 sysfs_add_battery(battery);
1054 }
25be5821
KM		 1055 break;
1056 }
1057
1058 return 0;
1059}
1060
a90b4038
LT		 1061static struct dmi_system_id bat_dmi_table[] = {
1062 {
1063 .ident = "NEC LZ750/LS",
1064 .matches = {
1065 DMI_MATCH(DMI_SYS_VENDOR, "NEC"),
1066 DMI_MATCH(DMI_PRODUCT_NAME, "PC-LZ750LS"),
1067 },
1068 },
1069 {},
1070};
1071
4be44fcd 1072static int acpi_battery_add(struct acpi_device *device)
1da177e4 1073{
4be44fcd 1074 int result = 0;
4be44fcd 1075 struct acpi_battery *battery = NULL;
952c63e9 1076
1da177e4 1077 if (!device)
d550d98d 1078 return -EINVAL;
36bcbec7 1079 battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL);
1da177e4 1080 if (!battery)
d550d98d 1081 return -ENOMEM;
145def84 1082 battery->device = device;
1da177e4
LT		 1083 strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME);
1084 strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS);
db89b4f0 1085 device->driver_data = battery;
038fdea2 1086 mutex_init(&battery->lock);
69d94ec6 1087 mutex_init(&battery->sysfs_lock);
952c63e9 1088 if (acpi_has_method(battery->device->handle, "_BIX"))
c67fcd67 1089 set_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags);
eb03cb02
SH		 1090 result = acpi_battery_update(battery);
1091 if (result)
1092 goto fail;
3a670cc7
LT		 1093#ifdef CONFIG_ACPI_PROCFS_POWER
1094 result = acpi_battery_add_fs(device);
1095#endif
1096 if (result) {
1097#ifdef CONFIG_ACPI_PROCFS_POWER
1098 acpi_battery_remove_fs(device);
1099#endif
1100 goto fail;
1101 }
25be5821 1102
e80bba4b
SH		 1103 printk(KERN_INFO PREFIX "%s Slot [%s] (battery %s)\n",
1104 ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device),
1105 device->status.battery_present ? "present" : "absent");
1106
25be5821
KM		 1107 battery->pm_nb.notifier_call = battery_notify;
1108 register_pm_notifier(&battery->pm_nb);
1109
d550d98d 1110 return result;
e80bba4b
SH		 1111
1112fail:
1113 sysfs_remove_battery(battery);
1114 mutex_destroy(&battery->lock);
69d94ec6 1115 mutex_destroy(&battery->sysfs_lock);
e80bba4b
SH		 1116 kfree(battery);
1117 return result;
1da177e4
LT		 1118}
1119
51fac838 1120static int acpi_battery_remove(struct acpi_device *device)
1da177e4 1121{
4be44fcd 1122 struct acpi_battery *battery = NULL;
1da177e4 1123
1da177e4 1124 if (!device || !acpi_driver_data(device))
d550d98d 1125 return -EINVAL;
50dd0969 1126 battery = acpi_driver_data(device);
25be5821 1127 unregister_pm_notifier(&battery->pm_nb);
3a670cc7
LT		 1128#ifdef CONFIG_ACPI_PROCFS_POWER
1129 acpi_battery_remove_fs(device);
1130#endif
508df92d 1131 sysfs_remove_battery(battery);
038fdea2 1132 mutex_destroy(&battery->lock);
69d94ec6 1133 mutex_destroy(&battery->sysfs_lock);
1da177e4 1134 kfree(battery);
d550d98d 1135 return 0;
1da177e4
LT		 1136}
1137
90692404 1138#ifdef CONFIG_PM_SLEEP
34c4415a 1139/* this is needed to learn about changes made in suspended state */
a6f50dc8 1140static int acpi_battery_resume(struct device *dev)
34c4415a
JK		 1141{
1142 struct acpi_battery *battery;
a6f50dc8
RW		 1143
1144 if (!dev)
34c4415a 1145 return -EINVAL;
a6f50dc8
RW		 1146
1147 battery = acpi_driver_data(to_acpi_device(dev));
1148 if (!battery)
1149 return -EINVAL;
1150
f1d4661a 1151 battery->update_time = 0;
508df92d 1152 acpi_battery_update(battery);
b6ce4083 1153 return 0;
34c4415a 1154}
7f6895c6
SK		 1155#else
1156#define acpi_battery_resume NULL
90692404 1157#endif
34c4415a 1158
a6f50dc8
RW		 1159static SIMPLE_DEV_PM_OPS(acpi_battery_pm, NULL, acpi_battery_resume);
1160
aa650bbd
AS		 1161static struct acpi_driver acpi_battery_driver = {
1162 .name = "battery",
1163 .class = ACPI_BATTERY_CLASS,
1164 .ids = battery_device_ids,
d9406691 1165 .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
aa650bbd
AS		 1166 .ops = {
1167 .add = acpi_battery_add,
aa650bbd 1168 .remove = acpi_battery_remove,
d9406691 1169 .notify = acpi_battery_notify,
aa650bbd 1170 },
a6f50dc8 1171 .drv.pm = &acpi_battery_pm,
aa650bbd
AS		 1172};
1173
b0cbc861 1174static void __init acpi_battery_init_async(void *unused, async_cookie_t cookie)
1da177e4 1175{
4d8316d5 1176 if (acpi_disabled)
0f66af53 1177 return;
a90b4038
LT		 1178
1179 if (dmi_check_system(bat_dmi_table))
1180 battery_bix_broken_package = 1;
3a670cc7
LT		 1181
1182#ifdef CONFIG_ACPI_PROCFS_POWER
1183 acpi_battery_dir = acpi_lock_battery_dir();
1184 if (!acpi_battery_dir)
1185 return;
1186#endif
1187 if (acpi_bus_register_driver(&acpi_battery_driver) < 0) {
1188#ifdef CONFIG_ACPI_PROCFS_POWER
1189 acpi_unlock_battery_dir(acpi_battery_dir);
1190#endif
1191 return;
1192 }
1193 return;
0f66af53
AV		 1194}
1195
1196static int __init acpi_battery_init(void)
1197{
1198 async_schedule(acpi_battery_init_async, NULL);
d550d98d 1199 return 0;
1da177e4
LT		 1200}
1201
4be44fcd 1202static void __exit acpi_battery_exit(void)
1da177e4 1203{
1da177e4 1204 acpi_bus_unregister_driver(&acpi_battery_driver);
3a670cc7
LT		 1205#ifdef CONFIG_ACPI_PROCFS_POWER
1206 acpi_unlock_battery_dir(acpi_battery_dir);
1207#endif
1da177e4
LT		 1208}
1209
1da177e4
LT		 1210module_init(acpi_battery_init);
1211module_exit(acpi_battery_exit);
Ubuntu Artful kernel mirror