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