drivers/acpi/battery.c

   1 /*
   2  *  battery.c - ACPI Battery Driver (Revision: 2.0)
   3  *
   4  *  Copyright (C) 2007 Alexey Starikovskiy <astarikovskiy@suse.de>
   5  *  Copyright (C) 2004-2007 Vladimir Lebedev <vladimir.p.lebedev@intel.com>
   6  *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
   7  *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
   8  *
   9  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  10  *
  11  *  This program is free software; you can redistribute it and/or modify
  12  *  it under the terms of the GNU General Public License as published by
  13  *  the Free Software Foundation; either version 2 of the License, or (at
  14  *  your option) any later version.
  15  *
  16  *  This program is distributed in the hope that it will be useful, but
  17  *  WITHOUT ANY WARRANTY; without even the implied warranty of
  18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  *  General Public License for more details.
  20  *
  21  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  22  */
  23
  24 #include <linux/kernel.h>
  25 #include <linux/module.h>
  26 #include <linux/init.h>
  27 #include <linux/types.h>
  28 #include <linux/jiffies.h>
  29 #include <linux/async.h>
  30 #include <linux/dmi.h>
  31 #include <linux/delay.h>
  32 #include <linux/slab.h>
  33 #include <linux/suspend.h>
  34 #include <asm/unaligned.h>
  35
  36 #ifdef CONFIG_ACPI_PROCFS_POWER
  37 #include <linux/proc_fs.h>
  38 #include <linux/seq_file.h>
  39 #include <asm/uaccess.h>
  40 #endif
  41
  42 #include <linux/acpi.h>
  43 #include <linux/power_supply.h>
  44
  45 #include "battery.h"
  46
  47 #define PREFIX "ACPI: "
  48
  49 #define ACPI_BATTERY_VALUE_UNKNOWN 0xFFFFFFFF
  50
  51 #define ACPI_BATTERY_DEVICE_NAME        "Battery"
  52
  53 /* Battery power unit: 0 means mW, 1 means mA */
  54 #define ACPI_BATTERY_POWER_UNIT_MA      1
  55
  56 #define ACPI_BATTERY_STATE_DISCHARGING  0x1
  57 #define ACPI_BATTERY_STATE_CHARGING     0x2
  58 #define ACPI_BATTERY_STATE_CRITICAL     0x4
  59
  60 #define _COMPONENT              ACPI_BATTERY_COMPONENT
  61
  62 ACPI_MODULE_NAME("battery");
  63
  64 MODULE_AUTHOR("Paul Diefenbaugh");
  65 MODULE_AUTHOR("Alexey Starikovskiy <astarikovskiy@suse.de>");
  66 MODULE_DESCRIPTION("ACPI Battery Driver");
  67 MODULE_LICENSE("GPL");
  68
  69 static async_cookie_t async_cookie;
  70 static int battery_bix_broken_package;
  71 static int battery_notification_delay_ms;
  72 static unsigned int cache_time = 1000;
  73 module_param(cache_time, uint, 0644);
  74 MODULE_PARM_DESC(cache_time, "cache time in milliseconds");
  75
  76 #ifdef CONFIG_ACPI_PROCFS_POWER
  77 extern struct proc_dir_entry *acpi_lock_battery_dir(void);
  78 extern void *acpi_unlock_battery_dir(struct proc_dir_entry *acpi_battery_dir);
  79
  80 enum acpi_battery_files {
  81         info_tag = 0,
  82         state_tag,
  83         alarm_tag,
  84         ACPI_BATTERY_NUMFILES,
  85 };
  86
  87 #endif
  88
  89 static const struct acpi_device_id battery_device_ids[] = {
  90         {"PNP0C0A", 0},
  91         {"", 0},
  92 };
  93
  94 MODULE_DEVICE_TABLE(acpi, battery_device_ids);
  95
  96 enum {
  97         ACPI_BATTERY_ALARM_PRESENT,
  98         ACPI_BATTERY_XINFO_PRESENT,
  99         ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY,
 100         /* On Lenovo Thinkpad models from 2010 and 2011, the power unit
 101            switches between mWh and mAh depending on whether the system
 102            is running on battery or not.  When mAh is the unit, most
 103            reported values are incorrect and need to be adjusted by
 104            10000/design_voltage.  Verified on x201, t410, t410s, and x220.
 105            Pre-2010 and 2012 models appear to always report in mWh and
 106            are thus unaffected (tested with t42, t61, t500, x200, x300,
 107            and x230).  Also, in mid-2012 Lenovo issued a BIOS update for
 108            the 2011 models that fixes the issue (tested on x220 with a
 109            post-1.29 BIOS), but as of Nov. 2012, no such update is
 110            available for the 2010 models.  */
 111         ACPI_BATTERY_QUIRK_THINKPAD_MAH,
 112 };
 113
 114 struct acpi_battery {
 115         struct mutex lock;
 116         struct mutex sysfs_lock;
 117         struct power_supply *bat;
 118         struct power_supply_desc bat_desc;
 119         struct acpi_device *device;
 120         struct notifier_block pm_nb;
 121         unsigned long update_time;
 122         int revision;
 123         int rate_now;
 124         int capacity_now;
 125         int voltage_now;
 126         int design_capacity;
 127         int full_charge_capacity;
 128         int technology;
 129         int design_voltage;
 130         int design_capacity_warning;
 131         int design_capacity_low;
 132         int cycle_count;
 133         int measurement_accuracy;
 134         int max_sampling_time;
 135         int min_sampling_time;
 136         int max_averaging_interval;
 137         int min_averaging_interval;
 138         int capacity_granularity_1;
 139         int capacity_granularity_2;
 140         int alarm;
 141         char model_number[32];
 142         char serial_number[32];
 143         char type[32];
 144         char oem_info[32];
 145         int state;
 146         int power_unit;
 147         unsigned long flags;
 148 };
 149
 150 #define to_acpi_battery(x) power_supply_get_drvdata(x)
 151
 152 static inline int acpi_battery_present(struct acpi_battery *battery)
 153 {
 154         return battery->device->status.battery_present;
 155 }
 156
 157 static int acpi_battery_technology(struct acpi_battery *battery)
 158 {
 159         if (!strcasecmp("NiCd", battery->type))
 160                 return POWER_SUPPLY_TECHNOLOGY_NiCd;
 161         if (!strcasecmp("NiMH", battery->type))
 162                 return POWER_SUPPLY_TECHNOLOGY_NiMH;
 163         if (!strcasecmp("LION", battery->type))
 164                 return POWER_SUPPLY_TECHNOLOGY_LION;
 165         if (!strncasecmp("LI-ION", battery->type, 6))
 166                 return POWER_SUPPLY_TECHNOLOGY_LION;
 167         if (!strcasecmp("LiP", battery->type))
 168                 return POWER_SUPPLY_TECHNOLOGY_LIPO;
 169         return POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
 170 }
 171
 172 static int acpi_battery_get_state(struct acpi_battery *battery);
 173
 174 static int acpi_battery_is_charged(struct acpi_battery *battery)
 175 {
 176         /* charging, discharging or critical low */
 177         if (battery->state != 0)
 178                 return 0;
 179
 180         /* battery not reporting charge */
 181         if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN ||
 182             battery->capacity_now == 0)
 183                 return 0;
 184
 185         /* good batteries update full_charge as the batteries degrade */
 186         if (battery->full_charge_capacity == battery->capacity_now)
 187                 return 1;
 188
 189         /* fallback to using design values for broken batteries */
 190         if (battery->design_capacity == battery->capacity_now)
 191                 return 1;
 192
 193         /* we don't do any sort of metric based on percentages */
 194         return 0;
 195 }
 196
 197 static int acpi_battery_get_property(struct power_supply *psy,
 198                                      enum power_supply_property psp,
 199                                      union power_supply_propval *val)
 200 {
 201         int ret = 0;
 202         struct acpi_battery *battery = to_acpi_battery(psy);
 203
 204         if (acpi_battery_present(battery)) {
 205                 /* run battery update only if it is present */
 206                 acpi_battery_get_state(battery);
 207         } else if (psp != POWER_SUPPLY_PROP_PRESENT)
 208                 return -ENODEV;
 209         switch (psp) {
 210         case POWER_SUPPLY_PROP_STATUS:
 211                 if (battery->state & ACPI_BATTERY_STATE_DISCHARGING)
 212                         val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
 213                 else if (battery->state & ACPI_BATTERY_STATE_CHARGING)
 214                         val->intval = POWER_SUPPLY_STATUS_CHARGING;
 215                 else if (acpi_battery_is_charged(battery))
 216                         val->intval = POWER_SUPPLY_STATUS_FULL;
 217                 else
 218                         val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
 219                 break;
 220         case POWER_SUPPLY_PROP_PRESENT:
 221                 val->intval = acpi_battery_present(battery);
 222                 break;
 223         case POWER_SUPPLY_PROP_TECHNOLOGY:
 224                 val->intval = acpi_battery_technology(battery);
 225                 break;
 226         case POWER_SUPPLY_PROP_CYCLE_COUNT:
 227                 val->intval = battery->cycle_count;
 228                 break;
 229         case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
 230                 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
 231                         ret = -ENODEV;
 232                 else
 233                         val->intval = battery->design_voltage * 1000;
 234                 break;
 235         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 236                 if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
 237                         ret = -ENODEV;
 238                 else
 239                         val->intval = battery->voltage_now * 1000;
 240                 break;
 241         case POWER_SUPPLY_PROP_CURRENT_NOW:
 242         case POWER_SUPPLY_PROP_POWER_NOW:
 243                 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
 244                         ret = -ENODEV;
 245                 else
 246                         val->intval = battery->rate_now * 1000;
 247                 break;
 248         case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
 249         case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
 250                 if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
 251                         ret = -ENODEV;
 252                 else
 253                         val->intval = battery->design_capacity * 1000;
 254                 break;
 255         case POWER_SUPPLY_PROP_CHARGE_FULL:
 256         case POWER_SUPPLY_PROP_ENERGY_FULL:
 257                 if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
 258                         ret = -ENODEV;
 259                 else
 260                         val->intval = battery->full_charge_capacity * 1000;
 261                 break;
 262         case POWER_SUPPLY_PROP_CHARGE_NOW:
 263         case POWER_SUPPLY_PROP_ENERGY_NOW:
 264                 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
 265                         ret = -ENODEV;
 266                 else
 267                         val->intval = battery->capacity_now * 1000;
 268                 break;
 269         case POWER_SUPPLY_PROP_CAPACITY:
 270                 if (battery->capacity_now && battery->full_charge_capacity)
 271                         val->intval = battery->capacity_now * 100/
 272                                         battery->full_charge_capacity;
 273                 else
 274                         val->intval = 0;
 275                 break;
 276         case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
 277                 if (battery->state & ACPI_BATTERY_STATE_CRITICAL)
 278                         val->intval = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
 279                 else if (test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags) &&
 280                         (battery->capacity_now <= battery->alarm))
 281                         val->intval = POWER_SUPPLY_CAPACITY_LEVEL_LOW;
 282                 else if (acpi_battery_is_charged(battery))
 283                         val->intval = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
 284                 else
 285                         val->intval = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
 286                 break;
 287         case POWER_SUPPLY_PROP_MODEL_NAME:
 288                 val->strval = battery->model_number;
 289                 break;
 290         case POWER_SUPPLY_PROP_MANUFACTURER:
 291                 val->strval = battery->oem_info;
 292                 break;
 293         case POWER_SUPPLY_PROP_SERIAL_NUMBER:
 294                 val->strval = battery->serial_number;
 295                 break;
 296         default:
 297                 ret = -EINVAL;
 298         }
 299         return ret;
 300 }
 301
 302 static enum power_supply_property charge_battery_props[] = {
 303         POWER_SUPPLY_PROP_STATUS,
 304         POWER_SUPPLY_PROP_PRESENT,
 305         POWER_SUPPLY_PROP_TECHNOLOGY,
 306         POWER_SUPPLY_PROP_CYCLE_COUNT,
 307         POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
 308         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 309         POWER_SUPPLY_PROP_CURRENT_NOW,
 310         POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
 311         POWER_SUPPLY_PROP_CHARGE_FULL,
 312         POWER_SUPPLY_PROP_CHARGE_NOW,
 313         POWER_SUPPLY_PROP_CAPACITY,
 314         POWER_SUPPLY_PROP_CAPACITY_LEVEL,
 315         POWER_SUPPLY_PROP_MODEL_NAME,
 316         POWER_SUPPLY_PROP_MANUFACTURER,
 317         POWER_SUPPLY_PROP_SERIAL_NUMBER,
 318 };
 319
 320 static enum power_supply_property energy_battery_props[] = {
 321         POWER_SUPPLY_PROP_STATUS,
 322         POWER_SUPPLY_PROP_PRESENT,
 323         POWER_SUPPLY_PROP_TECHNOLOGY,
 324         POWER_SUPPLY_PROP_CYCLE_COUNT,
 325         POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
 326         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 327         POWER_SUPPLY_PROP_POWER_NOW,
 328         POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
 329         POWER_SUPPLY_PROP_ENERGY_FULL,
 330         POWER_SUPPLY_PROP_ENERGY_NOW,
 331         POWER_SUPPLY_PROP_CAPACITY,
 332         POWER_SUPPLY_PROP_CAPACITY_LEVEL,
 333         POWER_SUPPLY_PROP_MODEL_NAME,
 334         POWER_SUPPLY_PROP_MANUFACTURER,
 335         POWER_SUPPLY_PROP_SERIAL_NUMBER,
 336 };
 337
 338 /* --------------------------------------------------------------------------
 339                                Battery Management
 340    -------------------------------------------------------------------------- */
 341 struct acpi_offsets {
 342         size_t offset;          /* offset inside struct acpi_sbs_battery */
 343         u8 mode;                /* int or string? */
 344 };
 345
 346 static const struct acpi_offsets state_offsets[] = {
 347         {offsetof(struct acpi_battery, state), 0},
 348         {offsetof(struct acpi_battery, rate_now), 0},
 349         {offsetof(struct acpi_battery, capacity_now), 0},
 350         {offsetof(struct acpi_battery, voltage_now), 0},
 351 };
 352
 353 static const struct acpi_offsets info_offsets[] = {
 354         {offsetof(struct acpi_battery, power_unit), 0},
 355         {offsetof(struct acpi_battery, design_capacity), 0},
 356         {offsetof(struct acpi_battery, full_charge_capacity), 0},
 357         {offsetof(struct acpi_battery, technology), 0},
 358         {offsetof(struct acpi_battery, design_voltage), 0},
 359         {offsetof(struct acpi_battery, design_capacity_warning), 0},
 360         {offsetof(struct acpi_battery, design_capacity_low), 0},
 361         {offsetof(struct acpi_battery, capacity_granularity_1), 0},
 362         {offsetof(struct acpi_battery, capacity_granularity_2), 0},
 363         {offsetof(struct acpi_battery, model_number), 1},
 364         {offsetof(struct acpi_battery, serial_number), 1},
 365         {offsetof(struct acpi_battery, type), 1},
 366         {offsetof(struct acpi_battery, oem_info), 1},
 367 };
 368
 369 static const struct acpi_offsets extended_info_offsets[] = {
 370         {offsetof(struct acpi_battery, revision), 0},
 371         {offsetof(struct acpi_battery, power_unit), 0},
 372         {offsetof(struct acpi_battery, design_capacity), 0},
 373         {offsetof(struct acpi_battery, full_charge_capacity), 0},
 374         {offsetof(struct acpi_battery, technology), 0},
 375         {offsetof(struct acpi_battery, design_voltage), 0},
 376         {offsetof(struct acpi_battery, design_capacity_warning), 0},
 377         {offsetof(struct acpi_battery, design_capacity_low), 0},
 378         {offsetof(struct acpi_battery, cycle_count), 0},
 379         {offsetof(struct acpi_battery, measurement_accuracy), 0},
 380         {offsetof(struct acpi_battery, max_sampling_time), 0},
 381         {offsetof(struct acpi_battery, min_sampling_time), 0},
 382         {offsetof(struct acpi_battery, max_averaging_interval), 0},
 383         {offsetof(struct acpi_battery, min_averaging_interval), 0},
 384         {offsetof(struct acpi_battery, capacity_granularity_1), 0},
 385         {offsetof(struct acpi_battery, capacity_granularity_2), 0},
 386         {offsetof(struct acpi_battery, model_number), 1},
 387         {offsetof(struct acpi_battery, serial_number), 1},
 388         {offsetof(struct acpi_battery, type), 1},
 389         {offsetof(struct acpi_battery, oem_info), 1},
 390 };
 391
 392 static int extract_package(struct acpi_battery *battery,
 393                            union acpi_object *package,
 394                            const struct acpi_offsets *offsets, int num)
 395 {
 396         int i;
 397         union acpi_object *element;
 398         if (package->type != ACPI_TYPE_PACKAGE)
 399                 return -EFAULT;
 400         for (i = 0; i < num; ++i) {
 401                 if (package->package.count <= i)
 402                         return -EFAULT;
 403                 element = &package->package.elements[i];
 404                 if (offsets[i].mode) {
 405                         u8 *ptr = (u8 *)battery + offsets[i].offset;
 406                         if (element->type == ACPI_TYPE_STRING ||
 407                             element->type == ACPI_TYPE_BUFFER)
 408                                 strncpy(ptr, element->string.pointer, 32);
 409                         else if (element->type == ACPI_TYPE_INTEGER) {
 410                                 strncpy(ptr, (u8 *)&element->integer.value,
 411                                         sizeof(u64));
 412                                 ptr[sizeof(u64)] = 0;
 413                         } else
 414                                 *ptr = 0; /* don't have value */
 415                 } else {
 416                         int *x = (int *)((u8 *)battery + offsets[i].offset);
 417                         *x = (element->type == ACPI_TYPE_INTEGER) ?
 418                                 element->integer.value : -1;
 419                 }
 420         }
 421         return 0;
 422 }
 423
 424 static int acpi_battery_get_status(struct acpi_battery *battery)
 425 {
 426         if (acpi_bus_get_status(battery->device)) {
 427                 ACPI_EXCEPTION((AE_INFO, AE_ERROR, "Evaluating _STA"));
 428                 return -ENODEV;
 429         }
 430         return 0;
 431 }
 432
 433 static int acpi_battery_get_info(struct acpi_battery *battery)
 434 {
 435         int result = -EFAULT;
 436         acpi_status status = 0;
 437         char *name = test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags) ?
 438                         "_BIX" : "_BIF";
 439
 440         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 441
 442         if (!acpi_battery_present(battery))
 443                 return 0;
 444         mutex_lock(&battery->lock);
 445         status = acpi_evaluate_object(battery->device->handle, name,
 446                                                 NULL, &buffer);
 447         mutex_unlock(&battery->lock);
 448
 449         if (ACPI_FAILURE(status)) {
 450                 ACPI_EXCEPTION((AE_INFO, status, "Evaluating %s", name));
 451                 return -ENODEV;
 452         }
 453
 454         if (battery_bix_broken_package)
 455                 result = extract_package(battery, buffer.pointer,
 456                                 extended_info_offsets + 1,
 457                                 ARRAY_SIZE(extended_info_offsets) - 1);
 458         else if (test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags))
 459                 result = extract_package(battery, buffer.pointer,
 460                                 extended_info_offsets,
 461                                 ARRAY_SIZE(extended_info_offsets));
 462         else
 463                 result = extract_package(battery, buffer.pointer,
 464                                 info_offsets, ARRAY_SIZE(info_offsets));
 465         kfree(buffer.pointer);
 466         if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
 467                 battery->full_charge_capacity = battery->design_capacity;
 468         if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
 469             battery->power_unit && battery->design_voltage) {
 470                 battery->design_capacity = battery->design_capacity *
 471                     10000 / battery->design_voltage;
 472                 battery->full_charge_capacity = battery->full_charge_capacity *
 473                     10000 / battery->design_voltage;
 474                 battery->design_capacity_warning =
 475                     battery->design_capacity_warning *
 476                     10000 / battery->design_voltage;
 477                 /* Curiously, design_capacity_low, unlike the rest of them,
 478                    is correct.  */
 479                 /* capacity_granularity_* equal 1 on the systems tested, so
 480                    it's impossible to tell if they would need an adjustment
 481                    or not if their values were higher.  */
 482         }
 483         return result;
 484 }
 485
 486 static int acpi_battery_get_state(struct acpi_battery *battery)
 487 {
 488         int result = 0;
 489         acpi_status status = 0;
 490         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 491
 492         if (!acpi_battery_present(battery))
 493                 return 0;
 494
 495         if (battery->update_time &&
 496             time_before(jiffies, battery->update_time +
 497                         msecs_to_jiffies(cache_time)))
 498                 return 0;
 499
 500         mutex_lock(&battery->lock);
 501         status = acpi_evaluate_object(battery->device->handle, "_BST",
 502                                       NULL, &buffer);
 503         mutex_unlock(&battery->lock);
 504
 505         if (ACPI_FAILURE(status)) {
 506                 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BST"));
 507                 return -ENODEV;
 508         }
 509
 510         result = extract_package(battery, buffer.pointer,
 511                                  state_offsets, ARRAY_SIZE(state_offsets));
 512         battery->update_time = jiffies;
 513         kfree(buffer.pointer);
 514
 515         /* For buggy DSDTs that report negative 16-bit values for either
 516          * charging or discharging current and/or report 0 as 65536
 517          * due to bad math.
 518          */
 519         if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA &&
 520                 battery->rate_now != ACPI_BATTERY_VALUE_UNKNOWN &&
 521                 (s16)(battery->rate_now) < 0) {
 522                 battery->rate_now = abs((s16)battery->rate_now);
 523                 printk_once(KERN_WARNING FW_BUG
 524                             "battery: (dis)charge rate invalid.\n");
 525         }
 526
 527         if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags)
 528             && battery->capacity_now >= 0 && battery->capacity_now <= 100)
 529                 battery->capacity_now = (battery->capacity_now *
 530                                 battery->full_charge_capacity) / 100;
 531         if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
 532             battery->power_unit && battery->design_voltage) {
 533                 battery->capacity_now = battery->capacity_now *
 534                     10000 / battery->design_voltage;
 535         }
 536         return result;
 537 }
 538
 539 static int acpi_battery_set_alarm(struct acpi_battery *battery)
 540 {
 541         acpi_status status = 0;
 542
 543         if (!acpi_battery_present(battery) ||
 544             !test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags))
 545                 return -ENODEV;
 546
 547         mutex_lock(&battery->lock);
 548         status = acpi_execute_simple_method(battery->device->handle, "_BTP",
 549                                             battery->alarm);
 550         mutex_unlock(&battery->lock);
 551
 552         if (ACPI_FAILURE(status))
 553                 return -ENODEV;
 554
 555         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Alarm set to %d\n", battery->alarm));
 556         return 0;
 557 }
 558
 559 static int acpi_battery_init_alarm(struct acpi_battery *battery)
 560 {
 561         /* See if alarms are supported, and if so, set default */
 562         if (!acpi_has_method(battery->device->handle, "_BTP")) {
 563                 clear_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
 564                 return 0;
 565         }
 566         set_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
 567         if (!battery->alarm)
 568                 battery->alarm = battery->design_capacity_warning;
 569         return acpi_battery_set_alarm(battery);
 570 }
 571
 572 static ssize_t acpi_battery_alarm_show(struct device *dev,
 573                                         struct device_attribute *attr,
 574                                         char *buf)
 575 {
 576         struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
 577         return sprintf(buf, "%d\n", battery->alarm * 1000);
 578 }
 579
 580 static ssize_t acpi_battery_alarm_store(struct device *dev,
 581                                         struct device_attribute *attr,
 582                                         const char *buf, size_t count)
 583 {
 584         unsigned long x;
 585         struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
 586         if (sscanf(buf, "%lu\n", &x) == 1)
 587                 battery->alarm = x/1000;
 588         if (acpi_battery_present(battery))
 589                 acpi_battery_set_alarm(battery);
 590         return count;
 591 }
 592
 593 static struct device_attribute alarm_attr = {
 594         .attr = {.name = "alarm", .mode = 0644},
 595         .show = acpi_battery_alarm_show,
 596         .store = acpi_battery_alarm_store,
 597 };
 598
 599 static int sysfs_add_battery(struct acpi_battery *battery)
 600 {
 601         struct power_supply_config psy_cfg = { .drv_data = battery, };
 602
 603         if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) {
 604                 battery->bat_desc.properties = charge_battery_props;
 605                 battery->bat_desc.num_properties =
 606                         ARRAY_SIZE(charge_battery_props);
 607         } else {
 608                 battery->bat_desc.properties = energy_battery_props;
 609                 battery->bat_desc.num_properties =
 610                         ARRAY_SIZE(energy_battery_props);
 611         }
 612
 613         battery->bat_desc.name = acpi_device_bid(battery->device);
 614         battery->bat_desc.type = POWER_SUPPLY_TYPE_BATTERY;
 615         battery->bat_desc.get_property = acpi_battery_get_property;
 616
 617         battery->bat = power_supply_register_no_ws(&battery->device->dev,
 618                                 &battery->bat_desc, &psy_cfg);
 619
 620         if (IS_ERR(battery->bat)) {
 621                 int result = PTR_ERR(battery->bat);
 622
 623                 battery->bat = NULL;
 624                 return result;
 625         }
 626         return device_create_file(&battery->bat->dev, &alarm_attr);
 627 }
 628
 629 static void sysfs_remove_battery(struct acpi_battery *battery)
 630 {
 631         mutex_lock(&battery->sysfs_lock);
 632         if (!battery->bat) {
 633                 mutex_unlock(&battery->sysfs_lock);
 634                 return;
 635         }
 636
 637         device_remove_file(&battery->bat->dev, &alarm_attr);
 638         power_supply_unregister(battery->bat);
 639         battery->bat = NULL;
 640         mutex_unlock(&battery->sysfs_lock);
 641 }
 642
 643 static void find_battery(const struct dmi_header *dm, void *private)
 644 {
 645         struct acpi_battery *battery = (struct acpi_battery *)private;
 646         /* Note: the hardcoded offsets below have been extracted from
 647            the source code of dmidecode.  */
 648         if (dm->type == DMI_ENTRY_PORTABLE_BATTERY && dm->length >= 8) {
 649                 const u8 *dmi_data = (const u8 *)(dm + 1);
 650                 int dmi_capacity = get_unaligned((const u16 *)(dmi_data + 6));
 651                 if (dm->length >= 18)
 652                         dmi_capacity *= dmi_data[17];
 653                 if (battery->design_capacity * battery->design_voltage / 1000
 654                     != dmi_capacity &&
 655                     battery->design_capacity * 10 == dmi_capacity)
 656                         set_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
 657                                 &battery->flags);
 658         }
 659 }
 660
 661 /*
 662  * According to the ACPI spec, some kinds of primary batteries can
 663  * report percentage battery remaining capacity directly to OS.
 664  * In this case, it reports the Last Full Charged Capacity == 100
 665  * and BatteryPresentRate == 0xFFFFFFFF.
 666  *
 667  * Now we found some battery reports percentage remaining capacity
 668  * even if it's rechargeable.
 669  * https://bugzilla.kernel.org/show_bug.cgi?id=15979
 670  *
 671  * Handle this correctly so that they won't break userspace.
 672  */
 673 static void acpi_battery_quirks(struct acpi_battery *battery)
 674 {
 675         if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
 676                 return;
 677
 678         if (battery->full_charge_capacity == 100 &&
 679                 battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN &&
 680                 battery->capacity_now >= 0 && battery->capacity_now <= 100) {
 681                 set_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags);
 682                 battery->full_charge_capacity = battery->design_capacity;
 683                 battery->capacity_now = (battery->capacity_now *
 684                                 battery->full_charge_capacity) / 100;
 685         }
 686
 687         if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags))
 688                 return;
 689
 690         if (battery->power_unit && dmi_name_in_vendors("LENOVO")) {
 691                 const char *s;
 692                 s = dmi_get_system_info(DMI_PRODUCT_VERSION);
 693                 if (s && !strncasecmp(s, "ThinkPad", 8)) {
 694                         dmi_walk(find_battery, battery);
 695                         if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
 696                                      &battery->flags) &&
 697                             battery->design_voltage) {
 698                                 battery->design_capacity =
 699                                     battery->design_capacity *
 700                                     10000 / battery->design_voltage;
 701                                 battery->full_charge_capacity =
 702                                     battery->full_charge_capacity *
 703                                     10000 / battery->design_voltage;
 704                                 battery->design_capacity_warning =
 705                                     battery->design_capacity_warning *
 706                                     10000 / battery->design_voltage;
 707                                 battery->capacity_now = battery->capacity_now *
 708                                     10000 / battery->design_voltage;
 709                         }
 710                 }
 711         }
 712 }
 713
 714 static int acpi_battery_update(struct acpi_battery *battery, bool resume)
 715 {
 716         int result, old_present = acpi_battery_present(battery);
 717         result = acpi_battery_get_status(battery);
 718         if (result)
 719                 return result;
 720         if (!acpi_battery_present(battery)) {
 721                 sysfs_remove_battery(battery);
 722                 battery->update_time = 0;
 723                 return 0;
 724         }
 725
 726         if (resume)
 727                 return 0;
 728
 729         if (!battery->update_time ||
 730             old_present != acpi_battery_present(battery)) {
 731                 result = acpi_battery_get_info(battery);
 732                 if (result)
 733                         return result;
 734                 acpi_battery_init_alarm(battery);
 735         }
 736         if (!battery->bat) {
 737                 result = sysfs_add_battery(battery);
 738                 if (result)
 739                         return result;
 740         }
 741         result = acpi_battery_get_state(battery);
 742         if (result)
 743                 return result;
 744         acpi_battery_quirks(battery);
 745
 746         /*
 747          * Wakeup the system if battery is critical low
 748          * or lower than the alarm level
 749          */
 750         if ((battery->state & ACPI_BATTERY_STATE_CRITICAL) ||
 751             (test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags) &&
 752             (battery->capacity_now <= battery->alarm)))
 753                 pm_wakeup_event(&battery->device->dev, 0);
 754
 755         return result;
 756 }
 757
 758 static void acpi_battery_refresh(struct acpi_battery *battery)
 759 {
 760         int power_unit;
 761
 762         if (!battery->bat)
 763                 return;
 764
 765         power_unit = battery->power_unit;
 766
 767         acpi_battery_get_info(battery);
 768
 769         if (power_unit == battery->power_unit)
 770                 return;
 771
 772         /* The battery has changed its reporting units. */
 773         sysfs_remove_battery(battery);
 774         sysfs_add_battery(battery);
 775 }
 776
 777 /* --------------------------------------------------------------------------
 778                               FS Interface (/proc)
 779    -------------------------------------------------------------------------- */
 780
 781 #ifdef CONFIG_ACPI_PROCFS_POWER
 782 static struct proc_dir_entry *acpi_battery_dir;
 783
 784 static const char *acpi_battery_units(const struct acpi_battery *battery)
 785 {
 786         return (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) ?
 787                 "mA" : "mW";
 788 }
 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 power_supply *old;
