Loading...
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * battery.c - ACPI Battery Driver (Revision: 2.0)
4 *
5 * Copyright (C) 2007 Alexey Starikovskiy <astarikovskiy@suse.de>
6 * Copyright (C) 2004-2007 Vladimir Lebedev <vladimir.p.lebedev@intel.com>
7 * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
8 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
9 */
10
11#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
12
13#include <linux/async.h>
14#include <linux/delay.h>
15#include <linux/dmi.h>
16#include <linux/jiffies.h>
17#include <linux/kernel.h>
18#include <linux/list.h>
19#include <linux/module.h>
20#include <linux/mutex.h>
21#include <linux/slab.h>
22#include <linux/suspend.h>
23#include <linux/types.h>
24
25#include <asm/unaligned.h>
26
27#include <linux/acpi.h>
28#include <linux/power_supply.h>
29
30#include <acpi/battery.h>
31
32#define PREFIX "ACPI: "
33
34#define ACPI_BATTERY_VALUE_UNKNOWN 0xFFFFFFFF
35#define ACPI_BATTERY_CAPACITY_VALID(capacity) \
36 ((capacity) != 0 && (capacity) != ACPI_BATTERY_VALUE_UNKNOWN)
37
38#define ACPI_BATTERY_DEVICE_NAME "Battery"
39
40/* Battery power unit: 0 means mW, 1 means mA */
41#define ACPI_BATTERY_POWER_UNIT_MA 1
42
43#define ACPI_BATTERY_STATE_DISCHARGING 0x1
44#define ACPI_BATTERY_STATE_CHARGING 0x2
45#define ACPI_BATTERY_STATE_CRITICAL 0x4
46
47#define _COMPONENT ACPI_BATTERY_COMPONENT
48
49ACPI_MODULE_NAME("battery");
50
51MODULE_AUTHOR("Paul Diefenbaugh");
52MODULE_AUTHOR("Alexey Starikovskiy <astarikovskiy@suse.de>");
53MODULE_DESCRIPTION("ACPI Battery Driver");
54MODULE_LICENSE("GPL");
55
56static async_cookie_t async_cookie;
57static bool battery_driver_registered;
58static int battery_bix_broken_package;
59static int battery_notification_delay_ms;
60static int battery_ac_is_broken;
61static int battery_check_pmic = 1;
62static unsigned int cache_time = 1000;
63module_param(cache_time, uint, 0644);
64MODULE_PARM_DESC(cache_time, "cache time in milliseconds");
65
66static const struct acpi_device_id battery_device_ids[] = {
67 {"PNP0C0A", 0},
68 {"", 0},
69};
70
71MODULE_DEVICE_TABLE(acpi, battery_device_ids);
72
73/* Lists of PMIC ACPI HIDs with an (often better) native battery driver */
74static const char * const acpi_battery_blacklist[] = {
75 "INT33F4", /* X-Powers AXP288 PMIC */
76};
77
78enum {
79 ACPI_BATTERY_ALARM_PRESENT,
80 ACPI_BATTERY_XINFO_PRESENT,
81 ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY,
82 /* On Lenovo Thinkpad models from 2010 and 2011, the power unit
83 switches between mWh and mAh depending on whether the system
84 is running on battery or not. When mAh is the unit, most
85 reported values are incorrect and need to be adjusted by
86 10000/design_voltage. Verified on x201, t410, t410s, and x220.
87 Pre-2010 and 2012 models appear to always report in mWh and
88 are thus unaffected (tested with t42, t61, t500, x200, x300,
89 and x230). Also, in mid-2012 Lenovo issued a BIOS update for
90 the 2011 models that fixes the issue (tested on x220 with a
91 post-1.29 BIOS), but as of Nov. 2012, no such update is
92 available for the 2010 models. */
93 ACPI_BATTERY_QUIRK_THINKPAD_MAH,
94 /* for batteries reporting current capacity with design capacity
95 * on a full charge, but showing degradation in full charge cap.
96 */
97 ACPI_BATTERY_QUIRK_DEGRADED_FULL_CHARGE,
98};
99
100struct acpi_battery {
101 struct mutex lock;
102 struct mutex sysfs_lock;
103 struct power_supply *bat;
104 struct power_supply_desc bat_desc;
105 struct acpi_device *device;
106 struct notifier_block pm_nb;
107 struct list_head list;
108 unsigned long update_time;
109 int revision;
110 int rate_now;
111 int capacity_now;
112 int voltage_now;
113 int design_capacity;
114 int full_charge_capacity;
115 int technology;
116 int design_voltage;
117 int design_capacity_warning;
118 int design_capacity_low;
119 int cycle_count;
120 int measurement_accuracy;
121 int max_sampling_time;
122 int min_sampling_time;
123 int max_averaging_interval;
124 int min_averaging_interval;
125 int capacity_granularity_1;
126 int capacity_granularity_2;
127 int alarm;
128 char model_number[32];
129 char serial_number[32];
130 char type[32];
131 char oem_info[32];
132 int state;
133 int power_unit;
134 unsigned long flags;
135};
136
137#define to_acpi_battery(x) power_supply_get_drvdata(x)
138
139static inline int acpi_battery_present(struct acpi_battery *battery)
140{
141 return battery->device->status.battery_present;
142}
143
144static int acpi_battery_technology(struct acpi_battery *battery)
145{
146 if (!strcasecmp("NiCd", battery->type))
147 return POWER_SUPPLY_TECHNOLOGY_NiCd;
148 if (!strcasecmp("NiMH", battery->type))
149 return POWER_SUPPLY_TECHNOLOGY_NiMH;
150 if (!strcasecmp("LION", battery->type))
151 return POWER_SUPPLY_TECHNOLOGY_LION;
152 if (!strncasecmp("LI-ION", battery->type, 6))
153 return POWER_SUPPLY_TECHNOLOGY_LION;
154 if (!strcasecmp("LiP", battery->type))
155 return POWER_SUPPLY_TECHNOLOGY_LIPO;
156 return POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
157}
158
159static int acpi_battery_get_state(struct acpi_battery *battery);
160
161static int acpi_battery_is_charged(struct acpi_battery *battery)
162{
163 /* charging, discharging or critical low */
164 if (battery->state != 0)
165 return 0;
166
167 /* battery not reporting charge */
168 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN ||
169 battery->capacity_now == 0)
170 return 0;
171
172 /* good batteries update full_charge as the batteries degrade */
173 if (battery->full_charge_capacity == battery->capacity_now)
174 return 1;
175
176 /* fallback to using design values for broken batteries */
177 if (battery->design_capacity == battery->capacity_now)
178 return 1;
179
180 /* we don't do any sort of metric based on percentages */
181 return 0;
182}
183
184static bool acpi_battery_is_degraded(struct acpi_battery *battery)
185{
186 return ACPI_BATTERY_CAPACITY_VALID(battery->full_charge_capacity) &&
187 ACPI_BATTERY_CAPACITY_VALID(battery->design_capacity) &&
188 battery->full_charge_capacity < battery->design_capacity;
189}
190
191static int acpi_battery_handle_discharging(struct acpi_battery *battery)
192{
193 /*
194 * Some devices wrongly report discharging if the battery's charge level
195 * was above the device's start charging threshold atm the AC adapter
196 * was plugged in and the device thus did not start a new charge cycle.
197 */
198 if ((battery_ac_is_broken || power_supply_is_system_supplied()) &&
199 battery->rate_now == 0)
200 return POWER_SUPPLY_STATUS_NOT_CHARGING;
201
202 return POWER_SUPPLY_STATUS_DISCHARGING;
203}
204
205static int acpi_battery_get_property(struct power_supply *psy,
206 enum power_supply_property psp,
207 union power_supply_propval *val)
208{
209 int full_capacity = ACPI_BATTERY_VALUE_UNKNOWN, ret = 0;
210 struct acpi_battery *battery = to_acpi_battery(psy);
211
212 if (acpi_battery_present(battery)) {
213 /* run battery update only if it is present */
214 acpi_battery_get_state(battery);
215 } else if (psp != POWER_SUPPLY_PROP_PRESENT)
216 return -ENODEV;
217 switch (psp) {
218 case POWER_SUPPLY_PROP_STATUS:
219 if (battery->state & ACPI_BATTERY_STATE_DISCHARGING)
220 val->intval = acpi_battery_handle_discharging(battery);
221 else if (battery->state & ACPI_BATTERY_STATE_CHARGING)
222 val->intval = POWER_SUPPLY_STATUS_CHARGING;
223 else if (acpi_battery_is_charged(battery))
224 val->intval = POWER_SUPPLY_STATUS_FULL;
225 else
226 val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
227 break;
228 case POWER_SUPPLY_PROP_PRESENT:
229 val->intval = acpi_battery_present(battery);
230 break;
231 case POWER_SUPPLY_PROP_TECHNOLOGY:
232 val->intval = acpi_battery_technology(battery);
233 break;
234 case POWER_SUPPLY_PROP_CYCLE_COUNT:
235 val->intval = battery->cycle_count;
236 break;
237 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
238 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
239 ret = -ENODEV;
240 else
241 val->intval = battery->design_voltage * 1000;
242 break;
243 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
244 if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
245 ret = -ENODEV;
246 else
247 val->intval = battery->voltage_now * 1000;
248 break;
249 case POWER_SUPPLY_PROP_CURRENT_NOW:
250 case POWER_SUPPLY_PROP_POWER_NOW:
251 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
252 ret = -ENODEV;
253 else
254 val->intval = battery->rate_now * 1000;
255 break;
256 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
257 case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
258 if (!ACPI_BATTERY_CAPACITY_VALID(battery->design_capacity))
259 ret = -ENODEV;
260 else
261 val->intval = battery->design_capacity * 1000;
262 break;
263 case POWER_SUPPLY_PROP_CHARGE_FULL:
264 case POWER_SUPPLY_PROP_ENERGY_FULL:
265 if (!ACPI_BATTERY_CAPACITY_VALID(battery->full_charge_capacity))
266 ret = -ENODEV;
267 else
268 val->intval = battery->full_charge_capacity * 1000;
269 break;
270 case POWER_SUPPLY_PROP_CHARGE_NOW:
271 case POWER_SUPPLY_PROP_ENERGY_NOW:
272 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
273 ret = -ENODEV;
274 else
275 val->intval = battery->capacity_now * 1000;
276 break;
277 case POWER_SUPPLY_PROP_CAPACITY:
278 if (ACPI_BATTERY_CAPACITY_VALID(battery->full_charge_capacity))
279 full_capacity = battery->full_charge_capacity;
280 else if (ACPI_BATTERY_CAPACITY_VALID(battery->design_capacity))
281 full_capacity = battery->design_capacity;
282
283 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN ||
284 full_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
285 ret = -ENODEV;
286 else
287 val->intval = battery->capacity_now * 100/
288 full_capacity;
289 break;
290 case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
291 if (battery->state & ACPI_BATTERY_STATE_CRITICAL)
292 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
293 else if (test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags) &&
294 (battery->capacity_now <= battery->alarm))
295 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_LOW;
296 else if (acpi_battery_is_charged(battery))
297 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
298 else
299 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
300 break;
301 case POWER_SUPPLY_PROP_MODEL_NAME:
302 val->strval = battery->model_number;
303 break;
304 case POWER_SUPPLY_PROP_MANUFACTURER:
305 val->strval = battery->oem_info;
306 break;
307 case POWER_SUPPLY_PROP_SERIAL_NUMBER:
308 val->strval = battery->serial_number;
309 break;
310 default:
311 ret = -EINVAL;
312 }
313 return ret;
314}
315
316static enum power_supply_property charge_battery_props[] = {
317 POWER_SUPPLY_PROP_STATUS,
318 POWER_SUPPLY_PROP_PRESENT,
319 POWER_SUPPLY_PROP_TECHNOLOGY,
320 POWER_SUPPLY_PROP_CYCLE_COUNT,
321 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
322 POWER_SUPPLY_PROP_VOLTAGE_NOW,
323 POWER_SUPPLY_PROP_CURRENT_NOW,
324 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
325 POWER_SUPPLY_PROP_CHARGE_FULL,
326 POWER_SUPPLY_PROP_CHARGE_NOW,
327 POWER_SUPPLY_PROP_CAPACITY,
328 POWER_SUPPLY_PROP_CAPACITY_LEVEL,
329 POWER_SUPPLY_PROP_MODEL_NAME,
330 POWER_SUPPLY_PROP_MANUFACTURER,
331 POWER_SUPPLY_PROP_SERIAL_NUMBER,
332};
333
334static enum power_supply_property charge_battery_full_cap_broken_props[] = {
335 POWER_SUPPLY_PROP_STATUS,
336 POWER_SUPPLY_PROP_PRESENT,
337 POWER_SUPPLY_PROP_TECHNOLOGY,
338 POWER_SUPPLY_PROP_CYCLE_COUNT,
339 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
340 POWER_SUPPLY_PROP_VOLTAGE_NOW,
341 POWER_SUPPLY_PROP_CURRENT_NOW,
342 POWER_SUPPLY_PROP_CHARGE_NOW,
343 POWER_SUPPLY_PROP_MODEL_NAME,
344 POWER_SUPPLY_PROP_MANUFACTURER,
345 POWER_SUPPLY_PROP_SERIAL_NUMBER,
346};
347
348static enum power_supply_property energy_battery_props[] = {
349 POWER_SUPPLY_PROP_STATUS,
350 POWER_SUPPLY_PROP_PRESENT,
351 POWER_SUPPLY_PROP_TECHNOLOGY,
352 POWER_SUPPLY_PROP_CYCLE_COUNT,
353 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
354 POWER_SUPPLY_PROP_VOLTAGE_NOW,
355 POWER_SUPPLY_PROP_POWER_NOW,
356 POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
357 POWER_SUPPLY_PROP_ENERGY_FULL,
358 POWER_SUPPLY_PROP_ENERGY_NOW,
359 POWER_SUPPLY_PROP_CAPACITY,
360 POWER_SUPPLY_PROP_CAPACITY_LEVEL,
361 POWER_SUPPLY_PROP_MODEL_NAME,
362 POWER_SUPPLY_PROP_MANUFACTURER,
363 POWER_SUPPLY_PROP_SERIAL_NUMBER,
364};
365
366static enum power_supply_property energy_battery_full_cap_broken_props[] = {
367 POWER_SUPPLY_PROP_STATUS,
368 POWER_SUPPLY_PROP_PRESENT,
369 POWER_SUPPLY_PROP_TECHNOLOGY,
370 POWER_SUPPLY_PROP_CYCLE_COUNT,
371 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
372 POWER_SUPPLY_PROP_VOLTAGE_NOW,
373 POWER_SUPPLY_PROP_POWER_NOW,
374 POWER_SUPPLY_PROP_ENERGY_NOW,
375 POWER_SUPPLY_PROP_MODEL_NAME,
376 POWER_SUPPLY_PROP_MANUFACTURER,
377 POWER_SUPPLY_PROP_SERIAL_NUMBER,
378};
379
380/* --------------------------------------------------------------------------
381 Battery Management
382 -------------------------------------------------------------------------- */
383struct acpi_offsets {
384 size_t offset; /* offset inside struct acpi_sbs_battery */
385 u8 mode; /* int or string? */
386};
387
388static const struct acpi_offsets state_offsets[] = {
389 {offsetof(struct acpi_battery, state), 0},
390 {offsetof(struct acpi_battery, rate_now), 0},
391 {offsetof(struct acpi_battery, capacity_now), 0},
392 {offsetof(struct acpi_battery, voltage_now), 0},
393};
394
395static const struct acpi_offsets info_offsets[] = {
396 {offsetof(struct acpi_battery, power_unit), 0},
397 {offsetof(struct acpi_battery, design_capacity), 0},
398 {offsetof(struct acpi_battery, full_charge_capacity), 0},
399 {offsetof(struct acpi_battery, technology), 0},
400 {offsetof(struct acpi_battery, design_voltage), 0},
401 {offsetof(struct acpi_battery, design_capacity_warning), 0},
402 {offsetof(struct acpi_battery, design_capacity_low), 0},
403 {offsetof(struct acpi_battery, capacity_granularity_1), 0},
404 {offsetof(struct acpi_battery, capacity_granularity_2), 0},
405 {offsetof(struct acpi_battery, model_number), 1},
406 {offsetof(struct acpi_battery, serial_number), 1},
407 {offsetof(struct acpi_battery, type), 1},
408 {offsetof(struct acpi_battery, oem_info), 1},
409};
410
411static const struct acpi_offsets extended_info_offsets[] = {
412 {offsetof(struct acpi_battery, revision), 0},
413 {offsetof(struct acpi_battery, power_unit), 0},
414 {offsetof(struct acpi_battery, design_capacity), 0},
415 {offsetof(struct acpi_battery, full_charge_capacity), 0},
416 {offsetof(struct acpi_battery, technology), 0},
417 {offsetof(struct acpi_battery, design_voltage), 0},
418 {offsetof(struct acpi_battery, design_capacity_warning), 0},
419 {offsetof(struct acpi_battery, design_capacity_low), 0},
420 {offsetof(struct acpi_battery, cycle_count), 0},
421 {offsetof(struct acpi_battery, measurement_accuracy), 0},
422 {offsetof(struct acpi_battery, max_sampling_time), 0},
423 {offsetof(struct acpi_battery, min_sampling_time), 0},
424 {offsetof(struct acpi_battery, max_averaging_interval), 0},
425 {offsetof(struct acpi_battery, min_averaging_interval), 0},
426 {offsetof(struct acpi_battery, capacity_granularity_1), 0},
427 {offsetof(struct acpi_battery, capacity_granularity_2), 0},
428 {offsetof(struct acpi_battery, model_number), 1},
429 {offsetof(struct acpi_battery, serial_number), 1},
430 {offsetof(struct acpi_battery, type), 1},
431 {offsetof(struct acpi_battery, oem_info), 1},
432};
433
434static int extract_package(struct acpi_battery *battery,
435 union acpi_object *package,
436 const struct acpi_offsets *offsets, int num)
437{
438 int i;
439 union acpi_object *element;
440 if (package->type != ACPI_TYPE_PACKAGE)
441 return -EFAULT;
442 for (i = 0; i < num; ++i) {
443 if (package->package.count <= i)
444 return -EFAULT;
445 element = &package->package.elements[i];
446 if (offsets[i].mode) {
447 u8 *ptr = (u8 *)battery + offsets[i].offset;
448 if (element->type == ACPI_TYPE_STRING ||
449 element->type == ACPI_TYPE_BUFFER)
450 strncpy(ptr, element->string.pointer, 32);
451 else if (element->type == ACPI_TYPE_INTEGER) {
452 strncpy(ptr, (u8 *)&element->integer.value,
453 sizeof(u64));
454 ptr[sizeof(u64)] = 0;
455 } else
456 *ptr = 0; /* don't have value */
457 } else {
458 int *x = (int *)((u8 *)battery + offsets[i].offset);
459 *x = (element->type == ACPI_TYPE_INTEGER) ?
460 element->integer.value : -1;
461 }
462 }
463 return 0;
464}
465
466static int acpi_battery_get_status(struct acpi_battery *battery)
467{
468 if (acpi_bus_get_status(battery->device)) {
469 ACPI_EXCEPTION((AE_INFO, AE_ERROR, "Evaluating _STA"));
470 return -ENODEV;
471 }
472 return 0;
473}
474
475
476static int extract_battery_info(const int use_bix,
477 struct acpi_battery *battery,
478 const struct acpi_buffer *buffer)
479{
480 int result = -EFAULT;
481
482 if (use_bix && battery_bix_broken_package)
483 result = extract_package(battery, buffer->pointer,
484 extended_info_offsets + 1,
485 ARRAY_SIZE(extended_info_offsets) - 1);
486 else if (use_bix)
487 result = extract_package(battery, buffer->pointer,
488 extended_info_offsets,
489 ARRAY_SIZE(extended_info_offsets));
490 else
491 result = extract_package(battery, buffer->pointer,
492 info_offsets, ARRAY_SIZE(info_offsets));
493 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
494 battery->full_charge_capacity = battery->design_capacity;
495 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
496 battery->power_unit && battery->design_voltage) {
497 battery->design_capacity = battery->design_capacity *
498 10000 / battery->design_voltage;
499 battery->full_charge_capacity = battery->full_charge_capacity *
500 10000 / battery->design_voltage;
501 battery->design_capacity_warning =
502 battery->design_capacity_warning *
503 10000 / battery->design_voltage;
504 /* Curiously, design_capacity_low, unlike the rest of them,
505 is correct. */
506 /* capacity_granularity_* equal 1 on the systems tested, so
507 it's impossible to tell if they would need an adjustment
508 or not if their values were higher. */
509 }
510 if (test_bit(ACPI_BATTERY_QUIRK_DEGRADED_FULL_CHARGE, &battery->flags) &&
511 battery->capacity_now > battery->full_charge_capacity)
512 battery->capacity_now = battery->full_charge_capacity;
513
514 return result;
515}
516
517static int acpi_battery_get_info(struct acpi_battery *battery)
518{
519 const int xinfo = test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags);
520 int use_bix;
521 int result = -ENODEV;
522
523 if (!acpi_battery_present(battery))
524 return 0;
525
526
527 for (use_bix = xinfo ? 1 : 0; use_bix >= 0; use_bix--) {
528 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
529 acpi_status status = AE_ERROR;
530
531 mutex_lock(&battery->lock);
532 status = acpi_evaluate_object(battery->device->handle,
533 use_bix ? "_BIX":"_BIF",
534 NULL, &buffer);
535 mutex_unlock(&battery->lock);
536
537 if (ACPI_FAILURE(status)) {
538 ACPI_EXCEPTION((AE_INFO, status, "Evaluating %s",
539 use_bix ? "_BIX":"_BIF"));
540 } else {
541 result = extract_battery_info(use_bix,
542 battery,
543 &buffer);
544
545 kfree(buffer.pointer);
546 break;
547 }
548 }
549
550 if (!result && !use_bix && xinfo)
551 pr_warn(FW_BUG "The _BIX method is broken, using _BIF.\n");
552
553 return result;
554}
555
556static int acpi_battery_get_state(struct acpi_battery *battery)
557{
558 int result = 0;
559 acpi_status status = 0;
560 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
561
562 if (!acpi_battery_present(battery))
563 return 0;
564
565 if (battery->update_time &&
566 time_before(jiffies, battery->update_time +
567 msecs_to_jiffies(cache_time)))
568 return 0;
569
570 mutex_lock(&battery->lock);
571 status = acpi_evaluate_object(battery->device->handle, "_BST",
572 NULL, &buffer);
573 mutex_unlock(&battery->lock);
574
575 if (ACPI_FAILURE(status)) {
576 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BST"));
577 return -ENODEV;
578 }
579
580 result = extract_package(battery, buffer.pointer,
581 state_offsets, ARRAY_SIZE(state_offsets));
582 battery->update_time = jiffies;
583 kfree(buffer.pointer);
584
585 /* For buggy DSDTs that report negative 16-bit values for either
586 * charging or discharging current and/or report 0 as 65536
587 * due to bad math.
588 */
589 if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA &&
590 battery->rate_now != ACPI_BATTERY_VALUE_UNKNOWN &&
591 (s16)(battery->rate_now) < 0) {
592 battery->rate_now = abs((s16)battery->rate_now);
593 pr_warn_once(FW_BUG "battery: (dis)charge rate invalid.\n");
594 }
595
596 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags)
597 && battery->capacity_now >= 0 && battery->capacity_now <= 100)
598 battery->capacity_now = (battery->capacity_now *
599 battery->full_charge_capacity) / 100;
600 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
601 battery->power_unit && battery->design_voltage) {
602 battery->capacity_now = battery->capacity_now *
603 10000 / battery->design_voltage;
604 }
605 if (test_bit(ACPI_BATTERY_QUIRK_DEGRADED_FULL_CHARGE, &battery->flags) &&
606 battery->capacity_now > battery->full_charge_capacity)
607 battery->capacity_now = battery->full_charge_capacity;
608
609 return result;
610}
611
612static int acpi_battery_set_alarm(struct acpi_battery *battery)
613{
614 acpi_status status = 0;
615
616 if (!acpi_battery_present(battery) ||
617 !test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags))
618 return -ENODEV;
619
620 mutex_lock(&battery->lock);
621 status = acpi_execute_simple_method(battery->device->handle, "_BTP",
622 battery->alarm);
623 mutex_unlock(&battery->lock);
624
625 if (ACPI_FAILURE(status))
626 return -ENODEV;
627
628 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Alarm set to %d\n", battery->alarm));
629 return 0;
630}
631
632static int acpi_battery_init_alarm(struct acpi_battery *battery)
633{
634 /* See if alarms are supported, and if so, set default */
635 if (!acpi_has_method(battery->device->handle, "_BTP")) {
636 clear_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
637 return 0;
638 }
639 set_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
640 if (!battery->alarm)
641 battery->alarm = battery->design_capacity_warning;
642 return acpi_battery_set_alarm(battery);
643}
644
645static ssize_t acpi_battery_alarm_show(struct device *dev,
646 struct device_attribute *attr,
647 char *buf)
648{
649 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
650 return sprintf(buf, "%d\n", battery->alarm * 1000);
651}
652
653static ssize_t acpi_battery_alarm_store(struct device *dev,
654 struct device_attribute *attr,
655 const char *buf, size_t count)
656{
657 unsigned long x;
658 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
659 if (sscanf(buf, "%lu\n", &x) == 1)
660 battery->alarm = x/1000;
661 if (acpi_battery_present(battery))
662 acpi_battery_set_alarm(battery);
663 return count;
664}
665
666static const struct device_attribute alarm_attr = {
667 .attr = {.name = "alarm", .mode = 0644},
668 .show = acpi_battery_alarm_show,
669 .store = acpi_battery_alarm_store,
670};
671
672/*
673 * The Battery Hooking API
674 *
675 * This API is used inside other drivers that need to expose
676 * platform-specific behaviour within the generic driver in a
677 * generic way.
678 *
679 */
680
681static LIST_HEAD(acpi_battery_list);
682static LIST_HEAD(battery_hook_list);
683static DEFINE_MUTEX(hook_mutex);
684
685static void __battery_hook_unregister(struct acpi_battery_hook *hook, int lock)
686{
687 struct acpi_battery *battery;
688 /*
689 * In order to remove a hook, we first need to
690 * de-register all the batteries that are registered.
691 */
692 if (lock)
693 mutex_lock(&hook_mutex);
694 list_for_each_entry(battery, &acpi_battery_list, list) {
695 hook->remove_battery(battery->bat);
696 }
697 list_del(&hook->list);
698 if (lock)
699 mutex_unlock(&hook_mutex);
700 pr_info("extension unregistered: %s\n", hook->name);
701}
702
703void battery_hook_unregister(struct acpi_battery_hook *hook)
704{
705 __battery_hook_unregister(hook, 1);
706}
707EXPORT_SYMBOL_GPL(battery_hook_unregister);
708
709void battery_hook_register(struct acpi_battery_hook *hook)
710{
711 struct acpi_battery *battery;
712
713 mutex_lock(&hook_mutex);
714 INIT_LIST_HEAD(&hook->list);
715 list_add(&hook->list, &battery_hook_list);
716 /*
717 * Now that the driver is registered, we need
718 * to notify the hook that a battery is available
719 * for each battery, so that the driver may add
720 * its attributes.
721 */
722 list_for_each_entry(battery, &acpi_battery_list, list) {
723 if (hook->add_battery(battery->bat)) {
724 /*
725 * If a add-battery returns non-zero,
726 * the registration of the extension has failed,
727 * and we will not add it to the list of loaded
728 * hooks.
729 */
730 pr_err("extension failed to load: %s", hook->name);
731 __battery_hook_unregister(hook, 0);
732 goto end;
733 }
734 }
735 pr_info("new extension: %s\n", hook->name);
736end:
737 mutex_unlock(&hook_mutex);
738}
739EXPORT_SYMBOL_GPL(battery_hook_register);
740
741/*
742 * This function gets called right after the battery sysfs
743 * attributes have been added, so that the drivers that
744 * define custom sysfs attributes can add their own.
745*/
746static void battery_hook_add_battery(struct acpi_battery *battery)
747{
748 struct acpi_battery_hook *hook_node, *tmp;
749
750 mutex_lock(&hook_mutex);
751 INIT_LIST_HEAD(&battery->list);
752 list_add(&battery->list, &acpi_battery_list);
753 /*
754 * Since we added a new battery to the list, we need to
755 * iterate over the hooks and call add_battery for each
756 * hook that was registered. This usually happens
757 * when a battery gets hotplugged or initialized
758 * during the battery module initialization.
759 */
760 list_for_each_entry_safe(hook_node, tmp, &battery_hook_list, list) {
761 if (hook_node->add_battery(battery->bat)) {
762 /*
763 * The notification of the extensions has failed, to
764 * prevent further errors we will unload the extension.
765 */
766 pr_err("error in extension, unloading: %s",
767 hook_node->name);
768 __battery_hook_unregister(hook_node, 0);
769 }
770 }
771 mutex_unlock(&hook_mutex);
772}
773
774static void battery_hook_remove_battery(struct acpi_battery *battery)
775{
776 struct acpi_battery_hook *hook;
777
778 mutex_lock(&hook_mutex);
779 /*
780 * Before removing the hook, we need to remove all
781 * custom attributes from the battery.
782 */
783 list_for_each_entry(hook, &battery_hook_list, list) {
784 hook->remove_battery(battery->bat);
785 }
786 /* Then, just remove the battery from the list */
787 list_del(&battery->list);
788 mutex_unlock(&hook_mutex);
789}
790
791static void __exit battery_hook_exit(void)
792{
793 struct acpi_battery_hook *hook;
794 struct acpi_battery_hook *ptr;
795 /*
796 * At this point, the acpi_bus_unregister_driver()
797 * has called remove for all batteries. We just
798 * need to remove the hooks.
799 */
800 list_for_each_entry_safe(hook, ptr, &battery_hook_list, list) {
801 __battery_hook_unregister(hook, 1);
802 }
803 mutex_destroy(&hook_mutex);
804}
805
806static int sysfs_add_battery(struct acpi_battery *battery)
807{
808 struct power_supply_config psy_cfg = { .drv_data = battery, };
809 bool full_cap_broken = false;
810
811 if (!ACPI_BATTERY_CAPACITY_VALID(battery->full_charge_capacity) &&
812 !ACPI_BATTERY_CAPACITY_VALID(battery->design_capacity))
813 full_cap_broken = true;
814
815 if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) {
816 if (full_cap_broken) {
817 battery->bat_desc.properties =
818 charge_battery_full_cap_broken_props;
819 battery->bat_desc.num_properties =
820 ARRAY_SIZE(charge_battery_full_cap_broken_props);
821 } else {
822 battery->bat_desc.properties = charge_battery_props;
823 battery->bat_desc.num_properties =
824 ARRAY_SIZE(charge_battery_props);
825 }
826 } else {
827 if (full_cap_broken) {
828 battery->bat_desc.properties =
829 energy_battery_full_cap_broken_props;
830 battery->bat_desc.num_properties =
831 ARRAY_SIZE(energy_battery_full_cap_broken_props);
832 } else {
833 battery->bat_desc.properties = energy_battery_props;
834 battery->bat_desc.num_properties =
835 ARRAY_SIZE(energy_battery_props);
836 }
837 }
838
839 battery->bat_desc.name = acpi_device_bid(battery->device);
840 battery->bat_desc.type = POWER_SUPPLY_TYPE_BATTERY;
841 battery->bat_desc.get_property = acpi_battery_get_property;
842
843 battery->bat = power_supply_register_no_ws(&battery->device->dev,
844 &battery->bat_desc, &psy_cfg);
845
846 if (IS_ERR(battery->bat)) {
847 int result = PTR_ERR(battery->bat);
848
849 battery->bat = NULL;
850 return result;
851 }
852 battery_hook_add_battery(battery);
853 return device_create_file(&battery->bat->dev, &alarm_attr);
854}
855
856static void sysfs_remove_battery(struct acpi_battery *battery)
857{
858 mutex_lock(&battery->sysfs_lock);
859 if (!battery->bat) {
860 mutex_unlock(&battery->sysfs_lock);
861 return;
862 }
863 battery_hook_remove_battery(battery);
864 device_remove_file(&battery->bat->dev, &alarm_attr);
865 power_supply_unregister(battery->bat);
866 battery->bat = NULL;
867 mutex_unlock(&battery->sysfs_lock);
868}
869
870static void find_battery(const struct dmi_header *dm, void *private)
871{
872 struct acpi_battery *battery = (struct acpi_battery *)private;
873 /* Note: the hardcoded offsets below have been extracted from
874 the source code of dmidecode. */
875 if (dm->type == DMI_ENTRY_PORTABLE_BATTERY && dm->length >= 8) {
876 const u8 *dmi_data = (const u8 *)(dm + 1);
877 int dmi_capacity = get_unaligned((const u16 *)(dmi_data + 6));
878 if (dm->length >= 18)
879 dmi_capacity *= dmi_data[17];
880 if (battery->design_capacity * battery->design_voltage / 1000
881 != dmi_capacity &&
882 battery->design_capacity * 10 == dmi_capacity)
883 set_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
884 &battery->flags);
885 }
886}
887
888/*
889 * According to the ACPI spec, some kinds of primary batteries can
890 * report percentage battery remaining capacity directly to OS.
891 * In this case, it reports the Last Full Charged Capacity == 100
892 * and BatteryPresentRate == 0xFFFFFFFF.
893 *
894 * Now we found some battery reports percentage remaining capacity
895 * even if it's rechargeable.
896 * https://bugzilla.kernel.org/show_bug.cgi?id=15979
897 *
898 * Handle this correctly so that they won't break userspace.
899 */
900static void acpi_battery_quirks(struct acpi_battery *battery)
901{
902 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
903 return;
904
905 if (battery->full_charge_capacity == 100 &&
906 battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN &&
907 battery->capacity_now >= 0 && battery->capacity_now <= 100) {
908 set_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags);
909 battery->full_charge_capacity = battery->design_capacity;
910 battery->capacity_now = (battery->capacity_now *
911 battery->full_charge_capacity) / 100;
912 }
913
914 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags))
915 return;
916
917 if (battery->power_unit && dmi_name_in_vendors("LENOVO")) {
918 const char *s;
919 s = dmi_get_system_info(DMI_PRODUCT_VERSION);
920 if (s && !strncasecmp(s, "ThinkPad", 8)) {
921 dmi_walk(find_battery, battery);
922 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
923 &battery->flags) &&
924 battery->design_voltage) {
925 battery->design_capacity =
926 battery->design_capacity *
927 10000 / battery->design_voltage;
928 battery->full_charge_capacity =
929 battery->full_charge_capacity *
930 10000 / battery->design_voltage;
931 battery->design_capacity_warning =
932 battery->design_capacity_warning *
933 10000 / battery->design_voltage;
934 battery->capacity_now = battery->capacity_now *
935 10000 / battery->design_voltage;
936 }
937 }
938 }
939
940 if (test_bit(ACPI_BATTERY_QUIRK_DEGRADED_FULL_CHARGE, &battery->flags))
941 return;
942
943 if (acpi_battery_is_degraded(battery) &&
944 battery->capacity_now > battery->full_charge_capacity) {
945 set_bit(ACPI_BATTERY_QUIRK_DEGRADED_FULL_CHARGE, &battery->flags);
946 battery->capacity_now = battery->full_charge_capacity;
947 }
948}
949
950static int acpi_battery_update(struct acpi_battery *battery, bool resume)
951{
952 int result = acpi_battery_get_status(battery);
953
954 if (result)
955 return result;
956
957 if (!acpi_battery_present(battery)) {
958 sysfs_remove_battery(battery);
959 battery->update_time = 0;
960 return 0;
961 }
962
963 if (resume)
964 return 0;
965
966 if (!battery->update_time) {
967 result = acpi_battery_get_info(battery);
968 if (result)
969 return result;
970 acpi_battery_init_alarm(battery);
971 }
972
973 result = acpi_battery_get_state(battery);
974 if (result)
975 return result;
976 acpi_battery_quirks(battery);
977
978 if (!battery->bat) {
979 result = sysfs_add_battery(battery);
980 if (result)
981 return result;
982 }
983
984 /*
985 * Wakeup the system if battery is critical low
986 * or lower than the alarm level
987 */
988 if ((battery->state & ACPI_BATTERY_STATE_CRITICAL) ||
989 (test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags) &&
990 (battery->capacity_now <= battery->alarm)))
991 acpi_pm_wakeup_event(&battery->device->dev);
992
993 return result;
994}
995
996static void acpi_battery_refresh(struct acpi_battery *battery)
997{
998 int power_unit;
999
1000 if (!battery->bat)
1001 return;
1002
1003 power_unit = battery->power_unit;
1004
1005 acpi_battery_get_info(battery);
1006
1007 if (power_unit == battery->power_unit)
1008 return;
1009
1010 /* The battery has changed its reporting units. */
1011 sysfs_remove_battery(battery);
1012 sysfs_add_battery(battery);
1013}
1014
1015/* --------------------------------------------------------------------------
1016 Driver Interface
1017 -------------------------------------------------------------------------- */
1018
1019static void acpi_battery_notify(struct acpi_device *device, u32 event)
1020{
1021 struct acpi_battery *battery = acpi_driver_data(device);
1022 struct power_supply *old;
1023
1024 if (!battery)
1025 return;
1026 old = battery->bat;
1027 /*
1028 * On Acer Aspire V5-573G notifications are sometimes triggered too
1029 * early. For example, when AC is unplugged and notification is
1030 * triggered, battery state is still reported as "Full", and changes to
1031 * "Discharging" only after short delay, without any notification.
1032 */
1033 if (battery_notification_delay_ms > 0)
1034 msleep(battery_notification_delay_ms);
1035 if (event == ACPI_BATTERY_NOTIFY_INFO)
1036 acpi_battery_refresh(battery);
1037 acpi_battery_update(battery, false);
1038 acpi_bus_generate_netlink_event(device->pnp.device_class,
1039 dev_name(&device->dev), event,
1040 acpi_battery_present(battery));
1041 acpi_notifier_call_chain(device, event, acpi_battery_present(battery));
1042 /* acpi_battery_update could remove power_supply object */
1043 if (old && battery->bat)
1044 power_supply_changed(battery->bat);
1045}
1046
1047static int battery_notify(struct notifier_block *nb,
1048 unsigned long mode, void *_unused)
1049{
1050 struct acpi_battery *battery = container_of(nb, struct acpi_battery,
1051 pm_nb);
1052 int result;
1053
1054 switch (mode) {
1055 case PM_POST_HIBERNATION:
1056 case PM_POST_SUSPEND:
1057 if (!acpi_battery_present(battery))
1058 return 0;
1059
1060 if (battery->bat) {
1061 acpi_battery_refresh(battery);
1062 } else {
1063 result = acpi_battery_get_info(battery);
1064 if (result)
1065 return result;
1066
1067 result = sysfs_add_battery(battery);
1068 if (result)
1069 return result;
1070 }
1071
1072 acpi_battery_init_alarm(battery);
1073 acpi_battery_get_state(battery);
1074 break;
1075 }
1076
1077 return 0;
1078}
1079
1080static int __init
1081battery_bix_broken_package_quirk(const struct dmi_system_id *d)
1082{
1083 battery_bix_broken_package = 1;
1084 return 0;
1085}
1086
1087static int __init
1088battery_notification_delay_quirk(const struct dmi_system_id *d)
1089{
1090 battery_notification_delay_ms = 1000;
1091 return 0;
1092}
1093
1094static int __init
1095battery_ac_is_broken_quirk(const struct dmi_system_id *d)
1096{
1097 battery_ac_is_broken = 1;
1098 return 0;
1099}
1100
1101static int __init
1102battery_do_not_check_pmic_quirk(const struct dmi_system_id *d)
1103{
1104 battery_check_pmic = 0;
1105 return 0;
1106}
1107
1108static const struct dmi_system_id bat_dmi_table[] __initconst = {
1109 {
1110 /* NEC LZ750/LS */
1111 .callback = battery_bix_broken_package_quirk,
1112 .matches = {
1113 DMI_MATCH(DMI_SYS_VENDOR, "NEC"),
1114 DMI_MATCH(DMI_PRODUCT_NAME, "PC-LZ750LS"),
1115 },
1116 },
1117 {
1118 /* Acer Aspire V5-573G */
1119 .callback = battery_notification_delay_quirk,
1120 .matches = {
1121 DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
1122 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire V5-573G"),
1123 },
1124 },
1125 {
1126 /* Point of View mobii wintab p800w */
1127 .callback = battery_ac_is_broken_quirk,
1128 .matches = {
1129 DMI_MATCH(DMI_BOARD_VENDOR, "AMI Corporation"),
1130 DMI_MATCH(DMI_BOARD_NAME, "Aptio CRB"),
1131 DMI_MATCH(DMI_BIOS_VERSION, "3BAIR1013"),
1132 /* Above matches are too generic, add bios-date match */
1133 DMI_MATCH(DMI_BIOS_DATE, "08/22/2014"),
1134 },
1135 },
1136 {
1137 /* ECS EF20EA, AXP288 PMIC but uses separate fuel-gauge */
1138 .callback = battery_do_not_check_pmic_quirk,
1139 .matches = {
1140 DMI_MATCH(DMI_PRODUCT_NAME, "EF20EA"),
1141 },
1142 },
1143 {
1144 /* Lenovo Ideapad Miix 320, AXP288 PMIC, separate fuel-gauge */
1145 .callback = battery_do_not_check_pmic_quirk,
1146 .matches = {
1147 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
1148 DMI_MATCH(DMI_PRODUCT_NAME, "80XF"),
1149 DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo MIIX 320-10ICR"),
1150 },
1151 },
1152 {},
1153};
1154
1155/*
1156 * Some machines'(E,G Lenovo Z480) ECs are not stable
1157 * during boot up and this causes battery driver fails to be
1158 * probed due to failure of getting battery information
1159 * from EC sometimes. After several retries, the operation
1160 * may work. So add retry code here and 20ms sleep between
1161 * every retries.
1162 */
1163static int acpi_battery_update_retry(struct acpi_battery *battery)
1164{
1165 int retry, ret;
1166
1167 for (retry = 5; retry; retry--) {
1168 ret = acpi_battery_update(battery, false);
1169 if (!ret)
1170 break;
1171
1172 msleep(20);
1173 }
1174 return ret;
1175}
1176
1177static int acpi_battery_add(struct acpi_device *device)
1178{
1179 int result = 0;
1180 struct acpi_battery *battery = NULL;
1181
1182 if (!device)
1183 return -EINVAL;
1184
1185 if (device->dep_unmet)
1186 return -EPROBE_DEFER;
1187
1188 battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL);
1189 if (!battery)
1190 return -ENOMEM;
1191 battery->device = device;
1192 strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME);
1193 strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS);
1194 device->driver_data = battery;
1195 mutex_init(&battery->lock);
1196 mutex_init(&battery->sysfs_lock);
1197 if (acpi_has_method(battery->device->handle, "_BIX"))
1198 set_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags);
1199
1200 result = acpi_battery_update_retry(battery);
1201 if (result)
1202 goto fail;
1203
1204 pr_info(PREFIX "%s Slot [%s] (battery %s)\n",
1205 ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device),
1206 device->status.battery_present ? "present" : "absent");
1207
1208 battery->pm_nb.notifier_call = battery_notify;
1209 register_pm_notifier(&battery->pm_nb);
1210
1211 device_init_wakeup(&device->dev, 1);
1212
1213 return result;
1214
1215fail:
1216 sysfs_remove_battery(battery);
1217 mutex_destroy(&battery->lock);
1218 mutex_destroy(&battery->sysfs_lock);
1219 kfree(battery);
1220 return result;
1221}
1222
1223static int acpi_battery_remove(struct acpi_device *device)
1224{
1225 struct acpi_battery *battery = NULL;
1226
1227 if (!device || !acpi_driver_data(device))
1228 return -EINVAL;
1229 device_init_wakeup(&device->dev, 0);
1230 battery = acpi_driver_data(device);
1231 unregister_pm_notifier(&battery->pm_nb);
1232 sysfs_remove_battery(battery);
1233 mutex_destroy(&battery->lock);
1234 mutex_destroy(&battery->sysfs_lock);
1235 kfree(battery);
1236 return 0;
1237}
1238
1239#ifdef CONFIG_PM_SLEEP
1240/* this is needed to learn about changes made in suspended state */
1241static int acpi_battery_resume(struct device *dev)
1242{
1243 struct acpi_battery *battery;
1244
1245 if (!dev)
1246 return -EINVAL;
1247
1248 battery = acpi_driver_data(to_acpi_device(dev));
1249 if (!battery)
1250 return -EINVAL;
1251
1252 battery->update_time = 0;
1253 acpi_battery_update(battery, true);
1254 return 0;
1255}
1256#else
1257#define acpi_battery_resume NULL
1258#endif
1259
1260static SIMPLE_DEV_PM_OPS(acpi_battery_pm, NULL, acpi_battery_resume);
1261
1262static struct acpi_driver acpi_battery_driver = {
1263 .name = "battery",
1264 .class = ACPI_BATTERY_CLASS,
1265 .ids = battery_device_ids,
1266 .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
1267 .ops = {
1268 .add = acpi_battery_add,
1269 .remove = acpi_battery_remove,
1270 .notify = acpi_battery_notify,
1271 },
1272 .drv.pm = &acpi_battery_pm,
1273};
1274
1275static void __init acpi_battery_init_async(void *unused, async_cookie_t cookie)
1276{
1277 unsigned int i;
1278 int result;
1279
1280 dmi_check_system(bat_dmi_table);
1281
1282 if (battery_check_pmic) {
1283 for (i = 0; i < ARRAY_SIZE(acpi_battery_blacklist); i++)
1284 if (acpi_dev_present(acpi_battery_blacklist[i], "1", -1)) {
1285 pr_info(PREFIX ACPI_BATTERY_DEVICE_NAME
1286 ": found native %s PMIC, not loading\n",
1287 acpi_battery_blacklist[i]);
1288 return;
1289 }
1290 }
1291
1292 result = acpi_bus_register_driver(&acpi_battery_driver);
1293 battery_driver_registered = (result == 0);
1294}
1295
1296static int __init acpi_battery_init(void)
1297{
1298 if (acpi_disabled)
1299 return -ENODEV;
1300
1301 async_cookie = async_schedule(acpi_battery_init_async, NULL);
1302 return 0;
1303}
1304
1305static void __exit acpi_battery_exit(void)
1306{
1307 async_synchronize_cookie(async_cookie + 1);
1308 if (battery_driver_registered) {
1309 acpi_bus_unregister_driver(&acpi_battery_driver);
1310 battery_hook_exit();
1311 }
1312}
1313
1314module_init(acpi_battery_init);
1315module_exit(acpi_battery_exit);
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * battery.c - ACPI Battery Driver (Revision: 2.0)
4 *
5 * Copyright (C) 2007 Alexey Starikovskiy <astarikovskiy@suse.de>
6 * Copyright (C) 2004-2007 Vladimir Lebedev <vladimir.p.lebedev@intel.com>
7 * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
8 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
9 */
10
11#define pr_fmt(fmt) "ACPI: battery: " fmt
12
13#include <linux/async.h>
14#include <linux/delay.h>
15#include <linux/dmi.h>
16#include <linux/jiffies.h>
17#include <linux/kernel.h>
18#include <linux/list.h>
19#include <linux/module.h>
20#include <linux/mutex.h>
21#include <linux/slab.h>
22#include <linux/suspend.h>
23#include <linux/types.h>
24
25#include <asm/unaligned.h>
26
27#include <linux/acpi.h>
28#include <linux/power_supply.h>
29
30#include <acpi/battery.h>
31
32#define ACPI_BATTERY_VALUE_UNKNOWN 0xFFFFFFFF
33#define ACPI_BATTERY_CAPACITY_VALID(capacity) \
34 ((capacity) != 0 && (capacity) != ACPI_BATTERY_VALUE_UNKNOWN)
35
36#define ACPI_BATTERY_DEVICE_NAME "Battery"
37
38/* Battery power unit: 0 means mW, 1 means mA */
39#define ACPI_BATTERY_POWER_UNIT_MA 1
40
41#define ACPI_BATTERY_STATE_DISCHARGING 0x1
42#define ACPI_BATTERY_STATE_CHARGING 0x2
43#define ACPI_BATTERY_STATE_CRITICAL 0x4
44
45MODULE_AUTHOR("Paul Diefenbaugh");
46MODULE_AUTHOR("Alexey Starikovskiy <astarikovskiy@suse.de>");
47MODULE_DESCRIPTION("ACPI Battery Driver");
48MODULE_LICENSE("GPL");
49
50static async_cookie_t async_cookie;
51static bool battery_driver_registered;
52static int battery_bix_broken_package;
53static int battery_notification_delay_ms;
54static int battery_ac_is_broken;
55static int battery_check_pmic = 1;
56static unsigned int cache_time = 1000;
57module_param(cache_time, uint, 0644);
58MODULE_PARM_DESC(cache_time, "cache time in milliseconds");
59
60static const struct acpi_device_id battery_device_ids[] = {
61 {"PNP0C0A", 0},
62 {"", 0},
63};
64
65MODULE_DEVICE_TABLE(acpi, battery_device_ids);
66
67/* Lists of PMIC ACPI HIDs with an (often better) native battery driver */
68static const char * const acpi_battery_blacklist[] = {
69 "INT33F4", /* X-Powers AXP288 PMIC */
70};
71
72enum {
73 ACPI_BATTERY_ALARM_PRESENT,
74 ACPI_BATTERY_XINFO_PRESENT,
75 ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY,
76 /* On Lenovo Thinkpad models from 2010 and 2011, the power unit
77 * switches between mWh and mAh depending on whether the system
78 * is running on battery or not. When mAh is the unit, most
79 * reported values are incorrect and need to be adjusted by
80 * 10000/design_voltage. Verified on x201, t410, t410s, and x220.
81 * Pre-2010 and 2012 models appear to always report in mWh and
82 * are thus unaffected (tested with t42, t61, t500, x200, x300,
83 * and x230). Also, in mid-2012 Lenovo issued a BIOS update for
84 * the 2011 models that fixes the issue (tested on x220 with a
85 * post-1.29 BIOS), but as of Nov. 2012, no such update is
86 * available for the 2010 models.
87 */
88 ACPI_BATTERY_QUIRK_THINKPAD_MAH,
89 /* for batteries reporting current capacity with design capacity
90 * on a full charge, but showing degradation in full charge cap.
91 */
92 ACPI_BATTERY_QUIRK_DEGRADED_FULL_CHARGE,
93};
94
95struct acpi_battery {
96 struct mutex lock;
97 struct mutex sysfs_lock;
98 struct power_supply *bat;
99 struct power_supply_desc bat_desc;
100 struct acpi_device *device;
101 struct notifier_block pm_nb;
102 struct list_head list;
103 unsigned long update_time;
104 int revision;
105 int rate_now;
106 int capacity_now;
107 int voltage_now;
108 int design_capacity;
109 int full_charge_capacity;
110 int technology;
111 int design_voltage;
112 int design_capacity_warning;
113 int design_capacity_low;
114 int cycle_count;
115 int measurement_accuracy;
116 int max_sampling_time;
117 int min_sampling_time;
118 int max_averaging_interval;
119 int min_averaging_interval;
120 int capacity_granularity_1;
121 int capacity_granularity_2;
122 int alarm;
123 char model_number[32];
124 char serial_number[32];
125 char type[32];
126 char oem_info[32];
127 int state;
128 int power_unit;
129 unsigned long flags;
130};
131
132#define to_acpi_battery(x) power_supply_get_drvdata(x)
133
134static inline int acpi_battery_present(struct acpi_battery *battery)
135{
136 return battery->device->status.battery_present;
137}
138
139static int acpi_battery_technology(struct acpi_battery *battery)
140{
141 if (!strcasecmp("NiCd", battery->type))
142 return POWER_SUPPLY_TECHNOLOGY_NiCd;
143 if (!strcasecmp("NiMH", battery->type))
144 return POWER_SUPPLY_TECHNOLOGY_NiMH;
145 if (!strcasecmp("LION", battery->type))
146 return POWER_SUPPLY_TECHNOLOGY_LION;
147 if (!strncasecmp("LI-ION", battery->type, 6))
148 return POWER_SUPPLY_TECHNOLOGY_LION;
149 if (!strcasecmp("LiP", battery->type))
150 return POWER_SUPPLY_TECHNOLOGY_LIPO;
151 return POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
152}
153
154static int acpi_battery_get_state(struct acpi_battery *battery);
155
156static int acpi_battery_is_charged(struct acpi_battery *battery)
157{
158 /* charging, discharging or critical low */
159 if (battery->state != 0)
160 return 0;
161
162 /* battery not reporting charge */
163 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN ||
164 battery->capacity_now == 0)
165 return 0;
166
167 /* good batteries update full_charge as the batteries degrade */
168 if (battery->full_charge_capacity == battery->capacity_now)
169 return 1;
170
171 /* fallback to using design values for broken batteries */
172 if (battery->design_capacity == battery->capacity_now)
173 return 1;
174
175 /* we don't do any sort of metric based on percentages */
176 return 0;
177}
178
179static bool acpi_battery_is_degraded(struct acpi_battery *battery)
180{
181 return ACPI_BATTERY_CAPACITY_VALID(battery->full_charge_capacity) &&
182 ACPI_BATTERY_CAPACITY_VALID(battery->design_capacity) &&
183 battery->full_charge_capacity < battery->design_capacity;
184}
185
186static int acpi_battery_handle_discharging(struct acpi_battery *battery)
187{
188 /*
189 * Some devices wrongly report discharging if the battery's charge level
190 * was above the device's start charging threshold atm the AC adapter
191 * was plugged in and the device thus did not start a new charge cycle.
192 */
193 if ((battery_ac_is_broken || power_supply_is_system_supplied()) &&
194 battery->rate_now == 0)
195 return POWER_SUPPLY_STATUS_NOT_CHARGING;
196
197 return POWER_SUPPLY_STATUS_DISCHARGING;
198}
199
200static int acpi_battery_get_property(struct power_supply *psy,
201 enum power_supply_property psp,
202 union power_supply_propval *val)
203{
204 int full_capacity = ACPI_BATTERY_VALUE_UNKNOWN, ret = 0;
205 struct acpi_battery *battery = to_acpi_battery(psy);
206
207 if (acpi_battery_present(battery)) {
208 /* run battery update only if it is present */
209 acpi_battery_get_state(battery);
210 } else if (psp != POWER_SUPPLY_PROP_PRESENT)
211 return -ENODEV;
212 switch (psp) {
213 case POWER_SUPPLY_PROP_STATUS:
214 if (battery->state & ACPI_BATTERY_STATE_DISCHARGING)
215 val->intval = acpi_battery_handle_discharging(battery);
216 else if (battery->state & ACPI_BATTERY_STATE_CHARGING)
217 val->intval = POWER_SUPPLY_STATUS_CHARGING;
218 else if (acpi_battery_is_charged(battery))
219 val->intval = POWER_SUPPLY_STATUS_FULL;
220 else
221 val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
222 break;
223 case POWER_SUPPLY_PROP_PRESENT:
224 val->intval = acpi_battery_present(battery);
225 break;
226 case POWER_SUPPLY_PROP_TECHNOLOGY:
227 val->intval = acpi_battery_technology(battery);
228 break;
229 case POWER_SUPPLY_PROP_CYCLE_COUNT:
230 val->intval = battery->cycle_count;
231 break;
232 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
233 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
234 ret = -ENODEV;
235 else
236 val->intval = battery->design_voltage * 1000;
237 break;
238 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
239 if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
240 ret = -ENODEV;
241 else
242 val->intval = battery->voltage_now * 1000;
243 break;
244 case POWER_SUPPLY_PROP_CURRENT_NOW:
245 case POWER_SUPPLY_PROP_POWER_NOW:
246 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
247 ret = -ENODEV;
248 else
249 val->intval = battery->rate_now * 1000;
250 break;
251 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
252 case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
253 if (!ACPI_BATTERY_CAPACITY_VALID(battery->design_capacity))
254 ret = -ENODEV;
255 else
256 val->intval = battery->design_capacity * 1000;
257 break;
258 case POWER_SUPPLY_PROP_CHARGE_FULL:
259 case POWER_SUPPLY_PROP_ENERGY_FULL:
260 if (!ACPI_BATTERY_CAPACITY_VALID(battery->full_charge_capacity))
261 ret = -ENODEV;
262 else
263 val->intval = battery->full_charge_capacity * 1000;
264 break;
265 case POWER_SUPPLY_PROP_CHARGE_NOW:
266 case POWER_SUPPLY_PROP_ENERGY_NOW:
267 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
268 ret = -ENODEV;
269 else
270 val->intval = battery->capacity_now * 1000;
271 break;
272 case POWER_SUPPLY_PROP_CAPACITY:
273 if (ACPI_BATTERY_CAPACITY_VALID(battery->full_charge_capacity))
274 full_capacity = battery->full_charge_capacity;
275 else if (ACPI_BATTERY_CAPACITY_VALID(battery->design_capacity))
276 full_capacity = battery->design_capacity;
277
278 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN ||
279 full_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
280 ret = -ENODEV;
281 else
282 val->intval = battery->capacity_now * 100/
283 full_capacity;
284 break;
285 case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
286 if (battery->state & ACPI_BATTERY_STATE_CRITICAL)
287 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
288 else if (test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags) &&
289 (battery->capacity_now <= battery->alarm))
290 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_LOW;
291 else if (acpi_battery_is_charged(battery))
292 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
293 else
294 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
295 break;
296 case POWER_SUPPLY_PROP_MODEL_NAME:
297 val->strval = battery->model_number;
298 break;
299 case POWER_SUPPLY_PROP_MANUFACTURER:
300 val->strval = battery->oem_info;
301 break;
302 case POWER_SUPPLY_PROP_SERIAL_NUMBER:
303 val->strval = battery->serial_number;
304 break;
305 default:
306 ret = -EINVAL;
307 }
308 return ret;
309}
310
311static enum power_supply_property charge_battery_props[] = {
312 POWER_SUPPLY_PROP_STATUS,
313 POWER_SUPPLY_PROP_PRESENT,
314 POWER_SUPPLY_PROP_TECHNOLOGY,
315 POWER_SUPPLY_PROP_CYCLE_COUNT,
316 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
317 POWER_SUPPLY_PROP_VOLTAGE_NOW,
318 POWER_SUPPLY_PROP_CURRENT_NOW,
319 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
320 POWER_SUPPLY_PROP_CHARGE_FULL,
321 POWER_SUPPLY_PROP_CHARGE_NOW,
322 POWER_SUPPLY_PROP_CAPACITY,
323 POWER_SUPPLY_PROP_CAPACITY_LEVEL,
324 POWER_SUPPLY_PROP_MODEL_NAME,
325 POWER_SUPPLY_PROP_MANUFACTURER,
326 POWER_SUPPLY_PROP_SERIAL_NUMBER,
327};
328
329static enum power_supply_property charge_battery_full_cap_broken_props[] = {
330 POWER_SUPPLY_PROP_STATUS,
331 POWER_SUPPLY_PROP_PRESENT,
332 POWER_SUPPLY_PROP_TECHNOLOGY,
333 POWER_SUPPLY_PROP_CYCLE_COUNT,
334 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
335 POWER_SUPPLY_PROP_VOLTAGE_NOW,
336 POWER_SUPPLY_PROP_CURRENT_NOW,
337 POWER_SUPPLY_PROP_CHARGE_NOW,
338 POWER_SUPPLY_PROP_MODEL_NAME,
339 POWER_SUPPLY_PROP_MANUFACTURER,
340 POWER_SUPPLY_PROP_SERIAL_NUMBER,
341};
342
343static enum power_supply_property energy_battery_props[] = {
344 POWER_SUPPLY_PROP_STATUS,
345 POWER_SUPPLY_PROP_PRESENT,
346 POWER_SUPPLY_PROP_TECHNOLOGY,
347 POWER_SUPPLY_PROP_CYCLE_COUNT,
348 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
349 POWER_SUPPLY_PROP_VOLTAGE_NOW,
350 POWER_SUPPLY_PROP_POWER_NOW,
351 POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
352 POWER_SUPPLY_PROP_ENERGY_FULL,
353 POWER_SUPPLY_PROP_ENERGY_NOW,
354 POWER_SUPPLY_PROP_CAPACITY,
355 POWER_SUPPLY_PROP_CAPACITY_LEVEL,
356 POWER_SUPPLY_PROP_MODEL_NAME,
357 POWER_SUPPLY_PROP_MANUFACTURER,
358 POWER_SUPPLY_PROP_SERIAL_NUMBER,
359};
360
361static enum power_supply_property energy_battery_full_cap_broken_props[] = {
362 POWER_SUPPLY_PROP_STATUS,
363 POWER_SUPPLY_PROP_PRESENT,
364 POWER_SUPPLY_PROP_TECHNOLOGY,
365 POWER_SUPPLY_PROP_CYCLE_COUNT,
366 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
367 POWER_SUPPLY_PROP_VOLTAGE_NOW,
368 POWER_SUPPLY_PROP_POWER_NOW,
369 POWER_SUPPLY_PROP_ENERGY_NOW,
370 POWER_SUPPLY_PROP_MODEL_NAME,
371 POWER_SUPPLY_PROP_MANUFACTURER,
372 POWER_SUPPLY_PROP_SERIAL_NUMBER,
373};
374
375/* Battery Management */
376struct acpi_offsets {
377 size_t offset; /* offset inside struct acpi_sbs_battery */
378 u8 mode; /* int or string? */
379};
380
381static const struct acpi_offsets state_offsets[] = {
382 {offsetof(struct acpi_battery, state), 0},
383 {offsetof(struct acpi_battery, rate_now), 0},
384 {offsetof(struct acpi_battery, capacity_now), 0},
385 {offsetof(struct acpi_battery, voltage_now), 0},
386};
387
388static const struct acpi_offsets info_offsets[] = {
389 {offsetof(struct acpi_battery, power_unit), 0},
390 {offsetof(struct acpi_battery, design_capacity), 0},
391 {offsetof(struct acpi_battery, full_charge_capacity), 0},
392 {offsetof(struct acpi_battery, technology), 0},
393 {offsetof(struct acpi_battery, design_voltage), 0},
394 {offsetof(struct acpi_battery, design_capacity_warning), 0},
395 {offsetof(struct acpi_battery, design_capacity_low), 0},
396 {offsetof(struct acpi_battery, capacity_granularity_1), 0},
397 {offsetof(struct acpi_battery, capacity_granularity_2), 0},
398 {offsetof(struct acpi_battery, model_number), 1},
399 {offsetof(struct acpi_battery, serial_number), 1},
400 {offsetof(struct acpi_battery, type), 1},
401 {offsetof(struct acpi_battery, oem_info), 1},
402};
403
404static const struct acpi_offsets extended_info_offsets[] = {
405 {offsetof(struct acpi_battery, revision), 0},
406 {offsetof(struct acpi_battery, power_unit), 0},
407 {offsetof(struct acpi_battery, design_capacity), 0},
408 {offsetof(struct acpi_battery, full_charge_capacity), 0},
409 {offsetof(struct acpi_battery, technology), 0},
410 {offsetof(struct acpi_battery, design_voltage), 0},
411 {offsetof(struct acpi_battery, design_capacity_warning), 0},
412 {offsetof(struct acpi_battery, design_capacity_low), 0},
413 {offsetof(struct acpi_battery, cycle_count), 0},
414 {offsetof(struct acpi_battery, measurement_accuracy), 0},
415 {offsetof(struct acpi_battery, max_sampling_time), 0},
416 {offsetof(struct acpi_battery, min_sampling_time), 0},
417 {offsetof(struct acpi_battery, max_averaging_interval), 0},
418 {offsetof(struct acpi_battery, min_averaging_interval), 0},
419 {offsetof(struct acpi_battery, capacity_granularity_1), 0},
420 {offsetof(struct acpi_battery, capacity_granularity_2), 0},
421 {offsetof(struct acpi_battery, model_number), 1},
422 {offsetof(struct acpi_battery, serial_number), 1},
423 {offsetof(struct acpi_battery, type), 1},
424 {offsetof(struct acpi_battery, oem_info), 1},
425};
426
427static int extract_package(struct acpi_battery *battery,
428 union acpi_object *package,
429 const struct acpi_offsets *offsets, int num)
430{
431 int i;
432 union acpi_object *element;
433
434 if (package->type != ACPI_TYPE_PACKAGE)
435 return -EFAULT;
436 for (i = 0; i < num; ++i) {
437 if (package->package.count <= i)
438 return -EFAULT;
439 element = &package->package.elements[i];
440 if (offsets[i].mode) {
441 u8 *ptr = (u8 *)battery + offsets[i].offset;
442
443 if (element->type == ACPI_TYPE_STRING ||
444 element->type == ACPI_TYPE_BUFFER)
445 strncpy(ptr, element->string.pointer, 32);
446 else if (element->type == ACPI_TYPE_INTEGER) {
447 strncpy(ptr, (u8 *)&element->integer.value,
448 sizeof(u64));
449 ptr[sizeof(u64)] = 0;
450 } else
451 *ptr = 0; /* don't have value */
452 } else {
453 int *x = (int *)((u8 *)battery + offsets[i].offset);
454 *x = (element->type == ACPI_TYPE_INTEGER) ?
455 element->integer.value : -1;
456 }
457 }
458 return 0;
459}
460
461static int acpi_battery_get_status(struct acpi_battery *battery)
462{
463 if (acpi_bus_get_status(battery->device)) {
464 acpi_handle_info(battery->device->handle,
465 "_STA evaluation failed\n");
466 return -ENODEV;
467 }
468 return 0;
469}
470
471
472static int extract_battery_info(const int use_bix,
473 struct acpi_battery *battery,
474 const struct acpi_buffer *buffer)
475{
476 int result = -EFAULT;
477
478 if (use_bix && battery_bix_broken_package)
479 result = extract_package(battery, buffer->pointer,
480 extended_info_offsets + 1,
481 ARRAY_SIZE(extended_info_offsets) - 1);
482 else if (use_bix)
483 result = extract_package(battery, buffer->pointer,
484 extended_info_offsets,
485 ARRAY_SIZE(extended_info_offsets));
486 else
487 result = extract_package(battery, buffer->pointer,
488 info_offsets, ARRAY_SIZE(info_offsets));
489 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
490 battery->full_charge_capacity = battery->design_capacity;
491 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
492 battery->power_unit && battery->design_voltage) {
493 battery->design_capacity = battery->design_capacity *
494 10000 / battery->design_voltage;
495 battery->full_charge_capacity = battery->full_charge_capacity *
496 10000 / battery->design_voltage;
497 battery->design_capacity_warning =
498 battery->design_capacity_warning *
499 10000 / battery->design_voltage;
500 /* Curiously, design_capacity_low, unlike the rest of them,
501 * is correct.
502 */
503 /* capacity_granularity_* equal 1 on the systems tested, so
504 * it's impossible to tell if they would need an adjustment
505 * or not if their values were higher.
506 */
507 }
508 if (test_bit(ACPI_BATTERY_QUIRK_DEGRADED_FULL_CHARGE, &battery->flags) &&
509 battery->capacity_now > battery->full_charge_capacity)
510 battery->capacity_now = battery->full_charge_capacity;
511
512 return result;
513}
514
515static int acpi_battery_get_info(struct acpi_battery *battery)
516{
517 const int xinfo = test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags);
518 int use_bix;
519 int result = -ENODEV;
520
521 if (!acpi_battery_present(battery))
522 return 0;
523
524
525 for (use_bix = xinfo ? 1 : 0; use_bix >= 0; use_bix--) {
526 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
527 acpi_status status = AE_ERROR;
528
529 mutex_lock(&battery->lock);
530 status = acpi_evaluate_object(battery->device->handle,
531 use_bix ? "_BIX":"_BIF",
532 NULL, &buffer);
533 mutex_unlock(&battery->lock);
534
535 if (ACPI_FAILURE(status)) {
536 acpi_handle_info(battery->device->handle,
537 "%s evaluation failed: %s\n",
538 use_bix ? "_BIX":"_BIF",
539 acpi_format_exception(status));
540 } else {
541 result = extract_battery_info(use_bix,
542 battery,
543 &buffer);
544
545 kfree(buffer.pointer);
546 break;
547 }
548 }
549
550 if (!result && !use_bix && xinfo)
551 pr_warn(FW_BUG "The _BIX method is broken, using _BIF.\n");
552
553 return result;
554}
555
556static int acpi_battery_get_state(struct acpi_battery *battery)
557{
558 int result = 0;
559 acpi_status status = 0;
560 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
561
562 if (!acpi_battery_present(battery))
563 return 0;
564
565 if (battery->update_time &&
566 time_before(jiffies, battery->update_time +
567 msecs_to_jiffies(cache_time)))
568 return 0;
569
570 mutex_lock(&battery->lock);
571 status = acpi_evaluate_object(battery->device->handle, "_BST",
572 NULL, &buffer);
573 mutex_unlock(&battery->lock);
574
575 if (ACPI_FAILURE(status)) {
576 acpi_handle_info(battery->device->handle,
577 "_BST evaluation failed: %s",
578 acpi_format_exception(status));
579 return -ENODEV;
580 }
581
582 result = extract_package(battery, buffer.pointer,
583 state_offsets, ARRAY_SIZE(state_offsets));
584 battery->update_time = jiffies;
585 kfree(buffer.pointer);
586
587 /* For buggy DSDTs that report negative 16-bit values for either
588 * charging or discharging current and/or report 0 as 65536
589 * due to bad math.
590 */
591 if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA &&
592 battery->rate_now != ACPI_BATTERY_VALUE_UNKNOWN &&
593 (s16)(battery->rate_now) < 0) {
594 battery->rate_now = abs((s16)battery->rate_now);
595 pr_warn_once(FW_BUG "(dis)charge rate invalid.\n");
596 }
597
598 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags)
599 && battery->capacity_now >= 0 && battery->capacity_now <= 100)
600 battery->capacity_now = (battery->capacity_now *
601 battery->full_charge_capacity) / 100;
602 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
603 battery->power_unit && battery->design_voltage) {
604 battery->capacity_now = battery->capacity_now *
605 10000 / battery->design_voltage;
606 }
607 if (test_bit(ACPI_BATTERY_QUIRK_DEGRADED_FULL_CHARGE, &battery->flags) &&
608 battery->capacity_now > battery->full_charge_capacity)
609 battery->capacity_now = battery->full_charge_capacity;
610
611 return result;
612}
613
614static int acpi_battery_set_alarm(struct acpi_battery *battery)
615{
616 acpi_status status = 0;
617
618 if (!acpi_battery_present(battery) ||
619 !test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags))
620 return -ENODEV;
621
622 mutex_lock(&battery->lock);
623 status = acpi_execute_simple_method(battery->device->handle, "_BTP",
624 battery->alarm);
625 mutex_unlock(&battery->lock);
626
627 if (ACPI_FAILURE(status))
628 return -ENODEV;
629
630 acpi_handle_debug(battery->device->handle, "Alarm set to %d\n",
631 battery->alarm);
632
633 return 0;
634}
635
636static int acpi_battery_init_alarm(struct acpi_battery *battery)
637{
638 /* See if alarms are supported, and if so, set default */
639 if (!acpi_has_method(battery->device->handle, "_BTP")) {
640 clear_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
641 return 0;
642 }
643 set_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
644 if (!battery->alarm)
645 battery->alarm = battery->design_capacity_warning;
646 return acpi_battery_set_alarm(battery);
647}
648
649static ssize_t acpi_battery_alarm_show(struct device *dev,
650 struct device_attribute *attr,
651 char *buf)
652{
653 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
654
655 return sprintf(buf, "%d\n", battery->alarm * 1000);
656}
657
658static ssize_t acpi_battery_alarm_store(struct device *dev,
659 struct device_attribute *attr,
660 const char *buf, size_t count)
661{
662 unsigned long x;
663 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
664
665 if (sscanf(buf, "%lu\n", &x) == 1)
666 battery->alarm = x/1000;
667 if (acpi_battery_present(battery))
668 acpi_battery_set_alarm(battery);
669 return count;
670}
671
672static const struct device_attribute alarm_attr = {
673 .attr = {.name = "alarm", .mode = 0644},
674 .show = acpi_battery_alarm_show,
675 .store = acpi_battery_alarm_store,
676};
677
678/*
679 * The Battery Hooking API
680 *
681 * This API is used inside other drivers that need to expose
682 * platform-specific behaviour within the generic driver in a
683 * generic way.
684 *
685 */
686
687static LIST_HEAD(acpi_battery_list);
688static LIST_HEAD(battery_hook_list);
689static DEFINE_MUTEX(hook_mutex);
690
691static void __battery_hook_unregister(struct acpi_battery_hook *hook, int lock)
692{
693 struct acpi_battery *battery;
694 /*
695 * In order to remove a hook, we first need to
696 * de-register all the batteries that are registered.
697 */
698 if (lock)
699 mutex_lock(&hook_mutex);
700 list_for_each_entry(battery, &acpi_battery_list, list) {
701 hook->remove_battery(battery->bat);
702 }
703 list_del(&hook->list);
704 if (lock)
705 mutex_unlock(&hook_mutex);
706 pr_info("extension unregistered: %s\n", hook->name);
707}
708
709void battery_hook_unregister(struct acpi_battery_hook *hook)
710{
711 __battery_hook_unregister(hook, 1);
712}
713EXPORT_SYMBOL_GPL(battery_hook_unregister);
714
715void battery_hook_register(struct acpi_battery_hook *hook)
716{
717 struct acpi_battery *battery;
718
719 mutex_lock(&hook_mutex);
720 INIT_LIST_HEAD(&hook->list);
721 list_add(&hook->list, &battery_hook_list);
722 /*
723 * Now that the driver is registered, we need
724 * to notify the hook that a battery is available
725 * for each battery, so that the driver may add
726 * its attributes.
727 */
728 list_for_each_entry(battery, &acpi_battery_list, list) {
729 if (hook->add_battery(battery->bat)) {
730 /*
731 * If a add-battery returns non-zero,
732 * the registration of the extension has failed,
733 * and we will not add it to the list of loaded
734 * hooks.
735 */
736 pr_err("extension failed to load: %s", hook->name);
737 __battery_hook_unregister(hook, 0);
738 goto end;
739 }
740 }
741 pr_info("new extension: %s\n", hook->name);
742end:
743 mutex_unlock(&hook_mutex);
744}
745EXPORT_SYMBOL_GPL(battery_hook_register);
746
747/*
748 * This function gets called right after the battery sysfs
749 * attributes have been added, so that the drivers that
750 * define custom sysfs attributes can add their own.
751 */
752static void battery_hook_add_battery(struct acpi_battery *battery)
753{
754 struct acpi_battery_hook *hook_node, *tmp;
755
756 mutex_lock(&hook_mutex);
757 INIT_LIST_HEAD(&battery->list);
758 list_add(&battery->list, &acpi_battery_list);
759 /*
760 * Since we added a new battery to the list, we need to
761 * iterate over the hooks and call add_battery for each
762 * hook that was registered. This usually happens
763 * when a battery gets hotplugged or initialized
764 * during the battery module initialization.
765 */
766 list_for_each_entry_safe(hook_node, tmp, &battery_hook_list, list) {
767 if (hook_node->add_battery(battery->bat)) {
768 /*
769 * The notification of the extensions has failed, to
770 * prevent further errors we will unload the extension.
771 */
772 pr_err("error in extension, unloading: %s",
773 hook_node->name);
774 __battery_hook_unregister(hook_node, 0);
775 }
776 }
777 mutex_unlock(&hook_mutex);
778}
779
780static void battery_hook_remove_battery(struct acpi_battery *battery)
781{
782 struct acpi_battery_hook *hook;
783
784 mutex_lock(&hook_mutex);
785 /*
786 * Before removing the hook, we need to remove all
787 * custom attributes from the battery.
788 */
789 list_for_each_entry(hook, &battery_hook_list, list) {
790 hook->remove_battery(battery->bat);
791 }
792 /* Then, just remove the battery from the list */
793 list_del(&battery->list);
794 mutex_unlock(&hook_mutex);
795}
796
797static void __exit battery_hook_exit(void)
798{
799 struct acpi_battery_hook *hook;
800 struct acpi_battery_hook *ptr;
801 /*
802 * At this point, the acpi_bus_unregister_driver()
803 * has called remove for all batteries. We just
804 * need to remove the hooks.
805 */
806 list_for_each_entry_safe(hook, ptr, &battery_hook_list, list) {
807 __battery_hook_unregister(hook, 1);
808 }
809 mutex_destroy(&hook_mutex);
810}
811
812static int sysfs_add_battery(struct acpi_battery *battery)
813{
814 struct power_supply_config psy_cfg = { .drv_data = battery, };
815 bool full_cap_broken = false;
816
817 if (!ACPI_BATTERY_CAPACITY_VALID(battery->full_charge_capacity) &&
818 !ACPI_BATTERY_CAPACITY_VALID(battery->design_capacity))
819 full_cap_broken = true;
820
821 if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) {
822 if (full_cap_broken) {
823 battery->bat_desc.properties =
824 charge_battery_full_cap_broken_props;
825 battery->bat_desc.num_properties =
826 ARRAY_SIZE(charge_battery_full_cap_broken_props);
827 } else {
828 battery->bat_desc.properties = charge_battery_props;
829 battery->bat_desc.num_properties =
830 ARRAY_SIZE(charge_battery_props);
831 }
832 } else {
833 if (full_cap_broken) {
834 battery->bat_desc.properties =
835 energy_battery_full_cap_broken_props;
836 battery->bat_desc.num_properties =
837 ARRAY_SIZE(energy_battery_full_cap_broken_props);
838 } else {
839 battery->bat_desc.properties = energy_battery_props;
840 battery->bat_desc.num_properties =
841 ARRAY_SIZE(energy_battery_props);
842 }
843 }
844
845 battery->bat_desc.name = acpi_device_bid(battery->device);
846 battery->bat_desc.type = POWER_SUPPLY_TYPE_BATTERY;
847 battery->bat_desc.get_property = acpi_battery_get_property;
848
849 battery->bat = power_supply_register_no_ws(&battery->device->dev,
850 &battery->bat_desc, &psy_cfg);
851
852 if (IS_ERR(battery->bat)) {
853 int result = PTR_ERR(battery->bat);
854
855 battery->bat = NULL;
856 return result;
857 }
858 battery_hook_add_battery(battery);
859 return device_create_file(&battery->bat->dev, &alarm_attr);
860}
861
862static void sysfs_remove_battery(struct acpi_battery *battery)
863{
864 mutex_lock(&battery->sysfs_lock);
865 if (!battery->bat) {
866 mutex_unlock(&battery->sysfs_lock);
867 return;
868 }
869 battery_hook_remove_battery(battery);
870 device_remove_file(&battery->bat->dev, &alarm_attr);
871 power_supply_unregister(battery->bat);
872 battery->bat = NULL;
873 mutex_unlock(&battery->sysfs_lock);
874}
875
876static void find_battery(const struct dmi_header *dm, void *private)
877{
878 struct acpi_battery *battery = (struct acpi_battery *)private;
879 /* Note: the hardcoded offsets below have been extracted from
880 * the source code of dmidecode.
881 */
882 if (dm->type == DMI_ENTRY_PORTABLE_BATTERY && dm->length >= 8) {
883 const u8 *dmi_data = (const u8 *)(dm + 1);
884 int dmi_capacity = get_unaligned((const u16 *)(dmi_data + 6));
885
886 if (dm->length >= 18)
887 dmi_capacity *= dmi_data[17];
888 if (battery->design_capacity * battery->design_voltage / 1000
889 != dmi_capacity &&
890 battery->design_capacity * 10 == dmi_capacity)
891 set_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
892 &battery->flags);
893 }
894}
895
896/*
897 * According to the ACPI spec, some kinds of primary batteries can
898 * report percentage battery remaining capacity directly to OS.
899 * In this case, it reports the Last Full Charged Capacity == 100
900 * and BatteryPresentRate == 0xFFFFFFFF.
901 *
902 * Now we found some battery reports percentage remaining capacity
903 * even if it's rechargeable.
904 * https://bugzilla.kernel.org/show_bug.cgi?id=15979
905 *
906 * Handle this correctly so that they won't break userspace.
907 */
908static void acpi_battery_quirks(struct acpi_battery *battery)
909{
910 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
911 return;
912
913 if (battery->full_charge_capacity == 100 &&
914 battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN &&
915 battery->capacity_now >= 0 && battery->capacity_now <= 100) {
916 set_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags);
917 battery->full_charge_capacity = battery->design_capacity;
918 battery->capacity_now = (battery->capacity_now *
919 battery->full_charge_capacity) / 100;
920 }
921
922 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags))
923 return;
924
925 if (battery->power_unit && dmi_name_in_vendors("LENOVO")) {
926 const char *s;
927
928 s = dmi_get_system_info(DMI_PRODUCT_VERSION);
929 if (s && !strncasecmp(s, "ThinkPad", 8)) {
930 dmi_walk(find_battery, battery);
931 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
932 &battery->flags) &&
933 battery->design_voltage) {
934 battery->design_capacity =
935 battery->design_capacity *
936 10000 / battery->design_voltage;
937 battery->full_charge_capacity =
938 battery->full_charge_capacity *
939 10000 / battery->design_voltage;
940 battery->design_capacity_warning =
941 battery->design_capacity_warning *
942 10000 / battery->design_voltage;
943 battery->capacity_now = battery->capacity_now *
944 10000 / battery->design_voltage;
945 }
946 }
947 }
948
949 if (test_bit(ACPI_BATTERY_QUIRK_DEGRADED_FULL_CHARGE, &battery->flags))
950 return;
951
952 if (acpi_battery_is_degraded(battery) &&
953 battery->capacity_now > battery->full_charge_capacity) {
954 set_bit(ACPI_BATTERY_QUIRK_DEGRADED_FULL_CHARGE, &battery->flags);
955 battery->capacity_now = battery->full_charge_capacity;
956 }
957}
958
959static int acpi_battery_update(struct acpi_battery *battery, bool resume)
960{
961 int result = acpi_battery_get_status(battery);
962
963 if (result)
964 return result;
965
966 if (!acpi_battery_present(battery)) {
967 sysfs_remove_battery(battery);
968 battery->update_time = 0;
969 return 0;
970 }
971
972 if (resume)
973 return 0;
974
975 if (!battery->update_time) {
976 result = acpi_battery_get_info(battery);
977 if (result)
978 return result;
979 acpi_battery_init_alarm(battery);
980 }
981
982 result = acpi_battery_get_state(battery);
983 if (result)
984 return result;
985 acpi_battery_quirks(battery);
986
987 if (!battery->bat) {
988 result = sysfs_add_battery(battery);
989 if (result)
990 return result;
991 }
992
993 /*
994 * Wakeup the system if battery is critical low
995 * or lower than the alarm level
996 */
997 if ((battery->state & ACPI_BATTERY_STATE_CRITICAL) ||
998 (test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags) &&
999 (battery->capacity_now <= battery->alarm)))
1000 acpi_pm_wakeup_event(&battery->device->dev);
1001
1002 return result;
1003}
1004
1005static void acpi_battery_refresh(struct acpi_battery *battery)
1006{
1007 int power_unit;
1008
1009 if (!battery->bat)
1010 return;
1011
1012 power_unit = battery->power_unit;
1013
1014 acpi_battery_get_info(battery);
1015
1016 if (power_unit == battery->power_unit)
1017 return;
1018
1019 /* The battery has changed its reporting units. */
1020 sysfs_remove_battery(battery);
1021 sysfs_add_battery(battery);
1022}
1023
1024/* Driver Interface */
1025static void acpi_battery_notify(struct acpi_device *device, u32 event)
1026{
1027 struct acpi_battery *battery = acpi_driver_data(device);
1028 struct power_supply *old;
1029
1030 if (!battery)
1031 return;
1032 old = battery->bat;
1033 /*
1034 * On Acer Aspire V5-573G notifications are sometimes triggered too
1035 * early. For example, when AC is unplugged and notification is
1036 * triggered, battery state is still reported as "Full", and changes to
1037 * "Discharging" only after short delay, without any notification.
1038 */
1039 if (battery_notification_delay_ms > 0)
1040 msleep(battery_notification_delay_ms);
1041 if (event == ACPI_BATTERY_NOTIFY_INFO)
1042 acpi_battery_refresh(battery);
1043 acpi_battery_update(battery, false);
1044 acpi_bus_generate_netlink_event(device->pnp.device_class,
1045 dev_name(&device->dev), event,
1046 acpi_battery_present(battery));
1047 acpi_notifier_call_chain(device, event, acpi_battery_present(battery));
1048 /* acpi_battery_update could remove power_supply object */
1049 if (old && battery->bat)
1050 power_supply_changed(battery->bat);
1051}
1052
1053static int battery_notify(struct notifier_block *nb,
1054 unsigned long mode, void *_unused)
1055{
1056 struct acpi_battery *battery = container_of(nb, struct acpi_battery,
1057 pm_nb);
1058 int result;
1059
1060 switch (mode) {
1061 case PM_POST_HIBERNATION:
1062 case PM_POST_SUSPEND:
1063 if (!acpi_battery_present(battery))
1064 return 0;
1065
1066 if (battery->bat) {
1067 acpi_battery_refresh(battery);
1068 } else {
1069 result = acpi_battery_get_info(battery);
1070 if (result)
1071 return result;
1072
1073 result = sysfs_add_battery(battery);
1074 if (result)
1075 return result;
1076 }
1077
1078 acpi_battery_init_alarm(battery);
1079 acpi_battery_get_state(battery);
1080 break;
1081 }
1082
1083 return 0;
1084}
1085
1086static int __init
1087battery_bix_broken_package_quirk(const struct dmi_system_id *d)
1088{
1089 battery_bix_broken_package = 1;
1090 return 0;
1091}
1092
1093static int __init
1094battery_notification_delay_quirk(const struct dmi_system_id *d)
1095{
1096 battery_notification_delay_ms = 1000;
1097 return 0;
1098}
1099
1100static int __init
1101battery_ac_is_broken_quirk(const struct dmi_system_id *d)
1102{
1103 battery_ac_is_broken = 1;
1104 return 0;
1105}
1106
1107static int __init
1108battery_do_not_check_pmic_quirk(const struct dmi_system_id *d)
1109{
1110 battery_check_pmic = 0;
1111 return 0;
1112}
1113
1114static const struct dmi_system_id bat_dmi_table[] __initconst = {
1115 {
1116 /* NEC LZ750/LS */
1117 .callback = battery_bix_broken_package_quirk,
1118 .matches = {
1119 DMI_MATCH(DMI_SYS_VENDOR, "NEC"),
1120 DMI_MATCH(DMI_PRODUCT_NAME, "PC-LZ750LS"),
1121 },
1122 },
1123 {
1124 /* Acer Aspire V5-573G */
1125 .callback = battery_notification_delay_quirk,
1126 .matches = {
1127 DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
1128 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire V5-573G"),
1129 },
1130 },
1131 {
1132 /* Point of View mobii wintab p800w */
1133 .callback = battery_ac_is_broken_quirk,
1134 .matches = {
1135 DMI_MATCH(DMI_BOARD_VENDOR, "AMI Corporation"),
1136 DMI_MATCH(DMI_BOARD_NAME, "Aptio CRB"),
1137 DMI_MATCH(DMI_BIOS_VERSION, "3BAIR1013"),
1138 /* Above matches are too generic, add bios-date match */
1139 DMI_MATCH(DMI_BIOS_DATE, "08/22/2014"),
1140 },
1141 },
1142 {
1143 /* ECS EF20EA, AXP288 PMIC but uses separate fuel-gauge */
1144 .callback = battery_do_not_check_pmic_quirk,
1145 .matches = {
1146 DMI_MATCH(DMI_PRODUCT_NAME, "EF20EA"),
1147 },
1148 },
1149 {
1150 /* Lenovo Ideapad Miix 320, AXP288 PMIC, separate fuel-gauge */
1151 .callback = battery_do_not_check_pmic_quirk,
1152 .matches = {
1153 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
1154 DMI_MATCH(DMI_PRODUCT_NAME, "80XF"),
1155 DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo MIIX 320-10ICR"),
1156 },
1157 },
1158 {},
1159};
1160
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
1183static int acpi_battery_add(struct acpi_device *device)
1184{
1185 int result = 0;
1186 struct acpi_battery *battery = NULL;
1187
1188 if (!device)
1189 return -EINVAL;
1190
1191 if (device->dep_unmet)
1192 return -EPROBE_DEFER;
1193
1194 battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL);
1195 if (!battery)
1196 return -ENOMEM;
1197 battery->device = device;
1198 strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME);
1199 strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS);
1200 device->driver_data = battery;
1201 mutex_init(&battery->lock);
1202 mutex_init(&battery->sysfs_lock);
1203 if (acpi_has_method(battery->device->handle, "_BIX"))
1204 set_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags);
1205
1206 result = acpi_battery_update_retry(battery);
1207 if (result)
1208 goto fail;
1209
1210 pr_info("Slot [%s] (battery %s)\n", acpi_device_bid(device),
1211 device->status.battery_present ? "present" : "absent");
1212
1213 battery->pm_nb.notifier_call = battery_notify;
1214 register_pm_notifier(&battery->pm_nb);
1215
1216 device_init_wakeup(&device->dev, 1);
1217
1218 return result;
1219
1220fail:
1221 sysfs_remove_battery(battery);
1222 mutex_destroy(&battery->lock);
1223 mutex_destroy(&battery->sysfs_lock);
1224 kfree(battery);
1225 return result;
1226}
1227
1228static int acpi_battery_remove(struct acpi_device *device)
1229{
1230 struct acpi_battery *battery = NULL;
1231
1232 if (!device || !acpi_driver_data(device))
1233 return -EINVAL;
1234 device_init_wakeup(&device->dev, 0);
1235 battery = acpi_driver_data(device);
1236 unregister_pm_notifier(&battery->pm_nb);
1237 sysfs_remove_battery(battery);
1238 mutex_destroy(&battery->lock);
1239 mutex_destroy(&battery->sysfs_lock);
1240 kfree(battery);
1241 return 0;
1242}
1243
1244#ifdef CONFIG_PM_SLEEP
1245/* this is needed to learn about changes made in suspended state */
1246static int acpi_battery_resume(struct device *dev)
1247{
1248 struct acpi_battery *battery;
1249
1250 if (!dev)
1251 return -EINVAL;
1252
1253 battery = acpi_driver_data(to_acpi_device(dev));
1254 if (!battery)
1255 return -EINVAL;
1256
1257 battery->update_time = 0;
1258 acpi_battery_update(battery, true);
1259 return 0;
1260}
1261#else
1262#define acpi_battery_resume NULL
1263#endif
1264
1265static SIMPLE_DEV_PM_OPS(acpi_battery_pm, NULL, acpi_battery_resume);
1266
1267static struct acpi_driver acpi_battery_driver = {
1268 .name = "battery",
1269 .class = ACPI_BATTERY_CLASS,
1270 .ids = battery_device_ids,
1271 .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
1272 .ops = {
1273 .add = acpi_battery_add,
1274 .remove = acpi_battery_remove,
1275 .notify = acpi_battery_notify,
1276 },
1277 .drv.pm = &acpi_battery_pm,
1278};
1279
1280static void __init acpi_battery_init_async(void *unused, async_cookie_t cookie)
1281{
1282 unsigned int i;
1283 int result;
1284
1285 dmi_check_system(bat_dmi_table);
1286
1287 if (battery_check_pmic) {
1288 for (i = 0; i < ARRAY_SIZE(acpi_battery_blacklist); i++)
1289 if (acpi_dev_present(acpi_battery_blacklist[i], "1", -1)) {
1290 pr_info("found native %s PMIC, not loading\n",
1291 acpi_battery_blacklist[i]);
1292 return;
1293 }
1294 }
1295
1296 result = acpi_bus_register_driver(&acpi_battery_driver);
1297 battery_driver_registered = (result == 0);
1298}
1299
1300static int __init acpi_battery_init(void)
1301{
1302 if (acpi_disabled)
1303 return -ENODEV;
1304
1305 async_cookie = async_schedule(acpi_battery_init_async, NULL);
1306 return 0;
1307}
1308
1309static void __exit acpi_battery_exit(void)
1310{
1311 async_synchronize_cookie(async_cookie + 1);
1312 if (battery_driver_registered) {
1313 acpi_bus_unregister_driver(&acpi_battery_driver);
1314 battery_hook_exit();
1315 }
1316}
1317
1318module_init(acpi_battery_init);
1319module_exit(acpi_battery_exit);