1
2
3
4
5
6
7
8
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
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
74static const char * const acpi_battery_blacklist[] = {
75 "INT33F4",
76};
77
78enum {
79 ACPI_BATTERY_ALARM_PRESENT,
80 ACPI_BATTERY_XINFO_PRESENT,
81 ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY,
82
83
84
85
86
87
88
89
90
91
92
93 ACPI_BATTERY_QUIRK_THINKPAD_MAH,
94
95
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
164 if (battery->state != 0)
165 return 0;
166
167
168 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN ||
169 battery->capacity_now == 0)
170 return 0;
171
172
173 if (battery->full_charge_capacity == battery->capacity_now)
174 return 1;
175
176
177 if (battery->design_capacity == battery->capacity_now)
178 return 1;
179
180
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
195
196
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
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
382
383struct acpi_offsets {
384 size_t offset;
385 u8 mode;
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;
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
505
506
507
508
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
586
587
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
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
674
675
676
677
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
690
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
718
719
720
721
722 list_for_each_entry(battery, &acpi_battery_list, list) {
723 if (hook->add_battery(battery->bat)) {
724
725
726
727
728
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
743
744
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
755
756
757
758
759
760 list_for_each_entry_safe(hook_node, tmp, &battery_hook_list, list) {
761 if (hook_node->add_battery(battery->bat)) {
762
763
764
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
781
782
783 list_for_each_entry(hook, &battery_hook_list, list) {
784 hook->remove_battery(battery->bat);
785 }
786
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
797
798
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
874
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
890
891
892
893
894
895
896
897
898
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
986
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
1011 sysfs_remove_battery(battery);
1012 sysfs_add_battery(battery);
1013}
1014
1015
1016
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
1029
1030
1031
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
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
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
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
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
1133 DMI_MATCH(DMI_BIOS_DATE, "08/22/2014"),
1134 },
1135 },
1136 {
1137
1138 .callback = battery_do_not_check_pmic_quirk,
1139 .matches = {
1140 DMI_MATCH(DMI_PRODUCT_NAME, "EF20EA"),
1141 },
1142 },
1143 {
1144
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
1157
1158
1159
1160
1161
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
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);
1316
