Loading...
1/*
2 * battery.c - ACPI Battery Driver (Revision: 2.0)
3 *
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>
8 *
9 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
10 *
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.
15 *
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.
20 *
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.
24 *
25 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
26 */
27
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
38#ifdef CONFIG_ACPI_PROCFS_POWER
39#include <linux/proc_fs.h>
40#include <linux/seq_file.h>
41#include <asm/uaccess.h>
42#endif
43
44#include <acpi/acpi_bus.h>
45#include <acpi/acpi_drivers.h>
46#include <linux/power_supply.h>
47
48#define PREFIX "ACPI: "
49
50#define ACPI_BATTERY_VALUE_UNKNOWN 0xFFFFFFFF
51
52#define ACPI_BATTERY_CLASS "battery"
53#define ACPI_BATTERY_DEVICE_NAME "Battery"
54#define ACPI_BATTERY_NOTIFY_STATUS 0x80
55#define ACPI_BATTERY_NOTIFY_INFO 0x81
56#define ACPI_BATTERY_NOTIFY_THRESHOLD 0x82
57
58/* Battery power unit: 0 means mW, 1 means mA */
59#define ACPI_BATTERY_POWER_UNIT_MA 1
60
61#define _COMPONENT ACPI_BATTERY_COMPONENT
62
63ACPI_MODULE_NAME("battery");
64
65MODULE_AUTHOR("Paul Diefenbaugh");
66MODULE_AUTHOR("Alexey Starikovskiy <astarikovskiy@suse.de>");
67MODULE_DESCRIPTION("ACPI Battery Driver");
68MODULE_LICENSE("GPL");
69
70static unsigned int cache_time = 1000;
71module_param(cache_time, uint, 0644);
72MODULE_PARM_DESC(cache_time, "cache time in milliseconds");
73
74#ifdef CONFIG_ACPI_PROCFS_POWER
75extern struct proc_dir_entry *acpi_lock_battery_dir(void);
76extern void *acpi_unlock_battery_dir(struct proc_dir_entry *acpi_battery_dir);
77
78enum acpi_battery_files {
79 info_tag = 0,
80 state_tag,
81 alarm_tag,
82 ACPI_BATTERY_NUMFILES,
83};
84
85#endif
86
87static const struct acpi_device_id battery_device_ids[] = {
88 {"PNP0C0A", 0},
89 {"", 0},
90};
91
92MODULE_DEVICE_TABLE(acpi, battery_device_ids);
93
94enum {
95 ACPI_BATTERY_ALARM_PRESENT,
96 ACPI_BATTERY_XINFO_PRESENT,
97 ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY,
98};
99
100struct acpi_battery {
101 struct mutex lock;
102 struct mutex sysfs_lock;
103 struct power_supply bat;
104 struct acpi_device *device;
105 struct notifier_block pm_nb;
106 unsigned long update_time;
107 int rate_now;
108 int capacity_now;
109 int voltage_now;
110 int design_capacity;
111 int full_charge_capacity;
112 int technology;
113 int design_voltage;
114 int design_capacity_warning;
115 int design_capacity_low;
116 int cycle_count;
117 int measurement_accuracy;
118 int max_sampling_time;
119 int min_sampling_time;
120 int max_averaging_interval;
121 int min_averaging_interval;
122 int capacity_granularity_1;
123 int capacity_granularity_2;
124 int alarm;
125 char model_number[32];
126 char serial_number[32];
127 char type[32];
128 char oem_info[32];
129 int state;
130 int power_unit;
131 unsigned long flags;
132};
133
134#define to_acpi_battery(x) container_of(x, struct acpi_battery, bat)
135
136inline int acpi_battery_present(struct acpi_battery *battery)
137{
138 return battery->device->status.battery_present;
139}
140
141static int acpi_battery_technology(struct acpi_battery *battery)
142{
143 if (!strcasecmp("NiCd", battery->type))
144 return POWER_SUPPLY_TECHNOLOGY_NiCd;
145 if (!strcasecmp("NiMH", battery->type))
146 return POWER_SUPPLY_TECHNOLOGY_NiMH;
147 if (!strcasecmp("LION", battery->type))
148 return POWER_SUPPLY_TECHNOLOGY_LION;
149 if (!strncasecmp("LI-ION", battery->type, 6))
150 return POWER_SUPPLY_TECHNOLOGY_LION;
151 if (!strcasecmp("LiP", battery->type))
152 return POWER_SUPPLY_TECHNOLOGY_LIPO;
153 return POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
154}
155
156static int acpi_battery_get_state(struct acpi_battery *battery);
157
158static int acpi_battery_is_charged(struct acpi_battery *battery)
159{
160 /* either charging or discharging */
161 if (battery->state != 0)
162 return 0;
163
164 /* battery not reporting charge */
165 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN ||
166 battery->capacity_now == 0)
167 return 0;
168
169 /* good batteries update full_charge as the batteries degrade */
170 if (battery->full_charge_capacity == battery->capacity_now)
171 return 1;
172
173 /* fallback to using design values for broken batteries */
174 if (battery->design_capacity == battery->capacity_now)
175 return 1;
176
177 /* we don't do any sort of metric based on percentages */
178 return 0;
179}
180
181static int acpi_battery_get_property(struct power_supply *psy,
182 enum power_supply_property psp,
183 union power_supply_propval *val)
184{
185 int ret = 0;
186 struct acpi_battery *battery = to_acpi_battery(psy);
187
188 if (acpi_battery_present(battery)) {
189 /* run battery update only if it is present */
190 acpi_battery_get_state(battery);
191 } else if (psp != POWER_SUPPLY_PROP_PRESENT)
192 return -ENODEV;
193 switch (psp) {
194 case POWER_SUPPLY_PROP_STATUS:
195 if (battery->state & 0x01)
196 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
197 else if (battery->state & 0x02)
198 val->intval = POWER_SUPPLY_STATUS_CHARGING;
199 else if (acpi_battery_is_charged(battery))
200 val->intval = POWER_SUPPLY_STATUS_FULL;
201 else
202 val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
203 break;
204 case POWER_SUPPLY_PROP_PRESENT:
205 val->intval = acpi_battery_present(battery);
206 break;
207 case POWER_SUPPLY_PROP_TECHNOLOGY:
208 val->intval = acpi_battery_technology(battery);
209 break;
210 case POWER_SUPPLY_PROP_CYCLE_COUNT:
211 val->intval = battery->cycle_count;
212 break;
213 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
214 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
215 ret = -ENODEV;
216 else
217 val->intval = battery->design_voltage * 1000;
218 break;
219 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
220 if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
221 ret = -ENODEV;
222 else
223 val->intval = battery->voltage_now * 1000;
224 break;
225 case POWER_SUPPLY_PROP_CURRENT_NOW:
226 case POWER_SUPPLY_PROP_POWER_NOW:
227 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
228 ret = -ENODEV;
229 else
230 val->intval = battery->rate_now * 1000;
231 break;
232 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
233 case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
234 if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
235 ret = -ENODEV;
236 else
237 val->intval = battery->design_capacity * 1000;
238 break;
239 case POWER_SUPPLY_PROP_CHARGE_FULL:
240 case POWER_SUPPLY_PROP_ENERGY_FULL:
241 if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
242 ret = -ENODEV;
243 else
244 val->intval = battery->full_charge_capacity * 1000;
245 break;
246 case POWER_SUPPLY_PROP_CHARGE_NOW:
247 case POWER_SUPPLY_PROP_ENERGY_NOW:
248 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
249 ret = -ENODEV;
250 else
251 val->intval = battery->capacity_now * 1000;
252 break;
253 case POWER_SUPPLY_PROP_MODEL_NAME:
254 val->strval = battery->model_number;
255 break;
256 case POWER_SUPPLY_PROP_MANUFACTURER:
257 val->strval = battery->oem_info;
258 break;
259 case POWER_SUPPLY_PROP_SERIAL_NUMBER:
260 val->strval = battery->serial_number;
261 break;
262 default:
263 ret = -EINVAL;
264 }
265 return ret;
266}
267
268static enum power_supply_property charge_battery_props[] = {
269 POWER_SUPPLY_PROP_STATUS,
270 POWER_SUPPLY_PROP_PRESENT,
271 POWER_SUPPLY_PROP_TECHNOLOGY,
272 POWER_SUPPLY_PROP_CYCLE_COUNT,
273 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
274 POWER_SUPPLY_PROP_VOLTAGE_NOW,
275 POWER_SUPPLY_PROP_CURRENT_NOW,
276 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
277 POWER_SUPPLY_PROP_CHARGE_FULL,
278 POWER_SUPPLY_PROP_CHARGE_NOW,
279 POWER_SUPPLY_PROP_MODEL_NAME,
280 POWER_SUPPLY_PROP_MANUFACTURER,
281 POWER_SUPPLY_PROP_SERIAL_NUMBER,
282};
283
284static enum power_supply_property energy_battery_props[] = {
285 POWER_SUPPLY_PROP_STATUS,
286 POWER_SUPPLY_PROP_PRESENT,
287 POWER_SUPPLY_PROP_TECHNOLOGY,
288 POWER_SUPPLY_PROP_CYCLE_COUNT,
289 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
290 POWER_SUPPLY_PROP_VOLTAGE_NOW,
291 POWER_SUPPLY_PROP_POWER_NOW,
292 POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
293 POWER_SUPPLY_PROP_ENERGY_FULL,
294 POWER_SUPPLY_PROP_ENERGY_NOW,
295 POWER_SUPPLY_PROP_MODEL_NAME,
296 POWER_SUPPLY_PROP_MANUFACTURER,
297 POWER_SUPPLY_PROP_SERIAL_NUMBER,
298};
299
300#ifdef CONFIG_ACPI_PROCFS_POWER
301inline char *acpi_battery_units(struct acpi_battery *battery)
302{
303 return (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) ?
304 "mA" : "mW";
305}
306#endif
307
308/* --------------------------------------------------------------------------
309 Battery Management
310 -------------------------------------------------------------------------- */
311struct acpi_offsets {
312 size_t offset; /* offset inside struct acpi_sbs_battery */
313 u8 mode; /* int or string? */
314};
315
316static struct acpi_offsets state_offsets[] = {
317 {offsetof(struct acpi_battery, state), 0},
318 {offsetof(struct acpi_battery, rate_now), 0},
319 {offsetof(struct acpi_battery, capacity_now), 0},
320 {offsetof(struct acpi_battery, voltage_now), 0},
321};
322
323static struct acpi_offsets info_offsets[] = {
324 {offsetof(struct acpi_battery, power_unit), 0},
325 {offsetof(struct acpi_battery, design_capacity), 0},
326 {offsetof(struct acpi_battery, full_charge_capacity), 0},
327 {offsetof(struct acpi_battery, technology), 0},
328 {offsetof(struct acpi_battery, design_voltage), 0},
329 {offsetof(struct acpi_battery, design_capacity_warning), 0},
330 {offsetof(struct acpi_battery, design_capacity_low), 0},
331 {offsetof(struct acpi_battery, capacity_granularity_1), 0},
332 {offsetof(struct acpi_battery, capacity_granularity_2), 0},
333 {offsetof(struct acpi_battery, model_number), 1},
334 {offsetof(struct acpi_battery, serial_number), 1},
335 {offsetof(struct acpi_battery, type), 1},
336 {offsetof(struct acpi_battery, oem_info), 1},
337};
338
339static struct acpi_offsets extended_info_offsets[] = {
340 {offsetof(struct acpi_battery, power_unit), 0},
341 {offsetof(struct acpi_battery, design_capacity), 0},
342 {offsetof(struct acpi_battery, full_charge_capacity), 0},
343 {offsetof(struct acpi_battery, technology), 0},
344 {offsetof(struct acpi_battery, design_voltage), 0},
345 {offsetof(struct acpi_battery, design_capacity_warning), 0},
346 {offsetof(struct acpi_battery, design_capacity_low), 0},
347 {offsetof(struct acpi_battery, cycle_count), 0},
348 {offsetof(struct acpi_battery, measurement_accuracy), 0},
349 {offsetof(struct acpi_battery, max_sampling_time), 0},
350 {offsetof(struct acpi_battery, min_sampling_time), 0},
351 {offsetof(struct acpi_battery, max_averaging_interval), 0},
352 {offsetof(struct acpi_battery, min_averaging_interval), 0},
353 {offsetof(struct acpi_battery, capacity_granularity_1), 0},
354 {offsetof(struct acpi_battery, capacity_granularity_2), 0},
355 {offsetof(struct acpi_battery, model_number), 1},
356 {offsetof(struct acpi_battery, serial_number), 1},
357 {offsetof(struct acpi_battery, type), 1},
358 {offsetof(struct acpi_battery, oem_info), 1},
359};
360
361static int extract_package(struct acpi_battery *battery,
362 union acpi_object *package,
363 struct acpi_offsets *offsets, int num)
364{
365 int i;
366 union acpi_object *element;
367 if (package->type != ACPI_TYPE_PACKAGE)
368 return -EFAULT;
369 for (i = 0; i < num; ++i) {
370 if (package->package.count <= i)
371 return -EFAULT;
372 element = &package->package.elements[i];
373 if (offsets[i].mode) {
374 u8 *ptr = (u8 *)battery + offsets[i].offset;
375 if (element->type == ACPI_TYPE_STRING ||
376 element->type == ACPI_TYPE_BUFFER)
377 strncpy(ptr, element->string.pointer, 32);
378 else if (element->type == ACPI_TYPE_INTEGER) {
379 strncpy(ptr, (u8 *)&element->integer.value,
380 sizeof(u64));
381 ptr[sizeof(u64)] = 0;
382 } else
383 *ptr = 0; /* don't have value */
384 } else {
385 int *x = (int *)((u8 *)battery + offsets[i].offset);
386 *x = (element->type == ACPI_TYPE_INTEGER) ?
387 element->integer.value : -1;
388 }
389 }
390 return 0;
391}
392
393static int acpi_battery_get_status(struct acpi_battery *battery)
394{
395 if (acpi_bus_get_status(battery->device)) {
396 ACPI_EXCEPTION((AE_INFO, AE_ERROR, "Evaluating _STA"));
397 return -ENODEV;
398 }
399 return 0;
400}
401
402static int acpi_battery_get_info(struct acpi_battery *battery)
403{
404 int result = -EFAULT;
405 acpi_status status = 0;
406 char *name = test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags)?
407 "_BIX" : "_BIF";
408
409 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
410
411 if (!acpi_battery_present(battery))
412 return 0;
413 mutex_lock(&battery->lock);
414 status = acpi_evaluate_object(battery->device->handle, name,
415 NULL, &buffer);
416 mutex_unlock(&battery->lock);
417
418 if (ACPI_FAILURE(status)) {
419 ACPI_EXCEPTION((AE_INFO, status, "Evaluating %s", name));
420 return -ENODEV;
421 }
422 if (test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags))
423 result = extract_package(battery, buffer.pointer,
424 extended_info_offsets,
425 ARRAY_SIZE(extended_info_offsets));
426 else
427 result = extract_package(battery, buffer.pointer,
428 info_offsets, ARRAY_SIZE(info_offsets));
429 kfree(buffer.pointer);
430 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
431 battery->full_charge_capacity = battery->design_capacity;
432 return result;
433}
434
435static int acpi_battery_get_state(struct acpi_battery *battery)
436{
437 int result = 0;
438 acpi_status status = 0;
439 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
440
441 if (!acpi_battery_present(battery))
442 return 0;
443
444 if (battery->update_time &&
445 time_before(jiffies, battery->update_time +
446 msecs_to_jiffies(cache_time)))
447 return 0;
448
449 mutex_lock(&battery->lock);
450 status = acpi_evaluate_object(battery->device->handle, "_BST",
451 NULL, &buffer);
452 mutex_unlock(&battery->lock);
453
454 if (ACPI_FAILURE(status)) {
455 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BST"));
456 return -ENODEV;
457 }
458
459 result = extract_package(battery, buffer.pointer,
460 state_offsets, ARRAY_SIZE(state_offsets));
461 battery->update_time = jiffies;
462 kfree(buffer.pointer);
463
464 /* For buggy DSDTs that report negative 16-bit values for either
465 * charging or discharging current and/or report 0 as 65536
466 * due to bad math.
467 */
468 if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA &&
469 battery->rate_now != ACPI_BATTERY_VALUE_UNKNOWN &&
470 (s16)(battery->rate_now) < 0) {
471 battery->rate_now = abs((s16)battery->rate_now);
472 printk_once(KERN_WARNING FW_BUG "battery: (dis)charge rate"
473 " invalid.\n");
474 }
475
476 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags)
477 && battery->capacity_now >= 0 && battery->capacity_now <= 100)
478 battery->capacity_now = (battery->capacity_now *
479 battery->full_charge_capacity) / 100;
480 return result;
481}
482
483static int acpi_battery_set_alarm(struct acpi_battery *battery)
484{
485 acpi_status status = 0;
486 union acpi_object arg0 = { .type = ACPI_TYPE_INTEGER };
487 struct acpi_object_list arg_list = { 1, &arg0 };
488
489 if (!acpi_battery_present(battery) ||
490 !test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags))
491 return -ENODEV;
492
493 arg0.integer.value = battery->alarm;
494
495 mutex_lock(&battery->lock);
496 status = acpi_evaluate_object(battery->device->handle, "_BTP",
497 &arg_list, NULL);
498 mutex_unlock(&battery->lock);
499
500 if (ACPI_FAILURE(status))
501 return -ENODEV;
502
503 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Alarm set to %d\n", battery->alarm));
504 return 0;
505}
506
507static int acpi_battery_init_alarm(struct acpi_battery *battery)
508{
509 acpi_status status = AE_OK;
510 acpi_handle handle = NULL;
511
512 /* See if alarms are supported, and if so, set default */
513 status = acpi_get_handle(battery->device->handle, "_BTP", &handle);
514 if (ACPI_FAILURE(status)) {
515 clear_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
516 return 0;
517 }
518 set_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
519 if (!battery->alarm)
520 battery->alarm = battery->design_capacity_warning;
521 return acpi_battery_set_alarm(battery);
522}
523
524static ssize_t acpi_battery_alarm_show(struct device *dev,
525 struct device_attribute *attr,
526 char *buf)
527{
528 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
529 return sprintf(buf, "%d\n", battery->alarm * 1000);
530}
531
532static ssize_t acpi_battery_alarm_store(struct device *dev,
533 struct device_attribute *attr,
534 const char *buf, size_t count)
535{
536 unsigned long x;
537 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
538 if (sscanf(buf, "%ld\n", &x) == 1)
539 battery->alarm = x/1000;
540 if (acpi_battery_present(battery))
541 acpi_battery_set_alarm(battery);
542 return count;
543}
544
545static struct device_attribute alarm_attr = {
546 .attr = {.name = "alarm", .mode = 0644},
547 .show = acpi_battery_alarm_show,
548 .store = acpi_battery_alarm_store,
549};
550
551static int sysfs_add_battery(struct acpi_battery *battery)
552{
553 int result;
554
555 if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) {
556 battery->bat.properties = charge_battery_props;
557 battery->bat.num_properties =
558 ARRAY_SIZE(charge_battery_props);
559 } else {
560 battery->bat.properties = energy_battery_props;
561 battery->bat.num_properties =
562 ARRAY_SIZE(energy_battery_props);
563 }
564
565 battery->bat.name = acpi_device_bid(battery->device);
566 battery->bat.type = POWER_SUPPLY_TYPE_BATTERY;
567 battery->bat.get_property = acpi_battery_get_property;
568
569 result = power_supply_register(&battery->device->dev, &battery->bat);
570 if (result)
571 return result;
572 return device_create_file(battery->bat.dev, &alarm_attr);
573}
574
575static void sysfs_remove_battery(struct acpi_battery *battery)
576{
577 mutex_lock(&battery->sysfs_lock);
578 if (!battery->bat.dev) {
579 mutex_unlock(&battery->sysfs_lock);
580 return;
581 }
582
583 device_remove_file(battery->bat.dev, &alarm_attr);
584 power_supply_unregister(&battery->bat);
585 battery->bat.dev = NULL;
586 mutex_unlock(&battery->sysfs_lock);
587}
588
589/*
590 * According to the ACPI spec, some kinds of primary batteries can
591 * report percentage battery remaining capacity directly to OS.
592 * In this case, it reports the Last Full Charged Capacity == 100
593 * and BatteryPresentRate == 0xFFFFFFFF.
594 *
595 * Now we found some battery reports percentage remaining capacity
596 * even if it's rechargeable.
597 * https://bugzilla.kernel.org/show_bug.cgi?id=15979
598 *
599 * Handle this correctly so that they won't break userspace.
600 */
601static void acpi_battery_quirks(struct acpi_battery *battery)
602{
603 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
604 return ;
605
606 if (battery->full_charge_capacity == 100 &&
607 battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN &&
608 battery->capacity_now >=0 && battery->capacity_now <= 100) {
609 set_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags);
610 battery->full_charge_capacity = battery->design_capacity;
611 battery->capacity_now = (battery->capacity_now *
612 battery->full_charge_capacity) / 100;
613 }
614}
615
616static int acpi_battery_update(struct acpi_battery *battery)
617{
618 int result, old_present = acpi_battery_present(battery);
619 result = acpi_battery_get_status(battery);
620 if (result)
621 return result;
622 if (!acpi_battery_present(battery)) {
623 sysfs_remove_battery(battery);
624 battery->update_time = 0;
625 return 0;
626 }
627 if (!battery->update_time ||
628 old_present != acpi_battery_present(battery)) {
629 result = acpi_battery_get_info(battery);
630 if (result)
631 return result;
632 acpi_battery_init_alarm(battery);
633 }
634 if (!battery->bat.dev) {
635 result = sysfs_add_battery(battery);
636 if (result)
637 return result;
638 }
639 result = acpi_battery_get_state(battery);
640 acpi_battery_quirks(battery);
641 return result;
642}
643
644static void acpi_battery_refresh(struct acpi_battery *battery)
645{
646 if (!battery->bat.dev)
647 return;
648
649 acpi_battery_get_info(battery);
650 /* The battery may have changed its reporting units. */
651 sysfs_remove_battery(battery);
652 sysfs_add_battery(battery);
653}
654
655/* --------------------------------------------------------------------------
656 FS Interface (/proc)
657 -------------------------------------------------------------------------- */
658
659#ifdef CONFIG_ACPI_PROCFS_POWER
660static struct proc_dir_entry *acpi_battery_dir;
661
662static int acpi_battery_print_info(struct seq_file *seq, int result)
663{
664 struct acpi_battery *battery = seq->private;
665
666 if (result)
667 goto end;
668
669 seq_printf(seq, "present: %s\n",
670 acpi_battery_present(battery)?"yes":"no");
671 if (!acpi_battery_present(battery))
672 goto end;
673 if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
674 seq_printf(seq, "design capacity: unknown\n");
675 else
676 seq_printf(seq, "design capacity: %d %sh\n",
677 battery->design_capacity,
678 acpi_battery_units(battery));
679
680 if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
681 seq_printf(seq, "last full capacity: unknown\n");
682 else
683 seq_printf(seq, "last full capacity: %d %sh\n",
684 battery->full_charge_capacity,
685 acpi_battery_units(battery));
686
687 seq_printf(seq, "battery technology: %srechargeable\n",
688 (!battery->technology)?"non-":"");
689
690 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
691 seq_printf(seq, "design voltage: unknown\n");
692 else
693 seq_printf(seq, "design voltage: %d mV\n",
694 battery->design_voltage);
695 seq_printf(seq, "design capacity warning: %d %sh\n",
696 battery->design_capacity_warning,
697 acpi_battery_units(battery));
698 seq_printf(seq, "design capacity low: %d %sh\n",
699 battery->design_capacity_low,
700 acpi_battery_units(battery));
701 seq_printf(seq, "cycle count: %i\n", battery->cycle_count);
702 seq_printf(seq, "capacity granularity 1: %d %sh\n",
703 battery->capacity_granularity_1,
704 acpi_battery_units(battery));
705 seq_printf(seq, "capacity granularity 2: %d %sh\n",
706 battery->capacity_granularity_2,
707 acpi_battery_units(battery));
708 seq_printf(seq, "model number: %s\n", battery->model_number);
709 seq_printf(seq, "serial number: %s\n", battery->serial_number);
710 seq_printf(seq, "battery type: %s\n", battery->type);
711 seq_printf(seq, "OEM info: %s\n", battery->oem_info);
712 end:
713 if (result)
714 seq_printf(seq, "ERROR: Unable to read battery info\n");
715 return result;
716}
717
718static int acpi_battery_print_state(struct seq_file *seq, int result)
719{
720 struct acpi_battery *battery = seq->private;
721
722 if (result)
723 goto end;
724
725 seq_printf(seq, "present: %s\n",
726 acpi_battery_present(battery)?"yes":"no");
727 if (!acpi_battery_present(battery))
728 goto end;
729
730 seq_printf(seq, "capacity state: %s\n",
731 (battery->state & 0x04)?"critical":"ok");
732 if ((battery->state & 0x01) && (battery->state & 0x02))
733 seq_printf(seq,
734 "charging state: charging/discharging\n");
735 else if (battery->state & 0x01)
736 seq_printf(seq, "charging state: discharging\n");
737 else if (battery->state & 0x02)
738 seq_printf(seq, "charging state: charging\n");
739 else
740 seq_printf(seq, "charging state: charged\n");
741
742 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
743 seq_printf(seq, "present rate: unknown\n");
744 else
745 seq_printf(seq, "present rate: %d %s\n",
746 battery->rate_now, acpi_battery_units(battery));
747
748 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
749 seq_printf(seq, "remaining capacity: unknown\n");
750 else
751 seq_printf(seq, "remaining capacity: %d %sh\n",
752 battery->capacity_now, acpi_battery_units(battery));
753 if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
754 seq_printf(seq, "present voltage: unknown\n");
755 else
756 seq_printf(seq, "present voltage: %d mV\n",
757 battery->voltage_now);
758 end:
759 if (result)
760 seq_printf(seq, "ERROR: Unable to read battery state\n");
761
762 return result;
763}
764
765static int acpi_battery_print_alarm(struct seq_file *seq, int result)
766{
767 struct acpi_battery *battery = seq->private;
768
769 if (result)
770 goto end;
771
772 if (!acpi_battery_present(battery)) {
773 seq_printf(seq, "present: no\n");
774 goto end;
775 }
776 seq_printf(seq, "alarm: ");
777 if (!battery->alarm)
778 seq_printf(seq, "unsupported\n");
779 else
780 seq_printf(seq, "%u %sh\n", battery->alarm,
781 acpi_battery_units(battery));
782 end:
783 if (result)
784 seq_printf(seq, "ERROR: Unable to read battery alarm\n");
785 return result;
786}
787
788static ssize_t acpi_battery_write_alarm(struct file *file,
789 const char __user * buffer,
790 size_t count, loff_t * ppos)
791{
792 int result = 0;
793 char alarm_string[12] = { '\0' };
794 struct seq_file *m = file->private_data;
795 struct acpi_battery *battery = m->private;
796
797 if (!battery || (count > sizeof(alarm_string) - 1))
798 return -EINVAL;
799 if (!acpi_battery_present(battery)) {
800 result = -ENODEV;
801 goto end;
802 }
803 if (copy_from_user(alarm_string, buffer, count)) {
804 result = -EFAULT;
805 goto end;
806 }
807 alarm_string[count] = '\0';
808 battery->alarm = simple_strtol(alarm_string, NULL, 0);
809 result = acpi_battery_set_alarm(battery);
810 end:
811 if (!result)
812 return count;
813 return result;
814}
815
816typedef int(*print_func)(struct seq_file *seq, int result);
817
818static print_func acpi_print_funcs[ACPI_BATTERY_NUMFILES] = {
819 acpi_battery_print_info,
820 acpi_battery_print_state,
821 acpi_battery_print_alarm,
822};
823
824static int acpi_battery_read(int fid, struct seq_file *seq)
825{
826 struct acpi_battery *battery = seq->private;
827 int result = acpi_battery_update(battery);
828 return acpi_print_funcs[fid](seq, result);
829}
830
831#define DECLARE_FILE_FUNCTIONS(_name) \
832static int acpi_battery_read_##_name(struct seq_file *seq, void *offset) \
833{ \
834 return acpi_battery_read(_name##_tag, seq); \
835} \
836static int acpi_battery_##_name##_open_fs(struct inode *inode, struct file *file) \
837{ \
838 return single_open(file, acpi_battery_read_##_name, PDE(inode)->data); \
839}
840
841DECLARE_FILE_FUNCTIONS(info);
842DECLARE_FILE_FUNCTIONS(state);
843DECLARE_FILE_FUNCTIONS(alarm);
844
845#undef DECLARE_FILE_FUNCTIONS
846
847#define FILE_DESCRIPTION_RO(_name) \
848 { \
849 .name = __stringify(_name), \
850 .mode = S_IRUGO, \
851 .ops = { \
852 .open = acpi_battery_##_name##_open_fs, \
853 .read = seq_read, \
854 .llseek = seq_lseek, \
855 .release = single_release, \
856 .owner = THIS_MODULE, \
857 }, \
858 }
859
860#define FILE_DESCRIPTION_RW(_name) \
861 { \
862 .name = __stringify(_name), \
863 .mode = S_IFREG | S_IRUGO | S_IWUSR, \
864 .ops = { \
865 .open = acpi_battery_##_name##_open_fs, \
866 .read = seq_read, \
867 .llseek = seq_lseek, \
868 .write = acpi_battery_write_##_name, \
869 .release = single_release, \
870 .owner = THIS_MODULE, \
871 }, \
872 }
873
874static const struct battery_file {
875 struct file_operations ops;
876 mode_t mode;
877 const char *name;
878} acpi_battery_file[] = {
879 FILE_DESCRIPTION_RO(info),
880 FILE_DESCRIPTION_RO(state),
881 FILE_DESCRIPTION_RW(alarm),
882};
883
884#undef FILE_DESCRIPTION_RO
885#undef FILE_DESCRIPTION_RW
886
887static int acpi_battery_add_fs(struct acpi_device *device)
888{
889 struct proc_dir_entry *entry = NULL;
890 int i;
891
892 printk(KERN_WARNING PREFIX "Deprecated procfs I/F for battery is loaded,"
893 " please retry with CONFIG_ACPI_PROCFS_POWER cleared\n");
894 if (!acpi_device_dir(device)) {
895 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
896 acpi_battery_dir);
897 if (!acpi_device_dir(device))
898 return -ENODEV;
899 }
900
901 for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i) {
902 entry = proc_create_data(acpi_battery_file[i].name,
903 acpi_battery_file[i].mode,
904 acpi_device_dir(device),
905 &acpi_battery_file[i].ops,
906 acpi_driver_data(device));
907 if (!entry)
908 return -ENODEV;
909 }
910 return 0;
911}
912
913static void acpi_battery_remove_fs(struct acpi_device *device)
914{
915 int i;
916 if (!acpi_device_dir(device))
917 return;
918 for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i)
919 remove_proc_entry(acpi_battery_file[i].name,
920 acpi_device_dir(device));
921
922 remove_proc_entry(acpi_device_bid(device), acpi_battery_dir);
923 acpi_device_dir(device) = NULL;
924}
925
926#endif
927
928/* --------------------------------------------------------------------------
929 Driver Interface
930 -------------------------------------------------------------------------- */
931
932static void acpi_battery_notify(struct acpi_device *device, u32 event)
933{
934 struct acpi_battery *battery = acpi_driver_data(device);
935 struct device *old;
936
937 if (!battery)
938 return;
939 old = battery->bat.dev;
940 if (event == ACPI_BATTERY_NOTIFY_INFO)
941 acpi_battery_refresh(battery);
942 acpi_battery_update(battery);
943 acpi_bus_generate_proc_event(device, event,
944 acpi_battery_present(battery));
945 acpi_bus_generate_netlink_event(device->pnp.device_class,
946 dev_name(&device->dev), event,
947 acpi_battery_present(battery));
948 /* acpi_battery_update could remove power_supply object */
949 if (old && battery->bat.dev)
950 power_supply_changed(&battery->bat);
951}
952
953static int battery_notify(struct notifier_block *nb,
954 unsigned long mode, void *_unused)
955{
956 struct acpi_battery *battery = container_of(nb, struct acpi_battery,
957 pm_nb);
958 switch (mode) {
959 case PM_POST_HIBERNATION:
960 case PM_POST_SUSPEND:
961 if (battery->bat.dev) {
962 sysfs_remove_battery(battery);
963 sysfs_add_battery(battery);
964 }
965 break;
966 }
967
968 return 0;
969}
970
971static int acpi_battery_add(struct acpi_device *device)
972{
973 int result = 0;
974 struct acpi_battery *battery = NULL;
975 acpi_handle handle;
976 if (!device)
977 return -EINVAL;
978 battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL);
979 if (!battery)
980 return -ENOMEM;
981 battery->device = device;
982 strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME);
983 strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS);
984 device->driver_data = battery;
985 mutex_init(&battery->lock);
986 mutex_init(&battery->sysfs_lock);
987 if (ACPI_SUCCESS(acpi_get_handle(battery->device->handle,
988 "_BIX", &handle)))
989 set_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags);
990 result = acpi_battery_update(battery);
991 if (result)
992 goto fail;
993#ifdef CONFIG_ACPI_PROCFS_POWER
994 result = acpi_battery_add_fs(device);
995#endif
996 if (result) {
997#ifdef CONFIG_ACPI_PROCFS_POWER
998 acpi_battery_remove_fs(device);
999#endif
1000 goto fail;
1001 }
1002
1003 printk(KERN_INFO PREFIX "%s Slot [%s] (battery %s)\n",
1004 ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device),
1005 device->status.battery_present ? "present" : "absent");
1006
1007 battery->pm_nb.notifier_call = battery_notify;
1008 register_pm_notifier(&battery->pm_nb);
1009
1010 return result;
1011
1012fail:
1013 sysfs_remove_battery(battery);
1014 mutex_destroy(&battery->lock);
1015 mutex_destroy(&battery->sysfs_lock);
1016 kfree(battery);
1017 return result;
1018}
1019
1020static int acpi_battery_remove(struct acpi_device *device, int type)
1021{
1022 struct acpi_battery *battery = NULL;
1023
1024 if (!device || !acpi_driver_data(device))
1025 return -EINVAL;
1026 battery = acpi_driver_data(device);
1027 unregister_pm_notifier(&battery->pm_nb);
1028#ifdef CONFIG_ACPI_PROCFS_POWER
1029 acpi_battery_remove_fs(device);
1030#endif
1031 sysfs_remove_battery(battery);
1032 mutex_destroy(&battery->lock);
1033 mutex_destroy(&battery->sysfs_lock);
1034 kfree(battery);
1035 return 0;
1036}
1037
1038/* this is needed to learn about changes made in suspended state */
1039static int acpi_battery_resume(struct acpi_device *device)
1040{
1041 struct acpi_battery *battery;
1042 if (!device)
1043 return -EINVAL;
1044 battery = acpi_driver_data(device);
1045 battery->update_time = 0;
1046 acpi_battery_update(battery);
1047 return 0;
1048}
1049
1050static struct acpi_driver acpi_battery_driver = {
1051 .name = "battery",
1052 .class = ACPI_BATTERY_CLASS,
1053 .ids = battery_device_ids,
1054 .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
1055 .ops = {
1056 .add = acpi_battery_add,
1057 .resume = acpi_battery_resume,
1058 .remove = acpi_battery_remove,
1059 .notify = acpi_battery_notify,
1060 },
1061};
1062
1063static void __init acpi_battery_init_async(void *unused, async_cookie_t cookie)
1064{
1065 if (acpi_disabled)
1066 return;
1067#ifdef CONFIG_ACPI_PROCFS_POWER
1068 acpi_battery_dir = acpi_lock_battery_dir();
1069 if (!acpi_battery_dir)
1070 return;
1071#endif
1072 if (acpi_bus_register_driver(&acpi_battery_driver) < 0) {
1073#ifdef CONFIG_ACPI_PROCFS_POWER
1074 acpi_unlock_battery_dir(acpi_battery_dir);
1075#endif
1076 return;
1077 }
1078 return;
1079}
1080
1081static int __init acpi_battery_init(void)
1082{
1083 async_schedule(acpi_battery_init_async, NULL);
1084 return 0;
1085}
1086
1087static void __exit acpi_battery_exit(void)
1088{
1089 acpi_bus_unregister_driver(&acpi_battery_driver);
1090#ifdef CONFIG_ACPI_PROCFS_POWER
1091 acpi_unlock_battery_dir(acpi_battery_dir);
1092#endif
1093}
1094
1095module_init(acpi_battery_init);
1096module_exit(acpi_battery_exit);
1/*
2 * battery.c - ACPI Battery Driver (Revision: 2.0)
3 *
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>
8 *
9 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
10 *
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.
15 *
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.
20 *
21 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
22 */
23
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>
35
36#ifdef CONFIG_ACPI_PROCFS_POWER
37#include <linux/proc_fs.h>
38#include <linux/seq_file.h>
39#include <linux/uaccess.h>
40#endif
41
42#include <linux/acpi.h>
43#include <linux/power_supply.h>
44
45#include "battery.h"
46
47#define PREFIX "ACPI: "
48
49#define ACPI_BATTERY_VALUE_UNKNOWN 0xFFFFFFFF
50
51#define ACPI_BATTERY_DEVICE_NAME "Battery"
52
53/* Battery power unit: 0 means mW, 1 means mA */
54#define ACPI_BATTERY_POWER_UNIT_MA 1
55
56#define ACPI_BATTERY_STATE_DISCHARGING 0x1
57#define ACPI_BATTERY_STATE_CHARGING 0x2
58#define ACPI_BATTERY_STATE_CRITICAL 0x4
59
60#define _COMPONENT ACPI_BATTERY_COMPONENT
61
62ACPI_MODULE_NAME("battery");
63
64MODULE_AUTHOR("Paul Diefenbaugh");
65MODULE_AUTHOR("Alexey Starikovskiy <astarikovskiy@suse.de>");
66MODULE_DESCRIPTION("ACPI Battery Driver");
67MODULE_LICENSE("GPL");
68
69static async_cookie_t async_cookie;
70static int battery_bix_broken_package;
71static int battery_notification_delay_ms;
72static unsigned int cache_time = 1000;
73module_param(cache_time, uint, 0644);
74MODULE_PARM_DESC(cache_time, "cache time in milliseconds");
75
76#ifdef CONFIG_ACPI_PROCFS_POWER
77extern struct proc_dir_entry *acpi_lock_battery_dir(void);
78extern void *acpi_unlock_battery_dir(struct proc_dir_entry *acpi_battery_dir);
79
80enum acpi_battery_files {
81 info_tag = 0,
82 state_tag,
83 alarm_tag,
84 ACPI_BATTERY_NUMFILES,
85};
86
87#endif
88
89static const struct acpi_device_id battery_device_ids[] = {
90 {"PNP0C0A", 0},
91 {"", 0},
92};
93
94MODULE_DEVICE_TABLE(acpi, battery_device_ids);
95
96enum {
97 ACPI_BATTERY_ALARM_PRESENT,
98 ACPI_BATTERY_XINFO_PRESENT,
99 ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY,
100 /* On Lenovo Thinkpad models from 2010 and 2011, the power unit
101 switches between mWh and mAh depending on whether the system
102 is running on battery or not. When mAh is the unit, most
103 reported values are incorrect and need to be adjusted by
104 10000/design_voltage. Verified on x201, t410, t410s, and x220.
105 Pre-2010 and 2012 models appear to always report in mWh and
106 are thus unaffected (tested with t42, t61, t500, x200, x300,
107 and x230). Also, in mid-2012 Lenovo issued a BIOS update for
108 the 2011 models that fixes the issue (tested on x220 with a
109 post-1.29 BIOS), but as of Nov. 2012, no such update is
110 available for the 2010 models. */
111 ACPI_BATTERY_QUIRK_THINKPAD_MAH,
112};
113
114struct acpi_battery {
115 struct mutex lock;
116 struct mutex sysfs_lock;
117 struct power_supply *bat;
118 struct power_supply_desc bat_desc;
119 struct acpi_device *device;
120 struct notifier_block pm_nb;
121 unsigned long update_time;
122 int revision;
123 int rate_now;
124 int capacity_now;
125 int voltage_now;
126 int design_capacity;
127 int full_charge_capacity;
128 int technology;
129 int design_voltage;
130 int design_capacity_warning;
131 int design_capacity_low;
132 int cycle_count;
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;
140 int alarm;
141 char model_number[32];
142 char serial_number[32];
143 char type[32];
144 char oem_info[32];
145 int state;
146 int power_unit;
147 unsigned long flags;
148};
149
150#define to_acpi_battery(x) power_supply_get_drvdata(x)
151
152static inline int acpi_battery_present(struct acpi_battery *battery)
153{
154 return battery->device->status.battery_present;
155}
156
157static int acpi_battery_technology(struct acpi_battery *battery)
158{
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;
170}
171
172static int acpi_battery_get_state(struct acpi_battery *battery);
173
174static int acpi_battery_is_charged(struct acpi_battery *battery)
175{
176 /* charging, discharging or critical low */
177 if (battery->state != 0)
178 return 0;
179
180 /* battery not reporting charge */
181 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN ||
182 battery->capacity_now == 0)
183 return 0;
184
185 /* good batteries update full_charge as the batteries degrade */
186 if (battery->full_charge_capacity == battery->capacity_now)
187 return 1;
188
189 /* fallback to using design values for broken batteries */
190 if (battery->design_capacity == battery->capacity_now)
191 return 1;
192
193 /* we don't do any sort of metric based on percentages */
194 return 0;
195}
196
197static int acpi_battery_get_property(struct power_supply *psy,
198 enum power_supply_property psp,
199 union power_supply_propval *val)
200{
201 int ret = 0;
202 struct acpi_battery *battery = to_acpi_battery(psy);
203
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)
208 return -ENODEV;
209 switch (psp) {
210 case POWER_SUPPLY_PROP_STATUS:
211 if (battery->state & ACPI_BATTERY_STATE_DISCHARGING)
212 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
213 else if (battery->state & ACPI_BATTERY_STATE_CHARGING)
214 val->intval = POWER_SUPPLY_STATUS_CHARGING;
215 else if (acpi_battery_is_charged(battery))
216 val->intval = POWER_SUPPLY_STATUS_FULL;
217 else
218 val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
219 break;
220 case POWER_SUPPLY_PROP_PRESENT:
221 val->intval = acpi_battery_present(battery);
222 break;
223 case POWER_SUPPLY_PROP_TECHNOLOGY:
224 val->intval = acpi_battery_technology(battery);
225 break;
226 case POWER_SUPPLY_PROP_CYCLE_COUNT:
227 val->intval = battery->cycle_count;
228 break;
229 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
230 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
231 ret = -ENODEV;
232 else
233 val->intval = battery->design_voltage * 1000;
234 break;
235 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
236 if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
237 ret = -ENODEV;
238 else
239 val->intval = battery->voltage_now * 1000;
240 break;
241 case POWER_SUPPLY_PROP_CURRENT_NOW:
242 case POWER_SUPPLY_PROP_POWER_NOW:
243 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
244 ret = -ENODEV;
245 else
246 val->intval = battery->rate_now * 1000;
247 break;
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)
251 ret = -ENODEV;
252 else
253 val->intval = battery->design_capacity * 1000;
254 break;
255 case POWER_SUPPLY_PROP_CHARGE_FULL:
256 case POWER_SUPPLY_PROP_ENERGY_FULL:
257 if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
258 ret = -ENODEV;
259 else
260 val->intval = battery->full_charge_capacity * 1000;
261 break;
262 case POWER_SUPPLY_PROP_CHARGE_NOW:
263 case POWER_SUPPLY_PROP_ENERGY_NOW:
264 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
265 ret = -ENODEV;
266 else
267 val->intval = battery->capacity_now * 1000;
268 break;
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;
273 else
274 val->intval = 0;
275 break;
276 case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
277 if (battery->state & ACPI_BATTERY_STATE_CRITICAL)
278 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
279 else if (test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags) &&
280 (battery->capacity_now <= battery->alarm))
281 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_LOW;
282 else if (acpi_battery_is_charged(battery))
283 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
284 else
285 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
286 break;
287 case POWER_SUPPLY_PROP_MODEL_NAME:
288 val->strval = battery->model_number;
289 break;
290 case POWER_SUPPLY_PROP_MANUFACTURER:
291 val->strval = battery->oem_info;
292 break;
293 case POWER_SUPPLY_PROP_SERIAL_NUMBER:
294 val->strval = battery->serial_number;
295 break;
296 default:
297 ret = -EINVAL;
298 }
299 return ret;
300}
301
302static enum power_supply_property charge_battery_props[] = {
303 POWER_SUPPLY_PROP_STATUS,
304 POWER_SUPPLY_PROP_PRESENT,
305 POWER_SUPPLY_PROP_TECHNOLOGY,
306 POWER_SUPPLY_PROP_CYCLE_COUNT,
307 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
308 POWER_SUPPLY_PROP_VOLTAGE_NOW,
309 POWER_SUPPLY_PROP_CURRENT_NOW,
310 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
311 POWER_SUPPLY_PROP_CHARGE_FULL,
312 POWER_SUPPLY_PROP_CHARGE_NOW,
313 POWER_SUPPLY_PROP_CAPACITY,
314 POWER_SUPPLY_PROP_CAPACITY_LEVEL,
315 POWER_SUPPLY_PROP_MODEL_NAME,
316 POWER_SUPPLY_PROP_MANUFACTURER,
317 POWER_SUPPLY_PROP_SERIAL_NUMBER,
318};
319
320static enum power_supply_property energy_battery_props[] = {
321 POWER_SUPPLY_PROP_STATUS,
322 POWER_SUPPLY_PROP_PRESENT,
323 POWER_SUPPLY_PROP_TECHNOLOGY,
324 POWER_SUPPLY_PROP_CYCLE_COUNT,
325 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
326 POWER_SUPPLY_PROP_VOLTAGE_NOW,
327 POWER_SUPPLY_PROP_POWER_NOW,
328 POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
329 POWER_SUPPLY_PROP_ENERGY_FULL,
330 POWER_SUPPLY_PROP_ENERGY_NOW,
331 POWER_SUPPLY_PROP_CAPACITY,
332 POWER_SUPPLY_PROP_CAPACITY_LEVEL,
333 POWER_SUPPLY_PROP_MODEL_NAME,
334 POWER_SUPPLY_PROP_MANUFACTURER,
335 POWER_SUPPLY_PROP_SERIAL_NUMBER,
336};
337
338/* --------------------------------------------------------------------------
339 Battery Management
340 -------------------------------------------------------------------------- */
341struct acpi_offsets {
342 size_t offset; /* offset inside struct acpi_sbs_battery */
343 u8 mode; /* int or string? */
344};
345
346static const struct acpi_offsets state_offsets[] = {
347 {offsetof(struct acpi_battery, state), 0},
348 {offsetof(struct acpi_battery, rate_now), 0},
349 {offsetof(struct acpi_battery, capacity_now), 0},
350 {offsetof(struct acpi_battery, voltage_now), 0},
351};
352
353static const struct acpi_offsets info_offsets[] = {
354 {offsetof(struct acpi_battery, power_unit), 0},
355 {offsetof(struct acpi_battery, design_capacity), 0},
356 {offsetof(struct acpi_battery, full_charge_capacity), 0},
357 {offsetof(struct acpi_battery, technology), 0},
358 {offsetof(struct acpi_battery, design_voltage), 0},
359 {offsetof(struct acpi_battery, design_capacity_warning), 0},
360 {offsetof(struct acpi_battery, design_capacity_low), 0},
361 {offsetof(struct acpi_battery, capacity_granularity_1), 0},
362 {offsetof(struct acpi_battery, capacity_granularity_2), 0},
363 {offsetof(struct acpi_battery, model_number), 1},
364 {offsetof(struct acpi_battery, serial_number), 1},
365 {offsetof(struct acpi_battery, type), 1},
366 {offsetof(struct acpi_battery, oem_info), 1},
367};
368
369static const struct acpi_offsets extended_info_offsets[] = {
370 {offsetof(struct acpi_battery, revision), 0},
371 {offsetof(struct acpi_battery, power_unit), 0},
372 {offsetof(struct acpi_battery, design_capacity), 0},
373 {offsetof(struct acpi_battery, full_charge_capacity), 0},
374 {offsetof(struct acpi_battery, technology), 0},
375 {offsetof(struct acpi_battery, design_voltage), 0},
376 {offsetof(struct acpi_battery, design_capacity_warning), 0},
377 {offsetof(struct acpi_battery, design_capacity_low), 0},
378 {offsetof(struct acpi_battery, cycle_count), 0},
379 {offsetof(struct acpi_battery, measurement_accuracy), 0},
380 {offsetof(struct acpi_battery, max_sampling_time), 0},
381 {offsetof(struct acpi_battery, min_sampling_time), 0},
382 {offsetof(struct acpi_battery, max_averaging_interval), 0},
383 {offsetof(struct acpi_battery, min_averaging_interval), 0},
384 {offsetof(struct acpi_battery, capacity_granularity_1), 0},
385 {offsetof(struct acpi_battery, capacity_granularity_2), 0},
386 {offsetof(struct acpi_battery, model_number), 1},
387 {offsetof(struct acpi_battery, serial_number), 1},
388 {offsetof(struct acpi_battery, type), 1},
389 {offsetof(struct acpi_battery, oem_info), 1},
390};
391
392static int extract_package(struct acpi_battery *battery,
393 union acpi_object *package,
394 const struct acpi_offsets *offsets, int num)
395{
396 int i;
397 union acpi_object *element;
398 if (package->type != ACPI_TYPE_PACKAGE)
399 return -EFAULT;
400 for (i = 0; i < num; ++i) {
401 if (package->package.count <= i)
402 return -EFAULT;
403 element = &package->package.elements[i];
404 if (offsets[i].mode) {
405 u8 *ptr = (u8 *)battery + offsets[i].offset;
406 if (element->type == ACPI_TYPE_STRING ||
407 element->type == ACPI_TYPE_BUFFER)
408 strncpy(ptr, element->string.pointer, 32);
409 else if (element->type == ACPI_TYPE_INTEGER) {
410 strncpy(ptr, (u8 *)&element->integer.value,
411 sizeof(u64));
412 ptr[sizeof(u64)] = 0;
413 } else
414 *ptr = 0; /* don't have value */
415 } else {
416 int *x = (int *)((u8 *)battery + offsets[i].offset);
417 *x = (element->type == ACPI_TYPE_INTEGER) ?
418 element->integer.value : -1;
419 }
420 }
421 return 0;
422}
423
424static int acpi_battery_get_status(struct acpi_battery *battery)
425{
426 if (acpi_bus_get_status(battery->device)) {
427 ACPI_EXCEPTION((AE_INFO, AE_ERROR, "Evaluating _STA"));
428 return -ENODEV;
429 }
430 return 0;
431}
432
433
434static int extract_battery_info(const int use_bix,
435 struct acpi_battery *battery,
436 const struct acpi_buffer *buffer)
437{
438 int result = -EFAULT;
439
440 if (use_bix && battery_bix_broken_package)
441 result = extract_package(battery, buffer->pointer,
442 extended_info_offsets + 1,
443 ARRAY_SIZE(extended_info_offsets) - 1);
444 else if (use_bix)
445 result = extract_package(battery, buffer->pointer,
446 extended_info_offsets,
447 ARRAY_SIZE(extended_info_offsets));
448 else
449 result = extract_package(battery, buffer->pointer,
450 info_offsets, ARRAY_SIZE(info_offsets));
451 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
452 battery->full_charge_capacity = battery->design_capacity;
453 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
454 battery->power_unit && battery->design_voltage) {
455 battery->design_capacity = battery->design_capacity *
456 10000 / battery->design_voltage;
457 battery->full_charge_capacity = battery->full_charge_capacity *
458 10000 / battery->design_voltage;
459 battery->design_capacity_warning =
460 battery->design_capacity_warning *
461 10000 / battery->design_voltage;
462 /* Curiously, design_capacity_low, unlike the rest of them,
463 is correct. */
464 /* capacity_granularity_* equal 1 on the systems tested, so
465 it's impossible to tell if they would need an adjustment
466 or not if their values were higher. */
467 }
468 return result;
469}
470
471static int acpi_battery_get_info(struct acpi_battery *battery)
472{
473 const int xinfo = test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags);
474 int use_bix;
475 int result = -ENODEV;
476
477 if (!acpi_battery_present(battery))
478 return 0;
479
480
481 for (use_bix = xinfo ? 1 : 0; use_bix >= 0; use_bix--) {
482 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
483 acpi_status status = AE_ERROR;
484
485 mutex_lock(&battery->lock);
486 status = acpi_evaluate_object(battery->device->handle,
487 use_bix ? "_BIX":"_BIF",
488 NULL, &buffer);
489 mutex_unlock(&battery->lock);
490
491 if (ACPI_FAILURE(status)) {
492 ACPI_EXCEPTION((AE_INFO, status, "Evaluating %s",
493 use_bix ? "_BIX":"_BIF"));
494 } else {
495 result = extract_battery_info(use_bix,
496 battery,
497 &buffer);
498
499 kfree(buffer.pointer);
500 break;
501 }
502 }
503
504 if (!result && !use_bix && xinfo)
505 pr_warn(FW_BUG "The _BIX method is broken, using _BIF.\n");
506
507 return result;
508}
509
510static int acpi_battery_get_state(struct acpi_battery *battery)
511{
512 int result = 0;
513 acpi_status status = 0;
514 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
515
516 if (!acpi_battery_present(battery))
517 return 0;
518
519 if (battery->update_time &&
520 time_before(jiffies, battery->update_time +
521 msecs_to_jiffies(cache_time)))
522 return 0;
523
524 mutex_lock(&battery->lock);
525 status = acpi_evaluate_object(battery->device->handle, "_BST",
526 NULL, &buffer);
527 mutex_unlock(&battery->lock);
528
529 if (ACPI_FAILURE(status)) {
530 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BST"));
531 return -ENODEV;
532 }
533
534 result = extract_package(battery, buffer.pointer,
535 state_offsets, ARRAY_SIZE(state_offsets));
536 battery->update_time = jiffies;
537 kfree(buffer.pointer);
538
539 /* For buggy DSDTs that report negative 16-bit values for either
540 * charging or discharging current and/or report 0 as 65536
541 * due to bad math.
542 */
543 if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA &&
544 battery->rate_now != ACPI_BATTERY_VALUE_UNKNOWN &&
545 (s16)(battery->rate_now) < 0) {
546 battery->rate_now = abs((s16)battery->rate_now);
547 printk_once(KERN_WARNING FW_BUG
548 "battery: (dis)charge rate invalid.\n");
549 }
550
551 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags)
552 && battery->capacity_now >= 0 && battery->capacity_now <= 100)
553 battery->capacity_now = (battery->capacity_now *
554 battery->full_charge_capacity) / 100;
555 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
556 battery->power_unit && battery->design_voltage) {
557 battery->capacity_now = battery->capacity_now *
558 10000 / battery->design_voltage;
559 }
560 return result;
561}
562
563static int acpi_battery_set_alarm(struct acpi_battery *battery)
564{
565 acpi_status status = 0;
566
567 if (!acpi_battery_present(battery) ||
568 !test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags))
569 return -ENODEV;
570
571 mutex_lock(&battery->lock);
572 status = acpi_execute_simple_method(battery->device->handle, "_BTP",
573 battery->alarm);
574 mutex_unlock(&battery->lock);
575
576 if (ACPI_FAILURE(status))
577 return -ENODEV;
578
579 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Alarm set to %d\n", battery->alarm));
580 return 0;
581}
582
583static int acpi_battery_init_alarm(struct acpi_battery *battery)
584{
585 /* See if alarms are supported, and if so, set default */
586 if (!acpi_has_method(battery->device->handle, "_BTP")) {
587 clear_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
588 return 0;
589 }
590 set_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
591 if (!battery->alarm)
592 battery->alarm = battery->design_capacity_warning;
593 return acpi_battery_set_alarm(battery);
594}
595
596static ssize_t acpi_battery_alarm_show(struct device *dev,
597 struct device_attribute *attr,
598 char *buf)
599{
600 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
601 return sprintf(buf, "%d\n", battery->alarm * 1000);
602}
603
604static ssize_t acpi_battery_alarm_store(struct device *dev,
605 struct device_attribute *attr,
606 const char *buf, size_t count)
607{
608 unsigned long x;
609 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
610 if (sscanf(buf, "%lu\n", &x) == 1)
611 battery->alarm = x/1000;
612 if (acpi_battery_present(battery))
613 acpi_battery_set_alarm(battery);
614 return count;
615}
616
617static struct device_attribute alarm_attr = {
618 .attr = {.name = "alarm", .mode = 0644},
619 .show = acpi_battery_alarm_show,
620 .store = acpi_battery_alarm_store,
621};
622
623static int sysfs_add_battery(struct acpi_battery *battery)
624{
625 struct power_supply_config psy_cfg = { .drv_data = battery, };
626
627 if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) {
628 battery->bat_desc.properties = charge_battery_props;
629 battery->bat_desc.num_properties =
630 ARRAY_SIZE(charge_battery_props);
631 } else {
632 battery->bat_desc.properties = energy_battery_props;
633 battery->bat_desc.num_properties =
634 ARRAY_SIZE(energy_battery_props);
635 }
636
637 battery->bat_desc.name = acpi_device_bid(battery->device);
638 battery->bat_desc.type = POWER_SUPPLY_TYPE_BATTERY;
639 battery->bat_desc.get_property = acpi_battery_get_property;
640
641 battery->bat = power_supply_register_no_ws(&battery->device->dev,
642 &battery->bat_desc, &psy_cfg);
643
644 if (IS_ERR(battery->bat)) {
645 int result = PTR_ERR(battery->bat);
646
647 battery->bat = NULL;
648 return result;
649 }
650 return device_create_file(&battery->bat->dev, &alarm_attr);
651}
652
653static void sysfs_remove_battery(struct acpi_battery *battery)
654{
655 mutex_lock(&battery->sysfs_lock);
656 if (!battery->bat) {
657 mutex_unlock(&battery->sysfs_lock);
658 return;
659 }
660
661 device_remove_file(&battery->bat->dev, &alarm_attr);
662 power_supply_unregister(battery->bat);
663 battery->bat = NULL;
664 mutex_unlock(&battery->sysfs_lock);
665}
666
667static void find_battery(const struct dmi_header *dm, void *private)
668{
669 struct acpi_battery *battery = (struct acpi_battery *)private;
670 /* Note: the hardcoded offsets below have been extracted from
671 the source code of dmidecode. */
672 if (dm->type == DMI_ENTRY_PORTABLE_BATTERY && dm->length >= 8) {
673 const u8 *dmi_data = (const u8 *)(dm + 1);
674 int dmi_capacity = get_unaligned((const u16 *)(dmi_data + 6));
675 if (dm->length >= 18)
676 dmi_capacity *= dmi_data[17];
677 if (battery->design_capacity * battery->design_voltage / 1000
678 != dmi_capacity &&
679 battery->design_capacity * 10 == dmi_capacity)
680 set_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
681 &battery->flags);
682 }
683}
684
685/*
686 * According to the ACPI spec, some kinds of primary batteries can
687 * report percentage battery remaining capacity directly to OS.
688 * In this case, it reports the Last Full Charged Capacity == 100
689 * and BatteryPresentRate == 0xFFFFFFFF.
690 *
691 * Now we found some battery reports percentage remaining capacity
692 * even if it's rechargeable.
693 * https://bugzilla.kernel.org/show_bug.cgi?id=15979
694 *
695 * Handle this correctly so that they won't break userspace.
696 */
697static void acpi_battery_quirks(struct acpi_battery *battery)
698{
699 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
700 return;
701
702 if (battery->full_charge_capacity == 100 &&
703 battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN &&
704 battery->capacity_now >= 0 && battery->capacity_now <= 100) {
705 set_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags);
706 battery->full_charge_capacity = battery->design_capacity;
707 battery->capacity_now = (battery->capacity_now *
708 battery->full_charge_capacity) / 100;
709 }
710
711 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags))
712 return;
713
714 if (battery->power_unit && dmi_name_in_vendors("LENOVO")) {
715 const char *s;
716 s = dmi_get_system_info(DMI_PRODUCT_VERSION);
717 if (s && !strncasecmp(s, "ThinkPad", 8)) {
718 dmi_walk(find_battery, battery);
719 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
720 &battery->flags) &&
721 battery->design_voltage) {
722 battery->design_capacity =
723 battery->design_capacity *
724 10000 / battery->design_voltage;
725 battery->full_charge_capacity =
726 battery->full_charge_capacity *
727 10000 / battery->design_voltage;
728 battery->design_capacity_warning =
729 battery->design_capacity_warning *
730 10000 / battery->design_voltage;
731 battery->capacity_now = battery->capacity_now *
732 10000 / battery->design_voltage;
733 }
734 }
735 }
736}
737
738static int acpi_battery_update(struct acpi_battery *battery, bool resume)
739{
740 int result, old_present = acpi_battery_present(battery);
741 result = acpi_battery_get_status(battery);
742 if (result)
743 return result;
744 if (!acpi_battery_present(battery)) {
745 sysfs_remove_battery(battery);
746 battery->update_time = 0;
747 return 0;
748 }
749
750 if (resume)
751 return 0;
752
753 if (!battery->update_time ||
754 old_present != acpi_battery_present(battery)) {
755 result = acpi_battery_get_info(battery);
756 if (result)
757 return result;
758 acpi_battery_init_alarm(battery);
759 }
760
761 result = acpi_battery_get_state(battery);
762 if (result)
763 return result;
764 acpi_battery_quirks(battery);
765
766 if (!battery->bat) {
767 result = sysfs_add_battery(battery);
768 if (result)
769 return result;
770 }
771
772 /*
773 * Wakeup the system if battery is critical low
774 * or lower than the alarm level
775 */
776 if ((battery->state & ACPI_BATTERY_STATE_CRITICAL) ||
777 (test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags) &&
778 (battery->capacity_now <= battery->alarm)))
779 pm_wakeup_event(&battery->device->dev, 0);
780
781 return result;
782}
783
784static void acpi_battery_refresh(struct acpi_battery *battery)
785{
786 int power_unit;
787
788 if (!battery->bat)
789 return;
790
791 power_unit = battery->power_unit;
792
793 acpi_battery_get_info(battery);
794
795 if (power_unit == battery->power_unit)
796 return;
797
798 /* The battery has changed its reporting units. */
799 sysfs_remove_battery(battery);
800 sysfs_add_battery(battery);
801}
802
803/* --------------------------------------------------------------------------
804 FS Interface (/proc)
805 -------------------------------------------------------------------------- */
806
807#ifdef CONFIG_ACPI_PROCFS_POWER
808static struct proc_dir_entry *acpi_battery_dir;
809
810static const char *acpi_battery_units(const struct acpi_battery *battery)
811{
812 return (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) ?
813 "mA" : "mW";
814}
815
816static int acpi_battery_print_info(struct seq_file *seq, int result)
817{
818 struct acpi_battery *battery = seq->private;
819
820 if (result)
821 goto end;
822
823 seq_printf(seq, "present: %s\n",
824 acpi_battery_present(battery) ? "yes" : "no");
825 if (!acpi_battery_present(battery))
826 goto end;
827 if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
828 seq_printf(seq, "design capacity: unknown\n");
829 else
830 seq_printf(seq, "design capacity: %d %sh\n",
831 battery->design_capacity,
832 acpi_battery_units(battery));
833
834 if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
835 seq_printf(seq, "last full capacity: unknown\n");
836 else
837 seq_printf(seq, "last full capacity: %d %sh\n",
838 battery->full_charge_capacity,
839 acpi_battery_units(battery));
840
841 seq_printf(seq, "battery technology: %srechargeable\n",
842 (!battery->technology)?"non-":"");
843
844 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
845 seq_printf(seq, "design voltage: unknown\n");
846 else
847 seq_printf(seq, "design voltage: %d mV\n",
848 battery->design_voltage);
849 seq_printf(seq, "design capacity warning: %d %sh\n",
850 battery->design_capacity_warning,
851 acpi_battery_units(battery));
852 seq_printf(seq, "design capacity low: %d %sh\n",
853 battery->design_capacity_low,
854 acpi_battery_units(battery));
855 seq_printf(seq, "cycle count: %i\n", battery->cycle_count);
856 seq_printf(seq, "capacity granularity 1: %d %sh\n",
857 battery->capacity_granularity_1,
858 acpi_battery_units(battery));
859 seq_printf(seq, "capacity granularity 2: %d %sh\n",
860 battery->capacity_granularity_2,
861 acpi_battery_units(battery));
862 seq_printf(seq, "model number: %s\n", battery->model_number);
863 seq_printf(seq, "serial number: %s\n", battery->serial_number);
864 seq_printf(seq, "battery type: %s\n", battery->type);
865 seq_printf(seq, "OEM info: %s\n", battery->oem_info);
866 end:
867 if (result)
868 seq_printf(seq, "ERROR: Unable to read battery info\n");
869 return result;
870}
871
872static int acpi_battery_print_state(struct seq_file *seq, int result)
873{
874 struct acpi_battery *battery = seq->private;
875
876 if (result)
877 goto end;
878
879 seq_printf(seq, "present: %s\n",
880 acpi_battery_present(battery) ? "yes" : "no");
881 if (!acpi_battery_present(battery))
882 goto end;
883
884 seq_printf(seq, "capacity state: %s\n",
885 (battery->state & 0x04) ? "critical" : "ok");
886 if ((battery->state & 0x01) && (battery->state & 0x02))
887 seq_printf(seq,
888 "charging state: charging/discharging\n");
889 else if (battery->state & 0x01)
890 seq_printf(seq, "charging state: discharging\n");
891 else if (battery->state & 0x02)
892 seq_printf(seq, "charging state: charging\n");
893 else
894 seq_printf(seq, "charging state: charged\n");
895
896 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
897 seq_printf(seq, "present rate: unknown\n");
898 else
899 seq_printf(seq, "present rate: %d %s\n",
900 battery->rate_now, acpi_battery_units(battery));
901
902 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
903 seq_printf(seq, "remaining capacity: unknown\n");
904 else
905 seq_printf(seq, "remaining capacity: %d %sh\n",
906 battery->capacity_now, acpi_battery_units(battery));
907 if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
908 seq_printf(seq, "present voltage: unknown\n");
909 else
910 seq_printf(seq, "present voltage: %d mV\n",
911 battery->voltage_now);
912 end:
913 if (result)
914 seq_printf(seq, "ERROR: Unable to read battery state\n");
915
916 return result;
917}
918
919static int acpi_battery_print_alarm(struct seq_file *seq, int result)
920{
921 struct acpi_battery *battery = seq->private;
922
923 if (result)
924 goto end;
925
926 if (!acpi_battery_present(battery)) {
927 seq_printf(seq, "present: no\n");
928 goto end;
929 }
930 seq_printf(seq, "alarm: ");
931 if (!battery->alarm)
932 seq_printf(seq, "unsupported\n");
933 else
934 seq_printf(seq, "%u %sh\n", battery->alarm,
935 acpi_battery_units(battery));
936 end:
937 if (result)
938 seq_printf(seq, "ERROR: Unable to read battery alarm\n");
939 return result;
940}
941
942static ssize_t acpi_battery_write_alarm(struct file *file,
943 const char __user * buffer,
944 size_t count, loff_t * ppos)
945{
946 int result = 0;
947 char alarm_string[12] = { '\0' };
948 struct seq_file *m = file->private_data;
949 struct acpi_battery *battery = m->private;
950
951 if (!battery || (count > sizeof(alarm_string) - 1))
952 return -EINVAL;
953 if (!acpi_battery_present(battery)) {
954 result = -ENODEV;
955 goto end;
956 }
957 if (copy_from_user(alarm_string, buffer, count)) {
958 result = -EFAULT;
959 goto end;
960 }
961 alarm_string[count] = '\0';
962 if (kstrtoint(alarm_string, 0, &battery->alarm)) {
963 result = -EINVAL;
964 goto end;
965 }
966 result = acpi_battery_set_alarm(battery);
967 end:
968 if (!result)
969 return count;
970 return result;
971}
972
973typedef int(*print_func)(struct seq_file *seq, int result);
974
975static print_func acpi_print_funcs[ACPI_BATTERY_NUMFILES] = {
976 acpi_battery_print_info,
977 acpi_battery_print_state,
978 acpi_battery_print_alarm,
979};
980
981static int acpi_battery_read(int fid, struct seq_file *seq)
982{
983 struct acpi_battery *battery = seq->private;
984 int result = acpi_battery_update(battery, false);
985 return acpi_print_funcs[fid](seq, result);
986}
987
988#define DECLARE_FILE_FUNCTIONS(_name) \
989static int acpi_battery_read_##_name(struct seq_file *seq, void *offset) \
990{ \
991 return acpi_battery_read(_name##_tag, seq); \
992} \
993static int acpi_battery_##_name##_open_fs(struct inode *inode, struct file *file) \
994{ \
995 return single_open(file, acpi_battery_read_##_name, PDE_DATA(inode)); \
996}
997
998DECLARE_FILE_FUNCTIONS(info);
999DECLARE_FILE_FUNCTIONS(state);
1000DECLARE_FILE_FUNCTIONS(alarm);
1001
1002#undef DECLARE_FILE_FUNCTIONS
1003
1004#define FILE_DESCRIPTION_RO(_name) \
1005 { \
1006 .name = __stringify(_name), \
1007 .mode = S_IRUGO, \
1008 .ops = { \
1009 .open = acpi_battery_##_name##_open_fs, \
1010 .read = seq_read, \
1011 .llseek = seq_lseek, \
1012 .release = single_release, \
1013 .owner = THIS_MODULE, \
1014 }, \
1015 }
1016
1017#define FILE_DESCRIPTION_RW(_name) \
1018 { \
1019 .name = __stringify(_name), \
1020 .mode = S_IFREG | S_IRUGO | S_IWUSR, \
1021 .ops = { \
1022 .open = acpi_battery_##_name##_open_fs, \
1023 .read = seq_read, \
1024 .llseek = seq_lseek, \
1025 .write = acpi_battery_write_##_name, \
1026 .release = single_release, \
1027 .owner = THIS_MODULE, \
1028 }, \
1029 }
1030
1031static const struct battery_file {
1032 struct file_operations ops;
1033 umode_t mode;
1034 const char *name;
1035} acpi_battery_file[] = {
1036 FILE_DESCRIPTION_RO(info),
1037 FILE_DESCRIPTION_RO(state),
1038 FILE_DESCRIPTION_RW(alarm),
1039};
1040
1041#undef FILE_DESCRIPTION_RO
1042#undef FILE_DESCRIPTION_RW
1043
1044static int acpi_battery_add_fs(struct acpi_device *device)
1045{
1046 struct proc_dir_entry *entry = NULL;
1047 int i;
1048
1049 printk(KERN_WARNING PREFIX "Deprecated procfs I/F for battery is loaded,"
1050 " please retry with CONFIG_ACPI_PROCFS_POWER cleared\n");
1051 if (!acpi_device_dir(device)) {
1052 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
1053 acpi_battery_dir);
1054 if (!acpi_device_dir(device))
1055 return -ENODEV;
1056 }
1057
1058 for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i) {
1059 entry = proc_create_data(acpi_battery_file[i].name,
1060 acpi_battery_file[i].mode,
1061 acpi_device_dir(device),
1062 &acpi_battery_file[i].ops,
1063 acpi_driver_data(device));
1064 if (!entry)
1065 return -ENODEV;
1066 }
1067 return 0;
1068}
1069
1070static void acpi_battery_remove_fs(struct acpi_device *device)
1071{
1072 int i;
1073 if (!acpi_device_dir(device))
1074 return;
1075 for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i)
1076 remove_proc_entry(acpi_battery_file[i].name,
1077 acpi_device_dir(device));
1078
1079 remove_proc_entry(acpi_device_bid(device), acpi_battery_dir);
1080 acpi_device_dir(device) = NULL;
1081}
1082
1083#endif
1084
1085/* --------------------------------------------------------------------------
1086 Driver Interface
1087 -------------------------------------------------------------------------- */
1088
1089static void acpi_battery_notify(struct acpi_device *device, u32 event)
1090{
1091 struct acpi_battery *battery = acpi_driver_data(device);
1092 struct power_supply *old;
1093
1094 if (!battery)
1095 return;
1096 old = battery->bat;
1097 /*
1098 * On Acer Aspire V5-573G notifications are sometimes triggered too
1099 * early. For example, when AC is unplugged and notification is
1100 * triggered, battery state is still reported as "Full", and changes to
1101 * "Discharging" only after short delay, without any notification.
1102 */
1103 if (battery_notification_delay_ms > 0)
1104 msleep(battery_notification_delay_ms);
1105 if (event == ACPI_BATTERY_NOTIFY_INFO)
1106 acpi_battery_refresh(battery);
1107 acpi_battery_update(battery, false);
1108 acpi_bus_generate_netlink_event(device->pnp.device_class,
1109 dev_name(&device->dev), event,
1110 acpi_battery_present(battery));
1111 acpi_notifier_call_chain(device, event, acpi_battery_present(battery));
1112 /* acpi_battery_update could remove power_supply object */
1113 if (old && battery->bat)
1114 power_supply_changed(battery->bat);
1115}
1116
1117static int battery_notify(struct notifier_block *nb,
1118 unsigned long mode, void *_unused)
1119{
1120 struct acpi_battery *battery = container_of(nb, struct acpi_battery,
1121 pm_nb);
1122 int result;
1123
1124 switch (mode) {
1125 case PM_POST_HIBERNATION:
1126 case PM_POST_SUSPEND:
1127 if (!acpi_battery_present(battery))
1128 return 0;
1129
1130 if (!battery->bat) {
1131 result = acpi_battery_get_info(battery);
1132 if (result)
1133 return result;
1134
1135 result = sysfs_add_battery(battery);
1136 if (result)
1137 return result;
1138 } else
1139 acpi_battery_refresh(battery);
1140
1141 acpi_battery_init_alarm(battery);
1142 acpi_battery_get_state(battery);
1143 break;
1144 }
1145
1146 return 0;
1147}
1148
1149static int __init
1150battery_bix_broken_package_quirk(const struct dmi_system_id *d)
1151{
1152 battery_bix_broken_package = 1;
1153 return 0;
1154}
1155
1156static int __init
1157battery_notification_delay_quirk(const struct dmi_system_id *d)
1158{
1159 battery_notification_delay_ms = 1000;
1160 return 0;
1161}
1162
1163static const struct dmi_system_id bat_dmi_table[] __initconst = {
1164 {
1165 .callback = battery_bix_broken_package_quirk,
1166 .ident = "NEC LZ750/LS",
1167 .matches = {
1168 DMI_MATCH(DMI_SYS_VENDOR, "NEC"),
1169 DMI_MATCH(DMI_PRODUCT_NAME, "PC-LZ750LS"),
1170 },
1171 },
1172 {
1173 .callback = battery_notification_delay_quirk,
1174 .ident = "Acer Aspire V5-573G",
1175 .matches = {
1176 DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
1177 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire V5-573G"),
1178 },
1179 },
1180 {},
1181};
1182
1183/*
1184 * Some machines'(E,G Lenovo Z480) ECs are not stable
1185 * during boot up and this causes battery driver fails to be
1186 * probed due to failure of getting battery information
1187 * from EC sometimes. After several retries, the operation
1188 * may work. So add retry code here and 20ms sleep between
1189 * every retries.
1190 */
1191static int acpi_battery_update_retry(struct acpi_battery *battery)
1192{
1193 int retry, ret;
1194
1195 for (retry = 5; retry; retry--) {
1196 ret = acpi_battery_update(battery, false);
1197 if (!ret)
1198 break;
1199
1200 msleep(20);
1201 }
1202 return ret;
1203}
1204
1205static int acpi_battery_add(struct acpi_device *device)
1206{
1207 int result = 0;
1208 struct acpi_battery *battery = NULL;
1209
1210 if (!device)
1211 return -EINVAL;
1212
1213 if (device->dep_unmet)
1214 return -EPROBE_DEFER;
1215
1216 battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL);
1217 if (!battery)
1218 return -ENOMEM;
1219 battery->device = device;
1220 strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME);
1221 strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS);
1222 device->driver_data = battery;
1223 mutex_init(&battery->lock);
1224 mutex_init(&battery->sysfs_lock);
1225 if (acpi_has_method(battery->device->handle, "_BIX"))
1226 set_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags);
1227
1228 result = acpi_battery_update_retry(battery);
1229 if (result)
1230 goto fail;
1231
1232#ifdef CONFIG_ACPI_PROCFS_POWER
1233 result = acpi_battery_add_fs(device);
1234#endif
1235 if (result) {
1236#ifdef CONFIG_ACPI_PROCFS_POWER
1237 acpi_battery_remove_fs(device);
1238#endif
1239 goto fail;
1240 }
1241
1242 printk(KERN_INFO PREFIX "%s Slot [%s] (battery %s)\n",
1243 ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device),
1244 device->status.battery_present ? "present" : "absent");
1245
1246 battery->pm_nb.notifier_call = battery_notify;
1247 register_pm_notifier(&battery->pm_nb);
1248
1249 device_init_wakeup(&device->dev, 1);
1250
1251 return result;
1252
1253fail:
1254 sysfs_remove_battery(battery);
1255 mutex_destroy(&battery->lock);
1256 mutex_destroy(&battery->sysfs_lock);
1257 kfree(battery);
1258 return result;
1259}
1260
1261static int acpi_battery_remove(struct acpi_device *device)
1262{
1263 struct acpi_battery *battery = NULL;
1264
1265 if (!device || !acpi_driver_data(device))
1266 return -EINVAL;
1267 device_init_wakeup(&device->dev, 0);
1268 battery = acpi_driver_data(device);
1269 unregister_pm_notifier(&battery->pm_nb);
1270#ifdef CONFIG_ACPI_PROCFS_POWER
1271 acpi_battery_remove_fs(device);
1272#endif
1273 sysfs_remove_battery(battery);
1274 mutex_destroy(&battery->lock);
1275 mutex_destroy(&battery->sysfs_lock);
1276 kfree(battery);
1277 return 0;
1278}
1279
1280#ifdef CONFIG_PM_SLEEP
1281/* this is needed to learn about changes made in suspended state */
1282static int acpi_battery_resume(struct device *dev)
1283{
1284 struct acpi_battery *battery;
1285
1286 if (!dev)
1287 return -EINVAL;
1288
1289 battery = acpi_driver_data(to_acpi_device(dev));
1290 if (!battery)
1291 return -EINVAL;
1292
1293 battery->update_time = 0;
1294 acpi_battery_update(battery, true);
1295 return 0;
1296}
1297#else
1298#define acpi_battery_resume NULL
1299#endif
1300
1301static SIMPLE_DEV_PM_OPS(acpi_battery_pm, NULL, acpi_battery_resume);
1302
1303static struct acpi_driver acpi_battery_driver = {
1304 .name = "battery",
1305 .class = ACPI_BATTERY_CLASS,
1306 .ids = battery_device_ids,
1307 .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
1308 .ops = {
1309 .add = acpi_battery_add,
1310 .remove = acpi_battery_remove,
1311 .notify = acpi_battery_notify,
1312 },
1313 .drv.pm = &acpi_battery_pm,
1314};
1315
1316static void __init acpi_battery_init_async(void *unused, async_cookie_t cookie)
1317{
1318 int result;
1319
1320 dmi_check_system(bat_dmi_table);
1321
1322#ifdef CONFIG_ACPI_PROCFS_POWER
1323 acpi_battery_dir = acpi_lock_battery_dir();
1324 if (!acpi_battery_dir)
1325 return;
1326#endif
1327 result = acpi_bus_register_driver(&acpi_battery_driver);
1328#ifdef CONFIG_ACPI_PROCFS_POWER
1329 if (result < 0)
1330 acpi_unlock_battery_dir(acpi_battery_dir);
1331#endif
1332}
1333
1334static int __init acpi_battery_init(void)
1335{
1336 if (acpi_disabled)
1337 return -ENODEV;
1338
1339 async_cookie = async_schedule(acpi_battery_init_async, NULL);
1340 return 0;
1341}
1342
1343static void __exit acpi_battery_exit(void)
1344{
1345 async_synchronize_cookie(async_cookie + 1);
1346 acpi_bus_unregister_driver(&acpi_battery_driver);
1347#ifdef CONFIG_ACPI_PROCFS_POWER
1348 acpi_unlock_battery_dir(acpi_battery_dir);
1349#endif
1350}
1351
1352module_init(acpi_battery_init);
1353module_exit(acpi_battery_exit);