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