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