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