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