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