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 #include <linux/kernel.h>
25 #include <linux/module.h>
26 #include <linux/init.h>
27 #include <linux/types.h>
28 #include <linux/jiffies.h>
29 #include <linux/async.h>
30 #include <linux/dmi.h>
31 #include <linux/delay.h>
32 #include <linux/slab.h>
33 #include <linux/suspend.h>
34 #include <asm/unaligned.h>
36 #ifdef CONFIG_ACPI_PROCFS_POWER
37 #include <linux/proc_fs.h>
38 #include <linux/seq_file.h>
39 #include <asm/uaccess.h>
42 #include <linux/acpi.h>
43 #include <linux/power_supply.h>
47 #define PREFIX "ACPI: "
49 #define ACPI_BATTERY_VALUE_UNKNOWN 0xFFFFFFFF
51 #define ACPI_BATTERY_DEVICE_NAME "Battery"
53 /* Battery power unit: 0 means mW, 1 means mA */
54 #define ACPI_BATTERY_POWER_UNIT_MA 1
56 #define ACPI_BATTERY_STATE_DISCHARGING 0x1
57 #define ACPI_BATTERY_STATE_CHARGING 0x2
58 #define ACPI_BATTERY_STATE_CRITICAL 0x4
60 #define _COMPONENT ACPI_BATTERY_COMPONENT
62 ACPI_MODULE_NAME("battery");
64 MODULE_AUTHOR("Paul Diefenbaugh");
65 MODULE_AUTHOR("Alexey Starikovskiy <astarikovskiy@suse.de>");
66 MODULE_DESCRIPTION("ACPI Battery Driver");
67 MODULE_LICENSE("GPL");
69 static async_cookie_t async_cookie;
70 static int battery_bix_broken_package;
71 static int battery_notification_delay_ms;
72 static unsigned int cache_time = 1000;
73 module_param(cache_time, uint, 0644);
74 MODULE_PARM_DESC(cache_time, "cache time in milliseconds");
76 #ifdef CONFIG_ACPI_PROCFS_POWER
77 extern struct proc_dir_entry *acpi_lock_battery_dir(void);
78 extern void *acpi_unlock_battery_dir(struct proc_dir_entry *acpi_battery_dir);
80 enum acpi_battery_files {
84 ACPI_BATTERY_NUMFILES,
89 static const struct acpi_device_id battery_device_ids[] = {
92 /* Microsoft Surface Go 3 */
98 MODULE_DEVICE_TABLE(acpi, battery_device_ids);
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,
118 struct acpi_battery {
120 struct mutex sysfs_lock;
121 struct power_supply *bat;
122 struct power_supply_desc bat_desc;
123 struct acpi_device *device;
124 struct notifier_block pm_nb;
125 unsigned long update_time;
131 int full_charge_capacity;
134 int design_capacity_warning;
135 int design_capacity_low;
137 int measurement_accuracy;
138 int max_sampling_time;
139 int min_sampling_time;
140 int max_averaging_interval;
141 int min_averaging_interval;
142 int capacity_granularity_1;
143 int capacity_granularity_2;
145 char model_number[32];
146 char serial_number[32];
154 #define to_acpi_battery(x) power_supply_get_drvdata(x)
156 static inline int acpi_battery_present(struct acpi_battery *battery)
158 return battery->device->status.battery_present;
161 static int acpi_battery_technology(struct acpi_battery *battery)
163 if (!strcasecmp("NiCd", battery->type))
164 return POWER_SUPPLY_TECHNOLOGY_NiCd;
165 if (!strcasecmp("NiMH", battery->type))
166 return POWER_SUPPLY_TECHNOLOGY_NiMH;
167 if (!strcasecmp("LION", battery->type))
168 return POWER_SUPPLY_TECHNOLOGY_LION;
169 if (!strncasecmp("LI-ION", battery->type, 6))
170 return POWER_SUPPLY_TECHNOLOGY_LION;
171 if (!strcasecmp("LiP", battery->type))
172 return POWER_SUPPLY_TECHNOLOGY_LIPO;
173 return POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
176 static int acpi_battery_get_state(struct acpi_battery *battery);
178 static int acpi_battery_is_charged(struct acpi_battery *battery)
180 /* charging, discharging or critical low */
181 if (battery->state != 0)
184 /* battery not reporting charge */
185 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN ||
186 battery->capacity_now == 0)
189 /* good batteries update full_charge as the batteries degrade */
190 if (battery->full_charge_capacity == battery->capacity_now)
193 /* fallback to using design values for broken batteries */
194 if (battery->design_capacity <= battery->capacity_now)
197 /* we don't do any sort of metric based on percentages */
201 static int acpi_battery_get_property(struct power_supply *psy,
202 enum power_supply_property psp,
203 union power_supply_propval *val)
206 struct acpi_battery *battery = to_acpi_battery(psy);
208 if (acpi_battery_present(battery)) {
209 /* run battery update only if it is present */
210 acpi_battery_get_state(battery);
211 } else if (psp != POWER_SUPPLY_PROP_PRESENT)
214 case POWER_SUPPLY_PROP_STATUS:
215 if (battery->state & ACPI_BATTERY_STATE_DISCHARGING)
216 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
217 else if (battery->state & ACPI_BATTERY_STATE_CHARGING)
218 val->intval = POWER_SUPPLY_STATUS_CHARGING;
219 else if (acpi_battery_is_charged(battery))
220 val->intval = POWER_SUPPLY_STATUS_FULL;
222 val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
224 case POWER_SUPPLY_PROP_PRESENT:
225 val->intval = acpi_battery_present(battery);
227 case POWER_SUPPLY_PROP_TECHNOLOGY:
228 val->intval = acpi_battery_technology(battery);
230 case POWER_SUPPLY_PROP_CYCLE_COUNT:
231 val->intval = battery->cycle_count;
233 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
234 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
237 val->intval = battery->design_voltage * 1000;
239 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
240 if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
243 val->intval = battery->voltage_now * 1000;
245 case POWER_SUPPLY_PROP_CURRENT_NOW:
246 case POWER_SUPPLY_PROP_POWER_NOW:
247 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
250 val->intval = battery->rate_now * 1000;
252 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
253 case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
254 if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
257 val->intval = battery->design_capacity * 1000;
259 case POWER_SUPPLY_PROP_CHARGE_FULL:
260 case POWER_SUPPLY_PROP_ENERGY_FULL:
261 if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
264 val->intval = battery->full_charge_capacity * 1000;
266 case POWER_SUPPLY_PROP_CHARGE_NOW:
267 case POWER_SUPPLY_PROP_ENERGY_NOW:
268 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
271 val->intval = battery->capacity_now * 1000;
273 case POWER_SUPPLY_PROP_CAPACITY:
274 if (battery->capacity_now && battery->full_charge_capacity)
275 val->intval = battery->capacity_now * 100/
276 battery->full_charge_capacity;
280 case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
281 if (battery->state & ACPI_BATTERY_STATE_CRITICAL)
282 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
283 else if (test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags) &&
284 (battery->capacity_now <= battery->alarm))
285 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_LOW;
286 else if (acpi_battery_is_charged(battery))
287 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
289 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
291 case POWER_SUPPLY_PROP_MODEL_NAME:
292 val->strval = battery->model_number;
294 case POWER_SUPPLY_PROP_MANUFACTURER:
295 val->strval = battery->oem_info;
297 case POWER_SUPPLY_PROP_SERIAL_NUMBER:
298 val->strval = battery->serial_number;
306 static enum power_supply_property charge_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_CURRENT_NOW,
314 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
315 POWER_SUPPLY_PROP_CHARGE_FULL,
316 POWER_SUPPLY_PROP_CHARGE_NOW,
317 POWER_SUPPLY_PROP_CAPACITY,
318 POWER_SUPPLY_PROP_CAPACITY_LEVEL,
319 POWER_SUPPLY_PROP_MODEL_NAME,
320 POWER_SUPPLY_PROP_MANUFACTURER,
321 POWER_SUPPLY_PROP_SERIAL_NUMBER,
324 static enum power_supply_property energy_battery_props[] = {
325 POWER_SUPPLY_PROP_STATUS,
326 POWER_SUPPLY_PROP_PRESENT,
327 POWER_SUPPLY_PROP_TECHNOLOGY,
328 POWER_SUPPLY_PROP_CYCLE_COUNT,
329 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
330 POWER_SUPPLY_PROP_VOLTAGE_NOW,
331 POWER_SUPPLY_PROP_POWER_NOW,
332 POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
333 POWER_SUPPLY_PROP_ENERGY_FULL,
334 POWER_SUPPLY_PROP_ENERGY_NOW,
335 POWER_SUPPLY_PROP_CAPACITY,
336 POWER_SUPPLY_PROP_CAPACITY_LEVEL,
337 POWER_SUPPLY_PROP_MODEL_NAME,
338 POWER_SUPPLY_PROP_MANUFACTURER,
339 POWER_SUPPLY_PROP_SERIAL_NUMBER,
342 /* --------------------------------------------------------------------------
344 -------------------------------------------------------------------------- */
345 struct acpi_offsets {
346 size_t offset; /* offset inside struct acpi_sbs_battery */
347 u8 mode; /* int or string? */
350 static const struct acpi_offsets state_offsets[] = {
351 {offsetof(struct acpi_battery, state), 0},
352 {offsetof(struct acpi_battery, rate_now), 0},
353 {offsetof(struct acpi_battery, capacity_now), 0},
354 {offsetof(struct acpi_battery, voltage_now), 0},
357 static const struct acpi_offsets info_offsets[] = {
358 {offsetof(struct acpi_battery, power_unit), 0},
359 {offsetof(struct acpi_battery, design_capacity), 0},
360 {offsetof(struct acpi_battery, full_charge_capacity), 0},
361 {offsetof(struct acpi_battery, technology), 0},
362 {offsetof(struct acpi_battery, design_voltage), 0},
363 {offsetof(struct acpi_battery, design_capacity_warning), 0},
364 {offsetof(struct acpi_battery, design_capacity_low), 0},
365 {offsetof(struct acpi_battery, capacity_granularity_1), 0},
366 {offsetof(struct acpi_battery, capacity_granularity_2), 0},
367 {offsetof(struct acpi_battery, model_number), 1},
368 {offsetof(struct acpi_battery, serial_number), 1},
369 {offsetof(struct acpi_battery, type), 1},
370 {offsetof(struct acpi_battery, oem_info), 1},
373 static const struct acpi_offsets extended_info_offsets[] = {
374 {offsetof(struct acpi_battery, revision), 0},
375 {offsetof(struct acpi_battery, power_unit), 0},
376 {offsetof(struct acpi_battery, design_capacity), 0},
377 {offsetof(struct acpi_battery, full_charge_capacity), 0},
378 {offsetof(struct acpi_battery, technology), 0},
379 {offsetof(struct acpi_battery, design_voltage), 0},
380 {offsetof(struct acpi_battery, design_capacity_warning), 0},
381 {offsetof(struct acpi_battery, design_capacity_low), 0},
382 {offsetof(struct acpi_battery, cycle_count), 0},
383 {offsetof(struct acpi_battery, measurement_accuracy), 0},
384 {offsetof(struct acpi_battery, max_sampling_time), 0},
385 {offsetof(struct acpi_battery, min_sampling_time), 0},
386 {offsetof(struct acpi_battery, max_averaging_interval), 0},
387 {offsetof(struct acpi_battery, min_averaging_interval), 0},
388 {offsetof(struct acpi_battery, capacity_granularity_1), 0},
389 {offsetof(struct acpi_battery, capacity_granularity_2), 0},
390 {offsetof(struct acpi_battery, model_number), 1},
391 {offsetof(struct acpi_battery, serial_number), 1},
392 {offsetof(struct acpi_battery, type), 1},
393 {offsetof(struct acpi_battery, oem_info), 1},
396 static int extract_package(struct acpi_battery *battery,
397 union acpi_object *package,
398 const struct acpi_offsets *offsets, int num)
401 union acpi_object *element;
402 if (package->type != ACPI_TYPE_PACKAGE)
404 for (i = 0; i < num; ++i) {
405 if (package->package.count <= i)
407 element = &package->package.elements[i];
408 if (offsets[i].mode) {
409 u8 *ptr = (u8 *)battery + offsets[i].offset;
410 if (element->type == ACPI_TYPE_STRING ||
411 element->type == ACPI_TYPE_BUFFER)
412 strncpy(ptr, element->string.pointer, 32);
413 else if (element->type == ACPI_TYPE_INTEGER) {
414 strncpy(ptr, (u8 *)&element->integer.value,
416 ptr[sizeof(u64)] = 0;
418 *ptr = 0; /* don't have value */
420 int *x = (int *)((u8 *)battery + offsets[i].offset);
421 *x = (element->type == ACPI_TYPE_INTEGER) ?
422 element->integer.value : -1;
428 static int acpi_battery_get_status(struct acpi_battery *battery)
430 if (acpi_bus_get_status(battery->device)) {
431 ACPI_EXCEPTION((AE_INFO, AE_ERROR, "Evaluating _STA"));
437 static int acpi_battery_get_info(struct acpi_battery *battery)
439 int result = -EFAULT;
440 acpi_status status = 0;
441 char *name = test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags) ?
444 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
446 if (!acpi_battery_present(battery))
448 mutex_lock(&battery->lock);
449 status = acpi_evaluate_object(battery->device->handle, name,
451 mutex_unlock(&battery->lock);
453 if (ACPI_FAILURE(status)) {
454 ACPI_EXCEPTION((AE_INFO, status, "Evaluating %s", name));
458 if (battery_bix_broken_package)
459 result = extract_package(battery, buffer.pointer,
460 extended_info_offsets + 1,
461 ARRAY_SIZE(extended_info_offsets) - 1);
462 else if (test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags))
463 result = extract_package(battery, buffer.pointer,
464 extended_info_offsets,
465 ARRAY_SIZE(extended_info_offsets));
467 result = extract_package(battery, buffer.pointer,
468 info_offsets, ARRAY_SIZE(info_offsets));
469 kfree(buffer.pointer);
470 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
471 battery->full_charge_capacity = battery->design_capacity;
472 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
473 battery->power_unit && battery->design_voltage) {
474 battery->design_capacity = battery->design_capacity *
475 10000 / battery->design_voltage;
476 battery->full_charge_capacity = battery->full_charge_capacity *
477 10000 / battery->design_voltage;
478 battery->design_capacity_warning =
479 battery->design_capacity_warning *
480 10000 / battery->design_voltage;
481 /* Curiously, design_capacity_low, unlike the rest of them,
483 /* capacity_granularity_* equal 1 on the systems tested, so
484 it's impossible to tell if they would need an adjustment
485 or not if their values were higher. */
490 static int acpi_battery_get_state(struct acpi_battery *battery)
493 acpi_status status = 0;
494 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
496 if (!acpi_battery_present(battery))
499 if (battery->update_time &&
500 time_before(jiffies, battery->update_time +
501 msecs_to_jiffies(cache_time)))
504 mutex_lock(&battery->lock);
505 status = acpi_evaluate_object(battery->device->handle, "_BST",
507 mutex_unlock(&battery->lock);
509 if (ACPI_FAILURE(status)) {
510 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BST"));
514 result = extract_package(battery, buffer.pointer,
515 state_offsets, ARRAY_SIZE(state_offsets));
516 battery->update_time = jiffies;
517 kfree(buffer.pointer);
519 /* For buggy DSDTs that report negative 16-bit values for either
520 * charging or discharging current and/or report 0 as 65536
523 if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA &&
524 battery->rate_now != ACPI_BATTERY_VALUE_UNKNOWN &&
525 (s16)(battery->rate_now) < 0) {
526 battery->rate_now = abs((s16)battery->rate_now);
527 printk_once(KERN_WARNING FW_BUG
528 "battery: (dis)charge rate invalid.\n");
531 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags)
532 && battery->capacity_now >= 0 && battery->capacity_now <= 100)
533 battery->capacity_now = (battery->capacity_now *
534 battery->full_charge_capacity) / 100;
535 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
536 battery->power_unit && battery->design_voltage) {
537 battery->capacity_now = battery->capacity_now *
538 10000 / battery->design_voltage;
543 static int acpi_battery_set_alarm(struct acpi_battery *battery)
545 acpi_status status = 0;
547 if (!acpi_battery_present(battery) ||
548 !test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags))
551 mutex_lock(&battery->lock);
552 status = acpi_execute_simple_method(battery->device->handle, "_BTP",
554 mutex_unlock(&battery->lock);
556 if (ACPI_FAILURE(status))
559 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Alarm set to %d\n", battery->alarm));
563 static int acpi_battery_init_alarm(struct acpi_battery *battery)
565 /* See if alarms are supported, and if so, set default */
566 if (!acpi_has_method(battery->device->handle, "_BTP")) {
567 clear_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
570 set_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
572 battery->alarm = battery->design_capacity_warning;
573 return acpi_battery_set_alarm(battery);
576 static ssize_t acpi_battery_alarm_show(struct device *dev,
577 struct device_attribute *attr,
580 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
581 return sprintf(buf, "%d\n", battery->alarm * 1000);
584 static ssize_t acpi_battery_alarm_store(struct device *dev,
585 struct device_attribute *attr,
586 const char *buf, size_t count)
589 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
590 if (sscanf(buf, "%lu\n", &x) == 1)
591 battery->alarm = x/1000;
592 if (acpi_battery_present(battery))
593 acpi_battery_set_alarm(battery);
597 static struct device_attribute alarm_attr = {
598 .attr = {.name = "alarm", .mode = 0644},
599 .show = acpi_battery_alarm_show,
600 .store = acpi_battery_alarm_store,
603 static int sysfs_add_battery(struct acpi_battery *battery)
605 struct power_supply_config psy_cfg = { .drv_data = battery, };
607 if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) {
608 battery->bat_desc.properties = charge_battery_props;
609 battery->bat_desc.num_properties =
610 ARRAY_SIZE(charge_battery_props);
612 battery->bat_desc.properties = energy_battery_props;
613 battery->bat_desc.num_properties =
614 ARRAY_SIZE(energy_battery_props);
617 battery->bat_desc.name = acpi_device_bid(battery->device);
618 battery->bat_desc.type = POWER_SUPPLY_TYPE_BATTERY;
619 battery->bat_desc.get_property = acpi_battery_get_property;
621 battery->bat = power_supply_register_no_ws(&battery->device->dev,
622 &battery->bat_desc, &psy_cfg);
624 if (IS_ERR(battery->bat)) {
625 int result = PTR_ERR(battery->bat);
630 return device_create_file(&battery->bat->dev, &alarm_attr);
633 static void sysfs_remove_battery(struct acpi_battery *battery)
635 mutex_lock(&battery->sysfs_lock);
637 mutex_unlock(&battery->sysfs_lock);
641 device_remove_file(&battery->bat->dev, &alarm_attr);
642 power_supply_unregister(battery->bat);
644 mutex_unlock(&battery->sysfs_lock);
647 static void find_battery(const struct dmi_header *dm, void *private)
649 struct acpi_battery *battery = (struct acpi_battery *)private;
650 /* Note: the hardcoded offsets below have been extracted from
651 the source code of dmidecode. */
652 if (dm->type == DMI_ENTRY_PORTABLE_BATTERY && dm->length >= 8) {
653 const u8 *dmi_data = (const u8 *)(dm + 1);
654 int dmi_capacity = get_unaligned((const u16 *)(dmi_data + 6));
655 if (dm->length >= 18)
656 dmi_capacity *= dmi_data[17];
657 if (battery->design_capacity * battery->design_voltage / 1000
659 battery->design_capacity * 10 == dmi_capacity)
660 set_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
666 * According to the ACPI spec, some kinds of primary batteries can
667 * report percentage battery remaining capacity directly to OS.
668 * In this case, it reports the Last Full Charged Capacity == 100
669 * and BatteryPresentRate == 0xFFFFFFFF.
671 * Now we found some battery reports percentage remaining capacity
672 * even if it's rechargeable.
673 * https://bugzilla.kernel.org/show_bug.cgi?id=15979
675 * Handle this correctly so that they won't break userspace.
677 static void acpi_battery_quirks(struct acpi_battery *battery)
679 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
682 if (battery->full_charge_capacity == 100 &&
683 battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN &&
684 battery->capacity_now >= 0 && battery->capacity_now <= 100) {
685 set_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags);
686 battery->full_charge_capacity = battery->design_capacity;
687 battery->capacity_now = (battery->capacity_now *
688 battery->full_charge_capacity) / 100;
691 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags))
694 if (battery->power_unit && dmi_name_in_vendors("LENOVO")) {
696 s = dmi_get_system_info(DMI_PRODUCT_VERSION);
697 if (s && !strncasecmp(s, "ThinkPad", 8)) {
698 dmi_walk(find_battery, battery);
699 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
701 battery->design_voltage) {
702 battery->design_capacity =
703 battery->design_capacity *
704 10000 / battery->design_voltage;
705 battery->full_charge_capacity =
706 battery->full_charge_capacity *
707 10000 / battery->design_voltage;
708 battery->design_capacity_warning =
709 battery->design_capacity_warning *
710 10000 / battery->design_voltage;
711 battery->capacity_now = battery->capacity_now *
712 10000 / battery->design_voltage;
718 static int acpi_battery_update(struct acpi_battery *battery, bool resume)
720 int result, old_present = acpi_battery_present(battery);
721 result = acpi_battery_get_status(battery);
724 if (!acpi_battery_present(battery)) {
725 sysfs_remove_battery(battery);
726 battery->update_time = 0;
733 if (!battery->update_time ||
734 old_present != acpi_battery_present(battery)) {
735 result = acpi_battery_get_info(battery);
738 acpi_battery_init_alarm(battery);
741 result = acpi_battery_get_state(battery);
744 acpi_battery_quirks(battery);
747 result = sysfs_add_battery(battery);
753 * Wakeup the system if battery is critical low
754 * or lower than the alarm level
756 if ((battery->state & ACPI_BATTERY_STATE_CRITICAL) ||
757 (test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags) &&
758 (battery->capacity_now <= battery->alarm)))
759 pm_wakeup_event(&battery->device->dev, 0);
764 static void acpi_battery_refresh(struct acpi_battery *battery)
771 power_unit = battery->power_unit;
773 acpi_battery_get_info(battery);
775 if (power_unit == battery->power_unit)
778 /* The battery has changed its reporting units. */
779 sysfs_remove_battery(battery);
780 sysfs_add_battery(battery);
783 /* --------------------------------------------------------------------------
785 -------------------------------------------------------------------------- */
787 #ifdef CONFIG_ACPI_PROCFS_POWER
788 static struct proc_dir_entry *acpi_battery_dir;
790 static const char *acpi_battery_units(const struct acpi_battery *battery)
792 return (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) ?
796 static int acpi_battery_print_info(struct seq_file *seq, int result)
798 struct acpi_battery *battery = seq->private;
803 seq_printf(seq, "present: %s\n",
804 acpi_battery_present(battery) ? "yes" : "no");
805 if (!acpi_battery_present(battery))
807 if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
808 seq_printf(seq, "design capacity: unknown\n");
810 seq_printf(seq, "design capacity: %d %sh\n",
811 battery->design_capacity,
812 acpi_battery_units(battery));
814 if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
815 seq_printf(seq, "last full capacity: unknown\n");
817 seq_printf(seq, "last full capacity: %d %sh\n",
818 battery->full_charge_capacity,
819 acpi_battery_units(battery));
821 seq_printf(seq, "battery technology: %srechargeable\n",
822 (!battery->technology)?"non-":"");
824 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
825 seq_printf(seq, "design voltage: unknown\n");
827 seq_printf(seq, "design voltage: %d mV\n",
828 battery->design_voltage);
829 seq_printf(seq, "design capacity warning: %d %sh\n",
830 battery->design_capacity_warning,
831 acpi_battery_units(battery));
832 seq_printf(seq, "design capacity low: %d %sh\n",
833 battery->design_capacity_low,
834 acpi_battery_units(battery));
835 seq_printf(seq, "cycle count: %i\n", battery->cycle_count);
836 seq_printf(seq, "capacity granularity 1: %d %sh\n",
837 battery->capacity_granularity_1,
838 acpi_battery_units(battery));
839 seq_printf(seq, "capacity granularity 2: %d %sh\n",
840 battery->capacity_granularity_2,
841 acpi_battery_units(battery));
842 seq_printf(seq, "model number: %s\n", battery->model_number);
843 seq_printf(seq, "serial number: %s\n", battery->serial_number);
844 seq_printf(seq, "battery type: %s\n", battery->type);
845 seq_printf(seq, "OEM info: %s\n", battery->oem_info);
848 seq_printf(seq, "ERROR: Unable to read battery info\n");
852 static int acpi_battery_print_state(struct seq_file *seq, int result)
854 struct acpi_battery *battery = seq->private;
859 seq_printf(seq, "present: %s\n",
860 acpi_battery_present(battery) ? "yes" : "no");
861 if (!acpi_battery_present(battery))
864 seq_printf(seq, "capacity state: %s\n",
865 (battery->state & 0x04) ? "critical" : "ok");
866 if ((battery->state & 0x01) && (battery->state & 0x02))
868 "charging state: charging/discharging\n");
869 else if (battery->state & 0x01)
870 seq_printf(seq, "charging state: discharging\n");
871 else if (battery->state & 0x02)
872 seq_printf(seq, "charging state: charging\n");
874 seq_printf(seq, "charging state: charged\n");
876 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
877 seq_printf(seq, "present rate: unknown\n");
879 seq_printf(seq, "present rate: %d %s\n",
880 battery->rate_now, acpi_battery_units(battery));
882 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
883 seq_printf(seq, "remaining capacity: unknown\n");
885 seq_printf(seq, "remaining capacity: %d %sh\n",
886 battery->capacity_now, acpi_battery_units(battery));
887 if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
888 seq_printf(seq, "present voltage: unknown\n");
890 seq_printf(seq, "present voltage: %d mV\n",
891 battery->voltage_now);
894 seq_printf(seq, "ERROR: Unable to read battery state\n");
899 static int acpi_battery_print_alarm(struct seq_file *seq, int result)
901 struct acpi_battery *battery = seq->private;
906 if (!acpi_battery_present(battery)) {
907 seq_printf(seq, "present: no\n");
910 seq_printf(seq, "alarm: ");
912 seq_printf(seq, "unsupported\n");
914 seq_printf(seq, "%u %sh\n", battery->alarm,
915 acpi_battery_units(battery));
918 seq_printf(seq, "ERROR: Unable to read battery alarm\n");
922 static ssize_t acpi_battery_write_alarm(struct file *file,
923 const char __user * buffer,
924 size_t count, loff_t * ppos)
927 char alarm_string[12] = { '\0' };
928 struct seq_file *m = file->private_data;
929 struct acpi_battery *battery = m->private;
931 if (!battery || (count > sizeof(alarm_string) - 1))
933 if (!acpi_battery_present(battery)) {
937 if (copy_from_user(alarm_string, buffer, count)) {
941 alarm_string[count] = '\0';
942 if (kstrtoint(alarm_string, 0, &battery->alarm)) {
946 result = acpi_battery_set_alarm(battery);
953 typedef int(*print_func)(struct seq_file *seq, int result);
955 static print_func acpi_print_funcs[ACPI_BATTERY_NUMFILES] = {
956 acpi_battery_print_info,
957 acpi_battery_print_state,
958 acpi_battery_print_alarm,
961 static int acpi_battery_read(int fid, struct seq_file *seq)
963 struct acpi_battery *battery = seq->private;
964 int result = acpi_battery_update(battery, false);
965 return acpi_print_funcs[fid](seq, result);
968 #define DECLARE_FILE_FUNCTIONS(_name) \
969 static int acpi_battery_read_##_name(struct seq_file *seq, void *offset) \
971 return acpi_battery_read(_name##_tag, seq); \
973 static int acpi_battery_##_name##_open_fs(struct inode *inode, struct file *file) \
975 return single_open(file, acpi_battery_read_##_name, PDE_DATA(inode)); \
978 DECLARE_FILE_FUNCTIONS(info);
979 DECLARE_FILE_FUNCTIONS(state);
980 DECLARE_FILE_FUNCTIONS(alarm);
982 #undef DECLARE_FILE_FUNCTIONS
984 #define FILE_DESCRIPTION_RO(_name) \
986 .name = __stringify(_name), \
989 .open = acpi_battery_##_name##_open_fs, \
991 .llseek = seq_lseek, \
992 .release = single_release, \
993 .owner = THIS_MODULE, \
997 #define FILE_DESCRIPTION_RW(_name) \
999 .name = __stringify(_name), \
1000 .mode = S_IFREG | S_IRUGO | S_IWUSR, \
1002 .open = acpi_battery_##_name##_open_fs, \
1004 .llseek = seq_lseek, \
1005 .write = acpi_battery_write_##_name, \
1006 .release = single_release, \
1007 .owner = THIS_MODULE, \
1011 static const struct battery_file {
1012 struct file_operations ops;
1015 } acpi_battery_file[] = {
1016 FILE_DESCRIPTION_RO(info),
1017 FILE_DESCRIPTION_RO(state),
1018 FILE_DESCRIPTION_RW(alarm),
1021 #undef FILE_DESCRIPTION_RO
1022 #undef FILE_DESCRIPTION_RW
1024 static int acpi_battery_add_fs(struct acpi_device *device)
1026 struct proc_dir_entry *entry = NULL;
1029 printk(KERN_WARNING PREFIX "Deprecated procfs I/F for battery is loaded,"
1030 " please retry with CONFIG_ACPI_PROCFS_POWER cleared\n");
1031 if (!acpi_device_dir(device)) {
1032 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
1034 if (!acpi_device_dir(device))
1038 for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i) {
1039 entry = proc_create_data(acpi_battery_file[i].name,
1040 acpi_battery_file[i].mode,
1041 acpi_device_dir(device),
1042 &acpi_battery_file[i].ops,
1043 acpi_driver_data(device));
1050 static void acpi_battery_remove_fs(struct acpi_device *device)
1053 if (!acpi_device_dir(device))
1055 for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i)
1056 remove_proc_entry(acpi_battery_file[i].name,
1057 acpi_device_dir(device));
1059 remove_proc_entry(acpi_device_bid(device), acpi_battery_dir);
1060 acpi_device_dir(device) = NULL;
1065 /* --------------------------------------------------------------------------
1067 -------------------------------------------------------------------------- */
1069 static void acpi_battery_notify(struct acpi_device *device, u32 event)
1071 struct acpi_battery *battery = acpi_driver_data(device);
1072 struct power_supply *old;
1078 * On Acer Aspire V5-573G notifications are sometimes triggered too
1079 * early. For example, when AC is unplugged and notification is
1080 * triggered, battery state is still reported as "Full", and changes to
1081 * "Discharging" only after short delay, without any notification.
1083 if (battery_notification_delay_ms > 0)
1084 msleep(battery_notification_delay_ms);
1085 if (event == ACPI_BATTERY_NOTIFY_INFO)
1086 acpi_battery_refresh(battery);
1087 acpi_battery_update(battery, false);
1088 acpi_bus_generate_netlink_event(device->pnp.device_class,
1089 dev_name(&device->dev), event,
1090 acpi_battery_present(battery));
1091 acpi_notifier_call_chain(device, event, acpi_battery_present(battery));
1092 /* acpi_battery_update could remove power_supply object */
1093 if (old && battery->bat)
1094 power_supply_changed(battery->bat);
1097 static int battery_notify(struct notifier_block *nb,
1098 unsigned long mode, void *_unused)
1100 struct acpi_battery *battery = container_of(nb, struct acpi_battery,
1105 case PM_POST_HIBERNATION:
1106 case PM_POST_SUSPEND:
1107 if (!acpi_battery_present(battery))
1110 if (!battery->bat) {
1111 result = acpi_battery_get_info(battery);
1115 result = sysfs_add_battery(battery);
1119 acpi_battery_refresh(battery);
1121 acpi_battery_init_alarm(battery);
1122 acpi_battery_get_state(battery);
1130 battery_bix_broken_package_quirk(const struct dmi_system_id *d)
1132 battery_bix_broken_package = 1;
1137 battery_notification_delay_quirk(const struct dmi_system_id *d)
1139 battery_notification_delay_ms = 1000;
1143 static const struct dmi_system_id bat_dmi_table[] __initconst = {
1145 .callback = battery_bix_broken_package_quirk,
1146 .ident = "NEC LZ750/LS",
1148 DMI_MATCH(DMI_SYS_VENDOR, "NEC"),
1149 DMI_MATCH(DMI_PRODUCT_NAME, "PC-LZ750LS"),
1153 .callback = battery_notification_delay_quirk,
1154 .ident = "Acer Aspire V5-573G",
1156 DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
1157 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire V5-573G"),
1161 /* Microsoft Surface Go 3 */
1162 .callback = battery_notification_delay_quirk,
1164 DMI_MATCH(DMI_SYS_VENDOR, "Microsoft Corporation"),
1165 DMI_MATCH(DMI_PRODUCT_NAME, "Surface Go 3"),
1172 * Some machines'(E,G Lenovo Z480) ECs are not stable
1173 * during boot up and this causes battery driver fails to be
1174 * probed due to failure of getting battery information
1175 * from EC sometimes. After several retries, the operation
1176 * may work. So add retry code here and 20ms sleep between
1179 static int acpi_battery_update_retry(struct acpi_battery *battery)
1183 for (retry = 5; retry; retry--) {
1184 ret = acpi_battery_update(battery, false);
1193 static int acpi_battery_add(struct acpi_device *device)
1196 struct acpi_battery *battery = NULL;
1201 if (device->dep_unmet)
1202 return -EPROBE_DEFER;
1204 battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL);
1207 battery->device = device;
1208 strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME);
1209 strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS);
1210 device->driver_data = battery;
1211 mutex_init(&battery->lock);
1212 mutex_init(&battery->sysfs_lock);
1213 if (acpi_has_method(battery->device->handle, "_BIX"))
1214 set_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags);
1216 result = acpi_battery_update_retry(battery);
1220 #ifdef CONFIG_ACPI_PROCFS_POWER
1221 result = acpi_battery_add_fs(device);
1224 #ifdef CONFIG_ACPI_PROCFS_POWER
1225 acpi_battery_remove_fs(device);
1230 printk(KERN_INFO PREFIX "%s Slot [%s] (battery %s)\n",
1231 ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device),
1232 device->status.battery_present ? "present" : "absent");
1234 battery->pm_nb.notifier_call = battery_notify;
1235 register_pm_notifier(&battery->pm_nb);
1237 device_init_wakeup(&device->dev, 1);
1242 sysfs_remove_battery(battery);
1243 mutex_destroy(&battery->lock);
1244 mutex_destroy(&battery->sysfs_lock);
1249 static int acpi_battery_remove(struct acpi_device *device)
1251 struct acpi_battery *battery = NULL;
1253 if (!device || !acpi_driver_data(device))
1255 device_init_wakeup(&device->dev, 0);
1256 battery = acpi_driver_data(device);
1257 unregister_pm_notifier(&battery->pm_nb);
1258 #ifdef CONFIG_ACPI_PROCFS_POWER
1259 acpi_battery_remove_fs(device);
1261 sysfs_remove_battery(battery);
1262 mutex_destroy(&battery->lock);
1263 mutex_destroy(&battery->sysfs_lock);
1268 #ifdef CONFIG_PM_SLEEP
1269 /* this is needed to learn about changes made in suspended state */
1270 static int acpi_battery_resume(struct device *dev)
1272 struct acpi_battery *battery;
1277 battery = acpi_driver_data(to_acpi_device(dev));
1281 battery->update_time = 0;
1282 acpi_battery_update(battery, true);
1286 #define acpi_battery_resume NULL
1289 static SIMPLE_DEV_PM_OPS(acpi_battery_pm, NULL, acpi_battery_resume);
1291 static struct acpi_driver acpi_battery_driver = {
1293 .class = ACPI_BATTERY_CLASS,
1294 .ids = battery_device_ids,
1295 .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
1297 .add = acpi_battery_add,
1298 .remove = acpi_battery_remove,
1299 .notify = acpi_battery_notify,
1301 .drv.pm = &acpi_battery_pm,
1304 static void __init acpi_battery_init_async(void *unused, async_cookie_t cookie)
1308 dmi_check_system(bat_dmi_table);
1310 #ifdef CONFIG_ACPI_PROCFS_POWER
1311 acpi_battery_dir = acpi_lock_battery_dir();
1312 if (!acpi_battery_dir)
1315 result = acpi_bus_register_driver(&acpi_battery_driver);
1316 #ifdef CONFIG_ACPI_PROCFS_POWER
1318 acpi_unlock_battery_dir(acpi_battery_dir);
1322 static int __init acpi_battery_init(void)
1327 async_cookie = async_schedule(acpi_battery_init_async, NULL);
1331 static void __exit acpi_battery_exit(void)
1333 async_synchronize_cookie(async_cookie + 1);
1334 acpi_bus_unregister_driver(&acpi_battery_driver);
1335 #ifdef CONFIG_ACPI_PROCFS_POWER
1336 acpi_unlock_battery_dir(acpi_battery_dir);
1340 module_init(acpi_battery_init);
1341 module_exit(acpi_battery_exit);