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