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