drivers/acpi/battery.c

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