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