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 <linux/acpi.h>
46 #include <linux/power_supply.h>
50 #define PREFIX "ACPI: "
52 #define ACPI_BATTERY_VALUE_UNKNOWN 0xFFFFFFFF
54 #define ACPI_BATTERY_DEVICE_NAME "Battery"
56 /* Battery power unit: 0 means mW, 1 means mA */
57 #define ACPI_BATTERY_POWER_UNIT_MA 1
59 #define _COMPONENT ACPI_BATTERY_COMPONENT
61 ACPI_MODULE_NAME("battery");
63 MODULE_AUTHOR("Paul Diefenbaugh");
64 MODULE_AUTHOR("Alexey Starikovskiy <astarikovskiy@suse.de>");
65 MODULE_DESCRIPTION("ACPI Battery Driver");
66 MODULE_LICENSE("GPL");
68 static int battery_bix_broken_package;
69 static unsigned int cache_time = 1000;
70 module_param(cache_time, uint, 0644);
71 MODULE_PARM_DESC(cache_time, "cache time in milliseconds");
73 #ifdef CONFIG_ACPI_PROCFS_POWER
74 extern struct proc_dir_entry *acpi_lock_battery_dir(void);
75 extern void *acpi_unlock_battery_dir(struct proc_dir_entry *acpi_battery_dir);
77 enum acpi_battery_files {
81 ACPI_BATTERY_NUMFILES,
86 static const struct acpi_device_id battery_device_ids[] = {
91 MODULE_DEVICE_TABLE(acpi, battery_device_ids);
94 ACPI_BATTERY_ALARM_PRESENT,
95 ACPI_BATTERY_XINFO_PRESENT,
96 ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY,
97 /* On Lenovo Thinkpad models from 2010 and 2011, the power unit
98 switches between mWh and mAh depending on whether the system
99 is running on battery or not. When mAh is the unit, most
100 reported values are incorrect and need to be adjusted by
101 10000/design_voltage. Verified on x201, t410, t410s, and x220.
102 Pre-2010 and 2012 models appear to always report in mWh and
103 are thus unaffected (tested with t42, t61, t500, x200, x300,
104 and x230). Also, in mid-2012 Lenovo issued a BIOS update for
105 the 2011 models that fixes the issue (tested on x220 with a
106 post-1.29 BIOS), but as of Nov. 2012, no such update is
107 available for the 2010 models. */
108 ACPI_BATTERY_QUIRK_THINKPAD_MAH,
111 struct acpi_battery {
113 struct mutex sysfs_lock;
114 struct power_supply bat;
115 struct acpi_device *device;
116 struct notifier_block pm_nb;
117 unsigned long update_time;
123 int full_charge_capacity;
126 int design_capacity_warning;
127 int design_capacity_low;
129 int measurement_accuracy;
130 int max_sampling_time;
131 int min_sampling_time;
132 int max_averaging_interval;
133 int min_averaging_interval;
134 int capacity_granularity_1;
135 int capacity_granularity_2;
137 char model_number[32];
138 char serial_number[32];
146 #define to_acpi_battery(x) container_of(x, struct acpi_battery, bat)
148 static inline int acpi_battery_present(struct acpi_battery *battery)
150 return battery->device->status.battery_present;
153 static int acpi_battery_technology(struct acpi_battery *battery)
155 if (!strcasecmp("NiCd", battery->type))
156 return POWER_SUPPLY_TECHNOLOGY_NiCd;
157 if (!strcasecmp("NiMH", battery->type))
158 return POWER_SUPPLY_TECHNOLOGY_NiMH;
159 if (!strcasecmp("LION", battery->type))
160 return POWER_SUPPLY_TECHNOLOGY_LION;
161 if (!strncasecmp("LI-ION", battery->type, 6))
162 return POWER_SUPPLY_TECHNOLOGY_LION;
163 if (!strcasecmp("LiP", battery->type))
164 return POWER_SUPPLY_TECHNOLOGY_LIPO;
165 return POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
168 static int acpi_battery_get_state(struct acpi_battery *battery);
170 static int acpi_battery_is_charged(struct acpi_battery *battery)
172 /* either charging or discharging */
173 if (battery->state != 0)
176 /* battery not reporting charge */
177 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN ||
178 battery->capacity_now == 0)
181 /* good batteries update full_charge as the batteries degrade */
182 if (battery->full_charge_capacity == battery->capacity_now)
185 /* fallback to using design values for broken batteries */
186 if (battery->design_capacity == battery->capacity_now)
189 /* we don't do any sort of metric based on percentages */
193 static int acpi_battery_get_property(struct power_supply *psy,
194 enum power_supply_property psp,
195 union power_supply_propval *val)
198 struct acpi_battery *battery = to_acpi_battery(psy);
200 if (acpi_battery_present(battery)) {
201 /* run battery update only if it is present */
202 acpi_battery_get_state(battery);
203 } else if (psp != POWER_SUPPLY_PROP_PRESENT)
206 case POWER_SUPPLY_PROP_STATUS:
207 if (battery->state & 0x01)
208 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
209 else if (battery->state & 0x02)
210 val->intval = POWER_SUPPLY_STATUS_CHARGING;
211 else if (acpi_battery_is_charged(battery))
212 val->intval = POWER_SUPPLY_STATUS_FULL;
214 val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
216 case POWER_SUPPLY_PROP_PRESENT:
217 val->intval = acpi_battery_present(battery);
219 case POWER_SUPPLY_PROP_TECHNOLOGY:
220 val->intval = acpi_battery_technology(battery);
222 case POWER_SUPPLY_PROP_CYCLE_COUNT:
223 val->intval = battery->cycle_count;
225 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
226 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
229 val->intval = battery->design_voltage * 1000;
231 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
232 if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
235 val->intval = battery->voltage_now * 1000;
237 case POWER_SUPPLY_PROP_CURRENT_NOW:
238 case POWER_SUPPLY_PROP_POWER_NOW:
239 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
242 val->intval = battery->rate_now * 1000;
244 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
245 case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
246 if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
249 val->intval = battery->design_capacity * 1000;
251 case POWER_SUPPLY_PROP_CHARGE_FULL:
252 case POWER_SUPPLY_PROP_ENERGY_FULL:
253 if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
256 val->intval = battery->full_charge_capacity * 1000;
258 case POWER_SUPPLY_PROP_CHARGE_NOW:
259 case POWER_SUPPLY_PROP_ENERGY_NOW:
260 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
263 val->intval = battery->capacity_now * 1000;
265 case POWER_SUPPLY_PROP_CAPACITY:
266 if (battery->capacity_now && battery->full_charge_capacity)
267 val->intval = battery->capacity_now * 100/
268 battery->full_charge_capacity;
272 case POWER_SUPPLY_PROP_MODEL_NAME:
273 val->strval = battery->model_number;
275 case POWER_SUPPLY_PROP_MANUFACTURER:
276 val->strval = battery->oem_info;
278 case POWER_SUPPLY_PROP_SERIAL_NUMBER:
279 val->strval = battery->serial_number;
287 static enum power_supply_property charge_battery_props[] = {
288 POWER_SUPPLY_PROP_STATUS,
289 POWER_SUPPLY_PROP_PRESENT,
290 POWER_SUPPLY_PROP_TECHNOLOGY,
291 POWER_SUPPLY_PROP_CYCLE_COUNT,
292 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
293 POWER_SUPPLY_PROP_VOLTAGE_NOW,
294 POWER_SUPPLY_PROP_CURRENT_NOW,
295 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
296 POWER_SUPPLY_PROP_CHARGE_FULL,
297 POWER_SUPPLY_PROP_CHARGE_NOW,
298 POWER_SUPPLY_PROP_CAPACITY,
299 POWER_SUPPLY_PROP_MODEL_NAME,
300 POWER_SUPPLY_PROP_MANUFACTURER,
301 POWER_SUPPLY_PROP_SERIAL_NUMBER,
304 static enum power_supply_property energy_battery_props[] = {
305 POWER_SUPPLY_PROP_STATUS,
306 POWER_SUPPLY_PROP_PRESENT,
307 POWER_SUPPLY_PROP_TECHNOLOGY,
308 POWER_SUPPLY_PROP_CYCLE_COUNT,
309 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
310 POWER_SUPPLY_PROP_VOLTAGE_NOW,
311 POWER_SUPPLY_PROP_POWER_NOW,
312 POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
313 POWER_SUPPLY_PROP_ENERGY_FULL,
314 POWER_SUPPLY_PROP_ENERGY_NOW,
315 POWER_SUPPLY_PROP_CAPACITY,
316 POWER_SUPPLY_PROP_MODEL_NAME,
317 POWER_SUPPLY_PROP_MANUFACTURER,
318 POWER_SUPPLY_PROP_SERIAL_NUMBER,
321 #ifdef CONFIG_ACPI_PROCFS_POWER
322 inline char *acpi_battery_units(struct acpi_battery *battery)
324 return (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) ?
329 /* --------------------------------------------------------------------------
331 -------------------------------------------------------------------------- */
332 struct acpi_offsets {
333 size_t offset; /* offset inside struct acpi_sbs_battery */
334 u8 mode; /* int or string? */
337 static struct acpi_offsets state_offsets[] = {
338 {offsetof(struct acpi_battery, state), 0},
339 {offsetof(struct acpi_battery, rate_now), 0},
340 {offsetof(struct acpi_battery, capacity_now), 0},
341 {offsetof(struct acpi_battery, voltage_now), 0},
344 static struct acpi_offsets info_offsets[] = {
345 {offsetof(struct acpi_battery, power_unit), 0},
346 {offsetof(struct acpi_battery, design_capacity), 0},
347 {offsetof(struct acpi_battery, full_charge_capacity), 0},
348 {offsetof(struct acpi_battery, technology), 0},
349 {offsetof(struct acpi_battery, design_voltage), 0},
350 {offsetof(struct acpi_battery, design_capacity_warning), 0},
351 {offsetof(struct acpi_battery, design_capacity_low), 0},
352 {offsetof(struct acpi_battery, capacity_granularity_1), 0},
353 {offsetof(struct acpi_battery, capacity_granularity_2), 0},
354 {offsetof(struct acpi_battery, model_number), 1},
355 {offsetof(struct acpi_battery, serial_number), 1},
356 {offsetof(struct acpi_battery, type), 1},
357 {offsetof(struct acpi_battery, oem_info), 1},
360 static struct acpi_offsets extended_info_offsets[] = {
361 {offsetof(struct acpi_battery, revision), 0},
362 {offsetof(struct acpi_battery, power_unit), 0},
363 {offsetof(struct acpi_battery, design_capacity), 0},
364 {offsetof(struct acpi_battery, full_charge_capacity), 0},
365 {offsetof(struct acpi_battery, technology), 0},
366 {offsetof(struct acpi_battery, design_voltage), 0},
367 {offsetof(struct acpi_battery, design_capacity_warning), 0},
368 {offsetof(struct acpi_battery, design_capacity_low), 0},
369 {offsetof(struct acpi_battery, cycle_count), 0},
370 {offsetof(struct acpi_battery, measurement_accuracy), 0},
371 {offsetof(struct acpi_battery, max_sampling_time), 0},
372 {offsetof(struct acpi_battery, min_sampling_time), 0},
373 {offsetof(struct acpi_battery, max_averaging_interval), 0},
374 {offsetof(struct acpi_battery, min_averaging_interval), 0},
375 {offsetof(struct acpi_battery, capacity_granularity_1), 0},
376 {offsetof(struct acpi_battery, capacity_granularity_2), 0},
377 {offsetof(struct acpi_battery, model_number), 1},
378 {offsetof(struct acpi_battery, serial_number), 1},
379 {offsetof(struct acpi_battery, type), 1},
380 {offsetof(struct acpi_battery, oem_info), 1},
383 static int extract_package(struct acpi_battery *battery,
384 union acpi_object *package,
385 struct acpi_offsets *offsets, int num)
388 union acpi_object *element;
389 if (package->type != ACPI_TYPE_PACKAGE)
391 for (i = 0; i < num; ++i) {
392 if (package->package.count <= i)
394 element = &package->package.elements[i];
395 if (offsets[i].mode) {
396 u8 *ptr = (u8 *)battery + offsets[i].offset;
397 if (element->type == ACPI_TYPE_STRING ||
398 element->type == ACPI_TYPE_BUFFER)
399 strncpy(ptr, element->string.pointer, 32);
400 else if (element->type == ACPI_TYPE_INTEGER) {
401 strncpy(ptr, (u8 *)&element->integer.value,
403 ptr[sizeof(u64)] = 0;
405 *ptr = 0; /* don't have value */
407 int *x = (int *)((u8 *)battery + offsets[i].offset);
408 *x = (element->type == ACPI_TYPE_INTEGER) ?
409 element->integer.value : -1;
415 static int acpi_battery_get_status(struct acpi_battery *battery)
417 if (acpi_bus_get_status(battery->device)) {
418 ACPI_EXCEPTION((AE_INFO, AE_ERROR, "Evaluating _STA"));
424 static int acpi_battery_get_info(struct acpi_battery *battery)
426 int result = -EFAULT;
427 acpi_status status = 0;
428 char *name = test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags) ?
431 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
433 if (!acpi_battery_present(battery))
435 mutex_lock(&battery->lock);
436 status = acpi_evaluate_object(battery->device->handle, name,
438 mutex_unlock(&battery->lock);
440 if (ACPI_FAILURE(status)) {
441 ACPI_EXCEPTION((AE_INFO, status, "Evaluating %s", name));
445 if (battery_bix_broken_package)
446 result = extract_package(battery, buffer.pointer,
447 extended_info_offsets + 1,
448 ARRAY_SIZE(extended_info_offsets) - 1);
449 else if (test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags))
450 result = extract_package(battery, buffer.pointer,
451 extended_info_offsets,
452 ARRAY_SIZE(extended_info_offsets));
454 result = extract_package(battery, buffer.pointer,
455 info_offsets, ARRAY_SIZE(info_offsets));
456 kfree(buffer.pointer);
457 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
458 battery->full_charge_capacity = battery->design_capacity;
459 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
460 battery->power_unit && battery->design_voltage) {
461 battery->design_capacity = battery->design_capacity *
462 10000 / battery->design_voltage;
463 battery->full_charge_capacity = battery->full_charge_capacity *
464 10000 / battery->design_voltage;
465 battery->design_capacity_warning =
466 battery->design_capacity_warning *
467 10000 / battery->design_voltage;
468 /* Curiously, design_capacity_low, unlike the rest of them,
470 /* capacity_granularity_* equal 1 on the systems tested, so
471 it's impossible to tell if they would need an adjustment
472 or not if their values were higher. */
477 static int acpi_battery_get_state(struct acpi_battery *battery)
480 acpi_status status = 0;
481 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
483 if (!acpi_battery_present(battery))
486 if (battery->update_time &&
487 time_before(jiffies, battery->update_time +
488 msecs_to_jiffies(cache_time)))
491 mutex_lock(&battery->lock);
492 status = acpi_evaluate_object(battery->device->handle, "_BST",
494 mutex_unlock(&battery->lock);
496 if (ACPI_FAILURE(status)) {
497 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BST"));
501 result = extract_package(battery, buffer.pointer,
502 state_offsets, ARRAY_SIZE(state_offsets));
503 battery->update_time = jiffies;
504 kfree(buffer.pointer);
506 /* For buggy DSDTs that report negative 16-bit values for either
507 * charging or discharging current and/or report 0 as 65536
510 if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA &&
511 battery->rate_now != ACPI_BATTERY_VALUE_UNKNOWN &&
512 (s16)(battery->rate_now) < 0) {
513 battery->rate_now = abs((s16)battery->rate_now);
514 printk_once(KERN_WARNING FW_BUG "battery: (dis)charge rate"
518 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags)
519 && battery->capacity_now >= 0 && battery->capacity_now <= 100)
520 battery->capacity_now = (battery->capacity_now *
521 battery->full_charge_capacity) / 100;
522 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
523 battery->power_unit && battery->design_voltage) {
524 battery->capacity_now = battery->capacity_now *
525 10000 / battery->design_voltage;
530 static int acpi_battery_set_alarm(struct acpi_battery *battery)
532 acpi_status status = 0;
534 if (!acpi_battery_present(battery) ||
535 !test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags))
538 mutex_lock(&battery->lock);
539 status = acpi_execute_simple_method(battery->device->handle, "_BTP",
541 mutex_unlock(&battery->lock);
543 if (ACPI_FAILURE(status))
546 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Alarm set to %d\n", battery->alarm));
550 static int acpi_battery_init_alarm(struct acpi_battery *battery)
552 /* See if alarms are supported, and if so, set default */
553 if (!acpi_has_method(battery->device->handle, "_BTP")) {
554 clear_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
557 set_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
559 battery->alarm = battery->design_capacity_warning;
560 return acpi_battery_set_alarm(battery);
563 static ssize_t acpi_battery_alarm_show(struct device *dev,
564 struct device_attribute *attr,
567 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
568 return sprintf(buf, "%d\n", battery->alarm * 1000);
571 static ssize_t acpi_battery_alarm_store(struct device *dev,
572 struct device_attribute *attr,
573 const char *buf, size_t count)
576 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
577 if (sscanf(buf, "%lu\n", &x) == 1)
578 battery->alarm = x/1000;
579 if (acpi_battery_present(battery))
580 acpi_battery_set_alarm(battery);
584 static struct device_attribute alarm_attr = {
585 .attr = {.name = "alarm", .mode = 0644},
586 .show = acpi_battery_alarm_show,
587 .store = acpi_battery_alarm_store,
590 static int sysfs_add_battery(struct acpi_battery *battery)
594 if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) {
595 battery->bat.properties = charge_battery_props;
596 battery->bat.num_properties =
597 ARRAY_SIZE(charge_battery_props);
599 battery->bat.properties = energy_battery_props;
600 battery->bat.num_properties =
601 ARRAY_SIZE(energy_battery_props);
604 battery->bat.name = acpi_device_bid(battery->device);
605 battery->bat.type = POWER_SUPPLY_TYPE_BATTERY;
606 battery->bat.get_property = acpi_battery_get_property;
608 result = power_supply_register(&battery->device->dev, &battery->bat);
611 return device_create_file(battery->bat.dev, &alarm_attr);
614 static void sysfs_remove_battery(struct acpi_battery *battery)
616 mutex_lock(&battery->sysfs_lock);
617 if (!battery->bat.dev) {
618 mutex_unlock(&battery->sysfs_lock);
622 device_remove_file(battery->bat.dev, &alarm_attr);
623 power_supply_unregister(&battery->bat);
624 battery->bat.dev = NULL;
625 mutex_unlock(&battery->sysfs_lock);
628 static void find_battery(const struct dmi_header *dm, void *private)
630 struct acpi_battery *battery = (struct acpi_battery *)private;
631 /* Note: the hardcoded offsets below have been extracted from
632 the source code of dmidecode. */
633 if (dm->type == DMI_ENTRY_PORTABLE_BATTERY && dm->length >= 8) {
634 const u8 *dmi_data = (const u8 *)(dm + 1);
635 int dmi_capacity = get_unaligned((const u16 *)(dmi_data + 6));
636 if (dm->length >= 18)
637 dmi_capacity *= dmi_data[17];
638 if (battery->design_capacity * battery->design_voltage / 1000
640 battery->design_capacity * 10 == dmi_capacity)
641 set_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
647 * According to the ACPI spec, some kinds of primary batteries can
648 * report percentage battery remaining capacity directly to OS.
649 * In this case, it reports the Last Full Charged Capacity == 100
650 * and BatteryPresentRate == 0xFFFFFFFF.
652 * Now we found some battery reports percentage remaining capacity
653 * even if it's rechargeable.
654 * https://bugzilla.kernel.org/show_bug.cgi?id=15979
656 * Handle this correctly so that they won't break userspace.
658 static void acpi_battery_quirks(struct acpi_battery *battery)
660 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
663 if (battery->full_charge_capacity == 100 &&
664 battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN &&
665 battery->capacity_now >= 0 && battery->capacity_now <= 100) {
666 set_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags);
667 battery->full_charge_capacity = battery->design_capacity;
668 battery->capacity_now = (battery->capacity_now *
669 battery->full_charge_capacity) / 100;
672 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags))
675 if (battery->power_unit && dmi_name_in_vendors("LENOVO")) {
677 s = dmi_get_system_info(DMI_PRODUCT_VERSION);
678 if (s && !strnicmp(s, "ThinkPad", 8)) {
679 dmi_walk(find_battery, battery);
680 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
682 battery->design_voltage) {
683 battery->design_capacity =
684 battery->design_capacity *
685 10000 / battery->design_voltage;
686 battery->full_charge_capacity =
687 battery->full_charge_capacity *
688 10000 / battery->design_voltage;
689 battery->design_capacity_warning =
690 battery->design_capacity_warning *
691 10000 / battery->design_voltage;
692 battery->capacity_now = battery->capacity_now *
693 10000 / battery->design_voltage;
699 static int acpi_battery_update(struct acpi_battery *battery)
701 int result, old_present = acpi_battery_present(battery);
702 result = acpi_battery_get_status(battery);
705 if (!acpi_battery_present(battery)) {
706 sysfs_remove_battery(battery);
707 battery->update_time = 0;
710 if (!battery->update_time ||
711 old_present != acpi_battery_present(battery)) {
712 result = acpi_battery_get_info(battery);
715 acpi_battery_init_alarm(battery);
717 if (!battery->bat.dev) {
718 result = sysfs_add_battery(battery);
722 result = acpi_battery_get_state(battery);
723 acpi_battery_quirks(battery);
727 static void acpi_battery_refresh(struct acpi_battery *battery)
731 if (!battery->bat.dev)
734 power_unit = battery->power_unit;
736 acpi_battery_get_info(battery);
738 if (power_unit == battery->power_unit)
741 /* The battery has changed its reporting units. */
742 sysfs_remove_battery(battery);
743 sysfs_add_battery(battery);
746 /* --------------------------------------------------------------------------
748 -------------------------------------------------------------------------- */
750 #ifdef CONFIG_ACPI_PROCFS_POWER
751 static struct proc_dir_entry *acpi_battery_dir;
753 static int acpi_battery_print_info(struct seq_file *seq, int result)
755 struct acpi_battery *battery = seq->private;
760 seq_printf(seq, "present: %s\n",
761 acpi_battery_present(battery) ? "yes" : "no");
762 if (!acpi_battery_present(battery))
764 if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
765 seq_printf(seq, "design capacity: unknown\n");
767 seq_printf(seq, "design capacity: %d %sh\n",
768 battery->design_capacity,
769 acpi_battery_units(battery));
771 if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
772 seq_printf(seq, "last full capacity: unknown\n");
774 seq_printf(seq, "last full capacity: %d %sh\n",
775 battery->full_charge_capacity,
776 acpi_battery_units(battery));
778 seq_printf(seq, "battery technology: %srechargeable\n",
779 (!battery->technology)?"non-":"");
781 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
782 seq_printf(seq, "design voltage: unknown\n");
784 seq_printf(seq, "design voltage: %d mV\n",
785 battery->design_voltage);
786 seq_printf(seq, "design capacity warning: %d %sh\n",
787 battery->design_capacity_warning,
788 acpi_battery_units(battery));
789 seq_printf(seq, "design capacity low: %d %sh\n",
790 battery->design_capacity_low,
791 acpi_battery_units(battery));
792 seq_printf(seq, "cycle count: %i\n", battery->cycle_count);
793 seq_printf(seq, "capacity granularity 1: %d %sh\n",
794 battery->capacity_granularity_1,
795 acpi_battery_units(battery));
796 seq_printf(seq, "capacity granularity 2: %d %sh\n",
797 battery->capacity_granularity_2,
798 acpi_battery_units(battery));
799 seq_printf(seq, "model number: %s\n", battery->model_number);
800 seq_printf(seq, "serial number: %s\n", battery->serial_number);
801 seq_printf(seq, "battery type: %s\n", battery->type);
802 seq_printf(seq, "OEM info: %s\n", battery->oem_info);
805 seq_printf(seq, "ERROR: Unable to read battery info\n");
809 static int acpi_battery_print_state(struct seq_file *seq, int result)
811 struct acpi_battery *battery = seq->private;
816 seq_printf(seq, "present: %s\n",
817 acpi_battery_present(battery) ? "yes" : "no");
818 if (!acpi_battery_present(battery))
821 seq_printf(seq, "capacity state: %s\n",
822 (battery->state & 0x04) ? "critical" : "ok");
823 if ((battery->state & 0x01) && (battery->state & 0x02))
825 "charging state: charging/discharging\n");
826 else if (battery->state & 0x01)
827 seq_printf(seq, "charging state: discharging\n");
828 else if (battery->state & 0x02)
829 seq_printf(seq, "charging state: charging\n");
831 seq_printf(seq, "charging state: charged\n");
833 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
834 seq_printf(seq, "present rate: unknown\n");
836 seq_printf(seq, "present rate: %d %s\n",
837 battery->rate_now, acpi_battery_units(battery));
839 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
840 seq_printf(seq, "remaining capacity: unknown\n");
842 seq_printf(seq, "remaining capacity: %d %sh\n",
843 battery->capacity_now, acpi_battery_units(battery));
844 if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
845 seq_printf(seq, "present voltage: unknown\n");
847 seq_printf(seq, "present voltage: %d mV\n",
848 battery->voltage_now);
851 seq_printf(seq, "ERROR: Unable to read battery state\n");
856 static int acpi_battery_print_alarm(struct seq_file *seq, int result)
858 struct acpi_battery *battery = seq->private;
863 if (!acpi_battery_present(battery)) {
864 seq_printf(seq, "present: no\n");
867 seq_printf(seq, "alarm: ");
869 seq_printf(seq, "unsupported\n");
871 seq_printf(seq, "%u %sh\n", battery->alarm,
872 acpi_battery_units(battery));
875 seq_printf(seq, "ERROR: Unable to read battery alarm\n");
879 static ssize_t acpi_battery_write_alarm(struct file *file,
880 const char __user * buffer,
881 size_t count, loff_t * ppos)
884 char alarm_string[12] = { '\0' };
885 struct seq_file *m = file->private_data;
886 struct acpi_battery *battery = m->private;
888 if (!battery || (count > sizeof(alarm_string) - 1))
890 if (!acpi_battery_present(battery)) {
894 if (copy_from_user(alarm_string, buffer, count)) {
898 alarm_string[count] = '\0';
899 battery->alarm = simple_strtol(alarm_string, NULL, 0);
900 result = acpi_battery_set_alarm(battery);
907 typedef int(*print_func)(struct seq_file *seq, int result);
909 static print_func acpi_print_funcs[ACPI_BATTERY_NUMFILES] = {
910 acpi_battery_print_info,
911 acpi_battery_print_state,
912 acpi_battery_print_alarm,
915 static int acpi_battery_read(int fid, struct seq_file *seq)
917 struct acpi_battery *battery = seq->private;
918 int result = acpi_battery_update(battery);
919 return acpi_print_funcs[fid](seq, result);
922 #define DECLARE_FILE_FUNCTIONS(_name) \
923 static int acpi_battery_read_##_name(struct seq_file *seq, void *offset) \
925 return acpi_battery_read(_name##_tag, seq); \
927 static int acpi_battery_##_name##_open_fs(struct inode *inode, struct file *file) \
929 return single_open(file, acpi_battery_read_##_name, PDE_DATA(inode)); \
932 DECLARE_FILE_FUNCTIONS(info);
933 DECLARE_FILE_FUNCTIONS(state);
934 DECLARE_FILE_FUNCTIONS(alarm);
936 #undef DECLARE_FILE_FUNCTIONS
938 #define FILE_DESCRIPTION_RO(_name) \
940 .name = __stringify(_name), \
943 .open = acpi_battery_##_name##_open_fs, \
945 .llseek = seq_lseek, \
946 .release = single_release, \
947 .owner = THIS_MODULE, \
951 #define FILE_DESCRIPTION_RW(_name) \
953 .name = __stringify(_name), \
954 .mode = S_IFREG | S_IRUGO | S_IWUSR, \
956 .open = acpi_battery_##_name##_open_fs, \
958 .llseek = seq_lseek, \
959 .write = acpi_battery_write_##_name, \
960 .release = single_release, \
961 .owner = THIS_MODULE, \
965 static const struct battery_file {
966 struct file_operations ops;
969 } acpi_battery_file[] = {
970 FILE_DESCRIPTION_RO(info),
971 FILE_DESCRIPTION_RO(state),
972 FILE_DESCRIPTION_RW(alarm),
975 #undef FILE_DESCRIPTION_RO
976 #undef FILE_DESCRIPTION_RW
978 static int acpi_battery_add_fs(struct acpi_device *device)
980 struct proc_dir_entry *entry = NULL;
983 printk(KERN_WARNING PREFIX "Deprecated procfs I/F for battery is loaded,"
984 " please retry with CONFIG_ACPI_PROCFS_POWER cleared\n");
985 if (!acpi_device_dir(device)) {
986 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
988 if (!acpi_device_dir(device))
992 for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i) {
993 entry = proc_create_data(acpi_battery_file[i].name,
994 acpi_battery_file[i].mode,
995 acpi_device_dir(device),
996 &acpi_battery_file[i].ops,
997 acpi_driver_data(device));
1004 static void acpi_battery_remove_fs(struct acpi_device *device)
1007 if (!acpi_device_dir(device))
1009 for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i)
1010 remove_proc_entry(acpi_battery_file[i].name,
1011 acpi_device_dir(device));
1013 remove_proc_entry(acpi_device_bid(device), acpi_battery_dir);
1014 acpi_device_dir(device) = NULL;
1019 /* --------------------------------------------------------------------------
1021 -------------------------------------------------------------------------- */
1023 static void acpi_battery_notify(struct acpi_device *device, u32 event)
1025 struct acpi_battery *battery = acpi_driver_data(device);
1030 old = battery->bat.dev;
1031 if (event == ACPI_BATTERY_NOTIFY_INFO)
1032 acpi_battery_refresh(battery);
1033 acpi_battery_update(battery);
1034 acpi_bus_generate_netlink_event(device->pnp.device_class,
1035 dev_name(&device->dev), event,
1036 acpi_battery_present(battery));
1037 acpi_notifier_call_chain(device, event, acpi_battery_present(battery));
1038 /* acpi_battery_update could remove power_supply object */
1039 if (old && battery->bat.dev)
1040 power_supply_changed(&battery->bat);
1043 static int battery_notify(struct notifier_block *nb,
1044 unsigned long mode, void *_unused)
1046 struct acpi_battery *battery = container_of(nb, struct acpi_battery,
1049 case PM_POST_HIBERNATION:
1050 case PM_POST_SUSPEND:
1051 if (battery->bat.dev) {
1052 sysfs_remove_battery(battery);
1053 sysfs_add_battery(battery);
1061 static struct dmi_system_id bat_dmi_table[] = {
1063 .ident = "NEC LZ750/LS",
1065 DMI_MATCH(DMI_SYS_VENDOR, "NEC"),
1066 DMI_MATCH(DMI_PRODUCT_NAME, "PC-LZ750LS"),
1072 static int acpi_battery_add(struct acpi_device *device)
1075 struct acpi_battery *battery = NULL;
1079 battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL);
1082 battery->device = device;
1083 strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME);
1084 strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS);
1085 device->driver_data = battery;
1086 mutex_init(&battery->lock);
1087 mutex_init(&battery->sysfs_lock);
1088 if (acpi_has_method(battery->device->handle, "_BIX"))
1089 set_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags);
1090 result = acpi_battery_update(battery);
1093 #ifdef CONFIG_ACPI_PROCFS_POWER
1094 result = acpi_battery_add_fs(device);
1097 #ifdef CONFIG_ACPI_PROCFS_POWER
1098 acpi_battery_remove_fs(device);
1103 printk(KERN_INFO PREFIX "%s Slot [%s] (battery %s)\n",
1104 ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device),
1105 device->status.battery_present ? "present" : "absent");
1107 battery->pm_nb.notifier_call = battery_notify;
1108 register_pm_notifier(&battery->pm_nb);
1113 sysfs_remove_battery(battery);
1114 mutex_destroy(&battery->lock);
1115 mutex_destroy(&battery->sysfs_lock);
1120 static int acpi_battery_remove(struct acpi_device *device)
1122 struct acpi_battery *battery = NULL;
1124 if (!device || !acpi_driver_data(device))
1126 battery = acpi_driver_data(device);
1127 unregister_pm_notifier(&battery->pm_nb);
1128 #ifdef CONFIG_ACPI_PROCFS_POWER
1129 acpi_battery_remove_fs(device);
1131 sysfs_remove_battery(battery);
1132 mutex_destroy(&battery->lock);
1133 mutex_destroy(&battery->sysfs_lock);
1138 #ifdef CONFIG_PM_SLEEP
1139 /* this is needed to learn about changes made in suspended state */
1140 static int acpi_battery_resume(struct device *dev)
1142 struct acpi_battery *battery;
1147 battery = acpi_driver_data(to_acpi_device(dev));
1151 battery->update_time = 0;
1152 acpi_battery_update(battery);
1156 #define acpi_battery_resume NULL
1159 static SIMPLE_DEV_PM_OPS(acpi_battery_pm, NULL, acpi_battery_resume);
1161 static struct acpi_driver acpi_battery_driver = {
1163 .class = ACPI_BATTERY_CLASS,
1164 .ids = battery_device_ids,
1165 .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
1167 .add = acpi_battery_add,
1168 .remove = acpi_battery_remove,
1169 .notify = acpi_battery_notify,
1171 .drv.pm = &acpi_battery_pm,
1174 static void __init acpi_battery_init_async(void *unused, async_cookie_t cookie)
1179 if (dmi_check_system(bat_dmi_table))
1180 battery_bix_broken_package = 1;
1182 #ifdef CONFIG_ACPI_PROCFS_POWER
1183 acpi_battery_dir = acpi_lock_battery_dir();
1184 if (!acpi_battery_dir)
1187 if (acpi_bus_register_driver(&acpi_battery_driver) < 0) {
1188 #ifdef CONFIG_ACPI_PROCFS_POWER
1189 acpi_unlock_battery_dir(acpi_battery_dir);
1196 static int __init acpi_battery_init(void)
1198 async_schedule(acpi_battery_init_async, NULL);
1202 static void __exit acpi_battery_exit(void)
1204 acpi_bus_unregister_driver(&acpi_battery_driver);
1205 #ifdef CONFIG_ACPI_PROCFS_POWER
1206 acpi_unlock_battery_dir(acpi_battery_dir);
1210 module_init(acpi_battery_init);
1211 module_exit(acpi_battery_exit);