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