1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
25
26#include <linux/async.h>
27#include <linux/delay.h>
28#include <linux/dmi.h>
29#include <linux/jiffies.h>
30#include <linux/kernel.h>
31#include <linux/list.h>
32#include <linux/module.h>
33#include <linux/mutex.h>
34#include <linux/slab.h>
35#include <linux/suspend.h>
36#include <linux/types.h>
37
38#include <asm/unaligned.h>
39
40#ifdef CONFIG_ACPI_PROCFS_POWER
41#include <linux/proc_fs.h>
42#include <linux/seq_file.h>
43#include <linux/uaccess.h>
44#endif
45
46#include <linux/acpi.h>
47#include <linux/power_supply.h>
48
49#include <acpi/battery.h>
50
51#define PREFIX "ACPI: "
52
53#define ACPI_BATTERY_VALUE_UNKNOWN 0xFFFFFFFF
54
55#define ACPI_BATTERY_DEVICE_NAME "Battery"
56
57
58#define ACPI_BATTERY_POWER_UNIT_MA 1
59
60#define ACPI_BATTERY_STATE_DISCHARGING 0x1
61#define ACPI_BATTERY_STATE_CHARGING 0x2
62#define ACPI_BATTERY_STATE_CRITICAL 0x4
63
64#define _COMPONENT ACPI_BATTERY_COMPONENT
65
66ACPI_MODULE_NAME("battery");
67
68MODULE_AUTHOR("Paul Diefenbaugh");
69MODULE_AUTHOR("Alexey Starikovskiy <astarikovskiy@suse.de>");
70MODULE_DESCRIPTION("ACPI Battery Driver");
71MODULE_LICENSE("GPL");
72
73static async_cookie_t async_cookie;
74static bool battery_driver_registered;
75static int battery_bix_broken_package;
76static int battery_notification_delay_ms;
77static int battery_ac_is_broken;
78static int battery_check_pmic = 1;
79static unsigned int cache_time = 1000;
80module_param(cache_time, uint, 0644);
81MODULE_PARM_DESC(cache_time, "cache time in milliseconds");
82
83#ifdef CONFIG_ACPI_PROCFS_POWER
84extern struct proc_dir_entry *acpi_lock_battery_dir(void);
85extern void *acpi_unlock_battery_dir(struct proc_dir_entry *acpi_battery_dir);
86#endif
87
88static const struct acpi_device_id battery_device_ids[] = {
89 {"PNP0C0A", 0},
90 {"", 0},
91};
92
93MODULE_DEVICE_TABLE(acpi, battery_device_ids);
94
95
96static const char * const acpi_battery_blacklist[] = {
97 "INT33F4",
98};
99
100enum {
101 ACPI_BATTERY_ALARM_PRESENT,
102 ACPI_BATTERY_XINFO_PRESENT,
103 ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY,
104
105
106
107
108
109
110
111
112
113
114
115 ACPI_BATTERY_QUIRK_THINKPAD_MAH,
116
117
118
119 ACPI_BATTERY_QUIRK_DEGRADED_FULL_CHARGE,
120};
121
122struct acpi_battery {
123 struct mutex lock;
124 struct mutex sysfs_lock;
125 struct power_supply *bat;
126 struct power_supply_desc bat_desc;
127 struct acpi_device *device;
128 struct notifier_block pm_nb;
129 struct list_head list;
130 unsigned long update_time;
131 int revision;
132 int rate_now;
133 int capacity_now;
134 int voltage_now;
135 int design_capacity;
136 int full_charge_capacity;
137 int technology;
138 int design_voltage;
139 int design_capacity_warning;
140 int design_capacity_low;
141 int cycle_count;
142 int measurement_accuracy;
143 int max_sampling_time;
144 int min_sampling_time;
145 int max_averaging_interval;
146 int min_averaging_interval;
147 int capacity_granularity_1;
148 int capacity_granularity_2;
149 int alarm;
150 char model_number[32];
151 char serial_number[32];
152 char type[32];
153 char oem_info[32];
154 int state;
155 int power_unit;
156 unsigned long flags;
157};
158
159#define to_acpi_battery(x) power_supply_get_drvdata(x)
160
161static inline int acpi_battery_present(struct acpi_battery *battery)
162{
163 return battery->device->status.battery_present;
164}
165
166static int acpi_battery_technology(struct acpi_battery *battery)
167{
168 if (!strcasecmp("NiCd", battery->type))
169 return POWER_SUPPLY_TECHNOLOGY_NiCd;
170 if (!strcasecmp("NiMH", battery->type))
171 return POWER_SUPPLY_TECHNOLOGY_NiMH;
172 if (!strcasecmp("LION", battery->type))
173 return POWER_SUPPLY_TECHNOLOGY_LION;
174 if (!strncasecmp("LI-ION", battery->type, 6))
175 return POWER_SUPPLY_TECHNOLOGY_LION;
176 if (!strcasecmp("LiP", battery->type))
177 return POWER_SUPPLY_TECHNOLOGY_LIPO;
178 return POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
179}
180
181static int acpi_battery_get_state(struct acpi_battery *battery);
182
183static int acpi_battery_is_charged(struct acpi_battery *battery)
184{
185
186 if (battery->state != 0)
187 return 0;
188
189
190 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN ||
191 battery->capacity_now == 0)
192 return 0;
193
194
195 if (battery->full_charge_capacity == battery->capacity_now)
196 return 1;
197
198
199 if (battery->design_capacity == battery->capacity_now)
200 return 1;
201
202
203 return 0;
204}
205
206static bool acpi_battery_is_degraded(struct acpi_battery *battery)
207{
208 return battery->full_charge_capacity && battery->design_capacity &&
209 battery->full_charge_capacity < battery->design_capacity;
210}
211
212static int acpi_battery_handle_discharging(struct acpi_battery *battery)
213{
214
215
216
217
218
219 if ((battery_ac_is_broken || power_supply_is_system_supplied()) &&
220 battery->rate_now == 0)
221 return POWER_SUPPLY_STATUS_NOT_CHARGING;
222
223 return POWER_SUPPLY_STATUS_DISCHARGING;
224}
225
226static int acpi_battery_get_property(struct power_supply *psy,
227 enum power_supply_property psp,
228 union power_supply_propval *val)
229{
230 int ret = 0;
231 struct acpi_battery *battery = to_acpi_battery(psy);
232
233 if (acpi_battery_present(battery)) {
234
235 acpi_battery_get_state(battery);
236 } else if (psp != POWER_SUPPLY_PROP_PRESENT)
237 return -ENODEV;
238 switch (psp) {
239 case POWER_SUPPLY_PROP_STATUS:
240 if (battery->state & ACPI_BATTERY_STATE_DISCHARGING)
241 val->intval = acpi_battery_handle_discharging(battery);
242 else if (battery->state & ACPI_BATTERY_STATE_CHARGING)
243 val->intval = POWER_SUPPLY_STATUS_CHARGING;
244 else if (acpi_battery_is_charged(battery))
245 val->intval = POWER_SUPPLY_STATUS_FULL;
246 else
247 val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
248 break;
249 case POWER_SUPPLY_PROP_PRESENT:
250 val->intval = acpi_battery_present(battery);
251 break;
252 case POWER_SUPPLY_PROP_TECHNOLOGY:
253 val->intval = acpi_battery_technology(battery);
254 break;
255 case POWER_SUPPLY_PROP_CYCLE_COUNT:
256 val->intval = battery->cycle_count;
257 break;
258 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
259 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
260 ret = -ENODEV;
261 else
262 val->intval = battery->design_voltage * 1000;
263 break;
264 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
265 if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
266 ret = -ENODEV;
267 else
268 val->intval = battery->voltage_now * 1000;
269 break;
270 case POWER_SUPPLY_PROP_CURRENT_NOW:
271 case POWER_SUPPLY_PROP_POWER_NOW:
272 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
273 ret = -ENODEV;
274 else
275 val->intval = battery->rate_now * 1000;
276 break;
277 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
278 case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
279 if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
280 ret = -ENODEV;
281 else
282 val->intval = battery->design_capacity * 1000;
283 break;
284 case POWER_SUPPLY_PROP_CHARGE_FULL:
285 case POWER_SUPPLY_PROP_ENERGY_FULL:
286 if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
287 ret = -ENODEV;
288 else
289 val->intval = battery->full_charge_capacity * 1000;
290 break;
291 case POWER_SUPPLY_PROP_CHARGE_NOW:
292 case POWER_SUPPLY_PROP_ENERGY_NOW:
293 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
294 ret = -ENODEV;
295 else
296 val->intval = battery->capacity_now * 1000;
297 break;
298 case POWER_SUPPLY_PROP_CAPACITY:
299 if (battery->capacity_now && battery->full_charge_capacity)
300 val->intval = battery->capacity_now * 100/
301 battery->full_charge_capacity;
302 else
303 val->intval = 0;
304 break;
305 case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
306 if (battery->state & ACPI_BATTERY_STATE_CRITICAL)
307 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
308 else if (test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags) &&
309 (battery->capacity_now <= battery->alarm))
310 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_LOW;
311 else if (acpi_battery_is_charged(battery))
312 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
313 else
314 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
315 break;
316 case POWER_SUPPLY_PROP_MODEL_NAME:
317 val->strval = battery->model_number;
318 break;
319 case POWER_SUPPLY_PROP_MANUFACTURER:
320 val->strval = battery->oem_info;
321 break;
322 case POWER_SUPPLY_PROP_SERIAL_NUMBER:
323 val->strval = battery->serial_number;
324 break;
325 default:
326 ret = -EINVAL;
327 }
328 return ret;
329}
330
331static enum power_supply_property charge_battery_props[] = {
332 POWER_SUPPLY_PROP_STATUS,
333 POWER_SUPPLY_PROP_PRESENT,
334 POWER_SUPPLY_PROP_TECHNOLOGY,
335 POWER_SUPPLY_PROP_CYCLE_COUNT,
336 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
337 POWER_SUPPLY_PROP_VOLTAGE_NOW,
338 POWER_SUPPLY_PROP_CURRENT_NOW,
339 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
340 POWER_SUPPLY_PROP_CHARGE_FULL,
341 POWER_SUPPLY_PROP_CHARGE_NOW,
342 POWER_SUPPLY_PROP_CAPACITY,
343 POWER_SUPPLY_PROP_CAPACITY_LEVEL,
344 POWER_SUPPLY_PROP_MODEL_NAME,
345 POWER_SUPPLY_PROP_MANUFACTURER,
346 POWER_SUPPLY_PROP_SERIAL_NUMBER,
347};
348
349static enum power_supply_property energy_battery_props[] = {
350 POWER_SUPPLY_PROP_STATUS,
351 POWER_SUPPLY_PROP_PRESENT,
352 POWER_SUPPLY_PROP_TECHNOLOGY,
353 POWER_SUPPLY_PROP_CYCLE_COUNT,
354 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
355 POWER_SUPPLY_PROP_VOLTAGE_NOW,
356 POWER_SUPPLY_PROP_POWER_NOW,
357 POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
358 POWER_SUPPLY_PROP_ENERGY_FULL,
359 POWER_SUPPLY_PROP_ENERGY_NOW,
360 POWER_SUPPLY_PROP_CAPACITY,
361 POWER_SUPPLY_PROP_CAPACITY_LEVEL,
362 POWER_SUPPLY_PROP_MODEL_NAME,
363 POWER_SUPPLY_PROP_MANUFACTURER,
364 POWER_SUPPLY_PROP_SERIAL_NUMBER,
365};
366
367static enum power_supply_property energy_battery_full_cap_broken_props[] = {
368 POWER_SUPPLY_PROP_STATUS,
369 POWER_SUPPLY_PROP_PRESENT,
370 POWER_SUPPLY_PROP_TECHNOLOGY,
371 POWER_SUPPLY_PROP_CYCLE_COUNT,
372 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
373 POWER_SUPPLY_PROP_VOLTAGE_NOW,
374 POWER_SUPPLY_PROP_POWER_NOW,
375 POWER_SUPPLY_PROP_ENERGY_NOW,
376 POWER_SUPPLY_PROP_MODEL_NAME,
377 POWER_SUPPLY_PROP_MANUFACTURER,
378 POWER_SUPPLY_PROP_SERIAL_NUMBER,
379};
380
381
382
383
384struct acpi_offsets {
385 size_t offset;
386 u8 mode;
387};
388
389static const struct acpi_offsets state_offsets[] = {
390 {offsetof(struct acpi_battery, state), 0},
391 {offsetof(struct acpi_battery, rate_now), 0},
392 {offsetof(struct acpi_battery, capacity_now), 0},
393 {offsetof(struct acpi_battery, voltage_now), 0},
394};
395
396static const struct acpi_offsets info_offsets[] = {
397 {offsetof(struct acpi_battery, power_unit), 0},
398 {offsetof(struct acpi_battery, design_capacity), 0},
399 {offsetof(struct acpi_battery, full_charge_capacity), 0},
400 {offsetof(struct acpi_battery, technology), 0},
401 {offsetof(struct acpi_battery, design_voltage), 0},
402 {offsetof(struct acpi_battery, design_capacity_warning), 0},
403 {offsetof(struct acpi_battery, design_capacity_low), 0},
404 {offsetof(struct acpi_battery, capacity_granularity_1), 0},
405 {offsetof(struct acpi_battery, capacity_granularity_2), 0},
406 {offsetof(struct acpi_battery, model_number), 1},
407 {offsetof(struct acpi_battery, serial_number), 1},
408 {offsetof(struct acpi_battery, type), 1},
409 {offsetof(struct acpi_battery, oem_info), 1},
410};
411
412static const struct acpi_offsets extended_info_offsets[] = {
413 {offsetof(struct acpi_battery, revision), 0},
414 {offsetof(struct acpi_battery, power_unit), 0},
415 {offsetof(struct acpi_battery, design_capacity), 0},
416 {offsetof(struct acpi_battery, full_charge_capacity), 0},
417 {offsetof(struct acpi_battery, technology), 0},
418 {offsetof(struct acpi_battery, design_voltage), 0},
419 {offsetof(struct acpi_battery, design_capacity_warning), 0},
420 {offsetof(struct acpi_battery, design_capacity_low), 0},
421 {offsetof(struct acpi_battery, cycle_count), 0},
422 {offsetof(struct acpi_battery, measurement_accuracy), 0},
423 {offsetof(struct acpi_battery, max_sampling_time), 0},
424 {offsetof(struct acpi_battery, min_sampling_time), 0},
425 {offsetof(struct acpi_battery, max_averaging_interval), 0},
426 {offsetof(struct acpi_battery, min_averaging_interval), 0},
427 {offsetof(struct acpi_battery, capacity_granularity_1), 0},
428 {offsetof(struct acpi_battery, capacity_granularity_2), 0},
429 {offsetof(struct acpi_battery, model_number), 1},
430 {offsetof(struct acpi_battery, serial_number), 1},
431 {offsetof(struct acpi_battery, type), 1},
432 {offsetof(struct acpi_battery, oem_info), 1},
433};
434
435static int extract_package(struct acpi_battery *battery,
436 union acpi_object *package,
437 const struct acpi_offsets *offsets, int num)
438{
439 int i;
440 union acpi_object *element;
441 if (package->type != ACPI_TYPE_PACKAGE)
442 return -EFAULT;
443 for (i = 0; i < num; ++i) {
444 if (package->package.count <= i)
445 return -EFAULT;
446 element = &package->package.elements[i];
447 if (offsets[i].mode) {
448 u8 *ptr = (u8 *)battery + offsets[i].offset;
449 if (element->type == ACPI_TYPE_STRING ||
450 element->type == ACPI_TYPE_BUFFER)
451 strncpy(ptr, element->string.pointer, 32);
452 else if (element->type == ACPI_TYPE_INTEGER) {
453 strncpy(ptr, (u8 *)&element->integer.value,
454 sizeof(u64));
455 ptr[sizeof(u64)] = 0;
456 } else
457 *ptr = 0;
458 } else {
459 int *x = (int *)((u8 *)battery + offsets[i].offset);
460 *x = (element->type == ACPI_TYPE_INTEGER) ?
461 element->integer.value : -1;
462 }
463 }
464 return 0;
465}
466
467static int acpi_battery_get_status(struct acpi_battery *battery)
468{
469 if (acpi_bus_get_status(battery->device)) {
470 ACPI_EXCEPTION((AE_INFO, AE_ERROR, "Evaluating _STA"));
471 return -ENODEV;
472 }
473 return 0;
474}
475
476
477static int extract_battery_info(const int use_bix,
478 struct acpi_battery *battery,
479 const struct acpi_buffer *buffer)
480{
481 int result = -EFAULT;
482
483 if (use_bix && battery_bix_broken_package)
484 result = extract_package(battery, buffer->pointer,
485 extended_info_offsets + 1,
486 ARRAY_SIZE(extended_info_offsets) - 1);
487 else if (use_bix)
488 result = extract_package(battery, buffer->pointer,
489 extended_info_offsets,
490 ARRAY_SIZE(extended_info_offsets));
491 else
492 result = extract_package(battery, buffer->pointer,
493 info_offsets, ARRAY_SIZE(info_offsets));
494 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
495 battery->full_charge_capacity = battery->design_capacity;
496 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
497 battery->power_unit && battery->design_voltage) {
498 battery->design_capacity = battery->design_capacity *
499 10000 / battery->design_voltage;
500 battery->full_charge_capacity = battery->full_charge_capacity *
501 10000 / battery->design_voltage;
502 battery->design_capacity_warning =
503 battery->design_capacity_warning *
504 10000 / battery->design_voltage;
505
506
507
508
509
510 }
511 if (test_bit(ACPI_BATTERY_QUIRK_DEGRADED_FULL_CHARGE, &battery->flags) &&
512 battery->capacity_now > battery->full_charge_capacity)
513 battery->capacity_now = battery->full_charge_capacity;
514
515 return result;
516}
517
518static int acpi_battery_get_info(struct acpi_battery *battery)
519{
520 const int xinfo = test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags);
521 int use_bix;
522 int result = -ENODEV;
523
524 if (!acpi_battery_present(battery))
525 return 0;
526
527
528 for (use_bix = xinfo ? 1 : 0; use_bix >= 0; use_bix--) {
529 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
530 acpi_status status = AE_ERROR;
531
532 mutex_lock(&battery->lock);
533 status = acpi_evaluate_object(battery->device->handle,
534 use_bix ? "_BIX":"_BIF",
535 NULL, &buffer);
536 mutex_unlock(&battery->lock);
537
538 if (ACPI_FAILURE(status)) {
539 ACPI_EXCEPTION((AE_INFO, status, "Evaluating %s",
540 use_bix ? "_BIX":"_BIF"));
541 } else {
542 result = extract_battery_info(use_bix,
543 battery,
544 &buffer);
545
546 kfree(buffer.pointer);
547 break;
548 }
549 }
550
551 if (!result && !use_bix && xinfo)
552 pr_warn(FW_BUG "The _BIX method is broken, using _BIF.\n");
553
554 return result;
555}
556
557static int acpi_battery_get_state(struct acpi_battery *battery)
558{
559 int result = 0;
560 acpi_status status = 0;
561 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
562
563 if (!acpi_battery_present(battery))
564 return 0;
565
566 if (battery->update_time &&
567 time_before(jiffies, battery->update_time +
568 msecs_to_jiffies(cache_time)))
569 return 0;
570
571 mutex_lock(&battery->lock);
572 status = acpi_evaluate_object(battery->device->handle, "_BST",
573 NULL, &buffer);
574 mutex_unlock(&battery->lock);
575
576 if (ACPI_FAILURE(status)) {
577 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BST"));
578 return -ENODEV;
579 }
580
581 result = extract_package(battery, buffer.pointer,
582 state_offsets, ARRAY_SIZE(state_offsets));
583 battery->update_time = jiffies;
584 kfree(buffer.pointer);
585
586
587
588
589
590 if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA &&
591 battery->rate_now != ACPI_BATTERY_VALUE_UNKNOWN &&
592 (s16)(battery->rate_now) < 0) {
593 battery->rate_now = abs((s16)battery->rate_now);
594 pr_warn_once(FW_BUG "battery: (dis)charge rate invalid.\n");
595 }
596
597 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags)
598 && battery->capacity_now >= 0 && battery->capacity_now <= 100)
599 battery->capacity_now = (battery->capacity_now *
600 battery->full_charge_capacity) / 100;
601 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
602 battery->power_unit && battery->design_voltage) {
603 battery->capacity_now = battery->capacity_now *
604 10000 / battery->design_voltage;
605 }
606 if (test_bit(ACPI_BATTERY_QUIRK_DEGRADED_FULL_CHARGE, &battery->flags) &&
607 battery->capacity_now > battery->full_charge_capacity)
608 battery->capacity_now = battery->full_charge_capacity;
609
610 return result;
611}
612
613static int acpi_battery_set_alarm(struct acpi_battery *battery)
614{
615 acpi_status status = 0;
616
617 if (!acpi_battery_present(battery) ||
618 !test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags))
619 return -ENODEV;
620
621 mutex_lock(&battery->lock);
622 status = acpi_execute_simple_method(battery->device->handle, "_BTP",
623 battery->alarm);
624 mutex_unlock(&battery->lock);
625
626 if (ACPI_FAILURE(status))
627 return -ENODEV;
628
629 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Alarm set to %d\n", battery->alarm));
630 return 0;
631}
632
633static int acpi_battery_init_alarm(struct acpi_battery *battery)
634{
635
636 if (!acpi_has_method(battery->device->handle, "_BTP")) {
637 clear_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
638 return 0;
639 }
640 set_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
641 if (!battery->alarm)
642 battery->alarm = battery->design_capacity_warning;
643 return acpi_battery_set_alarm(battery);
644}
645
646static ssize_t acpi_battery_alarm_show(struct device *dev,
647 struct device_attribute *attr,
648 char *buf)
649{
650 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
651 return sprintf(buf, "%d\n", battery->alarm * 1000);
652}
653
654static ssize_t acpi_battery_alarm_store(struct device *dev,
655 struct device_attribute *attr,
656 const char *buf, size_t count)
657{
658 unsigned long x;
659 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
660 if (sscanf(buf, "%lu\n", &x) == 1)
661 battery->alarm = x/1000;
662 if (acpi_battery_present(battery))
663 acpi_battery_set_alarm(battery);
664 return count;
665}
666
667static const struct device_attribute alarm_attr = {
668 .attr = {.name = "alarm", .mode = 0644},
669 .show = acpi_battery_alarm_show,
670 .store = acpi_battery_alarm_store,
671};
672
673
674
675
676
677
678
679
680
681
682static LIST_HEAD(acpi_battery_list);
683static LIST_HEAD(battery_hook_list);
684static DEFINE_MUTEX(hook_mutex);
685
686static void __battery_hook_unregister(struct acpi_battery_hook *hook, int lock)
687{
688 struct acpi_battery *battery;
689
690
691
692
693 if (lock)
694 mutex_lock(&hook_mutex);
695 list_for_each_entry(battery, &acpi_battery_list, list) {
696 hook->remove_battery(battery->bat);
697 }
698 list_del(&hook->list);
699 if (lock)
700 mutex_unlock(&hook_mutex);
701 pr_info("extension unregistered: %s\n", hook->name);
702}
703
704void battery_hook_unregister(struct acpi_battery_hook *hook)
705{
706 __battery_hook_unregister(hook, 1);
707}
708EXPORT_SYMBOL_GPL(battery_hook_unregister);
709
710void battery_hook_register(struct acpi_battery_hook *hook)
711{
712 struct acpi_battery *battery;
713
714 mutex_lock(&hook_mutex);
715 INIT_LIST_HEAD(&hook->list);
716 list_add(&hook->list, &battery_hook_list);
717
718
719
720
721
722
723 list_for_each_entry(battery, &acpi_battery_list, list) {
724 if (hook->add_battery(battery->bat)) {
725
726
727
728
729
730
731 pr_err("extension failed to load: %s", hook->name);
732 __battery_hook_unregister(hook, 0);
733 goto end;
734 }
735 }
736 pr_info("new extension: %s\n", hook->name);
737end:
738 mutex_unlock(&hook_mutex);
739}
740EXPORT_SYMBOL_GPL(battery_hook_register);
741
742
743
744
745
746
747static void battery_hook_add_battery(struct acpi_battery *battery)
748{
749 struct acpi_battery_hook *hook_node, *tmp;
750
751 mutex_lock(&hook_mutex);
752 INIT_LIST_HEAD(&battery->list);
753 list_add(&battery->list, &acpi_battery_list);
754
755
756
757
758
759
760
761 list_for_each_entry_safe(hook_node, tmp, &battery_hook_list, list) {
762 if (hook_node->add_battery(battery->bat)) {
763
764
765
766
767 pr_err("error in extension, unloading: %s",
768 hook_node->name);
769 __battery_hook_unregister(hook_node, 0);
770 }
771 }
772 mutex_unlock(&hook_mutex);
773}
774
775static void battery_hook_remove_battery(struct acpi_battery *battery)
776{
777 struct acpi_battery_hook *hook;
778
779 mutex_lock(&hook_mutex);
780
781
782
783
784 list_for_each_entry(hook, &battery_hook_list, list) {
785 hook->remove_battery(battery->bat);
786 }
787
788 list_del(&battery->list);
789 mutex_unlock(&hook_mutex);
790}
791
792static void __exit battery_hook_exit(void)
793{
794 struct acpi_battery_hook *hook;
795 struct acpi_battery_hook *ptr;
796
797
798
799
800
801 list_for_each_entry_safe(hook, ptr, &battery_hook_list, list) {
802 __battery_hook_unregister(hook, 1);
803 }
804 mutex_destroy(&hook_mutex);
805}
806
807static int sysfs_add_battery(struct acpi_battery *battery)
808{
809 struct power_supply_config psy_cfg = { .drv_data = battery, };
810
811 if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) {
812 battery->bat_desc.properties = charge_battery_props;
813 battery->bat_desc.num_properties =
814 ARRAY_SIZE(charge_battery_props);
815 } else if (battery->full_charge_capacity == 0) {
816 battery->bat_desc.properties =
817 energy_battery_full_cap_broken_props;
818 battery->bat_desc.num_properties =
819 ARRAY_SIZE(energy_battery_full_cap_broken_props);
820 } else {
821 battery->bat_desc.properties = energy_battery_props;
822 battery->bat_desc.num_properties =
823 ARRAY_SIZE(energy_battery_props);
824 }
825
826 battery->bat_desc.name = acpi_device_bid(battery->device);
827 battery->bat_desc.type = POWER_SUPPLY_TYPE_BATTERY;
828 battery->bat_desc.get_property = acpi_battery_get_property;
829
830 battery->bat = power_supply_register_no_ws(&battery->device->dev,
831 &battery->bat_desc, &psy_cfg);
832
833 if (IS_ERR(battery->bat)) {
834 int result = PTR_ERR(battery->bat);
835
836 battery->bat = NULL;
837 return result;
838 }
839 battery_hook_add_battery(battery);
840 return device_create_file(&battery->bat->dev, &alarm_attr);
841}
842
843static void sysfs_remove_battery(struct acpi_battery *battery)
844{
845 mutex_lock(&battery->sysfs_lock);
846 if (!battery->bat) {
847 mutex_unlock(&battery->sysfs_lock);
848 return;
849 }
850 battery_hook_remove_battery(battery);
851 device_remove_file(&battery->bat->dev, &alarm_attr);
852 power_supply_unregister(battery->bat);
853 battery->bat = NULL;
854 mutex_unlock(&battery->sysfs_lock);
855}
856
857static void find_battery(const struct dmi_header *dm, void *private)
858{
859 struct acpi_battery *battery = (struct acpi_battery *)private;
860
861
862 if (dm->type == DMI_ENTRY_PORTABLE_BATTERY && dm->length >= 8) {
863 const u8 *dmi_data = (const u8 *)(dm + 1);
864 int dmi_capacity = get_unaligned((const u16 *)(dmi_data + 6));
865 if (dm->length >= 18)
866 dmi_capacity *= dmi_data[17];
867 if (battery->design_capacity * battery->design_voltage / 1000
868 != dmi_capacity &&
869 battery->design_capacity * 10 == dmi_capacity)
870 set_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
871 &battery->flags);
872 }
873}
874
875
876
877
878
879
880
881
882
883
884
885
886
887static void acpi_battery_quirks(struct acpi_battery *battery)
888{
889 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
890 return;
891
892 if (battery->full_charge_capacity == 100 &&
893 battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN &&
894 battery->capacity_now >= 0 && battery->capacity_now <= 100) {
895 set_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags);
896 battery->full_charge_capacity = battery->design_capacity;
897 battery->capacity_now = (battery->capacity_now *
898 battery->full_charge_capacity) / 100;
899 }
900
901 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags))
902 return;
903
904 if (battery->power_unit && dmi_name_in_vendors("LENOVO")) {
905 const char *s;
906 s = dmi_get_system_info(DMI_PRODUCT_VERSION);
907 if (s && !strncasecmp(s, "ThinkPad", 8)) {
908 dmi_walk(find_battery, battery);
909 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
910 &battery->flags) &&
911 battery->design_voltage) {
912 battery->design_capacity =
913 battery->design_capacity *
914 10000 / battery->design_voltage;
915 battery->full_charge_capacity =
916 battery->full_charge_capacity *
917 10000 / battery->design_voltage;
918 battery->design_capacity_warning =
919 battery->design_capacity_warning *
920 10000 / battery->design_voltage;
921 battery->capacity_now = battery->capacity_now *
922 10000 / battery->design_voltage;
923 }
924 }
925 }
926
927 if (test_bit(ACPI_BATTERY_QUIRK_DEGRADED_FULL_CHARGE, &battery->flags))
928 return;
929
930 if (acpi_battery_is_degraded(battery) &&
931 battery->capacity_now > battery->full_charge_capacity) {
932 set_bit(ACPI_BATTERY_QUIRK_DEGRADED_FULL_CHARGE, &battery->flags);
933 battery->capacity_now = battery->full_charge_capacity;
934 }
935}
936
937static int acpi_battery_update(struct acpi_battery *battery, bool resume)
938{
939 int result = acpi_battery_get_status(battery);
940
941 if (result)
942 return result;
943
944 if (!acpi_battery_present(battery)) {
945 sysfs_remove_battery(battery);
946 battery->update_time = 0;
947 return 0;
948 }
949
950 if (resume)
951 return 0;
952
953 if (!battery->update_time) {
954 result = acpi_battery_get_info(battery);
955 if (result)
956 return result;
957 acpi_battery_init_alarm(battery);
958 }
959
960 result = acpi_battery_get_state(battery);
961 if (result)
962 return result;
963 acpi_battery_quirks(battery);
964
965 if (!battery->bat) {
966 result = sysfs_add_battery(battery);
967 if (result)
968 return result;
969 }
970
971
972
973
974
975 if ((battery->state & ACPI_BATTERY_STATE_CRITICAL) ||
976 (test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags) &&
977 (battery->capacity_now <= battery->alarm)))
978 acpi_pm_wakeup_event(&battery->device->dev);
979
980 return result;
981}
982
983static void acpi_battery_refresh(struct acpi_battery *battery)
984{
985 int power_unit;
986
987 if (!battery->bat)
988 return;
989
990 power_unit = battery->power_unit;
991
992 acpi_battery_get_info(battery);
993
994 if (power_unit == battery->power_unit)
995 return;
996
997
998 sysfs_remove_battery(battery);
999 sysfs_add_battery(battery);
1000}
1001
1002
1003
1004
1005
1006#ifdef CONFIG_ACPI_PROCFS_POWER
1007static struct proc_dir_entry *acpi_battery_dir;
1008
1009static const char *acpi_battery_units(const struct acpi_battery *battery)
1010{
1011 return (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) ?
1012 "mA" : "mW";
1013}
1014
1015static int acpi_battery_info_proc_show(struct seq_file *seq, void *offset)
1016{
1017 struct acpi_battery *battery = seq->private;
1018 int result = acpi_battery_update(battery, false);
1019
1020 if (result)
1021 goto end;
1022
1023 seq_printf(seq, "present: %s\n",
1024 acpi_battery_present(battery) ? "yes" : "no");
1025 if (!acpi_battery_present(battery))
1026 goto end;
1027 if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
1028 seq_printf(seq, "design capacity: unknown\n");
1029 else
1030 seq_printf(seq, "design capacity: %d %sh\n",
1031 battery->design_capacity,
1032 acpi_battery_units(battery));
1033
1034 if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
1035 seq_printf(seq, "last full capacity: unknown\n");
1036 else
1037 seq_printf(seq, "last full capacity: %d %sh\n",
1038 battery->full_charge_capacity,
1039 acpi_battery_units(battery));
1040
1041 seq_printf(seq, "battery technology: %srechargeable\n",
1042 battery->technology ? "" : "non-");
1043
1044 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
1045 seq_printf(seq, "design voltage: unknown\n");
1046 else
1047 seq_printf(seq, "design voltage: %d mV\n",
1048 battery->design_voltage);
1049 seq_printf(seq, "design capacity warning: %d %sh\n",
1050 battery->design_capacity_warning,
1051 acpi_battery_units(battery));
1052 seq_printf(seq, "design capacity low: %d %sh\n",
1053 battery->design_capacity_low,
1054 acpi_battery_units(battery));
1055 seq_printf(seq, "cycle count: %i\n", battery->cycle_count);
1056 seq_printf(seq, "capacity granularity 1: %d %sh\n",
1057 battery->capacity_granularity_1,
1058 acpi_battery_units(battery));
1059 seq_printf(seq, "capacity granularity 2: %d %sh\n",
1060 battery->capacity_granularity_2,
1061 acpi_battery_units(battery));
1062 seq_printf(seq, "model number: %s\n", battery->model_number);
1063 seq_printf(seq, "serial number: %s\n", battery->serial_number);
1064 seq_printf(seq, "battery type: %s\n", battery->type);
1065 seq_printf(seq, "OEM info: %s\n", battery->oem_info);
1066 end:
1067 if (result)
1068 seq_printf(seq, "ERROR: Unable to read battery info\n");
1069 return result;
1070}
1071
1072static int acpi_battery_state_proc_show(struct seq_file *seq, void *offset)
1073{
1074 struct acpi_battery *battery = seq->private;
1075 int result = acpi_battery_update(battery, false);
1076
1077 if (result)
1078 goto end;
1079
1080 seq_printf(seq, "present: %s\n",
1081 acpi_battery_present(battery) ? "yes" : "no");
1082 if (!acpi_battery_present(battery))
1083 goto end;
1084
1085 seq_printf(seq, "capacity state: %s\n",
1086 (battery->state & 0x04) ? "critical" : "ok");
1087 if ((battery->state & 0x01) && (battery->state & 0x02))
1088 seq_printf(seq,
1089 "charging state: charging/discharging\n");
1090 else if (battery->state & 0x01)
1091 seq_printf(seq, "charging state: discharging\n");
1092 else if (battery->state & 0x02)
1093 seq_printf(seq, "charging state: charging\n");
1094 else
1095 seq_printf(seq, "charging state: charged\n");
1096
1097 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
1098 seq_printf(seq, "present rate: unknown\n");
1099 else
1100 seq_printf(seq, "present rate: %d %s\n",
1101 battery->rate_now, acpi_battery_units(battery));
1102
1103 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
1104 seq_printf(seq, "remaining capacity: unknown\n");
1105 else
1106 seq_printf(seq, "remaining capacity: %d %sh\n",
1107 battery->capacity_now, acpi_battery_units(battery));
1108 if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
1109 seq_printf(seq, "present voltage: unknown\n");
1110 else
1111 seq_printf(seq, "present voltage: %d mV\n",
1112 battery->voltage_now);
1113 end:
1114 if (result)
1115 seq_printf(seq, "ERROR: Unable to read battery state\n");
1116
1117 return result;
1118}
1119
1120static int acpi_battery_alarm_proc_show(struct seq_file *seq, void *offset)
1121{
1122 struct acpi_battery *battery = seq->private;
1123 int result = acpi_battery_update(battery, false);
1124
1125 if (result)
1126 goto end;
1127
1128 if (!acpi_battery_present(battery)) {
1129 seq_printf(seq, "present: no\n");
1130 goto end;
1131 }
1132 seq_printf(seq, "alarm: ");
1133 if (battery->alarm) {
1134 seq_printf(seq, "%u %sh\n", battery->alarm,
1135 acpi_battery_units(battery));
1136 } else {
1137 seq_printf(seq, "unsupported\n");
1138 }
1139 end:
1140 if (result)
1141 seq_printf(seq, "ERROR: Unable to read battery alarm\n");
1142 return result;
1143}
1144
1145static ssize_t acpi_battery_write_alarm(struct file *file,
1146 const char __user * buffer,
1147 size_t count, loff_t * ppos)
1148{
1149 int result = 0;
1150 char alarm_string[12] = { '\0' };
1151 struct seq_file *m = file->private_data;
1152 struct acpi_battery *battery = m->private;
1153
1154 if (!battery || (count > sizeof(alarm_string) - 1))
1155 return -EINVAL;
1156 if (!acpi_battery_present(battery)) {
1157 result = -ENODEV;
1158 goto end;
1159 }
1160 if (copy_from_user(alarm_string, buffer, count)) {
1161 result = -EFAULT;
1162 goto end;
1163 }
1164 alarm_string[count] = '\0';
1165 if (kstrtoint(alarm_string, 0, &battery->alarm)) {
1166 result = -EINVAL;
1167 goto end;
1168 }
1169 result = acpi_battery_set_alarm(battery);
1170 end:
1171 if (result)
1172 return result;
1173 return count;
1174}
1175
1176static int acpi_battery_alarm_proc_open(struct inode *inode, struct file *file)
1177{
1178 return single_open(file, acpi_battery_alarm_proc_show, PDE_DATA(inode));
1179}
1180
1181static const struct file_operations acpi_battery_alarm_fops = {
1182 .owner = THIS_MODULE,
1183 .open = acpi_battery_alarm_proc_open,
1184 .read = seq_read,
1185 .write = acpi_battery_write_alarm,
1186 .llseek = seq_lseek,
1187 .release = single_release,
1188};
1189
1190static int acpi_battery_add_fs(struct acpi_device *device)
1191{
1192 pr_warning(PREFIX "Deprecated procfs I/F for battery is loaded, please retry with CONFIG_ACPI_PROCFS_POWER cleared\n");
1193 if (!acpi_device_dir(device)) {
1194 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
1195 acpi_battery_dir);
1196 if (!acpi_device_dir(device))
1197 return -ENODEV;
1198 }
1199
1200 if (!proc_create_single_data("info", S_IRUGO, acpi_device_dir(device),
1201 acpi_battery_info_proc_show, acpi_driver_data(device)))
1202 return -ENODEV;
1203 if (!proc_create_single_data("state", S_IRUGO, acpi_device_dir(device),
1204 acpi_battery_state_proc_show, acpi_driver_data(device)))
1205 return -ENODEV;
1206 if (!proc_create_data("alarm", S_IFREG | S_IRUGO | S_IWUSR,
1207 acpi_device_dir(device), &acpi_battery_alarm_fops,
1208 acpi_driver_data(device)))
1209 return -ENODEV;
1210 return 0;
1211}
1212
1213static void acpi_battery_remove_fs(struct acpi_device *device)
1214{
1215 if (!acpi_device_dir(device))
1216 return;
1217 remove_proc_subtree(acpi_device_bid(device), acpi_battery_dir);
1218 acpi_device_dir(device) = NULL;
1219}
1220
1221#endif
1222
1223
1224
1225
1226
1227static void acpi_battery_notify(struct acpi_device *device, u32 event)
1228{
1229 struct acpi_battery *battery = acpi_driver_data(device);
1230 struct power_supply *old;
1231
1232 if (!battery)
1233 return;
1234 old = battery->bat;
1235
1236
1237
1238
1239
1240
1241 if (battery_notification_delay_ms > 0)
1242 msleep(battery_notification_delay_ms);
1243 if (event == ACPI_BATTERY_NOTIFY_INFO)
1244 acpi_battery_refresh(battery);
1245 acpi_battery_update(battery, false);
1246 acpi_bus_generate_netlink_event(device->pnp.device_class,
1247 dev_name(&device->dev), event,
1248 acpi_battery_present(battery));
1249 acpi_notifier_call_chain(device, event, acpi_battery_present(battery));
1250
1251 if (old && battery->bat)
1252 power_supply_changed(battery->bat);
1253}
1254
1255static int battery_notify(struct notifier_block *nb,
1256 unsigned long mode, void *_unused)
1257{
1258 struct acpi_battery *battery = container_of(nb, struct acpi_battery,
1259 pm_nb);
1260 int result;
1261
1262 switch (mode) {
1263 case PM_POST_HIBERNATION:
1264 case PM_POST_SUSPEND:
1265 if (!acpi_battery_present(battery))
1266 return 0;
1267
1268 if (battery->bat) {
1269 acpi_battery_refresh(battery);
1270 } else {
1271 result = acpi_battery_get_info(battery);
1272 if (result)
1273 return result;
1274
1275 result = sysfs_add_battery(battery);
1276 if (result)
1277 return result;
1278 }
1279
1280 acpi_battery_init_alarm(battery);
1281 acpi_battery_get_state(battery);
1282 break;
1283 }
1284
1285 return 0;
1286}
1287
1288static int __init
1289battery_bix_broken_package_quirk(const struct dmi_system_id *d)
1290{
1291 battery_bix_broken_package = 1;
1292 return 0;
1293}
1294
1295static int __init
1296battery_notification_delay_quirk(const struct dmi_system_id *d)
1297{
1298 battery_notification_delay_ms = 1000;
1299 return 0;
1300}
1301
1302static int __init
1303battery_ac_is_broken_quirk(const struct dmi_system_id *d)
1304{
1305 battery_ac_is_broken = 1;
1306 return 0;
1307}
1308
1309static int __init
1310battery_do_not_check_pmic_quirk(const struct dmi_system_id *d)
1311{
1312 battery_check_pmic = 0;
1313 return 0;
1314}
1315
1316static const struct dmi_system_id bat_dmi_table[] __initconst = {
1317 {
1318
1319 .callback = battery_bix_broken_package_quirk,
1320 .matches = {
1321 DMI_MATCH(DMI_SYS_VENDOR, "NEC"),
1322 DMI_MATCH(DMI_PRODUCT_NAME, "PC-LZ750LS"),
1323 },
1324 },
1325 {
1326
1327 .callback = battery_notification_delay_quirk,
1328 .matches = {
1329 DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
1330 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire V5-573G"),
1331 },
1332 },
1333 {
1334
1335 .callback = battery_ac_is_broken_quirk,
1336 .matches = {
1337 DMI_MATCH(DMI_BOARD_VENDOR, "AMI Corporation"),
1338 DMI_MATCH(DMI_BOARD_NAME, "Aptio CRB"),
1339 DMI_MATCH(DMI_BIOS_VERSION, "3BAIR1013"),
1340
1341 DMI_MATCH(DMI_BIOS_DATE, "08/22/2014"),
1342 },
1343 },
1344 {
1345
1346 .callback = battery_do_not_check_pmic_quirk,
1347 .matches = {
1348 DMI_MATCH(DMI_PRODUCT_NAME, "EF20EA"),
1349 },
1350 },
1351 {
1352
1353 .callback = battery_do_not_check_pmic_quirk,
1354 .matches = {
1355 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "LENOVO"),
1356 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "80XF"),
1357 DMI_EXACT_MATCH(DMI_PRODUCT_VERSION, "Lenovo MIIX 320-10ICR"),
1358 },
1359 },
1360 {},
1361};
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371static int acpi_battery_update_retry(struct acpi_battery *battery)
1372{
1373 int retry, ret;
1374
1375 for (retry = 5; retry; retry--) {
1376 ret = acpi_battery_update(battery, false);
1377 if (!ret)
1378 break;
1379
1380 msleep(20);
1381 }
1382 return ret;
1383}
1384
1385static int acpi_battery_add(struct acpi_device *device)
1386{
1387 int result = 0;
1388 struct acpi_battery *battery = NULL;
1389
1390 if (!device)
1391 return -EINVAL;
1392
1393 if (device->dep_unmet)
1394 return -EPROBE_DEFER;
1395
1396 battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL);
1397 if (!battery)
1398 return -ENOMEM;
1399 battery->device = device;
1400 strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME);
1401 strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS);
1402 device->driver_data = battery;
1403 mutex_init(&battery->lock);
1404 mutex_init(&battery->sysfs_lock);
1405 if (acpi_has_method(battery->device->handle, "_BIX"))
1406 set_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags);
1407
1408 result = acpi_battery_update_retry(battery);
1409 if (result)
1410 goto fail;
1411
1412#ifdef CONFIG_ACPI_PROCFS_POWER
1413 result = acpi_battery_add_fs(device);
1414 if (result) {
1415 acpi_battery_remove_fs(device);
1416 goto fail;
1417 }
1418#endif
1419
1420 pr_info(PREFIX "%s Slot [%s] (battery %s)\n",
1421 ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device),
1422 device->status.battery_present ? "present" : "absent");
1423
1424 battery->pm_nb.notifier_call = battery_notify;
1425 register_pm_notifier(&battery->pm_nb);
1426
1427 device_init_wakeup(&device->dev, 1);
1428
1429 return result;
1430
1431fail:
1432 sysfs_remove_battery(battery);
1433 mutex_destroy(&battery->lock);
1434 mutex_destroy(&battery->sysfs_lock);
1435 kfree(battery);
1436 return result;
1437}
1438
1439static int acpi_battery_remove(struct acpi_device *device)
1440{
1441 struct acpi_battery *battery = NULL;
1442
1443 if (!device || !acpi_driver_data(device))
1444 return -EINVAL;
1445 device_init_wakeup(&device->dev, 0);
1446 battery = acpi_driver_data(device);
1447 unregister_pm_notifier(&battery->pm_nb);
1448#ifdef CONFIG_ACPI_PROCFS_POWER
1449 acpi_battery_remove_fs(device);
1450#endif
1451 sysfs_remove_battery(battery);
1452 mutex_destroy(&battery->lock);
1453 mutex_destroy(&battery->sysfs_lock);
1454 kfree(battery);
1455 return 0;
1456}
1457
1458#ifdef CONFIG_PM_SLEEP
1459
1460static int acpi_battery_resume(struct device *dev)
1461{
1462 struct acpi_battery *battery;
1463
1464 if (!dev)
1465 return -EINVAL;
1466
1467 battery = acpi_driver_data(to_acpi_device(dev));
1468 if (!battery)
1469 return -EINVAL;
1470
1471 battery->update_time = 0;
1472 acpi_battery_update(battery, true);
1473 return 0;
1474}
1475#else
1476#define acpi_battery_resume NULL
1477#endif
1478
1479static SIMPLE_DEV_PM_OPS(acpi_battery_pm, NULL, acpi_battery_resume);
1480
1481static struct acpi_driver acpi_battery_driver = {
1482 .name = "battery",
1483 .class = ACPI_BATTERY_CLASS,
1484 .ids = battery_device_ids,
1485 .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
1486 .ops = {
1487 .add = acpi_battery_add,
1488 .remove = acpi_battery_remove,
1489 .notify = acpi_battery_notify,
1490 },
1491 .drv.pm = &acpi_battery_pm,
1492};
1493
1494static void __init acpi_battery_init_async(void *unused, async_cookie_t cookie)
1495{
1496 unsigned int i;
1497 int result;
1498
1499 dmi_check_system(bat_dmi_table);
1500
1501 if (battery_check_pmic) {
1502 for (i = 0; i < ARRAY_SIZE(acpi_battery_blacklist); i++)
1503 if (acpi_dev_present(acpi_battery_blacklist[i], "1", -1)) {
1504 pr_info(PREFIX ACPI_BATTERY_DEVICE_NAME
1505 ": found native %s PMIC, not loading\n",
1506 acpi_battery_blacklist[i]);
1507 return;
1508 }
1509 }
1510
1511#ifdef CONFIG_ACPI_PROCFS_POWER
1512 acpi_battery_dir = acpi_lock_battery_dir();
1513 if (!acpi_battery_dir)
1514 return;
1515#endif
1516 result = acpi_bus_register_driver(&acpi_battery_driver);
1517#ifdef CONFIG_ACPI_PROCFS_POWER
1518 if (result < 0)
1519 acpi_unlock_battery_dir(acpi_battery_dir);
1520#endif
1521 battery_driver_registered = (result == 0);
1522}
1523
1524static int __init acpi_battery_init(void)
1525{
1526 if (acpi_disabled)
1527 return -ENODEV;
1528
1529 async_cookie = async_schedule(acpi_battery_init_async, NULL);
1530 return 0;
1531}
1532
1533static void __exit acpi_battery_exit(void)
1534{
1535 async_synchronize_cookie(async_cookie + 1);
1536 if (battery_driver_registered) {
1537 acpi_bus_unregister_driver(&acpi_battery_driver);
1538 battery_hook_exit();
1539 }
1540#ifdef CONFIG_ACPI_PROCFS_POWER
1541 if (acpi_battery_dir)
1542 acpi_unlock_battery_dir(acpi_battery_dir);
1543#endif
1544}
1545
1546module_init(acpi_battery_init);
1547module_exit(acpi_battery_exit);
1548
