drivers/acpi/battery.c

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