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 * You should have received a copy of the GNU General Public License along
22 * with this program; if not, write to the Free Software Foundation, Inc.,
23 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
25 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
28 #include <linux/kernel.h>
29 #include <linux/module.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/slab.h>
36 #include <linux/suspend.h>
37 #include <asm/unaligned.h>
39 #ifdef CONFIG_ACPI_PROCFS_POWER
40 #include <linux/proc_fs.h>
41 #include <linux/seq_file.h>
42 #include <asm/uaccess.h>
45 #include <acpi/acpi_bus.h>
46 #include <acpi/acpi_drivers.h>
47 #include <linux/power_supply.h>
49 #define PREFIX "ACPI: "
51 #define ACPI_BATTERY_VALUE_UNKNOWN 0xFFFFFFFF
53 #define ACPI_BATTERY_CLASS "battery"
54 #define ACPI_BATTERY_DEVICE_NAME "Battery"
55 #define ACPI_BATTERY_NOTIFY_STATUS 0x80
56 #define ACPI_BATTERY_NOTIFY_INFO 0x81
57 #define ACPI_BATTERY_NOTIFY_THRESHOLD 0x82
59 /* Battery power unit: 0 means mW, 1 means mA */
60 #define ACPI_BATTERY_POWER_UNIT_MA 1
62 #define _COMPONENT ACPI_BATTERY_COMPONENT
64 ACPI_MODULE_NAME("battery");
66 MODULE_AUTHOR("Paul Diefenbaugh");
67 MODULE_AUTHOR("Alexey Starikovskiy <astarikovskiy@suse.de>");
68 MODULE_DESCRIPTION("ACPI Battery Driver");
69 MODULE_LICENSE("GPL");
71 static unsigned int cache_time = 1000;
72 module_param(cache_time, uint, 0644);
73 MODULE_PARM_DESC(cache_time, "cache time in milliseconds");
75 #ifdef CONFIG_ACPI_PROCFS_POWER
76 extern struct proc_dir_entry *acpi_lock_battery_dir(void);
77 extern void *acpi_unlock_battery_dir(struct proc_dir_entry *acpi_battery_dir);
79 enum acpi_battery_files {
83 ACPI_BATTERY_NUMFILES,
88 static const struct acpi_device_id battery_device_ids[] = {
93 MODULE_DEVICE_TABLE(acpi, battery_device_ids);
96 ACPI_BATTERY_ALARM_PRESENT,
97 ACPI_BATTERY_XINFO_PRESENT,
98 ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY,
99 /* On Lenovo Thinkpad models from 2010 and 2011, the power unit
100 switches between mWh and mAh depending on whether the system
101 is running on battery or not. When mAh is the unit, most
102 reported values are incorrect and need to be adjusted by
103 10000/design_voltage. Verified on x201, t410, t410s, and x220.
104 Pre-2010 and 2012 models appear to always report in mWh and
105 are thus unaffected (tested with t42, t61, t500, x200, x300,
106 and x230). Also, in mid-2012 Lenovo issued a BIOS update for
107 the 2011 models that fixes the issue (tested on x220 with a
108 post-1.29 BIOS), but as of Nov. 2012, no such update is
109 available for the 2010 models. */
110 ACPI_BATTERY_QUIRK_THINKPAD_MAH,
113 struct acpi_battery {
115 struct mutex sysfs_lock;
116 struct power_supply bat;
117 struct acpi_device *device;
118 struct notifier_block pm_nb;
119 unsigned long update_time;
125 int full_charge_capacity;
128 int design_capacity_warning;
129 int design_capacity_low;
131 int measurement_accuracy;
132 int max_sampling_time;
133 int min_sampling_time;
134 int max_averaging_interval;
135 int min_averaging_interval;
136 int capacity_granularity_1;
137 int capacity_granularity_2;
139 char model_number[32];
140 char serial_number[32];
148 #define to_acpi_battery(x) container_of(x, struct acpi_battery, bat)
150 static inline int acpi_battery_present(struct acpi_battery *battery)
152 return battery->device->status.battery_present;
155 static int acpi_battery_technology(struct acpi_battery *battery)
157 if (!strcasecmp("NiCd", battery->type))
158 return POWER_SUPPLY_TECHNOLOGY_NiCd;
159 if (!strcasecmp("NiMH", battery->type))
160 return POWER_SUPPLY_TECHNOLOGY_NiMH;
161 if (!strcasecmp("LION", battery->type))
162 return POWER_SUPPLY_TECHNOLOGY_LION;
163 if (!strncasecmp("LI-ION", battery->type, 6))
164 return POWER_SUPPLY_TECHNOLOGY_LION;
165 if (!strcasecmp("LiP", battery->type))
166 return POWER_SUPPLY_TECHNOLOGY_LIPO;
167 return POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
170 static int acpi_battery_get_state(struct acpi_battery *battery);
172 static int acpi_battery_is_charged(struct acpi_battery *battery)
174 /* either charging or discharging */
175 if (battery->state != 0)
178 /* battery not reporting charge */
179 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN ||
180 battery->capacity_now == 0)
183 /* good batteries update full_charge as the batteries degrade */
184 if (battery->full_charge_capacity == battery->capacity_now)
187 /* fallback to using design values for broken batteries */
188 if (battery->design_capacity == battery->capacity_now)
191 /* we don't do any sort of metric based on percentages */
195 static int acpi_battery_get_property(struct power_supply *psy,
196 enum power_supply_property psp,
197 union power_supply_propval *val)
200 struct acpi_battery *battery = to_acpi_battery(psy);
202 if (acpi_battery_present(battery)) {
203 /* run battery update only if it is present */
204 acpi_battery_get_state(battery);
205 } else if (psp != POWER_SUPPLY_PROP_PRESENT)
208 case POWER_SUPPLY_PROP_STATUS:
209 if (battery->state & 0x01)
210 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
211 else if (battery->state & 0x02)
212 val->intval = POWER_SUPPLY_STATUS_CHARGING;
213 else if (acpi_battery_is_charged(battery))
214 val->intval = POWER_SUPPLY_STATUS_FULL;
216 val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
218 case POWER_SUPPLY_PROP_PRESENT:
219 val->intval = acpi_battery_present(battery);
221 case POWER_SUPPLY_PROP_TECHNOLOGY:
222 val->intval = acpi_battery_technology(battery);
224 case POWER_SUPPLY_PROP_CYCLE_COUNT:
225 val->intval = battery->cycle_count;
227 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
228 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
231 val->intval = battery->design_voltage * 1000;
233 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
234 if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
237 val->intval = battery->voltage_now * 1000;
239 case POWER_SUPPLY_PROP_CURRENT_NOW:
240 case POWER_SUPPLY_PROP_POWER_NOW:
241 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
244 val->intval = battery->rate_now * 1000;
246 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
247 case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
248 if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
251 val->intval = battery->design_capacity * 1000;
253 case POWER_SUPPLY_PROP_CHARGE_FULL:
254 case POWER_SUPPLY_PROP_ENERGY_FULL:
255 if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
258 val->intval = battery->full_charge_capacity * 1000;
260 case POWER_SUPPLY_PROP_CHARGE_NOW:
261 case POWER_SUPPLY_PROP_ENERGY_NOW:
262 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
265 val->intval = battery->capacity_now * 1000;
267 case POWER_SUPPLY_PROP_CAPACITY:
268 if (battery->capacity_now && battery->full_charge_capacity)
269 val->intval = battery->capacity_now * 100/
270 battery->full_charge_capacity;
274 case POWER_SUPPLY_PROP_MODEL_NAME:
275 val->strval = battery->model_number;
277 case POWER_SUPPLY_PROP_MANUFACTURER:
278 val->strval = battery->oem_info;
280 case POWER_SUPPLY_PROP_SERIAL_NUMBER:
281 val->strval = battery->serial_number;
289 static enum power_supply_property charge_battery_props[] = {
290 POWER_SUPPLY_PROP_STATUS,
291 POWER_SUPPLY_PROP_PRESENT,
292 POWER_SUPPLY_PROP_TECHNOLOGY,
293 POWER_SUPPLY_PROP_CYCLE_COUNT,
294 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
295 POWER_SUPPLY_PROP_VOLTAGE_NOW,
296 POWER_SUPPLY_PROP_CURRENT_NOW,
297 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
298 POWER_SUPPLY_PROP_CHARGE_FULL,
299 POWER_SUPPLY_PROP_CHARGE_NOW,
300 POWER_SUPPLY_PROP_CAPACITY,
301 POWER_SUPPLY_PROP_MODEL_NAME,
302 POWER_SUPPLY_PROP_MANUFACTURER,
303 POWER_SUPPLY_PROP_SERIAL_NUMBER,
306 static enum power_supply_property energy_battery_props[] = {
307 POWER_SUPPLY_PROP_STATUS,
308 POWER_SUPPLY_PROP_PRESENT,
309 POWER_SUPPLY_PROP_TECHNOLOGY,
310 POWER_SUPPLY_PROP_CYCLE_COUNT,
311 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
312 POWER_SUPPLY_PROP_VOLTAGE_NOW,
313 POWER_SUPPLY_PROP_POWER_NOW,
314 POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
315 POWER_SUPPLY_PROP_ENERGY_FULL,
316 POWER_SUPPLY_PROP_ENERGY_NOW,
317 POWER_SUPPLY_PROP_CAPACITY,
318 POWER_SUPPLY_PROP_MODEL_NAME,
319 POWER_SUPPLY_PROP_MANUFACTURER,
320 POWER_SUPPLY_PROP_SERIAL_NUMBER,
323 #ifdef CONFIG_ACPI_PROCFS_POWER
324 inline char *acpi_battery_units(struct acpi_battery *battery)
326 return (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) ?
331 /* --------------------------------------------------------------------------
333 -------------------------------------------------------------------------- */
334 struct acpi_offsets {
335 size_t offset; /* offset inside struct acpi_sbs_battery */
336 u8 mode; /* int or string? */
339 static struct acpi_offsets state_offsets[] = {
340 {offsetof(struct acpi_battery, state), 0},
341 {offsetof(struct acpi_battery, rate_now), 0},
342 {offsetof(struct acpi_battery, capacity_now), 0},
343 {offsetof(struct acpi_battery, voltage_now), 0},
346 static struct acpi_offsets info_offsets[] = {
347 {offsetof(struct acpi_battery, power_unit), 0},
348 {offsetof(struct acpi_battery, design_capacity), 0},
349 {offsetof(struct acpi_battery, full_charge_capacity), 0},
350 {offsetof(struct acpi_battery, technology), 0},
351 {offsetof(struct acpi_battery, design_voltage), 0},
352 {offsetof(struct acpi_battery, design_capacity_warning), 0},
353 {offsetof(struct acpi_battery, design_capacity_low), 0},
354 {offsetof(struct acpi_battery, capacity_granularity_1), 0},
355 {offsetof(struct acpi_battery, capacity_granularity_2), 0},
356 {offsetof(struct acpi_battery, model_number), 1},
357 {offsetof(struct acpi_battery, serial_number), 1},
358 {offsetof(struct acpi_battery, type), 1},
359 {offsetof(struct acpi_battery, oem_info), 1},
362 static struct acpi_offsets extended_info_offsets[] = {
363 {offsetof(struct acpi_battery, revision), 0},
364 {offsetof(struct acpi_battery, power_unit), 0},
365 {offsetof(struct acpi_battery, design_capacity), 0},
366 {offsetof(struct acpi_battery, full_charge_capacity), 0},
367 {offsetof(struct acpi_battery, technology), 0},
368 {offsetof(struct acpi_battery, design_voltage), 0},
369 {offsetof(struct acpi_battery, design_capacity_warning), 0},
370 {offsetof(struct acpi_battery, design_capacity_low), 0},
371 {offsetof(struct acpi_battery, cycle_count), 0},
372 {offsetof(struct acpi_battery, measurement_accuracy), 0},
373 {offsetof(struct acpi_battery, max_sampling_time), 0},
374 {offsetof(struct acpi_battery, min_sampling_time), 0},
375 {offsetof(struct acpi_battery, max_averaging_interval), 0},
376 {offsetof(struct acpi_battery, min_averaging_interval), 0},
377 {offsetof(struct acpi_battery, capacity_granularity_1), 0},
378 {offsetof(struct acpi_battery, capacity_granularity_2), 0},
379 {offsetof(struct acpi_battery, model_number), 1},
380 {offsetof(struct acpi_battery, serial_number), 1},
381 {offsetof(struct acpi_battery, type), 1},
382 {offsetof(struct acpi_battery, oem_info), 1},
385 static int extract_package(struct acpi_battery *battery,
386 union acpi_object *package,
387 struct acpi_offsets *offsets, int num)
390 union acpi_object *element;
391 if (package->type != ACPI_TYPE_PACKAGE)
393 for (i = 0; i < num; ++i) {
394 if (package->package.count <= i)
396 element = &package->package.elements[i];
397 if (offsets[i].mode) {
398 u8 *ptr = (u8 *)battery + offsets[i].offset;
399 if (element->type == ACPI_TYPE_STRING ||
400 element->type == ACPI_TYPE_BUFFER)
401 strncpy(ptr, element->string.pointer, 32);
402 else if (element->type == ACPI_TYPE_INTEGER) {
403 strncpy(ptr, (u8 *)&element->integer.value,
405 ptr[sizeof(u64)] = 0;
407 *ptr = 0; /* don't have value */
409 int *x = (int *)((u8 *)battery + offsets[i].offset);
410 *x = (element->type == ACPI_TYPE_INTEGER) ?
411 element->integer.value : -1;
417 static int acpi_battery_get_status(struct acpi_battery *battery)
419 if (acpi_bus_get_status(battery->device)) {
420 ACPI_EXCEPTION((AE_INFO, AE_ERROR, "Evaluating _STA"));
426 static int acpi_battery_get_info(struct acpi_battery *battery)
428 int result = -EFAULT;
429 acpi_status status = 0;
430 char *name = test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags)?
433 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
435 if (!acpi_battery_present(battery))
437 mutex_lock(&battery->lock);
438 status = acpi_evaluate_object(battery->device->handle, name,
440 mutex_unlock(&battery->lock);
442 if (ACPI_FAILURE(status)) {
443 ACPI_EXCEPTION((AE_INFO, status, "Evaluating %s", name));
446 if (test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags))
447 result = extract_package(battery, buffer.pointer,
448 extended_info_offsets,
449 ARRAY_SIZE(extended_info_offsets));
451 result = extract_package(battery, buffer.pointer,
452 info_offsets, ARRAY_SIZE(info_offsets));
453 kfree(buffer.pointer);
454 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
455 battery->full_charge_capacity = battery->design_capacity;
456 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
457 battery->power_unit && battery->design_voltage) {
458 battery->design_capacity = battery->design_capacity *
459 10000 / battery->design_voltage;
460 battery->full_charge_capacity = battery->full_charge_capacity *
461 10000 / battery->design_voltage;
462 battery->design_capacity_warning =
463 battery->design_capacity_warning *
464 10000 / battery->design_voltage;
465 /* Curiously, design_capacity_low, unlike the rest of them,
467 /* capacity_granularity_* equal 1 on the systems tested, so
468 it's impossible to tell if they would need an adjustment
469 or not if their values were higher. */
474 static int acpi_battery_get_state(struct acpi_battery *battery)
477 acpi_status status = 0;
478 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
480 if (!acpi_battery_present(battery))
483 if (battery->update_time &&
484 time_before(jiffies, battery->update_time +
485 msecs_to_jiffies(cache_time)))
488 mutex_lock(&battery->lock);
489 status = acpi_evaluate_object(battery->device->handle, "_BST",
491 mutex_unlock(&battery->lock);
493 if (ACPI_FAILURE(status)) {
494 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BST"));
498 result = extract_package(battery, buffer.pointer,
499 state_offsets, ARRAY_SIZE(state_offsets));
500 battery->update_time = jiffies;
501 kfree(buffer.pointer);
503 /* For buggy DSDTs that report negative 16-bit values for either
504 * charging or discharging current and/or report 0 as 65536
507 if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA &&
508 battery->rate_now != ACPI_BATTERY_VALUE_UNKNOWN &&
509 (s16)(battery->rate_now) < 0) {
510 battery->rate_now = abs((s16)battery->rate_now);
511 printk_once(KERN_WARNING FW_BUG "battery: (dis)charge rate"
515 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags)
516 && battery->capacity_now >= 0 && battery->capacity_now <= 100)
517 battery->capacity_now = (battery->capacity_now *
518 battery->full_charge_capacity) / 100;
519 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
520 battery->power_unit && battery->design_voltage) {
521 battery->capacity_now = battery->capacity_now *
522 10000 / battery->design_voltage;
527 static int acpi_battery_set_alarm(struct acpi_battery *battery)
529 acpi_status status = 0;
530 union acpi_object arg0 = { .type = ACPI_TYPE_INTEGER };
531 struct acpi_object_list arg_list = { 1, &arg0 };
533 if (!acpi_battery_present(battery) ||
534 !test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags))
537 arg0.integer.value = battery->alarm;
539 mutex_lock(&battery->lock);
540 status = acpi_evaluate_object(battery->device->handle, "_BTP",
542 mutex_unlock(&battery->lock);
544 if (ACPI_FAILURE(status))
547 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Alarm set to %d\n", battery->alarm));
551 static int acpi_battery_init_alarm(struct acpi_battery *battery)
553 acpi_status status = AE_OK;
554 acpi_handle handle = NULL;
556 /* See if alarms are supported, and if so, set default */
557 status = acpi_get_handle(battery->device->handle, "_BTP", &handle);
558 if (ACPI_FAILURE(status)) {
559 clear_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
562 set_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
564 battery->alarm = battery->design_capacity_warning;
565 return acpi_battery_set_alarm(battery);
568 static ssize_t acpi_battery_alarm_show(struct device *dev,
569 struct device_attribute *attr,
572 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
573 return sprintf(buf, "%d\n", battery->alarm * 1000);
576 static ssize_t acpi_battery_alarm_store(struct device *dev,
577 struct device_attribute *attr,
578 const char *buf, size_t count)
581 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
582 if (sscanf(buf, "%ld\n", &x) == 1)
583 battery->alarm = x/1000;
584 if (acpi_battery_present(battery))
585 acpi_battery_set_alarm(battery);
589 static struct device_attribute alarm_attr = {
590 .attr = {.name = "alarm", .mode = 0644},
591 .show = acpi_battery_alarm_show,
592 .store = acpi_battery_alarm_store,
595 static int sysfs_add_battery(struct acpi_battery *battery)
599 if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) {
600 battery->bat.properties = charge_battery_props;
601 battery->bat.num_properties =
602 ARRAY_SIZE(charge_battery_props);
604 battery->bat.properties = energy_battery_props;
605 battery->bat.num_properties =
606 ARRAY_SIZE(energy_battery_props);
609 battery->bat.name = acpi_device_bid(battery->device);
610 battery->bat.type = POWER_SUPPLY_TYPE_BATTERY;
611 battery->bat.get_property = acpi_battery_get_property;
613 result = power_supply_register(&battery->device->dev, &battery->bat);
616 return device_create_file(battery->bat.dev, &alarm_attr);
619 static void sysfs_remove_battery(struct acpi_battery *battery)
621 mutex_lock(&battery->sysfs_lock);
622 if (!battery->bat.dev) {
623 mutex_unlock(&battery->sysfs_lock);
627 device_remove_file(battery->bat.dev, &alarm_attr);
628 power_supply_unregister(&battery->bat);
629 battery->bat.dev = NULL;
630 mutex_unlock(&battery->sysfs_lock);
633 static void find_battery(const struct dmi_header *dm, void *private)
635 struct acpi_battery *battery = (struct acpi_battery *)private;
636 /* Note: the hardcoded offsets below have been extracted from
637 the source code of dmidecode. */
638 if (dm->type == DMI_ENTRY_PORTABLE_BATTERY && dm->length >= 8) {
639 const u8 *dmi_data = (const u8 *)(dm + 1);
640 int dmi_capacity = get_unaligned((const u16 *)(dmi_data + 6));
641 if (dm->length >= 18)
642 dmi_capacity *= dmi_data[17];
643 if (battery->design_capacity * battery->design_voltage / 1000
645 battery->design_capacity * 10 == dmi_capacity)
646 set_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
652 * According to the ACPI spec, some kinds of primary batteries can
653 * report percentage battery remaining capacity directly to OS.
654 * In this case, it reports the Last Full Charged Capacity == 100
655 * and BatteryPresentRate == 0xFFFFFFFF.
657 * Now we found some battery reports percentage remaining capacity
658 * even if it's rechargeable.
659 * https://bugzilla.kernel.org/show_bug.cgi?id=15979
661 * Handle this correctly so that they won't break userspace.
663 static void acpi_battery_quirks(struct acpi_battery *battery)
665 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
668 if (battery->full_charge_capacity == 100 &&
669 battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN &&
670 battery->capacity_now >=0 && battery->capacity_now <= 100) {
671 set_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags);
672 battery->full_charge_capacity = battery->design_capacity;
673 battery->capacity_now = (battery->capacity_now *
674 battery->full_charge_capacity) / 100;
677 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags))
680 if (battery->power_unit && dmi_name_in_vendors("LENOVO")) {
682 s = dmi_get_system_info(DMI_PRODUCT_VERSION);
683 if (s && !strnicmp(s, "ThinkPad", 8)) {
684 dmi_walk(find_battery, battery);
685 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
687 battery->design_voltage) {
688 battery->design_capacity =
689 battery->design_capacity *
690 10000 / battery->design_voltage;
691 battery->full_charge_capacity =
692 battery->full_charge_capacity *
693 10000 / battery->design_voltage;
694 battery->design_capacity_warning =
695 battery->design_capacity_warning *
696 10000 / battery->design_voltage;
697 battery->capacity_now = battery->capacity_now *
698 10000 / battery->design_voltage;
704 static int acpi_battery_update(struct acpi_battery *battery)
706 int result, old_present = acpi_battery_present(battery);
707 result = acpi_battery_get_status(battery);
710 if (!acpi_battery_present(battery)) {
711 sysfs_remove_battery(battery);
712 battery->update_time = 0;
715 if (!battery->update_time ||
716 old_present != acpi_battery_present(battery)) {
717 result = acpi_battery_get_info(battery);
720 acpi_battery_init_alarm(battery);
722 if (!battery->bat.dev) {
723 result = sysfs_add_battery(battery);
727 result = acpi_battery_get_state(battery);
728 acpi_battery_quirks(battery);
732 static void acpi_battery_refresh(struct acpi_battery *battery)
736 if (!battery->bat.dev)
739 power_unit = battery->power_unit;
741 acpi_battery_get_info(battery);
743 if (power_unit == battery->power_unit)
746 /* The battery has changed its reporting units. */
747 sysfs_remove_battery(battery);
748 sysfs_add_battery(battery);
751 /* --------------------------------------------------------------------------
753 -------------------------------------------------------------------------- */
755 #ifdef CONFIG_ACPI_PROCFS_POWER
756 static struct proc_dir_entry *acpi_battery_dir;
758 static int acpi_battery_print_info(struct seq_file *seq, int result)
760 struct acpi_battery *battery = seq->private;
765 seq_printf(seq, "present: %s\n",
766 acpi_battery_present(battery)?"yes":"no");
767 if (!acpi_battery_present(battery))
769 if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
770 seq_printf(seq, "design capacity: unknown\n");
772 seq_printf(seq, "design capacity: %d %sh\n",
773 battery->design_capacity,
774 acpi_battery_units(battery));
776 if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
777 seq_printf(seq, "last full capacity: unknown\n");
779 seq_printf(seq, "last full capacity: %d %sh\n",
780 battery->full_charge_capacity,
781 acpi_battery_units(battery));
783 seq_printf(seq, "battery technology: %srechargeable\n",
784 (!battery->technology)?"non-":"");
786 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
787 seq_printf(seq, "design voltage: unknown\n");
789 seq_printf(seq, "design voltage: %d mV\n",
790 battery->design_voltage);
791 seq_printf(seq, "design capacity warning: %d %sh\n",
792 battery->design_capacity_warning,
793 acpi_battery_units(battery));
794 seq_printf(seq, "design capacity low: %d %sh\n",
795 battery->design_capacity_low,
796 acpi_battery_units(battery));
797 seq_printf(seq, "cycle count: %i\n", battery->cycle_count);
798 seq_printf(seq, "capacity granularity 1: %d %sh\n",
799 battery->capacity_granularity_1,
800 acpi_battery_units(battery));
801 seq_printf(seq, "capacity granularity 2: %d %sh\n",
802 battery->capacity_granularity_2,
803 acpi_battery_units(battery));
804 seq_printf(seq, "model number: %s\n", battery->model_number);
805 seq_printf(seq, "serial number: %s\n", battery->serial_number);
806 seq_printf(seq, "battery type: %s\n", battery->type);
807 seq_printf(seq, "OEM info: %s\n", battery->oem_info);
810 seq_printf(seq, "ERROR: Unable to read battery info\n");
814 static int acpi_battery_print_state(struct seq_file *seq, int result)
816 struct acpi_battery *battery = seq->private;
821 seq_printf(seq, "present: %s\n",
822 acpi_battery_present(battery)?"yes":"no");
823 if (!acpi_battery_present(battery))
826 seq_printf(seq, "capacity state: %s\n",
827 (battery->state & 0x04)?"critical":"ok");
828 if ((battery->state & 0x01) && (battery->state & 0x02))
830 "charging state: charging/discharging\n");
831 else if (battery->state & 0x01)
832 seq_printf(seq, "charging state: discharging\n");
833 else if (battery->state & 0x02)
834 seq_printf(seq, "charging state: charging\n");
836 seq_printf(seq, "charging state: charged\n");
838 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
839 seq_printf(seq, "present rate: unknown\n");
841 seq_printf(seq, "present rate: %d %s\n",
842 battery->rate_now, acpi_battery_units(battery));
844 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
845 seq_printf(seq, "remaining capacity: unknown\n");
847 seq_printf(seq, "remaining capacity: %d %sh\n",
848 battery->capacity_now, acpi_battery_units(battery));
849 if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
850 seq_printf(seq, "present voltage: unknown\n");
852 seq_printf(seq, "present voltage: %d mV\n",
853 battery->voltage_now);
856 seq_printf(seq, "ERROR: Unable to read battery state\n");
861 static int acpi_battery_print_alarm(struct seq_file *seq, int result)
863 struct acpi_battery *battery = seq->private;
868 if (!acpi_battery_present(battery)) {
869 seq_printf(seq, "present: no\n");
872 seq_printf(seq, "alarm: ");
874 seq_printf(seq, "unsupported\n");
876 seq_printf(seq, "%u %sh\n", battery->alarm,
877 acpi_battery_units(battery));
880 seq_printf(seq, "ERROR: Unable to read battery alarm\n");
884 static ssize_t acpi_battery_write_alarm(struct file *file,
885 const char __user * buffer,
886 size_t count, loff_t * ppos)
889 char alarm_string[12] = { '\0' };
890 struct seq_file *m = file->private_data;
891 struct acpi_battery *battery = m->private;
893 if (!battery || (count > sizeof(alarm_string) - 1))
895 if (!acpi_battery_present(battery)) {
899 if (copy_from_user(alarm_string, buffer, count)) {
903 alarm_string[count] = '\0';
904 battery->alarm = simple_strtol(alarm_string, NULL, 0);
905 result = acpi_battery_set_alarm(battery);
912 typedef int(*print_func)(struct seq_file *seq, int result);
914 static print_func acpi_print_funcs[ACPI_BATTERY_NUMFILES] = {
915 acpi_battery_print_info,
916 acpi_battery_print_state,
917 acpi_battery_print_alarm,
920 static int acpi_battery_read(int fid, struct seq_file *seq)
922 struct acpi_battery *battery = seq->private;
923 int result = acpi_battery_update(battery);
924 return acpi_print_funcs[fid](seq, result);
927 #define DECLARE_FILE_FUNCTIONS(_name) \
928 static int acpi_battery_read_##_name(struct seq_file *seq, void *offset) \
930 return acpi_battery_read(_name##_tag, seq); \
932 static int acpi_battery_##_name##_open_fs(struct inode *inode, struct file *file) \
934 return single_open(file, acpi_battery_read_##_name, PDE_DATA(inode)); \
937 DECLARE_FILE_FUNCTIONS(info);
938 DECLARE_FILE_FUNCTIONS(state);
939 DECLARE_FILE_FUNCTIONS(alarm);
941 #undef DECLARE_FILE_FUNCTIONS
943 #define FILE_DESCRIPTION_RO(_name) \
945 .name = __stringify(_name), \
948 .open = acpi_battery_##_name##_open_fs, \
950 .llseek = seq_lseek, \
951 .release = single_release, \
952 .owner = THIS_MODULE, \
956 #define FILE_DESCRIPTION_RW(_name) \
958 .name = __stringify(_name), \
959 .mode = S_IFREG | S_IRUGO | S_IWUSR, \
961 .open = acpi_battery_##_name##_open_fs, \
963 .llseek = seq_lseek, \
964 .write = acpi_battery_write_##_name, \
965 .release = single_release, \
966 .owner = THIS_MODULE, \
970 static const struct battery_file {
971 struct file_operations ops;
974 } acpi_battery_file[] = {
975 FILE_DESCRIPTION_RO(info),
976 FILE_DESCRIPTION_RO(state),
977 FILE_DESCRIPTION_RW(alarm),
980 #undef FILE_DESCRIPTION_RO
981 #undef FILE_DESCRIPTION_RW
983 static int acpi_battery_add_fs(struct acpi_device *device)
985 struct proc_dir_entry *entry = NULL;
988 printk(KERN_WARNING PREFIX "Deprecated procfs I/F for battery is loaded,"
989 " please retry with CONFIG_ACPI_PROCFS_POWER cleared\n");
990 if (!acpi_device_dir(device)) {
991 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
993 if (!acpi_device_dir(device))
997 for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i) {
998 entry = proc_create_data(acpi_battery_file[i].name,
999 acpi_battery_file[i].mode,
1000 acpi_device_dir(device),
1001 &acpi_battery_file[i].ops,
1002 acpi_driver_data(device));
1009 static void acpi_battery_remove_fs(struct acpi_device *device)
1012 if (!acpi_device_dir(device))
1014 for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i)
1015 remove_proc_entry(acpi_battery_file[i].name,
1016 acpi_device_dir(device));
1018 remove_proc_entry(acpi_device_bid(device), acpi_battery_dir);
1019 acpi_device_dir(device) = NULL;
1024 /* --------------------------------------------------------------------------
1026 -------------------------------------------------------------------------- */
1028 static void acpi_battery_notify(struct acpi_device *device, u32 event)
1030 struct acpi_battery *battery = acpi_driver_data(device);
1035 old = battery->bat.dev;
1036 if (event == ACPI_BATTERY_NOTIFY_INFO)
1037 acpi_battery_refresh(battery);
1038 acpi_battery_update(battery);
1039 acpi_bus_generate_proc_event(device, event,
1040 acpi_battery_present(battery));
1041 acpi_bus_generate_netlink_event(device->pnp.device_class,
1042 dev_name(&device->dev), event,
1043 acpi_battery_present(battery));
1044 /* acpi_battery_update could remove power_supply object */
1045 if (old && battery->bat.dev)
1046 power_supply_changed(&battery->bat);
1049 static int battery_notify(struct notifier_block *nb,
1050 unsigned long mode, void *_unused)
1052 struct acpi_battery *battery = container_of(nb, struct acpi_battery,
1055 case PM_POST_HIBERNATION:
1056 case PM_POST_SUSPEND:
1057 if (battery->bat.dev) {
1058 sysfs_remove_battery(battery);
1059 sysfs_add_battery(battery);
1067 static int acpi_battery_add(struct acpi_device *device)
1070 struct acpi_battery *battery = NULL;
1074 battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL);
1077 battery->device = device;
1078 strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME);
1079 strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS);
1080 device->driver_data = battery;
1081 mutex_init(&battery->lock);
1082 mutex_init(&battery->sysfs_lock);
1083 if (ACPI_SUCCESS(acpi_get_handle(battery->device->handle,
1085 set_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags);
1086 result = acpi_battery_update(battery);
1089 #ifdef CONFIG_ACPI_PROCFS_POWER
1090 result = acpi_battery_add_fs(device);
1093 #ifdef CONFIG_ACPI_PROCFS_POWER
1094 acpi_battery_remove_fs(device);
1099 printk(KERN_INFO PREFIX "%s Slot [%s] (battery %s)\n",
1100 ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device),
1101 device->status.battery_present ? "present" : "absent");
1103 battery->pm_nb.notifier_call = battery_notify;
1104 register_pm_notifier(&battery->pm_nb);
1109 sysfs_remove_battery(battery);
1110 mutex_destroy(&battery->lock);
1111 mutex_destroy(&battery->sysfs_lock);
1116 static int acpi_battery_remove(struct acpi_device *device)
1118 struct acpi_battery *battery = NULL;
1120 if (!device || !acpi_driver_data(device))
1122 battery = acpi_driver_data(device);
1123 unregister_pm_notifier(&battery->pm_nb);
1124 #ifdef CONFIG_ACPI_PROCFS_POWER
1125 acpi_battery_remove_fs(device);
1127 sysfs_remove_battery(battery);
1128 mutex_destroy(&battery->lock);
1129 mutex_destroy(&battery->sysfs_lock);
1134 #ifdef CONFIG_PM_SLEEP
1135 /* this is needed to learn about changes made in suspended state */
1136 static int acpi_battery_resume(struct device *dev)
1138 struct acpi_battery *battery;
1143 battery = acpi_driver_data(to_acpi_device(dev));
1147 battery->update_time = 0;
1148 acpi_battery_update(battery);
1153 static SIMPLE_DEV_PM_OPS(acpi_battery_pm, NULL, acpi_battery_resume);
1155 static struct acpi_driver acpi_battery_driver = {
1157 .class = ACPI_BATTERY_CLASS,
1158 .ids = battery_device_ids,
1159 .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
1161 .add = acpi_battery_add,
1162 .remove = acpi_battery_remove,
1163 .notify = acpi_battery_notify,
1165 .drv.pm = &acpi_battery_pm,
1168 static void __init acpi_battery_init_async(void *unused, async_cookie_t cookie)
1172 #ifdef CONFIG_ACPI_PROCFS_POWER
1173 acpi_battery_dir = acpi_lock_battery_dir();
1174 if (!acpi_battery_dir)
1177 if (acpi_bus_register_driver(&acpi_battery_driver) < 0) {
1178 #ifdef CONFIG_ACPI_PROCFS_POWER
1179 acpi_unlock_battery_dir(acpi_battery_dir);
1186 static int __init acpi_battery_init(void)
1188 async_schedule(acpi_battery_init_async, NULL);
1192 static void __exit acpi_battery_exit(void)
1194 acpi_bus_unregister_driver(&acpi_battery_driver);
1195 #ifdef CONFIG_ACPI_PROCFS_POWER
1196 acpi_unlock_battery_dir(acpi_battery_dir);
1200 module_init(acpi_battery_init);
1201 module_exit(acpi_battery_exit);