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