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