drivers/acpi/battery.c

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