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