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