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