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 <linux/delay.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 <asm/uaccess.h>
46 #include <acpi/acpi_bus.h>
47 #include <acpi/acpi_drivers.h>
48 #include <linux/power_supply.h>
50 #define PREFIX "ACPI: "
52 #define ACPI_BATTERY_VALUE_UNKNOWN 0xFFFFFFFF
54 #define ACPI_BATTERY_CLASS "battery"
55 #define ACPI_BATTERY_DEVICE_NAME "Battery"
56 #define ACPI_BATTERY_NOTIFY_STATUS 0x80
57 #define ACPI_BATTERY_NOTIFY_INFO 0x81
58 #define ACPI_BATTERY_NOTIFY_THRESHOLD 0x82
60 /* Battery power unit: 0 means mW, 1 means mA */
61 #define ACPI_BATTERY_POWER_UNIT_MA 1
63 #define _COMPONENT ACPI_BATTERY_COMPONENT
65 ACPI_MODULE_NAME("battery");
67 MODULE_AUTHOR("Paul Diefenbaugh");
68 MODULE_AUTHOR("Alexey Starikovskiy <astarikovskiy@suse.de>");
69 MODULE_DESCRIPTION("ACPI Battery Driver");
70 MODULE_LICENSE("GPL");
72 static int battery_bix_broken_package;
73 static unsigned int cache_time = 1000;
74 module_param(cache_time, uint, 0644);
75 MODULE_PARM_DESC(cache_time, "cache time in milliseconds");
77 #ifdef CONFIG_ACPI_PROCFS_POWER
78 extern struct proc_dir_entry *acpi_lock_battery_dir(void);
79 extern void *acpi_unlock_battery_dir(struct proc_dir_entry *acpi_battery_dir);
81 enum acpi_battery_files {
85 ACPI_BATTERY_NUMFILES,
90 static const struct acpi_device_id battery_device_ids[] = {
95 MODULE_DEVICE_TABLE(acpi, battery_device_ids);
98 ACPI_BATTERY_ALARM_PRESENT,
99 ACPI_BATTERY_XINFO_PRESENT,
100 ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY,
101 /* On Lenovo Thinkpad models from 2010 and 2011, the power unit
102 switches between mWh and mAh depending on whether the system
103 is running on battery or not. When mAh is the unit, most
104 reported values are incorrect and need to be adjusted by
105 10000/design_voltage. Verified on x201, t410, t410s, and x220.
106 Pre-2010 and 2012 models appear to always report in mWh and
107 are thus unaffected (tested with t42, t61, t500, x200, x300,
108 and x230). Also, in mid-2012 Lenovo issued a BIOS update for
109 the 2011 models that fixes the issue (tested on x220 with a
110 post-1.29 BIOS), but as of Nov. 2012, no such update is
111 available for the 2010 models. */
112 ACPI_BATTERY_QUIRK_THINKPAD_MAH,
115 struct acpi_battery {
117 struct mutex sysfs_lock;
118 struct power_supply bat;
119 struct acpi_device *device;
120 struct notifier_block pm_nb;
121 unsigned long update_time;
127 int full_charge_capacity;
130 int design_capacity_warning;
131 int design_capacity_low;
133 int measurement_accuracy;
134 int max_sampling_time;
135 int min_sampling_time;
136 int max_averaging_interval;
137 int min_averaging_interval;
138 int capacity_granularity_1;
139 int capacity_granularity_2;
141 char model_number[32];
142 char serial_number[32];
150 #define to_acpi_battery(x) container_of(x, struct acpi_battery, bat)
152 static inline int acpi_battery_present(struct acpi_battery *battery)
154 return battery->device->status.battery_present;
157 static int acpi_battery_technology(struct acpi_battery *battery)
159 if (!strcasecmp("NiCd", battery->type))
160 return POWER_SUPPLY_TECHNOLOGY_NiCd;
161 if (!strcasecmp("NiMH", battery->type))
162 return POWER_SUPPLY_TECHNOLOGY_NiMH;
163 if (!strcasecmp("LION", battery->type))
164 return POWER_SUPPLY_TECHNOLOGY_LION;
165 if (!strncasecmp("LI-ION", battery->type, 6))
166 return POWER_SUPPLY_TECHNOLOGY_LION;
167 if (!strcasecmp("LiP", battery->type))
168 return POWER_SUPPLY_TECHNOLOGY_LIPO;
169 return POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
172 static int acpi_battery_get_state(struct acpi_battery *battery);
174 static int acpi_battery_is_charged(struct acpi_battery *battery)
176 /* either charging or discharging */
177 if (battery->state != 0)
180 /* battery not reporting charge */
181 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN ||
182 battery->capacity_now == 0)
185 /* good batteries update full_charge as the batteries degrade */
186 if (battery->full_charge_capacity == battery->capacity_now)
189 /* fallback to using design values for broken batteries */
190 if (battery->design_capacity == battery->capacity_now)
193 /* we don't do any sort of metric based on percentages */
197 static int acpi_battery_get_property(struct power_supply *psy,
198 enum power_supply_property psp,
199 union power_supply_propval *val)
202 struct acpi_battery *battery = to_acpi_battery(psy);
204 if (acpi_battery_present(battery)) {
205 /* run battery update only if it is present */
206 acpi_battery_get_state(battery);
207 } else if (psp != POWER_SUPPLY_PROP_PRESENT)
210 case POWER_SUPPLY_PROP_STATUS:
211 if (battery->state & 0x01)
212 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
213 else if (battery->state & 0x02)
214 val->intval = POWER_SUPPLY_STATUS_CHARGING;
215 else if (acpi_battery_is_charged(battery))
216 val->intval = POWER_SUPPLY_STATUS_FULL;
218 val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
220 case POWER_SUPPLY_PROP_PRESENT:
221 val->intval = acpi_battery_present(battery);
223 case POWER_SUPPLY_PROP_TECHNOLOGY:
224 val->intval = acpi_battery_technology(battery);
226 case POWER_SUPPLY_PROP_CYCLE_COUNT:
227 val->intval = battery->cycle_count;
229 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
230 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
233 val->intval = battery->design_voltage * 1000;
235 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
236 if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
239 val->intval = battery->voltage_now * 1000;
241 case POWER_SUPPLY_PROP_CURRENT_NOW:
242 case POWER_SUPPLY_PROP_POWER_NOW:
243 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
246 val->intval = battery->rate_now * 1000;
248 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
249 case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
250 if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
253 val->intval = battery->design_capacity * 1000;
255 case POWER_SUPPLY_PROP_CHARGE_FULL:
256 case POWER_SUPPLY_PROP_ENERGY_FULL:
257 if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
260 val->intval = battery->full_charge_capacity * 1000;
262 case POWER_SUPPLY_PROP_CHARGE_NOW:
263 case POWER_SUPPLY_PROP_ENERGY_NOW:
264 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
267 val->intval = battery->capacity_now * 1000;
269 case POWER_SUPPLY_PROP_CAPACITY:
270 if (battery->capacity_now && battery->full_charge_capacity)
271 val->intval = battery->capacity_now * 100/
272 battery->full_charge_capacity;
276 case POWER_SUPPLY_PROP_MODEL_NAME:
277 val->strval = battery->model_number;
279 case POWER_SUPPLY_PROP_MANUFACTURER:
280 val->strval = battery->oem_info;
282 case POWER_SUPPLY_PROP_SERIAL_NUMBER:
283 val->strval = battery->serial_number;
291 static enum power_supply_property charge_battery_props[] = {
292 POWER_SUPPLY_PROP_STATUS,
293 POWER_SUPPLY_PROP_PRESENT,
294 POWER_SUPPLY_PROP_TECHNOLOGY,
295 POWER_SUPPLY_PROP_CYCLE_COUNT,
296 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
297 POWER_SUPPLY_PROP_VOLTAGE_NOW,
298 POWER_SUPPLY_PROP_CURRENT_NOW,
299 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
300 POWER_SUPPLY_PROP_CHARGE_FULL,
301 POWER_SUPPLY_PROP_CHARGE_NOW,
302 POWER_SUPPLY_PROP_CAPACITY,
303 POWER_SUPPLY_PROP_MODEL_NAME,
304 POWER_SUPPLY_PROP_MANUFACTURER,
305 POWER_SUPPLY_PROP_SERIAL_NUMBER,
308 static enum power_supply_property energy_battery_props[] = {
309 POWER_SUPPLY_PROP_STATUS,
310 POWER_SUPPLY_PROP_PRESENT,
311 POWER_SUPPLY_PROP_TECHNOLOGY,
312 POWER_SUPPLY_PROP_CYCLE_COUNT,
313 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
314 POWER_SUPPLY_PROP_VOLTAGE_NOW,
315 POWER_SUPPLY_PROP_POWER_NOW,
316 POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
317 POWER_SUPPLY_PROP_ENERGY_FULL,
318 POWER_SUPPLY_PROP_ENERGY_NOW,
319 POWER_SUPPLY_PROP_CAPACITY,
320 POWER_SUPPLY_PROP_MODEL_NAME,
321 POWER_SUPPLY_PROP_MANUFACTURER,
322 POWER_SUPPLY_PROP_SERIAL_NUMBER,
325 #ifdef CONFIG_ACPI_PROCFS_POWER
326 inline char *acpi_battery_units(struct acpi_battery *battery)
328 return (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) ?
333 /* --------------------------------------------------------------------------
335 -------------------------------------------------------------------------- */
336 struct acpi_offsets {
337 size_t offset; /* offset inside struct acpi_sbs_battery */
338 u8 mode; /* int or string? */
341 static struct acpi_offsets state_offsets[] = {
342 {offsetof(struct acpi_battery, state), 0},
343 {offsetof(struct acpi_battery, rate_now), 0},
344 {offsetof(struct acpi_battery, capacity_now), 0},
345 {offsetof(struct acpi_battery, voltage_now), 0},
348 static struct acpi_offsets info_offsets[] = {
349 {offsetof(struct acpi_battery, power_unit), 0},
350 {offsetof(struct acpi_battery, design_capacity), 0},
351 {offsetof(struct acpi_battery, full_charge_capacity), 0},
352 {offsetof(struct acpi_battery, technology), 0},
353 {offsetof(struct acpi_battery, design_voltage), 0},
354 {offsetof(struct acpi_battery, design_capacity_warning), 0},
355 {offsetof(struct acpi_battery, design_capacity_low), 0},
356 {offsetof(struct acpi_battery, capacity_granularity_1), 0},
357 {offsetof(struct acpi_battery, capacity_granularity_2), 0},
358 {offsetof(struct acpi_battery, model_number), 1},
359 {offsetof(struct acpi_battery, serial_number), 1},
360 {offsetof(struct acpi_battery, type), 1},
361 {offsetof(struct acpi_battery, oem_info), 1},
364 static struct acpi_offsets extended_info_offsets[] = {
365 {offsetof(struct acpi_battery, revision), 0},
366 {offsetof(struct acpi_battery, power_unit), 0},
367 {offsetof(struct acpi_battery, design_capacity), 0},
368 {offsetof(struct acpi_battery, full_charge_capacity), 0},
369 {offsetof(struct acpi_battery, technology), 0},
370 {offsetof(struct acpi_battery, design_voltage), 0},
371 {offsetof(struct acpi_battery, design_capacity_warning), 0},
372 {offsetof(struct acpi_battery, design_capacity_low), 0},
373 {offsetof(struct acpi_battery, cycle_count), 0},
374 {offsetof(struct acpi_battery, measurement_accuracy), 0},
375 {offsetof(struct acpi_battery, max_sampling_time), 0},
376 {offsetof(struct acpi_battery, min_sampling_time), 0},
377 {offsetof(struct acpi_battery, max_averaging_interval), 0},
378 {offsetof(struct acpi_battery, min_averaging_interval), 0},
379 {offsetof(struct acpi_battery, capacity_granularity_1), 0},
380 {offsetof(struct acpi_battery, capacity_granularity_2), 0},
381 {offsetof(struct acpi_battery, model_number), 1},
382 {offsetof(struct acpi_battery, serial_number), 1},
383 {offsetof(struct acpi_battery, type), 1},
384 {offsetof(struct acpi_battery, oem_info), 1},
387 static int extract_package(struct acpi_battery *battery,
388 union acpi_object *package,
389 struct acpi_offsets *offsets, int num)
392 union acpi_object *element;
393 if (package->type != ACPI_TYPE_PACKAGE)
395 for (i = 0; i < num; ++i) {
396 if (package->package.count <= i)
398 element = &package->package.elements[i];
399 if (offsets[i].mode) {
400 u8 *ptr = (u8 *)battery + offsets[i].offset;
401 if (element->type == ACPI_TYPE_STRING ||
402 element->type == ACPI_TYPE_BUFFER)
403 strncpy(ptr, element->string.pointer, 32);
404 else if (element->type == ACPI_TYPE_INTEGER) {
405 strncpy(ptr, (u8 *)&element->integer.value,
407 ptr[sizeof(u64)] = 0;
409 *ptr = 0; /* don't have value */
411 int *x = (int *)((u8 *)battery + offsets[i].offset);
412 *x = (element->type == ACPI_TYPE_INTEGER) ?
413 element->integer.value : -1;
419 static int acpi_battery_get_status(struct acpi_battery *battery)
421 if (acpi_bus_get_status(battery->device)) {
422 ACPI_EXCEPTION((AE_INFO, AE_ERROR, "Evaluating _STA"));
428 static int acpi_battery_get_info(struct acpi_battery *battery)
430 int result = -EFAULT;
431 acpi_status status = 0;
432 char *name = test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags)?
435 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
437 if (!acpi_battery_present(battery))
439 mutex_lock(&battery->lock);
440 status = acpi_evaluate_object(battery->device->handle, name,
442 mutex_unlock(&battery->lock);
444 if (ACPI_FAILURE(status)) {
445 ACPI_EXCEPTION((AE_INFO, status, "Evaluating %s", name));
449 if (battery_bix_broken_package)
450 result = extract_package(battery, buffer.pointer,
451 extended_info_offsets + 1,
452 ARRAY_SIZE(extended_info_offsets) - 1);
453 else if (test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags))
454 result = extract_package(battery, buffer.pointer,
455 extended_info_offsets,
456 ARRAY_SIZE(extended_info_offsets));
458 result = extract_package(battery, buffer.pointer,
459 info_offsets, ARRAY_SIZE(info_offsets));
460 kfree(buffer.pointer);
461 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
462 battery->full_charge_capacity = battery->design_capacity;
463 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
464 battery->power_unit && battery->design_voltage) {
465 battery->design_capacity = battery->design_capacity *
466 10000 / battery->design_voltage;
467 battery->full_charge_capacity = battery->full_charge_capacity *
468 10000 / battery->design_voltage;
469 battery->design_capacity_warning =
470 battery->design_capacity_warning *
471 10000 / battery->design_voltage;
472 /* Curiously, design_capacity_low, unlike the rest of them,
474 /* capacity_granularity_* equal 1 on the systems tested, so
475 it's impossible to tell if they would need an adjustment
476 or not if their values were higher. */
481 static int acpi_battery_get_state(struct acpi_battery *battery)
484 acpi_status status = 0;
485 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
487 if (!acpi_battery_present(battery))
490 if (battery->update_time &&
491 time_before(jiffies, battery->update_time +
492 msecs_to_jiffies(cache_time)))
495 mutex_lock(&battery->lock);
496 status = acpi_evaluate_object(battery->device->handle, "_BST",
498 mutex_unlock(&battery->lock);
500 if (ACPI_FAILURE(status)) {
501 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BST"));
505 result = extract_package(battery, buffer.pointer,
506 state_offsets, ARRAY_SIZE(state_offsets));
507 battery->update_time = jiffies;
508 kfree(buffer.pointer);
510 /* For buggy DSDTs that report negative 16-bit values for either
511 * charging or discharging current and/or report 0 as 65536
514 if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA &&
515 battery->rate_now != ACPI_BATTERY_VALUE_UNKNOWN &&
516 (s16)(battery->rate_now) < 0) {
517 battery->rate_now = abs((s16)battery->rate_now);
518 printk_once(KERN_WARNING FW_BUG "battery: (dis)charge rate"
522 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags)
523 && battery->capacity_now >= 0 && battery->capacity_now <= 100)
524 battery->capacity_now = (battery->capacity_now *
525 battery->full_charge_capacity) / 100;
526 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
527 battery->power_unit && battery->design_voltage) {
528 battery->capacity_now = battery->capacity_now *
529 10000 / battery->design_voltage;
534 static int acpi_battery_set_alarm(struct acpi_battery *battery)
536 acpi_status status = 0;
537 union acpi_object arg0 = { .type = ACPI_TYPE_INTEGER };
538 struct acpi_object_list arg_list = { 1, &arg0 };
540 if (!acpi_battery_present(battery) ||
541 !test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags))
544 arg0.integer.value = battery->alarm;
546 mutex_lock(&battery->lock);
547 status = acpi_evaluate_object(battery->device->handle, "_BTP",
549 mutex_unlock(&battery->lock);
551 if (ACPI_FAILURE(status))
554 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Alarm set to %d\n", battery->alarm));
558 static int acpi_battery_init_alarm(struct acpi_battery *battery)
560 acpi_status status = AE_OK;
561 acpi_handle handle = NULL;
563 /* See if alarms are supported, and if so, set default */
564 status = acpi_get_handle(battery->device->handle, "_BTP", &handle);
565 if (ACPI_FAILURE(status)) {
566 clear_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
569 set_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
571 battery->alarm = battery->design_capacity_warning;
572 return acpi_battery_set_alarm(battery);
575 static ssize_t acpi_battery_alarm_show(struct device *dev,
576 struct device_attribute *attr,
579 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
580 return sprintf(buf, "%d\n", battery->alarm * 1000);
583 static ssize_t acpi_battery_alarm_store(struct device *dev,
584 struct device_attribute *attr,
585 const char *buf, size_t count)
588 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
589 if (sscanf(buf, "%ld\n", &x) == 1)
590 battery->alarm = x/1000;
591 if (acpi_battery_present(battery))
592 acpi_battery_set_alarm(battery);
596 static struct device_attribute alarm_attr = {
597 .attr = {.name = "alarm", .mode = 0644},
598 .show = acpi_battery_alarm_show,
599 .store = acpi_battery_alarm_store,
602 static int sysfs_add_battery(struct acpi_battery *battery)
606 if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) {
607 battery->bat.properties = charge_battery_props;
608 battery->bat.num_properties =
609 ARRAY_SIZE(charge_battery_props);
611 battery->bat.properties = energy_battery_props;
612 battery->bat.num_properties =
613 ARRAY_SIZE(energy_battery_props);
616 battery->bat.name = acpi_device_bid(battery->device);
617 battery->bat.type = POWER_SUPPLY_TYPE_BATTERY;
618 battery->bat.get_property = acpi_battery_get_property;
620 result = power_supply_register(&battery->device->dev, &battery->bat);
623 return device_create_file(battery->bat.dev, &alarm_attr);
626 static void sysfs_remove_battery(struct acpi_battery *battery)
628 mutex_lock(&battery->sysfs_lock);
629 if (!battery->bat.dev) {
630 mutex_unlock(&battery->sysfs_lock);
634 device_remove_file(battery->bat.dev, &alarm_attr);
635 power_supply_unregister(&battery->bat);
636 battery->bat.dev = NULL;
637 mutex_unlock(&battery->sysfs_lock);
640 static void find_battery(const struct dmi_header *dm, void *private)
642 struct acpi_battery *battery = (struct acpi_battery *)private;
643 /* Note: the hardcoded offsets below have been extracted from
644 the source code of dmidecode. */
645 if (dm->type == DMI_ENTRY_PORTABLE_BATTERY && dm->length >= 8) {
646 const u8 *dmi_data = (const u8 *)(dm + 1);
647 int dmi_capacity = get_unaligned((const u16 *)(dmi_data + 6));
648 if (dm->length >= 18)
649 dmi_capacity *= dmi_data[17];
650 if (battery->design_capacity * battery->design_voltage / 1000
652 battery->design_capacity * 10 == dmi_capacity)
653 set_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
659 * According to the ACPI spec, some kinds of primary batteries can
660 * report percentage battery remaining capacity directly to OS.
661 * In this case, it reports the Last Full Charged Capacity == 100
662 * and BatteryPresentRate == 0xFFFFFFFF.
664 * Now we found some battery reports percentage remaining capacity
665 * even if it's rechargeable.
666 * https://bugzilla.kernel.org/show_bug.cgi?id=15979
668 * Handle this correctly so that they won't break userspace.
670 static void acpi_battery_quirks(struct acpi_battery *battery)
672 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
675 if (battery->full_charge_capacity == 100 &&
676 battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN &&
677 battery->capacity_now >=0 && battery->capacity_now <= 100) {
678 set_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags);
679 battery->full_charge_capacity = battery->design_capacity;
680 battery->capacity_now = (battery->capacity_now *
681 battery->full_charge_capacity) / 100;
684 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags))
687 if (battery->power_unit && dmi_name_in_vendors("LENOVO")) {
689 s = dmi_get_system_info(DMI_PRODUCT_VERSION);
690 if (s && !strnicmp(s, "ThinkPad", 8)) {
691 dmi_walk(find_battery, battery);
692 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
694 battery->design_voltage) {
695 battery->design_capacity =
696 battery->design_capacity *
697 10000 / battery->design_voltage;
698 battery->full_charge_capacity =
699 battery->full_charge_capacity *
700 10000 / battery->design_voltage;
701 battery->design_capacity_warning =
702 battery->design_capacity_warning *
703 10000 / battery->design_voltage;
704 battery->capacity_now = battery->capacity_now *
705 10000 / battery->design_voltage;
711 static int acpi_battery_update(struct acpi_battery *battery)
713 int result, old_present = acpi_battery_present(battery);
714 result = acpi_battery_get_status(battery);
717 if (!acpi_battery_present(battery)) {
718 sysfs_remove_battery(battery);
719 battery->update_time = 0;
722 if (!battery->update_time ||
723 old_present != acpi_battery_present(battery)) {
724 result = acpi_battery_get_info(battery);
727 acpi_battery_init_alarm(battery);
729 if (!battery->bat.dev) {
730 result = sysfs_add_battery(battery);
734 result = acpi_battery_get_state(battery);
735 acpi_battery_quirks(battery);
739 static void acpi_battery_refresh(struct acpi_battery *battery)
743 if (!battery->bat.dev)
746 power_unit = battery->power_unit;
748 acpi_battery_get_info(battery);
750 if (power_unit == battery->power_unit)
753 /* The battery has changed its reporting units. */
754 sysfs_remove_battery(battery);
755 sysfs_add_battery(battery);
758 /* --------------------------------------------------------------------------
760 -------------------------------------------------------------------------- */
762 #ifdef CONFIG_ACPI_PROCFS_POWER
763 static struct proc_dir_entry *acpi_battery_dir;
765 static int acpi_battery_print_info(struct seq_file *seq, int result)
767 struct acpi_battery *battery = seq->private;
772 seq_printf(seq, "present: %s\n",
773 acpi_battery_present(battery)?"yes":"no");
774 if (!acpi_battery_present(battery))
776 if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
777 seq_printf(seq, "design capacity: unknown\n");
779 seq_printf(seq, "design capacity: %d %sh\n",
780 battery->design_capacity,
781 acpi_battery_units(battery));
783 if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
784 seq_printf(seq, "last full capacity: unknown\n");
786 seq_printf(seq, "last full capacity: %d %sh\n",
787 battery->full_charge_capacity,
788 acpi_battery_units(battery));
790 seq_printf(seq, "battery technology: %srechargeable\n",
791 (!battery->technology)?"non-":"");
793 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
794 seq_printf(seq, "design voltage: unknown\n");
796 seq_printf(seq, "design voltage: %d mV\n",
797 battery->design_voltage);
798 seq_printf(seq, "design capacity warning: %d %sh\n",
799 battery->design_capacity_warning,
800 acpi_battery_units(battery));
801 seq_printf(seq, "design capacity low: %d %sh\n",
802 battery->design_capacity_low,
803 acpi_battery_units(battery));
804 seq_printf(seq, "cycle count: %i\n", battery->cycle_count);
805 seq_printf(seq, "capacity granularity 1: %d %sh\n",
806 battery->capacity_granularity_1,
807 acpi_battery_units(battery));
808 seq_printf(seq, "capacity granularity 2: %d %sh\n",
809 battery->capacity_granularity_2,
810 acpi_battery_units(battery));
811 seq_printf(seq, "model number: %s\n", battery->model_number);
812 seq_printf(seq, "serial number: %s\n", battery->serial_number);
813 seq_printf(seq, "battery type: %s\n", battery->type);
814 seq_printf(seq, "OEM info: %s\n", battery->oem_info);
817 seq_printf(seq, "ERROR: Unable to read battery info\n");
821 static int acpi_battery_print_state(struct seq_file *seq, int result)
823 struct acpi_battery *battery = seq->private;
828 seq_printf(seq, "present: %s\n",
829 acpi_battery_present(battery)?"yes":"no");
830 if (!acpi_battery_present(battery))
833 seq_printf(seq, "capacity state: %s\n",
834 (battery->state & 0x04)?"critical":"ok");
835 if ((battery->state & 0x01) && (battery->state & 0x02))
837 "charging state: charging/discharging\n");
838 else if (battery->state & 0x01)
839 seq_printf(seq, "charging state: discharging\n");
840 else if (battery->state & 0x02)
841 seq_printf(seq, "charging state: charging\n");
843 seq_printf(seq, "charging state: charged\n");
845 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
846 seq_printf(seq, "present rate: unknown\n");
848 seq_printf(seq, "present rate: %d %s\n",
849 battery->rate_now, acpi_battery_units(battery));
851 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
852 seq_printf(seq, "remaining capacity: unknown\n");
854 seq_printf(seq, "remaining capacity: %d %sh\n",
855 battery->capacity_now, acpi_battery_units(battery));
856 if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
857 seq_printf(seq, "present voltage: unknown\n");
859 seq_printf(seq, "present voltage: %d mV\n",
860 battery->voltage_now);
863 seq_printf(seq, "ERROR: Unable to read battery state\n");
868 static int acpi_battery_print_alarm(struct seq_file *seq, int result)
870 struct acpi_battery *battery = seq->private;
875 if (!acpi_battery_present(battery)) {
876 seq_printf(seq, "present: no\n");
879 seq_printf(seq, "alarm: ");
881 seq_printf(seq, "unsupported\n");
883 seq_printf(seq, "%u %sh\n", battery->alarm,
884 acpi_battery_units(battery));
887 seq_printf(seq, "ERROR: Unable to read battery alarm\n");
891 static ssize_t acpi_battery_write_alarm(struct file *file,
892 const char __user * buffer,
893 size_t count, loff_t * ppos)
896 char alarm_string[12] = { '\0' };
897 struct seq_file *m = file->private_data;
898 struct acpi_battery *battery = m->private;
900 if (!battery || (count > sizeof(alarm_string) - 1))
902 if (!acpi_battery_present(battery)) {
906 if (copy_from_user(alarm_string, buffer, count)) {
910 alarm_string[count] = '\0';
911 battery->alarm = simple_strtol(alarm_string, NULL, 0);
912 result = acpi_battery_set_alarm(battery);
919 typedef int(*print_func)(struct seq_file *seq, int result);
921 static print_func acpi_print_funcs[ACPI_BATTERY_NUMFILES] = {
922 acpi_battery_print_info,
923 acpi_battery_print_state,
924 acpi_battery_print_alarm,
927 static int acpi_battery_read(int fid, struct seq_file *seq)
929 struct acpi_battery *battery = seq->private;
930 int result = acpi_battery_update(battery);
931 return acpi_print_funcs[fid](seq, result);
934 #define DECLARE_FILE_FUNCTIONS(_name) \
935 static int acpi_battery_read_##_name(struct seq_file *seq, void *offset) \
937 return acpi_battery_read(_name##_tag, seq); \
939 static int acpi_battery_##_name##_open_fs(struct inode *inode, struct file *file) \
941 return single_open(file, acpi_battery_read_##_name, PDE_DATA(inode)); \
944 DECLARE_FILE_FUNCTIONS(info);
945 DECLARE_FILE_FUNCTIONS(state);
946 DECLARE_FILE_FUNCTIONS(alarm);
948 #undef DECLARE_FILE_FUNCTIONS
950 #define FILE_DESCRIPTION_RO(_name) \
952 .name = __stringify(_name), \
955 .open = acpi_battery_##_name##_open_fs, \
957 .llseek = seq_lseek, \
958 .release = single_release, \
959 .owner = THIS_MODULE, \
963 #define FILE_DESCRIPTION_RW(_name) \
965 .name = __stringify(_name), \
966 .mode = S_IFREG | S_IRUGO | S_IWUSR, \
968 .open = acpi_battery_##_name##_open_fs, \
970 .llseek = seq_lseek, \
971 .write = acpi_battery_write_##_name, \
972 .release = single_release, \
973 .owner = THIS_MODULE, \
977 static const struct battery_file {
978 struct file_operations ops;
981 } acpi_battery_file[] = {
982 FILE_DESCRIPTION_RO(info),
983 FILE_DESCRIPTION_RO(state),
984 FILE_DESCRIPTION_RW(alarm),
987 #undef FILE_DESCRIPTION_RO
988 #undef FILE_DESCRIPTION_RW
990 static int acpi_battery_add_fs(struct acpi_device *device)
992 struct proc_dir_entry *entry = NULL;
995 printk(KERN_WARNING PREFIX "Deprecated procfs I/F for battery is loaded,"
996 " please retry with CONFIG_ACPI_PROCFS_POWER cleared\n");
997 if (!acpi_device_dir(device)) {
998 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
1000 if (!acpi_device_dir(device))
1004 for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i) {
1005 entry = proc_create_data(acpi_battery_file[i].name,
1006 acpi_battery_file[i].mode,
1007 acpi_device_dir(device),
1008 &acpi_battery_file[i].ops,
1009 acpi_driver_data(device));
1016 static void acpi_battery_remove_fs(struct acpi_device *device)
1019 if (!acpi_device_dir(device))
1021 for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i)
1022 remove_proc_entry(acpi_battery_file[i].name,
1023 acpi_device_dir(device));
1025 remove_proc_entry(acpi_device_bid(device), acpi_battery_dir);
1026 acpi_device_dir(device) = NULL;
1031 /* --------------------------------------------------------------------------
1033 -------------------------------------------------------------------------- */
1035 static void acpi_battery_notify(struct acpi_device *device, u32 event)
1037 struct acpi_battery *battery = acpi_driver_data(device);
1042 old = battery->bat.dev;
1043 if (event == ACPI_BATTERY_NOTIFY_INFO)
1044 acpi_battery_refresh(battery);
1045 acpi_battery_update(battery);
1046 acpi_bus_generate_proc_event(device, event,
1047 acpi_battery_present(battery));
1048 acpi_bus_generate_netlink_event(device->pnp.device_class,
1049 dev_name(&device->dev), event,
1050 acpi_battery_present(battery));
1051 /* acpi_battery_update could remove power_supply object */
1052 if (old && battery->bat.dev)
1053 power_supply_changed(&battery->bat);
1056 static int battery_notify(struct notifier_block *nb,
1057 unsigned long mode, void *_unused)
1059 struct acpi_battery *battery = container_of(nb, struct acpi_battery,
1062 case PM_POST_HIBERNATION:
1063 case PM_POST_SUSPEND:
1064 if (battery->bat.dev) {
1065 sysfs_remove_battery(battery);
1066 sysfs_add_battery(battery);
1074 static struct dmi_system_id bat_dmi_table[] = {
1076 .ident = "NEC LZ750/LS",
1078 DMI_MATCH(DMI_SYS_VENDOR, "NEC"),
1079 DMI_MATCH(DMI_PRODUCT_NAME, "PC-LZ750LS"),
1086 * Some machines'(E,G Lenovo Z480) ECs are not stable
1087 * during boot up and this causes battery driver fails to be
1088 * probed due to failure of getting battery information
1089 * from EC sometimes. After several retries, the operation
1090 * may work. So add retry code here and 20ms sleep between
1093 static int acpi_battery_update_retry(struct acpi_battery *battery)
1097 for (retry = 5; retry; retry--) {
1098 ret = acpi_battery_update(battery);
1107 static int acpi_battery_add(struct acpi_device *device)
1110 struct acpi_battery *battery = NULL;
1114 battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL);
1117 battery->device = device;
1118 strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME);
1119 strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS);
1120 device->driver_data = battery;
1121 mutex_init(&battery->lock);
1122 mutex_init(&battery->sysfs_lock);
1123 if (ACPI_SUCCESS(acpi_get_handle(battery->device->handle,
1125 set_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags);
1127 result = acpi_battery_update_retry(battery);
1131 #ifdef CONFIG_ACPI_PROCFS_POWER
1132 result = acpi_battery_add_fs(device);
1135 #ifdef CONFIG_ACPI_PROCFS_POWER
1136 acpi_battery_remove_fs(device);
1141 printk(KERN_INFO PREFIX "%s Slot [%s] (battery %s)\n",
1142 ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device),
1143 device->status.battery_present ? "present" : "absent");
1145 battery->pm_nb.notifier_call = battery_notify;
1146 register_pm_notifier(&battery->pm_nb);
1151 sysfs_remove_battery(battery);
1152 mutex_destroy(&battery->lock);
1153 mutex_destroy(&battery->sysfs_lock);
1158 static int acpi_battery_remove(struct acpi_device *device)
1160 struct acpi_battery *battery = NULL;
1162 if (!device || !acpi_driver_data(device))
1164 battery = acpi_driver_data(device);
1165 unregister_pm_notifier(&battery->pm_nb);
1166 #ifdef CONFIG_ACPI_PROCFS_POWER
1167 acpi_battery_remove_fs(device);
1169 sysfs_remove_battery(battery);
1170 mutex_destroy(&battery->lock);
1171 mutex_destroy(&battery->sysfs_lock);
1176 #ifdef CONFIG_PM_SLEEP
1177 /* this is needed to learn about changes made in suspended state */
1178 static int acpi_battery_resume(struct device *dev)
1180 struct acpi_battery *battery;
1185 battery = acpi_driver_data(to_acpi_device(dev));
1189 battery->update_time = 0;
1190 acpi_battery_update(battery);
1195 static SIMPLE_DEV_PM_OPS(acpi_battery_pm, NULL, acpi_battery_resume);
1197 static struct acpi_driver acpi_battery_driver = {
1199 .class = ACPI_BATTERY_CLASS,
1200 .ids = battery_device_ids,
1201 .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
1203 .add = acpi_battery_add,
1204 .remove = acpi_battery_remove,
1205 .notify = acpi_battery_notify,
1207 .drv.pm = &acpi_battery_pm,
1210 static void __init acpi_battery_init_async(void *unused, async_cookie_t cookie)
1214 #ifdef CONFIG_ACPI_PROCFS_POWER
1215 acpi_battery_dir = acpi_lock_battery_dir();
1216 if (!acpi_battery_dir)
1219 if (dmi_check_system(bat_dmi_table))
1220 battery_bix_broken_package = 1;
1221 if (acpi_bus_register_driver(&acpi_battery_driver) < 0) {
1222 #ifdef CONFIG_ACPI_PROCFS_POWER
1223 acpi_unlock_battery_dir(acpi_battery_dir);
1230 static int __init acpi_battery_init(void)
1232 async_schedule(acpi_battery_init_async, NULL);
1236 static void __exit acpi_battery_exit(void)
1238 acpi_bus_unregister_driver(&acpi_battery_driver);
1239 #ifdef CONFIG_ACPI_PROCFS_POWER
1240 acpi_unlock_battery_dir(acpi_battery_dir);
1244 module_init(acpi_battery_init);
1245 module_exit(acpi_battery_exit);