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