drivers/acpi/battery.c

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