drivers/acpi/battery.c

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