drivers/acpi/battery.c

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