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