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 revision;
 121         int rate_now;
 122         int capacity_now;
 123         int voltage_now;
 124         int design_capacity;
 125         int full_charge_capacity;
 126         int technology;
 127         int design_voltage;
 128         int design_capacity_warning;
 129         int design_capacity_low;
 130         int cycle_count;
 131         int measurement_accuracy;
 132         int max_sampling_time;
 133         int min_sampling_time;
 134         int max_averaging_interval;
 135         int min_averaging_interval;
 136         int capacity_granularity_1;
 137         int capacity_granularity_2;
 138         int alarm;
 139         char model_number[32];
 140         char serial_number[32];
 141         char type[32];
 142         char oem_info[32];
 143         int state;
 144         int power_unit;
 145         unsigned long flags;
 146 };
 147
 148 #define to_acpi_battery(x) container_of(x, struct acpi_battery, bat)
 149
 150 static inline int acpi_battery_present(struct acpi_battery *battery)
 151 {
 152         return battery->device->status.battery_present;
 153 }
 154
 155 static int acpi_battery_technology(struct acpi_battery *battery)
 156 {
 157         if (!strcasecmp("NiCd", battery->type))
 158                 return POWER_SUPPLY_TECHNOLOGY_NiCd;
 159         if (!strcasecmp("NiMH", battery->type))
 160                 return POWER_SUPPLY_TECHNOLOGY_NiMH;
 161         if (!strcasecmp("LION", battery->type))
 162                 return POWER_SUPPLY_TECHNOLOGY_LION;
 163         if (!strncasecmp("LI-ION", battery->type, 6))
 164                 return POWER_SUPPLY_TECHNOLOGY_LION;
 165         if (!strcasecmp("LiP", battery->type))
 166                 return POWER_SUPPLY_TECHNOLOGY_LIPO;
 167         return POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
 168 }
 169
 170 static int acpi_battery_get_state(struct acpi_battery *battery);
 171
 172 static int acpi_battery_is_charged(struct acpi_battery *battery)
 173 {
 174         /* either charging or discharging */
 175         if (battery->state != 0)
 176                 return 0;
 177
 178         /* battery not reporting charge */
 179         if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN ||
 180             battery->capacity_now == 0)
 181                 return 0;
 182
 183         /* good batteries update full_charge as the batteries degrade */
 184         if (battery->full_charge_capacity == battery->capacity_now)
 185                 return 1;
 186
 187         /* fallback to using design values for broken batteries */
 188         if (battery->design_capacity == battery->capacity_now)
 189                 return 1;
 190
 191         /* we don't do any sort of metric based on percentages */
 192         return 0;
 193 }
 194
 195 static int acpi_battery_get_property(struct power_supply *psy,
 196                                      enum power_supply_property psp,
 197                                      union power_supply_propval *val)
 198 {
 199         int ret = 0;
 200         struct acpi_battery *battery = to_acpi_battery(psy);
 201
 202         if (acpi_battery_present(battery)) {
 203                 /* run battery update only if it is present */
 204                 acpi_battery_get_state(battery);
 205         } else if (psp != POWER_SUPPLY_PROP_PRESENT)
 206                 return -ENODEV;
 207         switch (psp) {
 208         case POWER_SUPPLY_PROP_STATUS:
 209                 if (battery->state & 0x01)
 210                         val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
 211                 else if (battery->state & 0x02)
 212                         val->intval = POWER_SUPPLY_STATUS_CHARGING;
 213                 else if (acpi_battery_is_charged(battery))
 214                         val->intval = POWER_SUPPLY_STATUS_FULL;
 215                 else
 216                         val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
 217                 break;
 218         case POWER_SUPPLY_PROP_PRESENT:
 219                 val->intval = acpi_battery_present(battery);
 220                 break;
 221         case POWER_SUPPLY_PROP_TECHNOLOGY:
 222                 val->intval = acpi_battery_technology(battery);
 223                 break;
 224         case POWER_SUPPLY_PROP_CYCLE_COUNT:
 225                 val->intval = battery->cycle_count;
 226                 break;
 227         case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
 228                 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
 229                         ret = -ENODEV;
 230                 else
 231                         val->intval = battery->design_voltage * 1000;
 232                 break;
 233         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 234                 if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
 235                         ret = -ENODEV;
 236                 else
 237                         val->intval = battery->voltage_now * 1000;
 238                 break;
 239         case POWER_SUPPLY_PROP_CURRENT_NOW:
 240         case POWER_SUPPLY_PROP_POWER_NOW:
 241                 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
 242                         ret = -ENODEV;
 243                 else
 244                         val->intval = battery->rate_now * 1000;
 245                 break;
 246         case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
 247         case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
 248                 if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
 249                         ret = -ENODEV;
 250                 else
 251                         val->intval = battery->design_capacity * 1000;
 252                 break;
 253         case POWER_SUPPLY_PROP_CHARGE_FULL:
 254         case POWER_SUPPLY_PROP_ENERGY_FULL:
 255                 if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
 256                         ret = -ENODEV;
 257                 else
 258                         val->intval = battery->full_charge_capacity * 1000;
 259                 break;
 260         case POWER_SUPPLY_PROP_CHARGE_NOW:
 261         case POWER_SUPPLY_PROP_ENERGY_NOW:
 262                 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
 263                         ret = -ENODEV;
 264                 else
 265                         val->intval = battery->capacity_now * 1000;
 266                 break;
 267         case POWER_SUPPLY_PROP_CAPACITY:
 268                 if (battery->capacity_now && battery->full_charge_capacity)
 269                         val->intval = battery->capacity_now * 100/
 270                                         battery->full_charge_capacity;
 271                 else
 272                         val->intval = 0;
 273                 break;
 274         case POWER_SUPPLY_PROP_MODEL_NAME:
 275                 val->strval = battery->model_number;
 276                 break;
 277         case POWER_SUPPLY_PROP_MANUFACTURER:
 278                 val->strval = battery->oem_info;
 279                 break;
 280         case POWER_SUPPLY_PROP_SERIAL_NUMBER:
 281                 val->strval = battery->serial_number;
 282                 break;
 283         default:
 284                 ret = -EINVAL;
 285         }
 286         return ret;
 287 }
 288
 289 static enum power_supply_property charge_battery_props[] = {
 290         POWER_SUPPLY_PROP_STATUS,
 291         POWER_SUPPLY_PROP_PRESENT,
 292         POWER_SUPPLY_PROP_TECHNOLOGY,
 293         POWER_SUPPLY_PROP_CYCLE_COUNT,
 294         POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
 295         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 296         POWER_SUPPLY_PROP_CURRENT_NOW,
 297         POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
 298         POWER_SUPPLY_PROP_CHARGE_FULL,
 299         POWER_SUPPLY_PROP_CHARGE_NOW,
 300         POWER_SUPPLY_PROP_CAPACITY,
 301         POWER_SUPPLY_PROP_MODEL_NAME,
 302         POWER_SUPPLY_PROP_MANUFACTURER,
 303         POWER_SUPPLY_PROP_SERIAL_NUMBER,
 304 };
 305
 306 static enum power_supply_property energy_battery_props[] = {
 307         POWER_SUPPLY_PROP_STATUS,
 308         POWER_SUPPLY_PROP_PRESENT,
 309         POWER_SUPPLY_PROP_TECHNOLOGY,
 310         POWER_SUPPLY_PROP_CYCLE_COUNT,
 311         POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
 312         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 313         POWER_SUPPLY_PROP_POWER_NOW,
 314         POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
 315         POWER_SUPPLY_PROP_ENERGY_FULL,
 316         POWER_SUPPLY_PROP_ENERGY_NOW,
 317         POWER_SUPPLY_PROP_CAPACITY,
 318         POWER_SUPPLY_PROP_MODEL_NAME,
 319         POWER_SUPPLY_PROP_MANUFACTURER,
 320         POWER_SUPPLY_PROP_SERIAL_NUMBER,
 321 };
 322
 323 #ifdef CONFIG_ACPI_PROCFS_POWER
 324 inline char *acpi_battery_units(struct acpi_battery *battery)
 325 {
 326         return (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) ?
 327                 "mA" : "mW";
 328 }
 329 #endif
 330
 331 /* --------------------------------------------------------------------------
 332                                Battery Management
 333    -------------------------------------------------------------------------- */
 334 struct acpi_offsets {
 335         size_t offset;          /* offset inside struct acpi_sbs_battery */
 336         u8 mode;                /* int or string? */
 337 };
 338
 339 static struct acpi_offsets state_offsets[] = {
 340         {offsetof(struct acpi_battery, state), 0},
 341         {offsetof(struct acpi_battery, rate_now), 0},
 342         {offsetof(struct acpi_battery, capacity_now), 0},
 343         {offsetof(struct acpi_battery, voltage_now), 0},
 344 };
 345
 346 static struct acpi_offsets info_offsets[] = {
 347         {offsetof(struct acpi_battery, power_unit), 0},
 348         {offsetof(struct acpi_battery, design_capacity), 0},
 349         {offsetof(struct acpi_battery, full_charge_capacity), 0},
 350         {offsetof(struct acpi_battery, technology), 0},
 351         {offsetof(struct acpi_battery, design_voltage), 0},
 352         {offsetof(struct acpi_battery, design_capacity_warning), 0},
 353         {offsetof(struct acpi_battery, design_capacity_low), 0},
 354         {offsetof(struct acpi_battery, capacity_granularity_1), 0},
 355         {offsetof(struct acpi_battery, capacity_granularity_2), 0},
 356         {offsetof(struct acpi_battery, model_number), 1},
 357         {offsetof(struct acpi_battery, serial_number), 1},
 358         {offsetof(struct acpi_battery, type), 1},
 359         {offsetof(struct acpi_battery, oem_info), 1},
 360 };
 361
 362 static struct acpi_offsets extended_info_offsets[] = {
 363         {offsetof(struct acpi_battery, revision), 0},
 364         {offsetof(struct acpi_battery, power_unit), 0},
 365         {offsetof(struct acpi_battery, design_capacity), 0},
 366         {offsetof(struct acpi_battery, full_charge_capacity), 0},
 367         {offsetof(struct acpi_battery, technology), 0},
 368         {offsetof(struct acpi_battery, design_voltage), 0},
 369         {offsetof(struct acpi_battery, design_capacity_warning), 0},
 370         {offsetof(struct acpi_battery, design_capacity_low), 0},
 371         {offsetof(struct acpi_battery, cycle_count), 0},
 372         {offsetof(struct acpi_battery, measurement_accuracy), 0},
 373         {offsetof(struct acpi_battery, max_sampling_time), 0},
 374         {offsetof(struct acpi_battery, min_sampling_time), 0},
 375         {offsetof(struct acpi_battery, max_averaging_interval), 0},
 376         {offsetof(struct acpi_battery, min_averaging_interval), 0},
 377         {offsetof(struct acpi_battery, capacity_granularity_1), 0},
 378         {offsetof(struct acpi_battery, capacity_granularity_2), 0},
 379         {offsetof(struct acpi_battery, model_number), 1},
 380         {offsetof(struct acpi_battery, serial_number), 1},
 381         {offsetof(struct acpi_battery, type), 1},
 382         {offsetof(struct acpi_battery, oem_info), 1},
 383 };
 384
 385 static int extract_package(struct acpi_battery *battery,
 386                            union acpi_object *package,
 387                            struct acpi_offsets *offsets, int num)
 388 {
 389         int i;
 390         union acpi_object *element;
 391         if (package->type != ACPI_TYPE_PACKAGE)
 392                 return -EFAULT;
 393         for (i = 0; i < num; ++i) {
 394                 if (package->package.count <= i)
 395                         return -EFAULT;
 396                 element = &package->package.elements[i];
 397                 if (offsets[i].mode) {
 398                         u8 *ptr = (u8 *)battery + offsets[i].offset;
 399                         if (element->type == ACPI_TYPE_STRING ||
 400                             element->type == ACPI_TYPE_BUFFER)
 401                                 strncpy(ptr, element->string.pointer, 32);
 402                         else if (element->type == ACPI_TYPE_INTEGER) {
 403                                 strncpy(ptr, (u8 *)&element->integer.value,
 404                                         sizeof(u64));
 405                                 ptr[sizeof(u64)] = 0;
 406                         } else
 407                                 *ptr = 0; /* don't have value */
 408                 } else {
 409                         int *x = (int *)((u8 *)battery + offsets[i].offset);
 410                         *x = (element->type == ACPI_TYPE_INTEGER) ?
 411                                 element->integer.value : -1;
 412                 }
 413         }
 414         return 0;
 415 }
 416
 417 static int acpi_battery_get_status(struct acpi_battery *battery)
 418 {
 419         if (acpi_bus_get_status(battery->device)) {
 420                 ACPI_EXCEPTION((AE_INFO, AE_ERROR, "Evaluating _STA"));
 421                 return -ENODEV;
 422         }
 423         return 0;
 424 }
 425
 426 static int acpi_battery_get_info(struct acpi_battery *battery)
 427 {
 428         int result = -EFAULT;
 429         acpi_status status = 0;
 430         char *name = test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags) ?
 431                         "_BIX" : "_BIF";
 432
 433         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 434
 435         if (!acpi_battery_present(battery))
 436                 return 0;
 437         mutex_lock(&battery->lock);
 438         status = acpi_evaluate_object(battery->device->handle, name,
 439                                                 NULL, &buffer);
 440         mutex_unlock(&battery->lock);
 441
 442         if (ACPI_FAILURE(status)) {
 443                 ACPI_EXCEPTION((AE_INFO, status, "Evaluating %s", name));
 444                 return -ENODEV;
 445         }
 446         if (test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags))
 447                 result = extract_package(battery, buffer.pointer,
 448                                 extended_info_offsets,
 449                                 ARRAY_SIZE(extended_info_offsets));
 450         else
 451                 result = extract_package(battery, buffer.pointer,
 452                                 info_offsets, ARRAY_SIZE(info_offsets));
 453         kfree(buffer.pointer);
 454         if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
 455                 battery->full_charge_capacity = battery->design_capacity;
 456         if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
 457             battery->power_unit && battery->design_voltage) {
 458                 battery->design_capacity = battery->design_capacity *
 459                     10000 / battery->design_voltage;
 460                 battery->full_charge_capacity = battery->full_charge_capacity *
 461                     10000 / battery->design_voltage;
 462                 battery->design_capacity_warning =
 463                     battery->design_capacity_warning *
 464                     10000 / battery->design_voltage;
 465                 /* Curiously, design_capacity_low, unlike the rest of them,
 466                    is correct.  */
 467                 /* capacity_granularity_* equal 1 on the systems tested, so
 468                    it's impossible to tell if they would need an adjustment
 469                    or not if their values were higher.  */
 470         }
 471         return result;
 472 }
 473
 474 static int acpi_battery_get_state(struct acpi_battery *battery)
 475 {
 476         int result = 0;
 477         acpi_status status = 0;
 478         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 479
 480         if (!acpi_battery_present(battery))
 481                 return 0;
 482
 483         if (battery->update_time &&
 484             time_before(jiffies, battery->update_time +
 485                         msecs_to_jiffies(cache_time)))
 486                 return 0;
 487
 488         mutex_lock(&battery->lock);
 489         status = acpi_evaluate_object(battery->device->handle, "_BST",
 490                                       NULL, &buffer);
 491         mutex_unlock(&battery->lock);
 492
 493         if (ACPI_FAILURE(status)) {
 494                 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BST"));
 495                 return -ENODEV;
 496         }
 497
 498         result = extract_package(battery, buffer.pointer,
 499                                  state_offsets, ARRAY_SIZE(state_offsets));
 500         battery->update_time = jiffies;
 501         kfree(buffer.pointer);
 502
 503         /* For buggy DSDTs that report negative 16-bit values for either
 504          * charging or discharging current and/or report 0 as 65536
 505          * due to bad math.
 506          */
 507         if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA &&
 508                 battery->rate_now != ACPI_BATTERY_VALUE_UNKNOWN &&
 509                 (s16)(battery->rate_now) < 0) {
 510                 battery->rate_now = abs((s16)battery->rate_now);
 511                 printk_once(KERN_WARNING FW_BUG "battery: (dis)charge rate"
 512                         " invalid.\n");
 513         }
 514
 515         if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags)
 516             && battery->capacity_now >= 0 && battery->capacity_now <= 100)
 517                 battery->capacity_now = (battery->capacity_now *
 518                                 battery->full_charge_capacity) / 100;
 519         if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
 520             battery->power_unit && battery->design_voltage) {
 521                 battery->capacity_now = battery->capacity_now *
 522                     10000 / battery->design_voltage;
 523         }
 524         return result;
 525 }
 526
 527 static int acpi_battery_set_alarm(struct acpi_battery *battery)
 528 {
 529         acpi_status status = 0;
 530
 531         if (!acpi_battery_present(battery) ||
 532             !test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags))
 533                 return -ENODEV;
 534
 535         mutex_lock(&battery->lock);
 536         status = acpi_execute_simple_method(battery->device->handle, "_BTP",
 537                                             battery->alarm);
 538         mutex_unlock(&battery->lock);
 539
 540         if (ACPI_FAILURE(status))
 541                 return -ENODEV;
 542
 543         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Alarm set to %d\n", battery->alarm));
 544         return 0;
 545 }
 546
 547 static int acpi_battery_init_alarm(struct acpi_battery *battery)
 548 {
 549         /* See if alarms are supported, and if so, set default */
 550         if (!acpi_has_method(battery->device->handle, "_BTP")) {
 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_DATA(inode)); \
 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         umode_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_netlink_event(device->pnp.device_class,
1032                                         dev_name(&device->dev), event,
1033                                         acpi_battery_present(battery));
1034         /* acpi_battery_update could remove power_supply object */
1035         if (old && battery->bat.dev)
1036                 power_supply_changed(&battery->bat);
1037 }
1038
1039 static int battery_notify(struct notifier_block *nb,
1040                                unsigned long mode, void *_unused)
1041 {
1042         struct acpi_battery *battery = container_of(nb, struct acpi_battery,
1043                                                     pm_nb);
1044         switch (mode) {
1045         case PM_POST_HIBERNATION:
1046         case PM_POST_SUSPEND:
1047                 if (battery->bat.dev) {
1048                         sysfs_remove_battery(battery);
1049                         sysfs_add_battery(battery);
1050                 }
1051                 break;
1052         }
1053
1054         return 0;
1055 }
1056
1057 static int acpi_battery_add(struct acpi_device *device)
1058 {
1059         int result = 0;
1060         struct acpi_battery *battery = NULL;
1061
1062         if (!device)
1063                 return -EINVAL;
1064         battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL);
1065         if (!battery)
1066                 return -ENOMEM;
1067         battery->device = device;
1068         strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME);
1069         strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS);
1070         device->driver_data = battery;
1071         mutex_init(&battery->lock);
1072         mutex_init(&battery->sysfs_lock);
1073         if (acpi_has_method(battery->device->handle, "_BIX"))
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)
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 #ifdef CONFIG_PM_SLEEP
1124 /* this is needed to learn about changes made in suspended state */
1125 static int acpi_battery_resume(struct device *dev)
1126 {
1127         struct acpi_battery *battery;
1128
1129         if (!dev)
1130                 return -EINVAL;
1131
1132         battery = acpi_driver_data(to_acpi_device(dev));
1133         if (!battery)
1134                 return -EINVAL;
1135
1136         battery->update_time = 0;
1137         acpi_battery_update(battery);
1138         return 0;
1139 }
1140 #endif
1141
1142 static SIMPLE_DEV_PM_OPS(acpi_battery_pm, NULL, acpi_battery_resume);
1143
1144 static struct acpi_driver acpi_battery_driver = {
1145         .name = "battery",
1146         .class = ACPI_BATTERY_CLASS,
1147         .ids = battery_device_ids,
1148         .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
1149         .ops = {
1150                 .add = acpi_battery_add,
1151                 .remove = acpi_battery_remove,
1152                 .notify = acpi_battery_notify,
1153                 },
1154         .drv.pm = &acpi_battery_pm,
1155 };
1156
1157 static void __init acpi_battery_init_async(void *unused, async_cookie_t cookie)
1158 {
1159         if (acpi_disabled)
1160                 return;
1161 #ifdef CONFIG_ACPI_PROCFS_POWER
1162         acpi_battery_dir = acpi_lock_battery_dir();
1163         if (!acpi_battery_dir)
1164                 return;
1165 #endif
1166         if (acpi_bus_register_driver(&acpi_battery_driver) < 0) {
1167 #ifdef CONFIG_ACPI_PROCFS_POWER
1168                 acpi_unlock_battery_dir(acpi_battery_dir);
1169 #endif
1170                 return;
1171         }
1172         return;
1173 }
1174
1175 static int __init acpi_battery_init(void)
1176 {
1177         async_schedule(acpi_battery_init_async, NULL);
1178         return 0;
1179 }
1180
1181 static void __exit acpi_battery_exit(void)
1182 {
1183         acpi_bus_unregister_driver(&acpi_battery_driver);
1184 #ifdef CONFIG_ACPI_PROCFS_POWER
1185         acpi_unlock_battery_dir(acpi_battery_dir);
1186 #endif
1187 }
1188
1189 module_init(acpi_battery_init);
1190 module_exit(acpi_battery_exit);