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 int power_unit;
647
648 if (!battery->bat.dev)
649 return;
650
651 power_unit = battery->power_unit;
652
653 acpi_battery_get_info(battery);
654
655 if (power_unit == battery->power_unit)
656 return;
657
658 /* The battery has changed its reporting units. */
659 sysfs_remove_battery(battery);
660 sysfs_add_battery(battery);
661}
662
663/* --------------------------------------------------------------------------
664 FS Interface (/proc)
665 -------------------------------------------------------------------------- */
666
667#ifdef CONFIG_ACPI_PROCFS_POWER
668static struct proc_dir_entry *acpi_battery_dir;
669
670static int acpi_battery_print_info(struct seq_file *seq, int result)
671{
672 struct acpi_battery *battery = seq->private;
673
674 if (result)
675 goto end;
676
677 seq_printf(seq, "present: %s\n",
678 acpi_battery_present(battery)?"yes":"no");
679 if (!acpi_battery_present(battery))
680 goto end;
681 if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
682 seq_printf(seq, "design capacity: unknown\n");
683 else
684 seq_printf(seq, "design capacity: %d %sh\n",
685 battery->design_capacity,
686 acpi_battery_units(battery));
687
688 if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
689 seq_printf(seq, "last full capacity: unknown\n");
690 else
691 seq_printf(seq, "last full capacity: %d %sh\n",
692 battery->full_charge_capacity,
693 acpi_battery_units(battery));
694
695 seq_printf(seq, "battery technology: %srechargeable\n",
696 (!battery->technology)?"non-":"");
697
698 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
699 seq_printf(seq, "design voltage: unknown\n");
700 else
701 seq_printf(seq, "design voltage: %d mV\n",
702 battery->design_voltage);
703 seq_printf(seq, "design capacity warning: %d %sh\n",
704 battery->design_capacity_warning,
705 acpi_battery_units(battery));
706 seq_printf(seq, "design capacity low: %d %sh\n",
707 battery->design_capacity_low,
708 acpi_battery_units(battery));
709 seq_printf(seq, "cycle count: %i\n", battery->cycle_count);
710 seq_printf(seq, "capacity granularity 1: %d %sh\n",
711 battery->capacity_granularity_1,
712 acpi_battery_units(battery));
713 seq_printf(seq, "capacity granularity 2: %d %sh\n",
714 battery->capacity_granularity_2,
715 acpi_battery_units(battery));
716 seq_printf(seq, "model number: %s\n", battery->model_number);
717 seq_printf(seq, "serial number: %s\n", battery->serial_number);
718 seq_printf(seq, "battery type: %s\n", battery->type);
719 seq_printf(seq, "OEM info: %s\n", battery->oem_info);
720 end:
721 if (result)
722 seq_printf(seq, "ERROR: Unable to read battery info\n");
723 return result;
724}
725
726static int acpi_battery_print_state(struct seq_file *seq, int result)
727{
728 struct acpi_battery *battery = seq->private;
729
730 if (result)
731 goto end;
732
733 seq_printf(seq, "present: %s\n",
734 acpi_battery_present(battery)?"yes":"no");
735 if (!acpi_battery_present(battery))
736 goto end;
737
738 seq_printf(seq, "capacity state: %s\n",
739 (battery->state & 0x04)?"critical":"ok");
740 if ((battery->state & 0x01) && (battery->state & 0x02))
741 seq_printf(seq,
742 "charging state: charging/discharging\n");
743 else if (battery->state & 0x01)
744 seq_printf(seq, "charging state: discharging\n");
745 else if (battery->state & 0x02)
746 seq_printf(seq, "charging state: charging\n");
747 else
748 seq_printf(seq, "charging state: charged\n");
749
750 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
751 seq_printf(seq, "present rate: unknown\n");
752 else
753 seq_printf(seq, "present rate: %d %s\n",
754 battery->rate_now, acpi_battery_units(battery));
755
756 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
757 seq_printf(seq, "remaining capacity: unknown\n");
758 else
759 seq_printf(seq, "remaining capacity: %d %sh\n",
760 battery->capacity_now, acpi_battery_units(battery));
761 if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
762 seq_printf(seq, "present voltage: unknown\n");
763 else
764 seq_printf(seq, "present voltage: %d mV\n",
765 battery->voltage_now);
766 end:
767 if (result)
768 seq_printf(seq, "ERROR: Unable to read battery state\n");
769
770 return result;
771}
772
773static int acpi_battery_print_alarm(struct seq_file *seq, int result)
774{
775 struct acpi_battery *battery = seq->private;
776
777 if (result)
778 goto end;
779
780 if (!acpi_battery_present(battery)) {
781 seq_printf(seq, "present: no\n");
782 goto end;
783 }
784 seq_printf(seq, "alarm: ");
785 if (!battery->alarm)
786 seq_printf(seq, "unsupported\n");
787 else
788 seq_printf(seq, "%u %sh\n", battery->alarm,
789 acpi_battery_units(battery));
790 end:
791 if (result)
792 seq_printf(seq, "ERROR: Unable to read battery alarm\n");
793 return result;
794}
795
796static ssize_t acpi_battery_write_alarm(struct file *file,
797 const char __user * buffer,
798 size_t count, loff_t * ppos)
799{
800 int result = 0;
801 char alarm_string[12] = { '\0' };
802 struct seq_file *m = file->private_data;
803 struct acpi_battery *battery = m->private;
804
805 if (!battery || (count > sizeof(alarm_string) - 1))
806 return -EINVAL;
807 if (!acpi_battery_present(battery)) {
808 result = -ENODEV;
809 goto end;
810 }
811 if (copy_from_user(alarm_string, buffer, count)) {
812 result = -EFAULT;
813 goto end;
814 }
815 alarm_string[count] = '\0';
816 battery->alarm = simple_strtol(alarm_string, NULL, 0);
817 result = acpi_battery_set_alarm(battery);
818 end:
819 if (!result)
820 return count;
821 return result;
822}
823
824typedef int(*print_func)(struct seq_file *seq, int result);
825
826static print_func acpi_print_funcs[ACPI_BATTERY_NUMFILES] = {
827 acpi_battery_print_info,
828 acpi_battery_print_state,
829 acpi_battery_print_alarm,
830};
831
832static int acpi_battery_read(int fid, struct seq_file *seq)
833{
834 struct acpi_battery *battery = seq->private;
835 int result = acpi_battery_update(battery);
836 return acpi_print_funcs[fid](seq, result);
837}
838
839#define DECLARE_FILE_FUNCTIONS(_name) \
840static int acpi_battery_read_##_name(struct seq_file *seq, void *offset) \
841{ \
842 return acpi_battery_read(_name##_tag, seq); \
843} \
844static int acpi_battery_##_name##_open_fs(struct inode *inode, struct file *file) \
845{ \
846 return single_open(file, acpi_battery_read_##_name, PDE(inode)->data); \
847}
848
849DECLARE_FILE_FUNCTIONS(info);
850DECLARE_FILE_FUNCTIONS(state);
851DECLARE_FILE_FUNCTIONS(alarm);
852
853#undef DECLARE_FILE_FUNCTIONS
854
855#define FILE_DESCRIPTION_RO(_name) \
856 { \
857 .name = __stringify(_name), \
858 .mode = S_IRUGO, \
859 .ops = { \
860 .open = acpi_battery_##_name##_open_fs, \
861 .read = seq_read, \
862 .llseek = seq_lseek, \
863 .release = single_release, \
864 .owner = THIS_MODULE, \
865 }, \
866 }
867
868#define FILE_DESCRIPTION_RW(_name) \
869 { \
870 .name = __stringify(_name), \
871 .mode = S_IFREG | S_IRUGO | S_IWUSR, \
872 .ops = { \
873 .open = acpi_battery_##_name##_open_fs, \
874 .read = seq_read, \
875 .llseek = seq_lseek, \
876 .write = acpi_battery_write_##_name, \
877 .release = single_release, \
878 .owner = THIS_MODULE, \
879 }, \
880 }
881
882static const struct battery_file {
883 struct file_operations ops;
884 umode_t mode;
885 const char *name;
886} acpi_battery_file[] = {
887 FILE_DESCRIPTION_RO(info),
888 FILE_DESCRIPTION_RO(state),
889 FILE_DESCRIPTION_RW(alarm),
890};
891
892#undef FILE_DESCRIPTION_RO
893#undef FILE_DESCRIPTION_RW
894
895static int acpi_battery_add_fs(struct acpi_device *device)
896{
897 struct proc_dir_entry *entry = NULL;
898 int i;
899
900 printk(KERN_WARNING PREFIX "Deprecated procfs I/F for battery is loaded,"
901 " please retry with CONFIG_ACPI_PROCFS_POWER cleared\n");
902 if (!acpi_device_dir(device)) {
903 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
904 acpi_battery_dir);
905 if (!acpi_device_dir(device))
906 return -ENODEV;
907 }
908
909 for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i) {
910 entry = proc_create_data(acpi_battery_file[i].name,
911 acpi_battery_file[i].mode,
912 acpi_device_dir(device),
913 &acpi_battery_file[i].ops,
914 acpi_driver_data(device));
915 if (!entry)
916 return -ENODEV;
917 }
918 return 0;
919}
920
921static void acpi_battery_remove_fs(struct acpi_device *device)
922{
923 int i;
924 if (!acpi_device_dir(device))
925 return;
926 for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i)
927 remove_proc_entry(acpi_battery_file[i].name,
928 acpi_device_dir(device));
929
930 remove_proc_entry(acpi_device_bid(device), acpi_battery_dir);
931 acpi_device_dir(device) = NULL;
932}
933
934#endif
935
936/* --------------------------------------------------------------------------
937 Driver Interface
938 -------------------------------------------------------------------------- */
939
940static void acpi_battery_notify(struct acpi_device *device, u32 event)
941{
942 struct acpi_battery *battery = acpi_driver_data(device);
943 struct device *old;
944
945 if (!battery)
946 return;
947 old = battery->bat.dev;
948 if (event == ACPI_BATTERY_NOTIFY_INFO)
949 acpi_battery_refresh(battery);
950 acpi_battery_update(battery);
951 acpi_bus_generate_proc_event(device, event,
952 acpi_battery_present(battery));
953 acpi_bus_generate_netlink_event(device->pnp.device_class,
954 dev_name(&device->dev), event,
955 acpi_battery_present(battery));
956 /* acpi_battery_update could remove power_supply object */
957 if (old && battery->bat.dev)
958 power_supply_changed(&battery->bat);
959}
960
961static int battery_notify(struct notifier_block *nb,
962 unsigned long mode, void *_unused)
963{
964 struct acpi_battery *battery = container_of(nb, struct acpi_battery,
965 pm_nb);
966 switch (mode) {
967 case PM_POST_HIBERNATION:
968 case PM_POST_SUSPEND:
969 if (battery->bat.dev) {
970 sysfs_remove_battery(battery);
971 sysfs_add_battery(battery);
972 }
973 break;
974 }
975
976 return 0;
977}
978
979static int acpi_battery_add(struct acpi_device *device)
980{
981 int result = 0;
982 struct acpi_battery *battery = NULL;
983 acpi_handle handle;
984 if (!device)
985 return -EINVAL;
986 battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL);
987 if (!battery)
988 return -ENOMEM;
989 battery->device = device;
990 strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME);
991 strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS);
992 device->driver_data = battery;
993 mutex_init(&battery->lock);
994 mutex_init(&battery->sysfs_lock);
995 if (ACPI_SUCCESS(acpi_get_handle(battery->device->handle,
996 "_BIX", &handle)))
997 set_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags);
998 result = acpi_battery_update(battery);
999 if (result)
1000 goto fail;
1001#ifdef CONFIG_ACPI_PROCFS_POWER
1002 result = acpi_battery_add_fs(device);
1003#endif
1004 if (result) {
1005#ifdef CONFIG_ACPI_PROCFS_POWER
1006 acpi_battery_remove_fs(device);
1007#endif
1008 goto fail;
1009 }
1010
1011 printk(KERN_INFO PREFIX "%s Slot [%s] (battery %s)\n",
1012 ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device),
1013 device->status.battery_present ? "present" : "absent");
1014
1015 battery->pm_nb.notifier_call = battery_notify;
1016 register_pm_notifier(&battery->pm_nb);
1017
1018 return result;
1019
1020fail:
1021 sysfs_remove_battery(battery);
1022 mutex_destroy(&battery->lock);
1023 mutex_destroy(&battery->sysfs_lock);
1024 kfree(battery);
1025 return result;
1026}
1027
1028static int acpi_battery_remove(struct acpi_device *device, int type)
1029{
1030 struct acpi_battery *battery = NULL;
1031
1032 if (!device || !acpi_driver_data(device))
1033 return -EINVAL;
1034 battery = acpi_driver_data(device);
1035 unregister_pm_notifier(&battery->pm_nb);
1036#ifdef CONFIG_ACPI_PROCFS_POWER
1037 acpi_battery_remove_fs(device);
1038#endif
1039 sysfs_remove_battery(battery);
1040 mutex_destroy(&battery->lock);
1041 mutex_destroy(&battery->sysfs_lock);
1042 kfree(battery);
1043 return 0;
1044}
1045
1046/* this is needed to learn about changes made in suspended state */
1047static int acpi_battery_resume(struct acpi_device *device)
1048{
1049 struct acpi_battery *battery;
1050 if (!device)
1051 return -EINVAL;
1052 battery = acpi_driver_data(device);
1053 battery->update_time = 0;
1054 acpi_battery_update(battery);
1055 return 0;
1056}
1057
1058static struct acpi_driver acpi_battery_driver = {
1059 .name = "battery",
1060 .class = ACPI_BATTERY_CLASS,
1061 .ids = battery_device_ids,
1062 .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
1063 .ops = {
1064 .add = acpi_battery_add,
1065 .resume = acpi_battery_resume,
1066 .remove = acpi_battery_remove,
1067 .notify = acpi_battery_notify,
1068 },
1069};
1070
1071static void __init acpi_battery_init_async(void *unused, async_cookie_t cookie)
1072{
1073 if (acpi_disabled)
1074 return;
1075#ifdef CONFIG_ACPI_PROCFS_POWER
1076 acpi_battery_dir = acpi_lock_battery_dir();
1077 if (!acpi_battery_dir)
1078 return;
1079#endif
1080 if (acpi_bus_register_driver(&acpi_battery_driver) < 0) {
1081#ifdef CONFIG_ACPI_PROCFS_POWER
1082 acpi_unlock_battery_dir(acpi_battery_dir);
1083#endif
1084 return;
1085 }
1086 return;
1087}
1088
1089static int __init acpi_battery_init(void)
1090{
1091 async_schedule(acpi_battery_init_async, NULL);
1092 return 0;
1093}
1094
1095static void __exit acpi_battery_exit(void)
1096{
1097 acpi_bus_unregister_driver(&acpi_battery_driver);
1098#ifdef CONFIG_ACPI_PROCFS_POWER
1099 acpi_unlock_battery_dir(acpi_battery_dir);
1100#endif
1101}
1102
1103module_init(acpi_battery_init);
1104module_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 * 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#include <asm/unaligned.h>
38
39#ifdef CONFIG_ACPI_PROCFS_POWER
40#include <linux/proc_fs.h>
41#include <linux/seq_file.h>
42#include <asm/uaccess.h>
43#endif
44
45#include <linux/acpi.h>
46#include <linux/power_supply.h>
47
48#include "battery.h"
49
50#define PREFIX "ACPI: "
51
52#define ACPI_BATTERY_VALUE_UNKNOWN 0xFFFFFFFF
53
54#define ACPI_BATTERY_DEVICE_NAME "Battery"
55
56/* Battery power unit: 0 means mW, 1 means mA */
57#define ACPI_BATTERY_POWER_UNIT_MA 1
58
59#define _COMPONENT ACPI_BATTERY_COMPONENT
60
61ACPI_MODULE_NAME("battery");
62
63MODULE_AUTHOR("Paul Diefenbaugh");
64MODULE_AUTHOR("Alexey Starikovskiy <astarikovskiy@suse.de>");
65MODULE_DESCRIPTION("ACPI Battery Driver");
66MODULE_LICENSE("GPL");
67
68static int battery_bix_broken_package;
69static unsigned int cache_time = 1000;
70module_param(cache_time, uint, 0644);
71MODULE_PARM_DESC(cache_time, "cache time in milliseconds");
72
73#ifdef CONFIG_ACPI_PROCFS_POWER
74extern struct proc_dir_entry *acpi_lock_battery_dir(void);
75extern void *acpi_unlock_battery_dir(struct proc_dir_entry *acpi_battery_dir);
76
77enum acpi_battery_files {
78 info_tag = 0,
79 state_tag,
80 alarm_tag,
81 ACPI_BATTERY_NUMFILES,
82};
83
84#endif
85
86static const struct acpi_device_id battery_device_ids[] = {
87 {"PNP0C0A", 0},
88 {"", 0},
89};
90
91MODULE_DEVICE_TABLE(acpi, battery_device_ids);
92
93enum {
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,
109};
110
111struct acpi_battery {
112 struct mutex lock;
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;
118 int revision;
119 int rate_now;
120 int capacity_now;
121 int voltage_now;
122 int design_capacity;
123 int full_charge_capacity;
124 int technology;
125 int design_voltage;
126 int design_capacity_warning;
127 int design_capacity_low;
128 int cycle_count;
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;
136 int alarm;
137 char model_number[32];
138 char serial_number[32];
139 char type[32];
140 char oem_info[32];
141 int state;
142 int power_unit;
143 unsigned long flags;
144};
145
146#define to_acpi_battery(x) container_of(x, struct acpi_battery, bat)
147
148static inline int acpi_battery_present(struct acpi_battery *battery)
149{
150 return battery->device->status.battery_present;
151}
152
153static int acpi_battery_technology(struct acpi_battery *battery)
154{
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;
166}
167
168static int acpi_battery_get_state(struct acpi_battery *battery);
169
170static int acpi_battery_is_charged(struct acpi_battery *battery)
171{
172 /* either charging or discharging */
173 if (battery->state != 0)
174 return 0;
175
176 /* battery not reporting charge */
177 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN ||
178 battery->capacity_now == 0)
179 return 0;
180
181 /* good batteries update full_charge as the batteries degrade */
182 if (battery->full_charge_capacity == battery->capacity_now)
183 return 1;
184
185 /* fallback to using design values for broken batteries */
186 if (battery->design_capacity == battery->capacity_now)
187 return 1;
188
189 /* we don't do any sort of metric based on percentages */
190 return 0;
191}
192
193static int acpi_battery_get_property(struct power_supply *psy,
194 enum power_supply_property psp,
195 union power_supply_propval *val)
196{
197 int ret = 0;
198 struct acpi_battery *battery = to_acpi_battery(psy);
199
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)
204 return -ENODEV;
205 switch (psp) {
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;
213 else
214 val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
215 break;
216 case POWER_SUPPLY_PROP_PRESENT:
217 val->intval = acpi_battery_present(battery);
218 break;
219 case POWER_SUPPLY_PROP_TECHNOLOGY:
220 val->intval = acpi_battery_technology(battery);
221 break;
222 case POWER_SUPPLY_PROP_CYCLE_COUNT:
223 val->intval = battery->cycle_count;
224 break;
225 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
226 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
227 ret = -ENODEV;
228 else
229 val->intval = battery->design_voltage * 1000;
230 break;
231 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
232 if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
233 ret = -ENODEV;
234 else
235 val->intval = battery->voltage_now * 1000;
236 break;
237 case POWER_SUPPLY_PROP_CURRENT_NOW:
238 case POWER_SUPPLY_PROP_POWER_NOW:
239 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
240 ret = -ENODEV;
241 else
242 val->intval = battery->rate_now * 1000;
243 break;
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)
247 ret = -ENODEV;
248 else
249 val->intval = battery->design_capacity * 1000;
250 break;
251 case POWER_SUPPLY_PROP_CHARGE_FULL:
252 case POWER_SUPPLY_PROP_ENERGY_FULL:
253 if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
254 ret = -ENODEV;
255 else
256 val->intval = battery->full_charge_capacity * 1000;
257 break;
258 case POWER_SUPPLY_PROP_CHARGE_NOW:
259 case POWER_SUPPLY_PROP_ENERGY_NOW:
260 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
261 ret = -ENODEV;
262 else
263 val->intval = battery->capacity_now * 1000;
264 break;
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;
269 else
270 val->intval = 0;
271 break;
272 case POWER_SUPPLY_PROP_MODEL_NAME:
273 val->strval = battery->model_number;
274 break;
275 case POWER_SUPPLY_PROP_MANUFACTURER:
276 val->strval = battery->oem_info;
277 break;
278 case POWER_SUPPLY_PROP_SERIAL_NUMBER:
279 val->strval = battery->serial_number;
280 break;
281 default:
282 ret = -EINVAL;
283 }
284 return ret;
285}
286
287static 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,
302};
303
304static 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,
319};
320
321#ifdef CONFIG_ACPI_PROCFS_POWER
322inline char *acpi_battery_units(struct acpi_battery *battery)
323{
324 return (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) ?
325 "mA" : "mW";
326}
327#endif
328
329/* --------------------------------------------------------------------------
330 Battery Management
331 -------------------------------------------------------------------------- */
332struct acpi_offsets {
333 size_t offset; /* offset inside struct acpi_sbs_battery */
334 u8 mode; /* int or string? */
335};
336
337static 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},
342};
343
344static 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},
358};
359
360static 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},
381};
382
383static int extract_package(struct acpi_battery *battery,
384 union acpi_object *package,
385 struct acpi_offsets *offsets, int num)
386{
387 int i;
388 union acpi_object *element;
389 if (package->type != ACPI_TYPE_PACKAGE)
390 return -EFAULT;
391 for (i = 0; i < num; ++i) {
392 if (package->package.count <= i)
393 return -EFAULT;
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,
402 sizeof(u64));
403 ptr[sizeof(u64)] = 0;
404 } else
405 *ptr = 0; /* don't have value */
406 } else {
407 int *x = (int *)((u8 *)battery + offsets[i].offset);
408 *x = (element->type == ACPI_TYPE_INTEGER) ?
409 element->integer.value : -1;
410 }
411 }
412 return 0;
413}
414
415static int acpi_battery_get_status(struct acpi_battery *battery)
416{
417 if (acpi_bus_get_status(battery->device)) {
418 ACPI_EXCEPTION((AE_INFO, AE_ERROR, "Evaluating _STA"));
419 return -ENODEV;
420 }
421 return 0;
422}
423
424static int acpi_battery_get_info(struct acpi_battery *battery)
425{
426 int result = -EFAULT;
427 acpi_status status = 0;
428 char *name = test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags) ?
429 "_BIX" : "_BIF";
430
431 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
432
433 if (!acpi_battery_present(battery))
434 return 0;
435 mutex_lock(&battery->lock);
436 status = acpi_evaluate_object(battery->device->handle, name,
437 NULL, &buffer);
438 mutex_unlock(&battery->lock);
439
440 if (ACPI_FAILURE(status)) {
441 ACPI_EXCEPTION((AE_INFO, status, "Evaluating %s", name));
442 return -ENODEV;
443 }
444
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));
453 else
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,
469 is correct. */
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. */
473 }
474 return result;
475}
476
477static int acpi_battery_get_state(struct acpi_battery *battery)
478{
479 int result = 0;
480 acpi_status status = 0;
481 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
482
483 if (!acpi_battery_present(battery))
484 return 0;
485
486 if (battery->update_time &&
487 time_before(jiffies, battery->update_time +
488 msecs_to_jiffies(cache_time)))
489 return 0;
490
491 mutex_lock(&battery->lock);
492 status = acpi_evaluate_object(battery->device->handle, "_BST",
493 NULL, &buffer);
494 mutex_unlock(&battery->lock);
495
496 if (ACPI_FAILURE(status)) {
497 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BST"));
498 return -ENODEV;
499 }
500
501 result = extract_package(battery, buffer.pointer,
502 state_offsets, ARRAY_SIZE(state_offsets));
503 battery->update_time = jiffies;
504 kfree(buffer.pointer);
505
506 /* For buggy DSDTs that report negative 16-bit values for either
507 * charging or discharging current and/or report 0 as 65536
508 * due to bad math.
509 */
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"
515 " invalid.\n");
516 }
517
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;
526 }
527 return result;
528}
529
530static int acpi_battery_set_alarm(struct acpi_battery *battery)
531{
532 acpi_status status = 0;
533
534 if (!acpi_battery_present(battery) ||
535 !test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags))
536 return -ENODEV;
537
538 mutex_lock(&battery->lock);
539 status = acpi_execute_simple_method(battery->device->handle, "_BTP",
540 battery->alarm);
541 mutex_unlock(&battery->lock);
542
543 if (ACPI_FAILURE(status))
544 return -ENODEV;
545
546 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Alarm set to %d\n", battery->alarm));
547 return 0;
548}
549
550static int acpi_battery_init_alarm(struct acpi_battery *battery)
551{
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);
555 return 0;
556 }
557 set_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
558 if (!battery->alarm)
559 battery->alarm = battery->design_capacity_warning;
560 return acpi_battery_set_alarm(battery);
561}
562
563static ssize_t acpi_battery_alarm_show(struct device *dev,
564 struct device_attribute *attr,
565 char *buf)
566{
567 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
568 return sprintf(buf, "%d\n", battery->alarm * 1000);
569}
570
571static ssize_t acpi_battery_alarm_store(struct device *dev,
572 struct device_attribute *attr,
573 const char *buf, size_t count)
574{
575 unsigned long x;
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);
581 return count;
582}
583
584static struct device_attribute alarm_attr = {
585 .attr = {.name = "alarm", .mode = 0644},
586 .show = acpi_battery_alarm_show,
587 .store = acpi_battery_alarm_store,
588};
589
590static int sysfs_add_battery(struct acpi_battery *battery)
591{
592 int result;
593
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);
598 } else {
599 battery->bat.properties = energy_battery_props;
600 battery->bat.num_properties =
601 ARRAY_SIZE(energy_battery_props);
602 }
603
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;
607
608 result = power_supply_register(&battery->device->dev, &battery->bat);
609 if (result)
610 return result;
611 return device_create_file(battery->bat.dev, &alarm_attr);
612}
613
614static void sysfs_remove_battery(struct acpi_battery *battery)
615{
616 mutex_lock(&battery->sysfs_lock);
617 if (!battery->bat.dev) {
618 mutex_unlock(&battery->sysfs_lock);
619 return;
620 }
621
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);
626}
627
628static void find_battery(const struct dmi_header *dm, void *private)
629{
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
639 != dmi_capacity &&
640 battery->design_capacity * 10 == dmi_capacity)
641 set_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
642 &battery->flags);
643 }
644}
645
646/*
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.
651 *
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
655 *
656 * Handle this correctly so that they won't break userspace.
657 */
658static void acpi_battery_quirks(struct acpi_battery *battery)
659{
660 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
661 return;
662
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;
670 }
671
672 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags))
673 return;
674
675 if (battery->power_unit && dmi_name_in_vendors("LENOVO")) {
676 const char *s;
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,
681 &battery->flags) &&
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;
694 }
695 }
696 }
697}
698
699static int acpi_battery_update(struct acpi_battery *battery)
700{
701 int result, old_present = acpi_battery_present(battery);
702 result = acpi_battery_get_status(battery);
703 if (result)
704 return result;
705 if (!acpi_battery_present(battery)) {
706 sysfs_remove_battery(battery);
707 battery->update_time = 0;
708 return 0;
709 }
710 if (!battery->update_time ||
711 old_present != acpi_battery_present(battery)) {
712 result = acpi_battery_get_info(battery);
713 if (result)
714 return result;
715 acpi_battery_init_alarm(battery);
716 }
717 if (!battery->bat.dev) {
718 result = sysfs_add_battery(battery);
719 if (result)
720 return result;
721 }
722 result = acpi_battery_get_state(battery);
723 acpi_battery_quirks(battery);
724 return result;
725}
726
727static void acpi_battery_refresh(struct acpi_battery *battery)
728{
729 int power_unit;
730
731 if (!battery->bat.dev)
732 return;
733
734 power_unit = battery->power_unit;
735
736 acpi_battery_get_info(battery);
737
738 if (power_unit == battery->power_unit)
739 return;
740
741 /* The battery has changed its reporting units. */
742 sysfs_remove_battery(battery);
743 sysfs_add_battery(battery);
744}
745
746/* --------------------------------------------------------------------------
747 FS Interface (/proc)
748 -------------------------------------------------------------------------- */
749
750#ifdef CONFIG_ACPI_PROCFS_POWER
751static struct proc_dir_entry *acpi_battery_dir;
752
753static int acpi_battery_print_info(struct seq_file *seq, int result)
754{
755 struct acpi_battery *battery = seq->private;
756
757 if (result)
758 goto end;
759
760 seq_printf(seq, "present: %s\n",
761 acpi_battery_present(battery) ? "yes" : "no");
762 if (!acpi_battery_present(battery))
763 goto end;
764 if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
765 seq_printf(seq, "design capacity: unknown\n");
766 else
767 seq_printf(seq, "design capacity: %d %sh\n",
768 battery->design_capacity,
769 acpi_battery_units(battery));
770
771 if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
772 seq_printf(seq, "last full capacity: unknown\n");
773 else
774 seq_printf(seq, "last full capacity: %d %sh\n",
775 battery->full_charge_capacity,
776 acpi_battery_units(battery));
777
778 seq_printf(seq, "battery technology: %srechargeable\n",
779 (!battery->technology)?"non-":"");
780
781 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
782 seq_printf(seq, "design voltage: unknown\n");
783 else
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);
803 end:
804 if (result)
805 seq_printf(seq, "ERROR: Unable to read battery info\n");
806 return result;
807}
808
809static int acpi_battery_print_state(struct seq_file *seq, int result)
810{
811 struct acpi_battery *battery = seq->private;
812
813 if (result)
814 goto end;
815
816 seq_printf(seq, "present: %s\n",
817 acpi_battery_present(battery) ? "yes" : "no");
818 if (!acpi_battery_present(battery))
819 goto end;
820
821 seq_printf(seq, "capacity state: %s\n",
822 (battery->state & 0x04) ? "critical" : "ok");
823 if ((battery->state & 0x01) && (battery->state & 0x02))
824 seq_printf(seq,
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");
830 else
831 seq_printf(seq, "charging state: charged\n");
832
833 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
834 seq_printf(seq, "present rate: unknown\n");
835 else
836 seq_printf(seq, "present rate: %d %s\n",
837 battery->rate_now, acpi_battery_units(battery));
838
839 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
840 seq_printf(seq, "remaining capacity: unknown\n");
841 else
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");
846 else
847 seq_printf(seq, "present voltage: %d mV\n",
848 battery->voltage_now);
849 end:
850 if (result)
851 seq_printf(seq, "ERROR: Unable to read battery state\n");
852
853 return result;
854}
855
856static int acpi_battery_print_alarm(struct seq_file *seq, int result)
857{
858 struct acpi_battery *battery = seq->private;
859
860 if (result)
861 goto end;
862
863 if (!acpi_battery_present(battery)) {
864 seq_printf(seq, "present: no\n");
865 goto end;
866 }
867 seq_printf(seq, "alarm: ");
868 if (!battery->alarm)
869 seq_printf(seq, "unsupported\n");
870 else
871 seq_printf(seq, "%u %sh\n", battery->alarm,
872 acpi_battery_units(battery));
873 end:
874 if (result)
875 seq_printf(seq, "ERROR: Unable to read battery alarm\n");
876 return result;
877}
878
879static ssize_t acpi_battery_write_alarm(struct file *file,
880 const char __user * buffer,
881 size_t count, loff_t * ppos)
882{
883 int result = 0;
884 char alarm_string[12] = { '\0' };
885 struct seq_file *m = file->private_data;
886 struct acpi_battery *battery = m->private;
887
888 if (!battery || (count > sizeof(alarm_string) - 1))
889 return -EINVAL;
890 if (!acpi_battery_present(battery)) {
891 result = -ENODEV;
892 goto end;
893 }
894 if (copy_from_user(alarm_string, buffer, count)) {
895 result = -EFAULT;
896 goto end;
897 }
898 alarm_string[count] = '\0';
899 battery->alarm = simple_strtol(alarm_string, NULL, 0);
900 result = acpi_battery_set_alarm(battery);
901 end:
902 if (!result)
903 return count;
904 return result;
905}
906
907typedef int(*print_func)(struct seq_file *seq, int result);
908
909static print_func acpi_print_funcs[ACPI_BATTERY_NUMFILES] = {
910 acpi_battery_print_info,
911 acpi_battery_print_state,
912 acpi_battery_print_alarm,
913};
914
915static int acpi_battery_read(int fid, struct seq_file *seq)
916{
917 struct acpi_battery *battery = seq->private;
918 int result = acpi_battery_update(battery);
919 return acpi_print_funcs[fid](seq, result);
920}
921
922#define DECLARE_FILE_FUNCTIONS(_name) \
923static int acpi_battery_read_##_name(struct seq_file *seq, void *offset) \
924{ \
925 return acpi_battery_read(_name##_tag, seq); \
926} \
927static int acpi_battery_##_name##_open_fs(struct inode *inode, struct file *file) \
928{ \
929 return single_open(file, acpi_battery_read_##_name, PDE_DATA(inode)); \
930}
931
932DECLARE_FILE_FUNCTIONS(info);
933DECLARE_FILE_FUNCTIONS(state);
934DECLARE_FILE_FUNCTIONS(alarm);
935
936#undef DECLARE_FILE_FUNCTIONS
937
938#define FILE_DESCRIPTION_RO(_name) \
939 { \
940 .name = __stringify(_name), \
941 .mode = S_IRUGO, \
942 .ops = { \
943 .open = acpi_battery_##_name##_open_fs, \
944 .read = seq_read, \
945 .llseek = seq_lseek, \
946 .release = single_release, \
947 .owner = THIS_MODULE, \
948 }, \
949 }
950
951#define FILE_DESCRIPTION_RW(_name) \
952 { \
953 .name = __stringify(_name), \
954 .mode = S_IFREG | S_IRUGO | S_IWUSR, \
955 .ops = { \
956 .open = acpi_battery_##_name##_open_fs, \
957 .read = seq_read, \
958 .llseek = seq_lseek, \
959 .write = acpi_battery_write_##_name, \
960 .release = single_release, \
961 .owner = THIS_MODULE, \
962 }, \
963 }
964
965static const struct battery_file {
966 struct file_operations ops;
967 umode_t mode;
968 const char *name;
969} acpi_battery_file[] = {
970 FILE_DESCRIPTION_RO(info),
971 FILE_DESCRIPTION_RO(state),
972 FILE_DESCRIPTION_RW(alarm),
973};
974
975#undef FILE_DESCRIPTION_RO
976#undef FILE_DESCRIPTION_RW
977
978static int acpi_battery_add_fs(struct acpi_device *device)
979{
980 struct proc_dir_entry *entry = NULL;
981 int i;
982
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),
987 acpi_battery_dir);
988 if (!acpi_device_dir(device))
989 return -ENODEV;
990 }
991
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));
998 if (!entry)
999 return -ENODEV;
1000 }
1001 return 0;
1002}
1003
1004static void acpi_battery_remove_fs(struct acpi_device *device)
1005{
1006 int i;
1007 if (!acpi_device_dir(device))
1008 return;
1009 for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i)
1010 remove_proc_entry(acpi_battery_file[i].name,
1011 acpi_device_dir(device));
1012
1013 remove_proc_entry(acpi_device_bid(device), acpi_battery_dir);
1014 acpi_device_dir(device) = NULL;
1015}
1016
1017#endif
1018
1019/* --------------------------------------------------------------------------
1020 Driver Interface
1021 -------------------------------------------------------------------------- */
1022
1023static void acpi_battery_notify(struct acpi_device *device, u32 event)
1024{
1025 struct acpi_battery *battery = acpi_driver_data(device);
1026 struct device *old;
1027
1028 if (!battery)
1029 return;
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);
1041}
1042
1043static int battery_notify(struct notifier_block *nb,
1044 unsigned long mode, void *_unused)
1045{
1046 struct acpi_battery *battery = container_of(nb, struct acpi_battery,
1047 pm_nb);
1048 switch (mode) {
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);
1054 }
1055 break;
1056 }
1057
1058 return 0;
1059}
1060
1061static struct dmi_system_id bat_dmi_table[] = {
1062 {
1063 .ident = "NEC LZ750/LS",
1064 .matches = {
1065 DMI_MATCH(DMI_SYS_VENDOR, "NEC"),
1066 DMI_MATCH(DMI_PRODUCT_NAME, "PC-LZ750LS"),
1067 },
1068 },
1069 {},
1070};
1071
1072static int acpi_battery_add(struct acpi_device *device)
1073{
1074 int result = 0;
1075 struct acpi_battery *battery = NULL;
1076
1077 if (!device)
1078 return -EINVAL;
1079 battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL);
1080 if (!battery)
1081 return -ENOMEM;
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);
1091 if (result)
1092 goto fail;
1093#ifdef CONFIG_ACPI_PROCFS_POWER
1094 result = acpi_battery_add_fs(device);
1095#endif
1096 if (result) {
1097#ifdef CONFIG_ACPI_PROCFS_POWER
1098 acpi_battery_remove_fs(device);
1099#endif
1100 goto fail;
1101 }
1102
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");
1106
1107 battery->pm_nb.notifier_call = battery_notify;
1108 register_pm_notifier(&battery->pm_nb);
1109
1110 return result;
1111
1112fail:
1113 sysfs_remove_battery(battery);
1114 mutex_destroy(&battery->lock);
1115 mutex_destroy(&battery->sysfs_lock);
1116 kfree(battery);
1117 return result;
1118}
1119
1120static int acpi_battery_remove(struct acpi_device *device)
1121{
1122 struct acpi_battery *battery = NULL;
1123
1124 if (!device || !acpi_driver_data(device))
1125 return -EINVAL;
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);
1130#endif
1131 sysfs_remove_battery(battery);
1132 mutex_destroy(&battery->lock);
1133 mutex_destroy(&battery->sysfs_lock);
1134 kfree(battery);
1135 return 0;
1136}
1137
1138#ifdef CONFIG_PM_SLEEP
1139/* this is needed to learn about changes made in suspended state */
1140static int acpi_battery_resume(struct device *dev)
1141{
1142 struct acpi_battery *battery;
1143
1144 if (!dev)
1145 return -EINVAL;
1146
1147 battery = acpi_driver_data(to_acpi_device(dev));
1148 if (!battery)
1149 return -EINVAL;
1150
1151 battery->update_time = 0;
1152 acpi_battery_update(battery);
1153 return 0;
1154}
1155#else
1156#define acpi_battery_resume NULL
1157#endif
1158
1159static SIMPLE_DEV_PM_OPS(acpi_battery_pm, NULL, acpi_battery_resume);
1160
1161static struct acpi_driver acpi_battery_driver = {
1162 .name = "battery",
1163 .class = ACPI_BATTERY_CLASS,
1164 .ids = battery_device_ids,
1165 .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
1166 .ops = {
1167 .add = acpi_battery_add,
1168 .remove = acpi_battery_remove,
1169 .notify = acpi_battery_notify,
1170 },
1171 .drv.pm = &acpi_battery_pm,
1172};
1173
1174static void __init acpi_battery_init_async(void *unused, async_cookie_t cookie)
1175{
1176 if (acpi_disabled)
1177 return;
1178
1179 if (dmi_check_system(bat_dmi_table))
1180 battery_bix_broken_package = 1;
1181
1182#ifdef CONFIG_ACPI_PROCFS_POWER
1183 acpi_battery_dir = acpi_lock_battery_dir();
1184 if (!acpi_battery_dir)
1185 return;
1186#endif
1187 if (acpi_bus_register_driver(&acpi_battery_driver) < 0) {
1188#ifdef CONFIG_ACPI_PROCFS_POWER
1189 acpi_unlock_battery_dir(acpi_battery_dir);
1190#endif
1191 return;
1192 }
1193 return;
1194}
1195
1196static int __init acpi_battery_init(void)
1197{
1198 async_schedule(acpi_battery_init_async, NULL);
1199 return 0;
1200}
1201
1202static void __exit acpi_battery_exit(void)
1203{
1204 acpi_bus_unregister_driver(&acpi_battery_driver);
1205#ifdef CONFIG_ACPI_PROCFS_POWER
1206 acpi_unlock_battery_dir(acpi_battery_dir);
1207#endif
1208}
1209
1210module_init(acpi_battery_init);
1211module_exit(acpi_battery_exit);