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