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