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