1067
1068         if (!battery)
1069                 return;
1070         old = battery->bat;
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)
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) {
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 __init
1124 battery_bix_broken_package_quirk(const struct dmi_system_id *d)
1125 {
1126         battery_bix_broken_package = 1;
1127         return 0;
1128 }
1129
1130 static int __init
1131 battery_notification_delay_quirk(const struct dmi_system_id *d)
1132 {
1133         battery_notification_delay_ms = 1000;
1134         return 0;
1135 }
1136
1137 static const struct dmi_system_id bat_dmi_table[] __initconst = {
1138         {
1139                 .callback = battery_bix_broken_package_quirk,
1140                 .ident = "NEC LZ750/LS",
1141                 .matches = {
1142                         DMI_MATCH(DMI_SYS_VENDOR, "NEC"),
1143                         DMI_MATCH(DMI_PRODUCT_NAME, "PC-LZ750LS"),
1144                 },
1145         },
1146         {
1147                 .callback = battery_notification_delay_quirk,
1148                 .ident = "Acer Aspire V5-573G",
1149                 .matches = {
1150                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
1151                         DMI_MATCH(DMI_PRODUCT_NAME, "Aspire V5-573G"),
1152                 },
1153         },
1154         {},
1155 };
1156
1157 /*
1158  * Some machines'(E,G Lenovo Z480) ECs are not stable
1159  * during boot up and this causes battery driver fails to be
1160  * probed due to failure of getting battery information
1161  * from EC sometimes. After several retries, the operation
1162  * may work. So add retry code here and 20ms sleep between
1163  * every retries.
1164  */
1165 static int acpi_battery_update_retry(struct acpi_battery *battery)
1166 {
1167         int retry, ret;
1168
1169         for (retry = 5; retry; retry--) {
1170                 ret = acpi_battery_update(battery, false);
1171                 if (!ret)
1172                         break;
1173
1174                 msleep(20);
1175         }
1176         return ret;
1177 }
1178
1179 static int acpi_battery_add(struct acpi_device *device)
1180 {
1181         int result = 0;
1182         struct acpi_battery *battery = NULL;
1183
1184         if (!device)
1185                 return -EINVAL;
1186
1187         if (device->dep_unmet)
1188                 return -EPROBE_DEFER;
1189
1190         battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL);
1191         if (!battery)
1192                 return -ENOMEM;
1193         battery->device = device;
1194         strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME);
1195         strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS);
1196         device->driver_data = battery;
1197         mutex_init(&battery->lock);
1198         mutex_init(&battery->sysfs_lock);
1199         if (acpi_has_method(battery->device->handle, "_BIX"))
1200                 set_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags);
1201
1202         result = acpi_battery_update_retry(battery);
1203         if (result)
1204                 goto fail;
1205
1206 #ifdef CONFIG_ACPI_PROCFS_POWER
1207         result = acpi_battery_add_fs(device);
1208 #endif
1209         if (result) {
1210 #ifdef CONFIG_ACPI_PROCFS_POWER
1211                 acpi_battery_remove_fs(device);
1212 #endif
1213                 goto fail;
1214         }
1215
1216         printk(KERN_INFO PREFIX "%s Slot [%s] (battery %s)\n",
1217                 ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device),
1218                 device->status.battery_present ? "present" : "absent");
1219
1220         battery->pm_nb.notifier_call = battery_notify;
1221         register_pm_notifier(&battery->pm_nb);
1222
1223         device_init_wakeup(&device->dev, 1);
1224
1225         return result;
1226
1227 fail:
1228         sysfs_remove_battery(battery);
1229         mutex_destroy(&battery->lock);
1230         mutex_destroy(&battery->sysfs_lock);
1231         kfree(battery);
1232         return result;
1233 }
1234
1235 static int acpi_battery_remove(struct acpi_device *device)
1236 {
1237         struct acpi_battery *battery = NULL;
1238
1239         if (!device || !acpi_driver_data(device))
1240                 return -EINVAL;
1241         device_init_wakeup(&device->dev, 0);
1242         battery = acpi_driver_data(device);
1243         unregister_pm_notifier(&battery->pm_nb);
1244 #ifdef CONFIG_ACPI_PROCFS_POWER
1245         acpi_battery_remove_fs(device);
1246 #endif
1247         sysfs_remove_battery(battery);
1248         mutex_destroy(&battery->lock);
1249         mutex_destroy(&battery->sysfs_lock);
1250         kfree(battery);
1251         return 0;
1252 }
1253
1254 #ifdef CONFIG_PM_SLEEP
1255 /* this is needed to learn about changes made in suspended state */
1256 static int acpi_battery_resume(struct device *dev)
1257 {
1258         struct acpi_battery *battery;
1259
1260         if (!dev)
1261                 return -EINVAL;
1262
1263         battery = acpi_driver_data(to_acpi_device(dev));
1264         if (!battery)
1265                 return -EINVAL;
1266
1267         battery->update_time = 0;
1268         acpi_battery_update(battery, true);
1269         return 0;
1270 }
1271 #else
1272 #define acpi_battery_resume NULL
1273 #endif
1274
1275 static SIMPLE_DEV_PM_OPS(acpi_battery_pm, NULL, acpi_battery_resume);
1276
1277 static struct acpi_driver acpi_battery_driver = {
1278         .name = "battery",
1279         .class = ACPI_BATTERY_CLASS,
1280         .ids = battery_device_ids,
1281         .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
1282         .ops = {
1283                 .add = acpi_battery_add,
1284                 .remove = acpi_battery_remove,
1285                 .notify = acpi_battery_notify,
1286                 },
1287         .drv.pm = &acpi_battery_pm,
1288 };
1289
1290 static void __init acpi_battery_init_async(void *unused, async_cookie_t cookie)
1291 {
1292         int result;
1293
1294         dmi_check_system(bat_dmi_table);
1295
1296 #ifdef CONFIG_ACPI_PROCFS_POWER
1297         acpi_battery_dir = acpi_lock_battery_dir();
1298         if (!acpi_battery_dir)
1299                 return;
1300 #endif
1301         result = acpi_bus_register_driver(&acpi_battery_driver);
1302 #ifdef CONFIG_ACPI_PROCFS_POWER
1303         if (result < 0)
1304                 acpi_unlock_battery_dir(acpi_battery_dir);
1305 #endif
1306 }
1307
1308 static int __init acpi_battery_init(void)
1309 {
1310         if (acpi_disabled)
1311                 return -ENODEV;
1312
1313         async_cookie = async_schedule(acpi_battery_init_async, NULL);
1314         return 0;
1315 }
1316
1317 static void __exit acpi_battery_exit(void)
1318 {
1319         async_synchronize_cookie(async_cookie + 1);
1320         acpi_bus_unregister_driver(&acpi_battery_driver);
1321 #ifdef CONFIG_ACPI_PROCFS_POWER
1322         acpi_unlock_battery_dir(acpi_battery_dir);
1323 #endif
1324 }
1325
1326 module_init(acpi_battery_init);
1327 module_exit(acpi_battery_exit);