2 * battery.c - ACPI Battery Driver (Revision: 2.0)
4 * Copyright (C) 2007 Alexey Starikovskiy <astarikovskiy@suse.de>
5 * Copyright (C) 2004-2007 Vladimir Lebedev <vladimir.p.lebedev@intel.com>
6 * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
7 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
9 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or (at
14 * your option) any later version.
16 * This program is distributed in the hope that it will be useful, but
17 * WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * General Public License for more details.
21 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
24 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
26 #include <linux/kernel.h>
27 #include <linux/list.h>
28 #include <linux/module.h>
29 #include <linux/mutex.h>
30 #include <linux/init.h>
31 #include <linux/types.h>
32 #include <linux/jiffies.h>
33 #include <linux/async.h>
34 #include <linux/dmi.h>
35 #include <linux/delay.h>
36 #include <linux/slab.h>
37 #include <linux/suspend.h>
38 #include <asm/unaligned.h>
40 #ifdef CONFIG_ACPI_PROCFS_POWER
41 #include <linux/proc_fs.h>
42 #include <linux/seq_file.h>
43 #include <linux/uaccess.h>
46 #include <linux/acpi.h>
47 #include <linux/power_supply.h>
49 #include <acpi/battery.h>
51 #define PREFIX "ACPI: "
53 #define ACPI_BATTERY_VALUE_UNKNOWN 0xFFFFFFFF
55 #define ACPI_BATTERY_DEVICE_NAME "Battery"
57 /* Battery power unit: 0 means mW, 1 means mA */
58 #define ACPI_BATTERY_POWER_UNIT_MA 1
60 #define ACPI_BATTERY_STATE_DISCHARGING 0x1
61 #define ACPI_BATTERY_STATE_CHARGING 0x2
62 #define ACPI_BATTERY_STATE_CRITICAL 0x4
64 #define _COMPONENT ACPI_BATTERY_COMPONENT
66 ACPI_MODULE_NAME("battery");
68 MODULE_AUTHOR("Paul Diefenbaugh");
69 MODULE_AUTHOR("Alexey Starikovskiy <astarikovskiy@suse.de>");
70 MODULE_DESCRIPTION("ACPI Battery Driver");
71 MODULE_LICENSE("GPL");
73 static async_cookie_t async_cookie;
74 static bool battery_driver_registered;
75 static int battery_bix_broken_package;
76 static int battery_notification_delay_ms;
77 static int battery_ac_is_broken;
78 static int battery_check_pmic = 1;
79 static unsigned int cache_time = 1000;
80 module_param(cache_time, uint, 0644);
81 MODULE_PARM_DESC(cache_time, "cache time in milliseconds");
83 #ifdef CONFIG_ACPI_PROCFS_POWER
84 extern struct proc_dir_entry *acpi_lock_battery_dir(void);
85 extern void *acpi_unlock_battery_dir(struct proc_dir_entry *acpi_battery_dir);
88 static const struct acpi_device_id battery_device_ids[] = {
93 MODULE_DEVICE_TABLE(acpi, battery_device_ids);
95 /* Lists of PMIC ACPI HIDs with an (often better) native battery driver */
96 static const char * const acpi_battery_blacklist[] = {
97 "INT33F4", /* X-Powers AXP288 PMIC */
101 ACPI_BATTERY_ALARM_PRESENT,
102 ACPI_BATTERY_XINFO_PRESENT,
103 ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY,
104 /* On Lenovo Thinkpad models from 2010 and 2011, the power unit
105 switches between mWh and mAh depending on whether the system
106 is running on battery or not. When mAh is the unit, most
107 reported values are incorrect and need to be adjusted by
108 10000/design_voltage. Verified on x201, t410, t410s, and x220.
109 Pre-2010 and 2012 models appear to always report in mWh and
110 are thus unaffected (tested with t42, t61, t500, x200, x300,
111 and x230). Also, in mid-2012 Lenovo issued a BIOS update for
112 the 2011 models that fixes the issue (tested on x220 with a
113 post-1.29 BIOS), but as of Nov. 2012, no such update is
114 available for the 2010 models. */
115 ACPI_BATTERY_QUIRK_THINKPAD_MAH,
116 /* for batteries reporting current capacity with design capacity
117 * on a full charge, but showing degradation in full charge cap.
119 ACPI_BATTERY_QUIRK_DEGRADED_FULL_CHARGE,
122 struct acpi_battery {
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;
136 int full_charge_capacity;
139 int design_capacity_warning;
140 int design_capacity_low;
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;
150 char model_number[32];
151 char serial_number[32];
159 #define to_acpi_battery(x) power_supply_get_drvdata(x)
161 static inline int acpi_battery_present(struct acpi_battery *battery)
163 return battery->device->status.battery_present;
166 static int acpi_battery_technology(struct acpi_battery *battery)
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;
181 static int acpi_battery_get_state(struct acpi_battery *battery);
183 static int acpi_battery_is_charged(struct acpi_battery *battery)
185 /* charging, discharging or critical low */
186 if (battery->state != 0)
189 /* battery not reporting charge */
190 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN ||
191 battery->capacity_now == 0)
194 /* good batteries update full_charge as the batteries degrade */
195 if (battery->full_charge_capacity == battery->capacity_now)
198 /* fallback to using design values for broken batteries */
199 if (battery->design_capacity == battery->capacity_now)
202 /* we don't do any sort of metric based on percentages */
206 static bool acpi_battery_is_degraded(struct acpi_battery *battery)
208 return battery->full_charge_capacity && battery->design_capacity &&
209 battery->full_charge_capacity < battery->design_capacity;
212 static int acpi_battery_handle_discharging(struct acpi_battery *battery)
215 * Some devices wrongly report discharging if the battery's charge level
216 * was above the device's start charging threshold atm the AC adapter
217 * was plugged in and the device thus did not start a new charge cycle.
219 if ((battery_ac_is_broken || power_supply_is_system_supplied()) &&
220 battery->rate_now == 0)
221 return POWER_SUPPLY_STATUS_NOT_CHARGING;
223 return POWER_SUPPLY_STATUS_DISCHARGING;
226 static int acpi_battery_get_property(struct power_supply *psy,
227 enum power_supply_property psp,
228 union power_supply_propval *val)
231 struct acpi_battery *battery = to_acpi_battery(psy);
233 if (acpi_battery_present(battery)) {
234 /* run battery update only if it is present */
235 acpi_battery_get_state(battery);
236 } else if (psp != POWER_SUPPLY_PROP_PRESENT)
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;
247 val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
249 case POWER_SUPPLY_PROP_PRESENT:
250 val->intval = acpi_battery_present(battery);
252 case POWER_SUPPLY_PROP_TECHNOLOGY:
253 val->intval = acpi_battery_technology(battery);
255 case POWER_SUPPLY_PROP_CYCLE_COUNT:
256 val->intval = battery->cycle_count;
258 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
259 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
262 val->intval = battery->design_voltage * 1000;
264 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
265 if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
268 val->intval = battery->voltage_now * 1000;
270 case POWER_SUPPLY_PROP_CURRENT_NOW:
271 case POWER_SUPPLY_PROP_POWER_NOW:
272 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
275 val->intval = battery->rate_now * 1000;
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)
282 val->intval = battery->design_capacity * 1000;
284 case POWER_SUPPLY_PROP_CHARGE_FULL:
285 case POWER_SUPPLY_PROP_ENERGY_FULL:
286 if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
289 val->intval = battery->full_charge_capacity * 1000;
291 case POWER_SUPPLY_PROP_CHARGE_NOW:
292 case POWER_SUPPLY_PROP_ENERGY_NOW:
293 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
296 val->intval = battery->capacity_now * 1000;
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;
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;
314 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
316 case POWER_SUPPLY_PROP_MODEL_NAME:
317 val->strval = battery->model_number;
319 case POWER_SUPPLY_PROP_MANUFACTURER:
320 val->strval = battery->oem_info;
322 case POWER_SUPPLY_PROP_SERIAL_NUMBER:
323 val->strval = battery->serial_number;
331 static 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,
349 static 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,
367 /* --------------------------------------------------------------------------
369 -------------------------------------------------------------------------- */
370 struct acpi_offsets {
371 size_t offset; /* offset inside struct acpi_sbs_battery */
372 u8 mode; /* int or string? */
375 static const struct acpi_offsets state_offsets[] = {
376 {offsetof(struct acpi_battery, state), 0},
377 {offsetof(struct acpi_battery, rate_now), 0},
378 {offsetof(struct acpi_battery, capacity_now), 0},
379 {offsetof(struct acpi_battery, voltage_now), 0},
382 static const struct acpi_offsets info_offsets[] = {
383 {offsetof(struct acpi_battery, power_unit), 0},
384 {offsetof(struct acpi_battery, design_capacity), 0},
385 {offsetof(struct acpi_battery, full_charge_capacity), 0},
386 {offsetof(struct acpi_battery, technology), 0},
387 {offsetof(struct acpi_battery, design_voltage), 0},
388 {offsetof(struct acpi_battery, design_capacity_warning), 0},
389 {offsetof(struct acpi_battery, design_capacity_low), 0},
390 {offsetof(struct acpi_battery, capacity_granularity_1), 0},
391 {offsetof(struct acpi_battery, capacity_granularity_2), 0},
392 {offsetof(struct acpi_battery, model_number), 1},
393 {offsetof(struct acpi_battery, serial_number), 1},
394 {offsetof(struct acpi_battery, type), 1},
395 {offsetof(struct acpi_battery, oem_info), 1},
398 static const struct acpi_offsets extended_info_offsets[] = {
399 {offsetof(struct acpi_battery, revision), 0},
400 {offsetof(struct acpi_battery, power_unit), 0},
401 {offsetof(struct acpi_battery, design_capacity), 0},
402 {offsetof(struct acpi_battery, full_charge_capacity), 0},
403 {offsetof(struct acpi_battery, technology), 0},
404 {offsetof(struct acpi_battery, design_voltage), 0},
405 {offsetof(struct acpi_battery, design_capacity_warning), 0},
406 {offsetof(struct acpi_battery, design_capacity_low), 0},
407 {offsetof(struct acpi_battery, cycle_count), 0},
408 {offsetof(struct acpi_battery, measurement_accuracy), 0},
409 {offsetof(struct acpi_battery, max_sampling_time), 0},
410 {offsetof(struct acpi_battery, min_sampling_time), 0},
411 {offsetof(struct acpi_battery, max_averaging_interval), 0},
412 {offsetof(struct acpi_battery, min_averaging_interval), 0},
413 {offsetof(struct acpi_battery, capacity_granularity_1), 0},
414 {offsetof(struct acpi_battery, capacity_granularity_2), 0},
415 {offsetof(struct acpi_battery, model_number), 1},
416 {offsetof(struct acpi_battery, serial_number), 1},
417 {offsetof(struct acpi_battery, type), 1},
418 {offsetof(struct acpi_battery, oem_info), 1},
421 static int extract_package(struct acpi_battery *battery,
422 union acpi_object *package,
423 const struct acpi_offsets *offsets, int num)
426 union acpi_object *element;
427 if (package->type != ACPI_TYPE_PACKAGE)
429 for (i = 0; i < num; ++i) {
430 if (package->package.count <= i)
432 element = &package->package.elements[i];
433 if (offsets[i].mode) {
434 u8 *ptr = (u8 *)battery + offsets[i].offset;
435 if (element->type == ACPI_TYPE_STRING ||
436 element->type == ACPI_TYPE_BUFFER)
437 strncpy(ptr, element->string.pointer, 32);
438 else if (element->type == ACPI_TYPE_INTEGER) {
439 strncpy(ptr, (u8 *)&element->integer.value,
441 ptr[sizeof(u64)] = 0;
443 *ptr = 0; /* don't have value */
445 int *x = (int *)((u8 *)battery + offsets[i].offset);
446 *x = (element->type == ACPI_TYPE_INTEGER) ?
447 element->integer.value : -1;
453 static int acpi_battery_get_status(struct acpi_battery *battery)
455 if (acpi_bus_get_status(battery->device)) {
456 ACPI_EXCEPTION((AE_INFO, AE_ERROR, "Evaluating _STA"));
463 static int extract_battery_info(const int use_bix,
464 struct acpi_battery *battery,
465 const struct acpi_buffer *buffer)
467 int result = -EFAULT;
469 if (use_bix && battery_bix_broken_package)
470 result = extract_package(battery, buffer->pointer,
471 extended_info_offsets + 1,
472 ARRAY_SIZE(extended_info_offsets) - 1);
474 result = extract_package(battery, buffer->pointer,
475 extended_info_offsets,
476 ARRAY_SIZE(extended_info_offsets));
478 result = extract_package(battery, buffer->pointer,
479 info_offsets, ARRAY_SIZE(info_offsets));
480 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
481 battery->full_charge_capacity = battery->design_capacity;
482 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
483 battery->power_unit && battery->design_voltage) {
484 battery->design_capacity = battery->design_capacity *
485 10000 / battery->design_voltage;
486 battery->full_charge_capacity = battery->full_charge_capacity *
487 10000 / battery->design_voltage;
488 battery->design_capacity_warning =
489 battery->design_capacity_warning *
490 10000 / battery->design_voltage;
491 /* Curiously, design_capacity_low, unlike the rest of them,
493 /* capacity_granularity_* equal 1 on the systems tested, so
494 it's impossible to tell if they would need an adjustment
495 or not if their values were higher. */
497 if (test_bit(ACPI_BATTERY_QUIRK_DEGRADED_FULL_CHARGE, &battery->flags) &&
498 battery->capacity_now > battery->full_charge_capacity)
499 battery->capacity_now = battery->full_charge_capacity;
504 static int acpi_battery_get_info(struct acpi_battery *battery)
506 const int xinfo = test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags);
508 int result = -ENODEV;
510 if (!acpi_battery_present(battery))
514 for (use_bix = xinfo ? 1 : 0; use_bix >= 0; use_bix--) {
515 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
516 acpi_status status = AE_ERROR;
518 mutex_lock(&battery->lock);
519 status = acpi_evaluate_object(battery->device->handle,
520 use_bix ? "_BIX":"_BIF",
522 mutex_unlock(&battery->lock);
524 if (ACPI_FAILURE(status)) {
525 ACPI_EXCEPTION((AE_INFO, status, "Evaluating %s",
526 use_bix ? "_BIX":"_BIF"));
528 result = extract_battery_info(use_bix,
532 kfree(buffer.pointer);
537 if (!result && !use_bix && xinfo)
538 pr_warn(FW_BUG "The _BIX method is broken, using _BIF.\n");
543 static int acpi_battery_get_state(struct acpi_battery *battery)
546 acpi_status status = 0;
547 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
549 if (!acpi_battery_present(battery))
552 if (battery->update_time &&
553 time_before(jiffies, battery->update_time +
554 msecs_to_jiffies(cache_time)))
557 mutex_lock(&battery->lock);
558 status = acpi_evaluate_object(battery->device->handle, "_BST",
560 mutex_unlock(&battery->lock);
562 if (ACPI_FAILURE(status)) {
563 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BST"));
567 result = extract_package(battery, buffer.pointer,
568 state_offsets, ARRAY_SIZE(state_offsets));
569 battery->update_time = jiffies;
570 kfree(buffer.pointer);
572 /* For buggy DSDTs that report negative 16-bit values for either
573 * charging or discharging current and/or report 0 as 65536
576 if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA &&
577 battery->rate_now != ACPI_BATTERY_VALUE_UNKNOWN &&
578 (s16)(battery->rate_now) < 0) {
579 battery->rate_now = abs((s16)battery->rate_now);
580 printk_once(KERN_WARNING FW_BUG
581 "battery: (dis)charge rate invalid.\n");
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;
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;
600 static int acpi_battery_set_alarm(struct acpi_battery *battery)
602 acpi_status status = 0;
604 if (!acpi_battery_present(battery) ||
605 !test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags))
608 mutex_lock(&battery->lock);
609 status = acpi_execute_simple_method(battery->device->handle, "_BTP",
611 mutex_unlock(&battery->lock);
613 if (ACPI_FAILURE(status))
616 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Alarm set to %d\n", battery->alarm));
620 static int acpi_battery_init_alarm(struct acpi_battery *battery)
622 /* See if alarms are supported, and if so, set default */
623 if (!acpi_has_method(battery->device->handle, "_BTP")) {
624 clear_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
627 set_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
629 battery->alarm = battery->design_capacity_warning;
630 return acpi_battery_set_alarm(battery);
633 static ssize_t acpi_battery_alarm_show(struct device *dev,
634 struct device_attribute *attr,
637 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
638 return sprintf(buf, "%d\n", battery->alarm * 1000);
641 static ssize_t acpi_battery_alarm_store(struct device *dev,
642 struct device_attribute *attr,
643 const char *buf, size_t count)
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);
654 static const struct device_attribute alarm_attr = {
655 .attr = {.name = "alarm", .mode = 0644},
656 .show = acpi_battery_alarm_show,
657 .store = acpi_battery_alarm_store,
661 * The Battery Hooking API
663 * This API is used inside other drivers that need to expose
664 * platform-specific behaviour within the generic driver in a
669 static LIST_HEAD(acpi_battery_list);
670 static LIST_HEAD(battery_hook_list);
671 static DEFINE_MUTEX(hook_mutex);
673 static void __battery_hook_unregister(struct acpi_battery_hook *hook, int lock)
675 struct acpi_battery *battery;
677 * In order to remove a hook, we first need to
678 * de-register all the batteries that are registered.
681 mutex_lock(&hook_mutex);
682 list_for_each_entry(battery, &acpi_battery_list, list) {
683 hook->remove_battery(battery->bat);
685 list_del(&hook->list);
687 mutex_unlock(&hook_mutex);
688 pr_info("extension unregistered: %s\n", hook->name);
691 void battery_hook_unregister(struct acpi_battery_hook *hook)
693 __battery_hook_unregister(hook, 1);
695 EXPORT_SYMBOL_GPL(battery_hook_unregister);
697 void battery_hook_register(struct acpi_battery_hook *hook)
699 struct acpi_battery *battery;
701 mutex_lock(&hook_mutex);
702 INIT_LIST_HEAD(&hook->list);
703 list_add(&hook->list, &battery_hook_list);
705 * Now that the driver is registered, we need
706 * to notify the hook that a battery is available
707 * for each battery, so that the driver may add
710 list_for_each_entry(battery, &acpi_battery_list, list) {
711 if (hook->add_battery(battery->bat)) {
713 * If a add-battery returns non-zero,
714 * the registration of the extension has failed,
715 * and we will not add it to the list of loaded
718 pr_err("extension failed to load: %s", hook->name);
719 __battery_hook_unregister(hook, 0);
723 pr_info("new extension: %s\n", hook->name);
725 mutex_unlock(&hook_mutex);
727 EXPORT_SYMBOL_GPL(battery_hook_register);
730 * This function gets called right after the battery sysfs
731 * attributes have been added, so that the drivers that
732 * define custom sysfs attributes can add their own.
734 static void battery_hook_add_battery(struct acpi_battery *battery)
736 struct acpi_battery_hook *hook_node, *tmp;
738 mutex_lock(&hook_mutex);
739 INIT_LIST_HEAD(&battery->list);
740 list_add(&battery->list, &acpi_battery_list);
742 * Since we added a new battery to the list, we need to
743 * iterate over the hooks and call add_battery for each
744 * hook that was registered. This usually happens
745 * when a battery gets hotplugged or initialized
746 * during the battery module initialization.
748 list_for_each_entry_safe(hook_node, tmp, &battery_hook_list, list) {
749 if (hook_node->add_battery(battery->bat)) {
751 * The notification of the extensions has failed, to
752 * prevent further errors we will unload the extension.
754 pr_err("error in extension, unloading: %s",
756 __battery_hook_unregister(hook_node, 0);
759 mutex_unlock(&hook_mutex);
762 static void battery_hook_remove_battery(struct acpi_battery *battery)
764 struct acpi_battery_hook *hook;
766 mutex_lock(&hook_mutex);
768 * Before removing the hook, we need to remove all
769 * custom attributes from the battery.
771 list_for_each_entry(hook, &battery_hook_list, list) {
772 hook->remove_battery(battery->bat);
774 /* Then, just remove the battery from the list */
775 list_del(&battery->list);
776 mutex_unlock(&hook_mutex);
779 static void __exit battery_hook_exit(void)
781 struct acpi_battery_hook *hook;
782 struct acpi_battery_hook *ptr;
784 * At this point, the acpi_bus_unregister_driver()
785 * has called remove for all batteries. We just
786 * need to remove the hooks.
788 list_for_each_entry_safe(hook, ptr, &battery_hook_list, list) {
789 __battery_hook_unregister(hook, 1);
791 mutex_destroy(&hook_mutex);
794 static int sysfs_add_battery(struct acpi_battery *battery)
796 struct power_supply_config psy_cfg = { .drv_data = battery, };
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);
803 battery->bat_desc.properties = energy_battery_props;
804 battery->bat_desc.num_properties =
805 ARRAY_SIZE(energy_battery_props);
808 battery->bat_desc.name = acpi_device_bid(battery->device);
809 battery->bat_desc.type = POWER_SUPPLY_TYPE_BATTERY;
810 battery->bat_desc.get_property = acpi_battery_get_property;
812 battery->bat = power_supply_register_no_ws(&battery->device->dev,
813 &battery->bat_desc, &psy_cfg);
815 if (IS_ERR(battery->bat)) {
816 int result = PTR_ERR(battery->bat);
821 battery_hook_add_battery(battery);
822 return device_create_file(&battery->bat->dev, &alarm_attr);
825 static void sysfs_remove_battery(struct acpi_battery *battery)
827 mutex_lock(&battery->sysfs_lock);
829 mutex_unlock(&battery->sysfs_lock);
832 battery_hook_remove_battery(battery);
833 device_remove_file(&battery->bat->dev, &alarm_attr);
834 power_supply_unregister(battery->bat);
836 mutex_unlock(&battery->sysfs_lock);
839 static void find_battery(const struct dmi_header *dm, void *private)
841 struct acpi_battery *battery = (struct acpi_battery *)private;
842 /* Note: the hardcoded offsets below have been extracted from
843 the source code of dmidecode. */
844 if (dm->type == DMI_ENTRY_PORTABLE_BATTERY && dm->length >= 8) {
845 const u8 *dmi_data = (const u8 *)(dm + 1);
846 int dmi_capacity = get_unaligned((const u16 *)(dmi_data + 6));
847 if (dm->length >= 18)
848 dmi_capacity *= dmi_data[17];
849 if (battery->design_capacity * battery->design_voltage / 1000
851 battery->design_capacity * 10 == dmi_capacity)
852 set_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
858 * According to the ACPI spec, some kinds of primary batteries can
859 * report percentage battery remaining capacity directly to OS.
860 * In this case, it reports the Last Full Charged Capacity == 100
861 * and BatteryPresentRate == 0xFFFFFFFF.
863 * Now we found some battery reports percentage remaining capacity
864 * even if it's rechargeable.
865 * https://bugzilla.kernel.org/show_bug.cgi?id=15979
867 * Handle this correctly so that they won't break userspace.
869 static void acpi_battery_quirks(struct acpi_battery *battery)
871 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
874 if (battery->full_charge_capacity == 100 &&
875 battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN &&
876 battery->capacity_now >= 0 && battery->capacity_now <= 100) {
877 set_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags);
878 battery->full_charge_capacity = battery->design_capacity;
879 battery->capacity_now = (battery->capacity_now *
880 battery->full_charge_capacity) / 100;
883 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags))
886 if (battery->power_unit && dmi_name_in_vendors("LENOVO")) {
888 s = dmi_get_system_info(DMI_PRODUCT_VERSION);
889 if (s && !strncasecmp(s, "ThinkPad", 8)) {
890 dmi_walk(find_battery, battery);
891 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
893 battery->design_voltage) {
894 battery->design_capacity =
895 battery->design_capacity *
896 10000 / battery->design_voltage;
897 battery->full_charge_capacity =
898 battery->full_charge_capacity *
899 10000 / battery->design_voltage;
900 battery->design_capacity_warning =
901 battery->design_capacity_warning *
902 10000 / battery->design_voltage;
903 battery->capacity_now = battery->capacity_now *
904 10000 / battery->design_voltage;
909 if (test_bit(ACPI_BATTERY_QUIRK_DEGRADED_FULL_CHARGE, &battery->flags))
912 if (acpi_battery_is_degraded(battery) &&
913 battery->capacity_now > battery->full_charge_capacity) {
914 set_bit(ACPI_BATTERY_QUIRK_DEGRADED_FULL_CHARGE, &battery->flags);
915 battery->capacity_now = battery->full_charge_capacity;
919 static int acpi_battery_update(struct acpi_battery *battery, bool resume)
921 int result, old_present = acpi_battery_present(battery);
922 result = acpi_battery_get_status(battery);
925 if (!acpi_battery_present(battery)) {
926 sysfs_remove_battery(battery);
927 battery->update_time = 0;
934 if (!battery->update_time ||
935 old_present != acpi_battery_present(battery)) {
936 result = acpi_battery_get_info(battery);
939 acpi_battery_init_alarm(battery);
942 result = acpi_battery_get_state(battery);
945 acpi_battery_quirks(battery);
948 result = sysfs_add_battery(battery);
954 * Wakeup the system if battery is critical low
955 * or lower than the alarm level
957 if ((battery->state & ACPI_BATTERY_STATE_CRITICAL) ||
958 (test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags) &&
959 (battery->capacity_now <= battery->alarm)))
960 acpi_pm_wakeup_event(&battery->device->dev);
965 static void acpi_battery_refresh(struct acpi_battery *battery)
972 power_unit = battery->power_unit;
974 acpi_battery_get_info(battery);
976 if (power_unit == battery->power_unit)
979 /* The battery has changed its reporting units. */
980 sysfs_remove_battery(battery);
981 sysfs_add_battery(battery);
984 /* --------------------------------------------------------------------------
986 -------------------------------------------------------------------------- */
988 #ifdef CONFIG_ACPI_PROCFS_POWER
989 static struct proc_dir_entry *acpi_battery_dir;
991 static const char *acpi_battery_units(const struct acpi_battery *battery)
993 return (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) ?
997 static int acpi_battery_info_proc_show(struct seq_file *seq, void *offset)
999 struct acpi_battery *battery = seq->private;
1000 int result = acpi_battery_update(battery, false);
1005 seq_printf(seq, "present: %s\n",
1006 acpi_battery_present(battery) ? "yes" : "no");
1007 if (!acpi_battery_present(battery))
1009 if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
1010 seq_printf(seq, "design capacity: unknown\n");
1012 seq_printf(seq, "design capacity: %d %sh\n",
1013 battery->design_capacity,
1014 acpi_battery_units(battery));
1016 if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
1017 seq_printf(seq, "last full capacity: unknown\n");
1019 seq_printf(seq, "last full capacity: %d %sh\n",
1020 battery->full_charge_capacity,
1021 acpi_battery_units(battery));
1023 seq_printf(seq, "battery technology: %srechargeable\n",
1024 (!battery->technology)?"non-":"");
1026 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
1027 seq_printf(seq, "design voltage: unknown\n");
1029 seq_printf(seq, "design voltage: %d mV\n",
1030 battery->design_voltage);
1031 seq_printf(seq, "design capacity warning: %d %sh\n",
1032 battery->design_capacity_warning,
1033 acpi_battery_units(battery));
1034 seq_printf(seq, "design capacity low: %d %sh\n",
1035 battery->design_capacity_low,
1036 acpi_battery_units(battery));
1037 seq_printf(seq, "cycle count: %i\n", battery->cycle_count);
1038 seq_printf(seq, "capacity granularity 1: %d %sh\n",
1039 battery->capacity_granularity_1,
1040 acpi_battery_units(battery));
1041 seq_printf(seq, "capacity granularity 2: %d %sh\n",
1042 battery->capacity_granularity_2,
1043 acpi_battery_units(battery));
1044 seq_printf(seq, "model number: %s\n", battery->model_number);
1045 seq_printf(seq, "serial number: %s\n", battery->serial_number);
1046 seq_printf(seq, "battery type: %s\n", battery->type);
1047 seq_printf(seq, "OEM info: %s\n", battery->oem_info);
1050 seq_printf(seq, "ERROR: Unable to read battery info\n");
1054 static int acpi_battery_state_proc_show(struct seq_file *seq, void *offset)
1056 struct acpi_battery *battery = seq->private;
1057 int result = acpi_battery_update(battery, false);
1062 seq_printf(seq, "present: %s\n",
1063 acpi_battery_present(battery) ? "yes" : "no");
1064 if (!acpi_battery_present(battery))
1067 seq_printf(seq, "capacity state: %s\n",
1068 (battery->state & 0x04) ? "critical" : "ok");
1069 if ((battery->state & 0x01) && (battery->state & 0x02))
1071 "charging state: charging/discharging\n");
1072 else if (battery->state & 0x01)
1073 seq_printf(seq, "charging state: discharging\n");
1074 else if (battery->state & 0x02)
1075 seq_printf(seq, "charging state: charging\n");
1077 seq_printf(seq, "charging state: charged\n");
1079 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
1080 seq_printf(seq, "present rate: unknown\n");
1082 seq_printf(seq, "present rate: %d %s\n",
1083 battery->rate_now, acpi_battery_units(battery));
1085 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
1086 seq_printf(seq, "remaining capacity: unknown\n");
1088 seq_printf(seq, "remaining capacity: %d %sh\n",
1089 battery->capacity_now, acpi_battery_units(battery));
1090 if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
1091 seq_printf(seq, "present voltage: unknown\n");
1093 seq_printf(seq, "present voltage: %d mV\n",
1094 battery->voltage_now);
1097 seq_printf(seq, "ERROR: Unable to read battery state\n");
1102 static int acpi_battery_alarm_proc_show(struct seq_file *seq, void *offset)
1104 struct acpi_battery *battery = seq->private;
1105 int result = acpi_battery_update(battery, false);
1110 if (!acpi_battery_present(battery)) {
1111 seq_printf(seq, "present: no\n");
1114 seq_printf(seq, "alarm: ");
1115 if (!battery->alarm)
1116 seq_printf(seq, "unsupported\n");
1118 seq_printf(seq, "%u %sh\n", battery->alarm,
1119 acpi_battery_units(battery));
1122 seq_printf(seq, "ERROR: Unable to read battery alarm\n");
1126 static ssize_t acpi_battery_write_alarm(struct file *file,
1127 const char __user * buffer,
1128 size_t count, loff_t * ppos)
1131 char alarm_string[12] = { '\0' };
1132 struct seq_file *m = file->private_data;
1133 struct acpi_battery *battery = m->private;
1135 if (!battery || (count > sizeof(alarm_string) - 1))
1137 if (!acpi_battery_present(battery)) {
1141 if (copy_from_user(alarm_string, buffer, count)) {
1145 alarm_string[count] = '\0';
1146 if (kstrtoint(alarm_string, 0, &battery->alarm)) {
1150 result = acpi_battery_set_alarm(battery);
1157 static int acpi_battery_alarm_proc_open(struct inode *inode, struct file *file)
1159 return single_open(file, acpi_battery_alarm_proc_show, PDE_DATA(inode));
1162 static const struct file_operations acpi_battery_alarm_fops = {
1163 .owner = THIS_MODULE,
1164 .open = acpi_battery_alarm_proc_open,
1166 .write = acpi_battery_write_alarm,
1167 .llseek = seq_lseek,
1168 .release = single_release,
1171 static int acpi_battery_add_fs(struct acpi_device *device)
1173 printk(KERN_WARNING PREFIX "Deprecated procfs I/F for battery is loaded,"
1174 " please retry with CONFIG_ACPI_PROCFS_POWER cleared\n");
1175 if (!acpi_device_dir(device)) {
1176 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
1178 if (!acpi_device_dir(device))
1182 if (!proc_create_single_data("info", S_IRUGO, acpi_device_dir(device),
1183 acpi_battery_info_proc_show, acpi_driver_data(device)))
1185 if (!proc_create_single_data("state", S_IRUGO, acpi_device_dir(device),
1186 acpi_battery_state_proc_show, acpi_driver_data(device)))
1188 if (!proc_create_data("alarm", S_IFREG | S_IRUGO | S_IWUSR,
1189 acpi_device_dir(device), &acpi_battery_alarm_fops,
1190 acpi_driver_data(device)))
1195 static void acpi_battery_remove_fs(struct acpi_device *device)
1197 if (!acpi_device_dir(device))
1199 remove_proc_subtree(acpi_device_bid(device), acpi_battery_dir);
1200 acpi_device_dir(device) = NULL;
1205 /* --------------------------------------------------------------------------
1207 -------------------------------------------------------------------------- */
1209 static void acpi_battery_notify(struct acpi_device *device, u32 event)
1211 struct acpi_battery *battery = acpi_driver_data(device);
1212 struct power_supply *old;
1218 * On Acer Aspire V5-573G notifications are sometimes triggered too
1219 * early. For example, when AC is unplugged and notification is
1220 * triggered, battery state is still reported as "Full", and changes to
1221 * "Discharging" only after short delay, without any notification.
1223 if (battery_notification_delay_ms > 0)
1224 msleep(battery_notification_delay_ms);
1225 if (event == ACPI_BATTERY_NOTIFY_INFO)
1226 acpi_battery_refresh(battery);
1227 acpi_battery_update(battery, false);
1228 acpi_bus_generate_netlink_event(device->pnp.device_class,
1229 dev_name(&device->dev), event,
1230 acpi_battery_present(battery));
1231 acpi_notifier_call_chain(device, event, acpi_battery_present(battery));
1232 /* acpi_battery_update could remove power_supply object */
1233 if (old && battery->bat)
1234 power_supply_changed(battery->bat);
1237 static int battery_notify(struct notifier_block *nb,
1238 unsigned long mode, void *_unused)
1240 struct acpi_battery *battery = container_of(nb, struct acpi_battery,
1245 case PM_POST_HIBERNATION:
1246 case PM_POST_SUSPEND:
1247 if (!acpi_battery_present(battery))
1250 if (!battery->bat) {
1251 result = acpi_battery_get_info(battery);
1255 result = sysfs_add_battery(battery);
1259 acpi_battery_refresh(battery);
1261 acpi_battery_init_alarm(battery);
1262 acpi_battery_get_state(battery);
1270 battery_bix_broken_package_quirk(const struct dmi_system_id *d)
1272 battery_bix_broken_package = 1;
1277 battery_notification_delay_quirk(const struct dmi_system_id *d)
1279 battery_notification_delay_ms = 1000;
1284 battery_ac_is_broken_quirk(const struct dmi_system_id *d)
1286 battery_ac_is_broken = 1;
1291 battery_do_not_check_pmic_quirk(const struct dmi_system_id *d)
1293 battery_check_pmic = 0;
1297 static const struct dmi_system_id bat_dmi_table[] __initconst = {
1300 .callback = battery_bix_broken_package_quirk,
1302 DMI_MATCH(DMI_SYS_VENDOR, "NEC"),
1303 DMI_MATCH(DMI_PRODUCT_NAME, "PC-LZ750LS"),
1307 /* Acer Aspire V5-573G */
1308 .callback = battery_notification_delay_quirk,
1310 DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
1311 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire V5-573G"),
1315 /* Point of View mobii wintab p800w */
1316 .callback = battery_ac_is_broken_quirk,
1318 DMI_MATCH(DMI_BOARD_VENDOR, "AMI Corporation"),
1319 DMI_MATCH(DMI_BOARD_NAME, "Aptio CRB"),
1320 DMI_MATCH(DMI_BIOS_VERSION, "3BAIR1013"),
1321 /* Above matches are too generic, add bios-date match */
1322 DMI_MATCH(DMI_BIOS_DATE, "08/22/2014"),
1327 .callback = battery_do_not_check_pmic_quirk,
1329 DMI_MATCH(DMI_PRODUCT_NAME, "EF20EA"),
1333 /* Lenovo Ideapad Miix 320 */
1334 .callback = battery_do_not_check_pmic_quirk,
1336 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "LENOVO"),
1337 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "80XF"),
1338 DMI_EXACT_MATCH(DMI_PRODUCT_VERSION, "Lenovo MIIX 320-10ICR"),
1345 * Some machines'(E,G Lenovo Z480) ECs are not stable
1346 * during boot up and this causes battery driver fails to be
1347 * probed due to failure of getting battery information
1348 * from EC sometimes. After several retries, the operation
1349 * may work. So add retry code here and 20ms sleep between
1352 static int acpi_battery_update_retry(struct acpi_battery *battery)
1356 for (retry = 5; retry; retry--) {
1357 ret = acpi_battery_update(battery, false);
1366 static int acpi_battery_add(struct acpi_device *device)
1369 struct acpi_battery *battery = NULL;
1374 if (device->dep_unmet)
1375 return -EPROBE_DEFER;
1377 battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL);
1380 battery->device = device;
1381 strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME);
1382 strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS);
1383 device->driver_data = battery;
1384 mutex_init(&battery->lock);
1385 mutex_init(&battery->sysfs_lock);
1386 if (acpi_has_method(battery->device->handle, "_BIX"))
1387 set_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags);
1389 result = acpi_battery_update_retry(battery);
1393 #ifdef CONFIG_ACPI_PROCFS_POWER
1394 result = acpi_battery_add_fs(device);
1396 acpi_battery_remove_fs(device);
1401 printk(KERN_INFO PREFIX "%s Slot [%s] (battery %s)\n",
1402 ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device),
1403 device->status.battery_present ? "present" : "absent");
1405 battery->pm_nb.notifier_call = battery_notify;
1406 register_pm_notifier(&battery->pm_nb);
1408 device_init_wakeup(&device->dev, 1);
1413 sysfs_remove_battery(battery);
1414 mutex_destroy(&battery->lock);
1415 mutex_destroy(&battery->sysfs_lock);
1420 static int acpi_battery_remove(struct acpi_device *device)
1422 struct acpi_battery *battery = NULL;
1424 if (!device || !acpi_driver_data(device))
1426 device_init_wakeup(&device->dev, 0);
1427 battery = acpi_driver_data(device);
1428 unregister_pm_notifier(&battery->pm_nb);
1429 #ifdef CONFIG_ACPI_PROCFS_POWER
1430 acpi_battery_remove_fs(device);
1432 sysfs_remove_battery(battery);
1433 mutex_destroy(&battery->lock);
1434 mutex_destroy(&battery->sysfs_lock);
1439 #ifdef CONFIG_PM_SLEEP
1440 /* this is needed to learn about changes made in suspended state */
1441 static int acpi_battery_resume(struct device *dev)
1443 struct acpi_battery *battery;
1448 battery = acpi_driver_data(to_acpi_device(dev));
1452 battery->update_time = 0;
1453 acpi_battery_update(battery, true);
1457 #define acpi_battery_resume NULL
1460 static SIMPLE_DEV_PM_OPS(acpi_battery_pm, NULL, acpi_battery_resume);
1462 static struct acpi_driver acpi_battery_driver = {
1464 .class = ACPI_BATTERY_CLASS,
1465 .ids = battery_device_ids,
1466 .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
1468 .add = acpi_battery_add,
1469 .remove = acpi_battery_remove,
1470 .notify = acpi_battery_notify,
1472 .drv.pm = &acpi_battery_pm,
1475 static void __init acpi_battery_init_async(void *unused, async_cookie_t cookie)
1480 dmi_check_system(bat_dmi_table);
1482 if (battery_check_pmic) {
1483 for (i = 0; i < ARRAY_SIZE(acpi_battery_blacklist); i++)
1484 if (acpi_dev_present(acpi_battery_blacklist[i], "1", -1)) {
1485 pr_info(PREFIX ACPI_BATTERY_DEVICE_NAME
1486 ": found native %s PMIC, not loading\n",
1487 acpi_battery_blacklist[i]);
1492 #ifdef CONFIG_ACPI_PROCFS_POWER
1493 acpi_battery_dir = acpi_lock_battery_dir();
1494 if (!acpi_battery_dir)
1497 result = acpi_bus_register_driver(&acpi_battery_driver);
1498 #ifdef CONFIG_ACPI_PROCFS_POWER
1500 acpi_unlock_battery_dir(acpi_battery_dir);
1502 battery_driver_registered = (result == 0);
1505 static int __init acpi_battery_init(void)
1510 async_cookie = async_schedule(acpi_battery_init_async, NULL);
1514 static void __exit acpi_battery_exit(void)
1516 async_synchronize_cookie(async_cookie + 1);
1517 if (battery_driver_registered) {
1518 acpi_bus_unregister_driver(&acpi_battery_driver);
1519 battery_hook_exit();
1521 #ifdef CONFIG_ACPI_PROCFS_POWER
1522 if (acpi_battery_dir)
1523 acpi_unlock_battery_dir(acpi_battery_dir);
1527 module_init(acpi_battery_init);
1528 module_exit(acpi_battery_exit);