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 static 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_CAPACITY:
 267                 if (battery->capacity_now && battery->full_charge_capacity)
 268                         val->intval = battery->capacity_now * 100/
 269                                         battery->full_charge_capacity;
 270                 else
 271                         val->intval = 0;
 272                 break;
 273         case POWER_SUPPLY_PROP_MODEL_NAME:
 274                 val->strval = battery->model_number;
 275                 break;
 276         case POWER_SUPPLY_PROP_MANUFACTURER:
 277                 val->strval = battery->oem_info;
 278                 break;
 279         case POWER_SUPPLY_PROP_SERIAL_NUMBER:
 280                 val->strval = battery->serial_number;
 281                 break;
 282         default:
 283                 ret = -EINVAL;
 284         }
 285         return ret;
 286 }
 287
 288 static enum power_supply_property charge_battery_props[] = {
 289         POWER_SUPPLY_PROP_STATUS,
 290         POWER_SUPPLY_PROP_PRESENT,
 291         POWER_SUPPLY_PROP_TECHNOLOGY,
 292         POWER_SUPPLY_PROP_CYCLE_COUNT,
 293         POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
 294         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 295         POWER_SUPPLY_PROP_CURRENT_NOW,
 296         POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
 297         POWER_SUPPLY_PROP_CHARGE_FULL,
 298         POWER_SUPPLY_PROP_CHARGE_NOW,
 299         POWER_SUPPLY_PROP_CAPACITY,
 300         POWER_SUPPLY_PROP_MODEL_NAME,
 301         POWER_SUPPLY_PROP_MANUFACTURER,
 302         POWER_SUPPLY_PROP_SERIAL_NUMBER,
 303 };
 304
 305 static enum power_supply_property energy_battery_props[] = {
 306         POWER_SUPPLY_PROP_STATUS,
 307         POWER_SUPPLY_PROP_PRESENT,
 308         POWER_SUPPLY_PROP_TECHNOLOGY,
 309         POWER_SUPPLY_PROP_CYCLE_COUNT,
 310         POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
 311         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 312         POWER_SUPPLY_PROP_POWER_NOW,
 313         POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
 314         POWER_SUPPLY_PROP_ENERGY_FULL,
 315         POWER_SUPPLY_PROP_ENERGY_NOW,
 316         POWER_SUPPLY_PROP_CAPACITY,
 317         POWER_SUPPLY_PROP_MODEL_NAME,
 318         POWER_SUPPLY_PROP_MANUFACTURER,
 319         POWER_SUPPLY_PROP_SERIAL_NUMBER,
 320 };
 321
 322 #ifdef CONFIG_ACPI_PROCFS_POWER
 323 inline char *acpi_battery_units(struct acpi_battery *battery)
 324 {
 325         return (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) ?
 326                 "mA" : "mW";
 327 }
 328 #endif
 329
 330 /* --------------------------------------------------------------------------
 331                                Battery Management
 332    -------------------------------------------------------------------------- */
 333 struct acpi_offsets {
 334         size_t offset;          /* offset inside struct acpi_sbs_battery */
 335         u8 mode;                /* int or string? */
 336 };
 337
 338 static struct acpi_offsets state_offsets[] = {
 339         {offsetof(struct acpi_battery, state), 0},
 340         {offsetof(struct acpi_battery, rate_now), 0},
 341         {offsetof(struct acpi_battery, capacity_now), 0},
 342         {offsetof(struct acpi_battery, voltage_now), 0},
 343 };
 344
 345 static struct acpi_offsets info_offsets[] = {
 346         {offsetof(struct acpi_battery, power_unit), 0},
 347         {offsetof(struct acpi_battery, design_capacity), 0},
 348         {offsetof(struct acpi_battery, full_charge_capacity), 0},
 349         {offsetof(struct acpi_battery, technology), 0},
 350         {offsetof(struct acpi_battery, design_voltage), 0},
 351         {offsetof(struct acpi_battery, design_capacity_warning), 0},
 352         {offsetof(struct acpi_battery, design_capacity_low), 0},
 353         {offsetof(struct acpi_battery, capacity_granularity_1), 0},
 354         {offsetof(struct acpi_battery, capacity_granularity_2), 0},
 355         {offsetof(struct acpi_battery, model_number), 1},
 356         {offsetof(struct acpi_battery, serial_number), 1},
 357         {offsetof(struct acpi_battery, type), 1},
 358         {offsetof(struct acpi_battery, oem_info), 1},
 359 };
 360
 361 static struct acpi_offsets extended_info_offsets[] = {
 362         {offsetof(struct acpi_battery, power_unit), 0},
 363         {offsetof(struct acpi_battery, design_capacity), 0},
 364         {offsetof(struct acpi_battery, full_charge_capacity), 0},
 365         {offsetof(struct acpi_battery, technology), 0},
 366         {offsetof(struct acpi_battery, design_voltage), 0},
 367         {offsetof(struct acpi_battery, design_capacity_warning), 0},
 368         {offsetof(struct acpi_battery, design_capacity_low), 0},
 369         {offsetof(struct acpi_battery, cycle_count), 0},
 370         {offsetof(struct acpi_battery, measurement_accuracy), 0},
 371         {offsetof(struct acpi_battery, max_sampling_time), 0},
 372         {offsetof(struct acpi_battery, min_sampling_time), 0},
 373         {offsetof(struct acpi_battery, max_averaging_interval), 0},
 374         {offsetof(struct acpi_battery, min_averaging_interval), 0},
 375         {offsetof(struct acpi_battery, capacity_granularity_1), 0},
 376         {offsetof(struct acpi_battery, capacity_granularity_2), 0},
 377         {offsetof(struct acpi_battery, model_number), 1},
 378         {offsetof(struct acpi_battery, serial_number), 1},
 379         {offsetof(struct acpi_battery, type), 1},
 380         {offsetof(struct acpi_battery, oem_info), 1},
 381 };
 382
 383 static int extract_package(struct acpi_battery *battery,
 384                            union acpi_object *package,
 385                            struct acpi_offsets *offsets, int num)
 386 {
 387         int i;
 388         union acpi_object *element;
 389         if (package->type != ACPI_TYPE_PACKAGE)
 390                 return -EFAULT;
 391         for (i = 0; i < num; ++i) {
 392                 if (package->package.count <= i)
 393                         return -EFAULT;
 394                 element = &package->package.elements[i];
 395                 if (offsets[i].mode) {
 396                         u8 *ptr = (u8 *)battery + offsets[i].offset;
 397                         if (element->type == ACPI_TYPE_STRING ||
 398                             element->type == ACPI_TYPE_BUFFER)
 399                                 strncpy(ptr, element->string.pointer, 32);
 400                         else if (element->type == ACPI_TYPE_INTEGER) {
 401                                 strncpy(ptr, (u8 *)&element->integer.value,
 402                                         sizeof(u64));
 403                                 ptr[sizeof(u64)] = 0;
 404                         } else
 405                                 *ptr = 0; /* don't have value */
 406                 } else {
 407                         int *x = (int *)((u8 *)battery + offsets[i].offset);
 408                         *x = (element->type == ACPI_TYPE_INTEGER) ?
 409                                 element->integer.value : -1;
 410                 }
 411         }
 412         return 0;
 413 }
 414
 415 static int acpi_battery_get_status(struct acpi_battery *battery)
 416 {
 417         if (acpi_bus_get_status(battery->device)) {
 418                 ACPI_EXCEPTION((AE_INFO, AE_ERROR, "Evaluating _STA"));
 419                 return -ENODEV;
 420         }
 421         return 0;
 422 }
 423
 424 static int acpi_battery_get_info(struct acpi_battery *battery)
 425 {
 426         int result = -EFAULT;
 427         acpi_status status = 0;
 428         char *name = test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags) ?
 429                         "_BIX" : "_BIF";
 430
 431         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 432
 433         if (!acpi_battery_present(battery))
 434                 return 0;
 435         mutex_lock(&battery->lock);
 436         status = acpi_evaluate_object(battery->device->handle, name,
 437                                                 NULL, &buffer);
 438         mutex_unlock(&battery->lock);
 439
 440         if (ACPI_FAILURE(status)) {
 441                 ACPI_EXCEPTION((AE_INFO, status, "Evaluating %s", name));
 442                 return -ENODEV;
 443         }
 444         if (test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags))
 445                 result = extract_package(battery, buffer.pointer,
 446                                 extended_info_offsets,
 447                                 ARRAY_SIZE(extended_info_offsets));
 448         else
 449                 result = extract_package(battery, buffer.pointer,
 450                                 info_offsets, ARRAY_SIZE(info_offsets));
 451         kfree(buffer.pointer);
 452         if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
 453                 battery->full_charge_capacity = battery->design_capacity;
 454         if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
 455             battery->power_unit && battery->design_voltage) {
 456                 battery->design_capacity = battery->design_capacity *
 457                     10000 / battery->design_voltage;
 458                 battery->full_charge_capacity = battery->full_charge_capacity *
 459                     10000 / battery->design_voltage;
 460                 battery->design_capacity_warning =
 461                     battery->design_capacity_warning *
 462                     10000 / battery->design_voltage;
 463                 /* Curiously, design_capacity_low, unlike the rest of them,
 464                    is correct.  */
 465                 /* capacity_granularity_* equal 1 on the systems tested, so
 466                    it's impossible to tell if they would need an adjustment
 467                    or not if their values were higher.  */
 468         }
 469         return result;
 470 }
 471
 472 static int acpi_battery_get_state(struct acpi_battery *battery)
 473 {
 474         int result = 0;
 475         acpi_status status = 0;
 476         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 477
 478         if (!acpi_battery_present(battery))
 479                 return 0;
 480
 481         if (battery->update_time &&
 482             time_before(jiffies, battery->update_time +
 483                         msecs_to_jiffies(cache_time)))
 484                 return 0;
 485
 486         mutex_lock(&battery->lock);
 487         status = acpi_evaluate_object(battery->device->handle, "_BST",
 488                                       NULL, &buffer);
 489         mutex_unlock(&battery->lock);
 490
 491         if (ACPI_FAILURE(status)) {
 492                 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BST"));
 493                 return -ENODEV;
 494         }
 495
 496         result = extract_package(battery, buffer.pointer,
 497                                  state_offsets, ARRAY_SIZE(state_offsets));
 498         battery->update_time = jiffies;
 499         kfree(buffer.pointer);
 500
 501         /* For buggy DSDTs that report negative 16-bit values for either
 502          * charging or discharging current and/or report 0 as 65536
 503          * due to bad math.
 504          */
 505         if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA &&
 506                 battery->rate_now != ACPI_BATTERY_VALUE_UNKNOWN &&
 507                 (s16)(battery->rate_now) < 0) {
 508                 battery->rate_now = abs((s16)battery->rate_now);
 509                 printk_once(KERN_WARNING FW_BUG "battery: (dis)charge rate"
 510                         " invalid.\n");
 511         }
 512
 513         if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags)
 514             && battery->capacity_now >= 0 && battery->capacity_now <= 100)
 515                 battery->capacity_now = (battery->capacity_now *
 516                                 battery->full_charge_capacity) / 100;
 517         if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
 518             battery->power_unit && battery->design_voltage) {
 519                 battery->capacity_now = battery->capacity_now *
 520                     10000 / battery->design_voltage;
 521         }
 522         return result;
 523 }
 524
 525 static int acpi_battery_set_alarm(struct acpi_battery *battery)
 526 {
 527         acpi_status status = 0;
 528
 529         if (!acpi_battery_present(battery) ||
 530             !test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags))
 531                 return -ENODEV;
 532
 533         mutex_lock(&battery->lock);
 534         status = acpi_execute_simple_method(battery->device->handle, "_BTP",
 535                                             battery->alarm);
 536         mutex_unlock(&battery->lock);
 537
 538         if (ACPI_FAILURE(status))
 539                 return -ENODEV;
 540
 541         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Alarm set to %d\n", battery->alarm));
 542         return 0;
 543 }
 544
 545 static int acpi_battery_init_alarm(struct acpi_battery *battery)
 546 {
 547         /* See if alarms are supported, and if so, set default */
 548         if (!acpi_has_method(battery->device->handle, "_BTP")) {
 549                 clear_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
 550                 return 0;
 551         }
 552         set_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
 553         if (!battery->alarm)
 554                 battery->alarm = battery->design_capacity_warning;
 555         return acpi_battery_set_alarm(battery);
 556 }
 557
 558 static ssize_t acpi_battery_alarm_show(struct device *dev,
 559                                         struct device_attribute *attr,
 560                                         char *buf)
 561 {
 562         struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
 563         return sprintf(buf, "%d\n", battery->alarm * 1000);
 564 }
 565
 566 static ssize_t acpi_battery_alarm_store(struct device *dev,
 567                                         struct device_attribute *attr,
 568                                         const char *buf, size_t count)
 569 {
 570         unsigned long x;
 571         struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
 572         if (sscanf(buf, "%ld\n", &x) == 1)
 573                 battery->alarm = x/1000;
 574         if (acpi_battery_present(battery))
 575                 acpi_battery_set_alarm(battery);
 576         return count;
 577 }
 578
 579 static struct device_attribute alarm_attr = {
 580         .attr = {.name = "alarm", .mode = 0644},
 581         .show = acpi_battery_alarm_show,
 582         .store = acpi_battery_alarm_store,
 583 };
 584
 585 static int sysfs_add_battery(struct acpi_battery *battery)
 586 {
 587         int result;
 588
 589         if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) {
 590                 battery->bat.properties = charge_battery_props;
 591                 battery->bat.num_properties =
 592                         ARRAY_SIZE(charge_battery_props);
 593         } else {
 594                 battery->bat.properties = energy_battery_props;
 595                 battery->bat.num_properties =
 596                         ARRAY_SIZE(energy_battery_props);
 597         }
 598
 599         battery->bat.name = acpi_device_bid(battery->device);
 600         battery->bat.type = POWER_SUPPLY_TYPE_BATTERY;
 601         battery->bat.get_property = acpi_battery_get_property;
 602
 603         result = power_supply_register(&battery->device->dev, &battery->bat);
 604         if (result)
 605                 return result;
 606         return device_create_file(battery->bat.dev, &alarm_attr);
 607 }
 608
 609 static void sysfs_remove_battery(struct acpi_battery *battery)
 610 {
 611         mutex_lock(&battery->sysfs_lock);
 612         if (!battery->bat.dev) {
 613                 mutex_unlock(&battery->sysfs_lock);
 614                 return;
 615         }
 616
 617         device_remove_file(battery->bat.dev, &alarm_attr);
 618         power_supply_unregister(&battery->bat);
 619         battery->bat.dev = NULL;
 620         mutex_unlock(&battery->sysfs_lock);
 621 }
 622
 623 static void find_battery(const struct dmi_header *dm, void *private)
 624 {
 625         struct acpi_battery *battery = (struct acpi_battery *)private;
 626         /* Note: the hardcoded offsets below have been extracted from
 627            the source code of dmidecode.  */
 628         if (dm->type == DMI_ENTRY_PORTABLE_BATTERY && dm->length >= 8) {
 629                 const u8 *dmi_data = (const u8 *)(dm + 1);
 630                 int dmi_capacity = get_unaligned((const u16 *)(dmi_data + 6));
 631                 if (dm->length >= 18)
 632                         dmi_capacity *= dmi_data[17];
 633                 if (battery->design_capacity * battery->design_voltage / 1000
 634                     != dmi_capacity &&
 635                     battery->design_capacity * 10 == dmi_capacity)
 636                         set_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
 637                                 &battery->flags);
 638         }
 639 }
 640
 641 /*
 642  * According to the ACPI spec, some kinds of primary batteries can
 643  * report percentage battery remaining capacity directly to OS.
 644  * In this case, it reports the Last Full Charged Capacity == 100
 645  * and BatteryPresentRate == 0xFFFFFFFF.
 646  *
 647  * Now we found some battery reports percentage remaining capacity
 648  * even if it's rechargeable.
 649  * https://bugzilla.kernel.org/show_bug.cgi?id=15979
 650  *
 651  * Handle this correctly so that they won't break userspace.
 652  */
 653 static void acpi_battery_quirks(struct acpi_battery *battery)
 654 {
 655         if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
 656                 return;
 657
 658         if (battery->full_charge_capacity == 100 &&
 659                 battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN &&
 660                 battery->capacity_now >= 0 && battery->capacity_now <= 100) {
 661                 set_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags);
 662                 battery->full_charge_capacity = battery->design_capacity;
 663                 battery->capacity_now = (battery->capacity_now *
 664                                 battery->full_charge_capacity) / 100;
 665         }
 666
 667         if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags))
 668                 return;
 669
 670         if (battery->power_unit && dmi_name_in_vendors("LENOVO")) {
 671                 const char *s;
 672                 s = dmi_get_system_info(DMI_PRODUCT_VERSION);
 673                 if (s && !strnicmp(s, "ThinkPad", 8)) {
 674                         dmi_walk(find_battery, battery);
 675                         if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
 676                                      &battery->flags) &&
 677                             battery->design_voltage) {
 678                                 battery->design_capacity =
 679                                     battery->design_capacity *
 680                                     10000 / battery->design_voltage;
 681                                 battery->full_charge_capacity =
 682                                     battery->full_charge_capacity *
 683                                     10000 / battery->design_voltage;
 684                                 battery->design_capacity_warning =
 685                                     battery->design_capacity_warning *
 686                                     10000 / battery->design_voltage;
 687                                 battery->capacity_now = battery->capacity_now *
 688                                     10000 / battery->design_voltage;
 689                         }
 690                 }
 691         }
 692 }
 693
 694 static int acpi_battery_update(struct acpi_battery *battery)
 695 {
 696         int result, old_present = acpi_battery_present(battery);
 697         result = acpi_battery_get_status(battery);
 698         if (result)
 699                 return result;
 700         if (!acpi_battery_present(battery)) {
 701                 sysfs_remove_battery(battery);
 702                 battery->update_time = 0;
 703                 return 0;
 704         }
 705         if (!battery->update_time ||
 706             old_present != acpi_battery_present(battery)) {
 707                 result = acpi_battery_get_info(battery);
 708                 if (result)
 709                         return result;
 710                 acpi_battery_init_alarm(battery);
 711         }
 712         if (!battery->bat.dev) {
 713                 result = sysfs_add_battery(battery);
 714                 if (result)
 715                         return result;
 716         }
 717         result = acpi_battery_get_state(battery);
 718         acpi_battery_quirks(battery);
 719         return result;
 720 }
 721
 722 static void acpi_battery_refresh(struct acpi_battery *battery)
 723 {
 724         int power_unit;
 725
 726         if (!battery->bat.dev)
 727                 return;
 728
 729         power_unit = battery->power_unit;
 730
 731         acpi_battery_get_info(battery);
 732
 733         if (power_unit == battery->power_unit)
 734                 return;
 735
 736         /* The battery has changed its reporting units. */
 737         sysfs_remove_battery(battery);
 738         sysfs_add_battery(battery);
 739 }
 740
 741 /* --------------------------------------------------------------------------
 742                               FS Interface (/proc)
 743    -------------------------------------------------------------------------- */
 744
 745 #ifdef CONFIG_ACPI_PROCFS_POWER
 746 static struct proc_dir_entry *acpi_battery_dir;
 747
 748 static int acpi_battery_print_info(struct seq_file *seq, int result)
 749 {
 750         struct acpi_battery *battery = seq->private;
 751
 752         if (result)
 753                 goto end;
 754
 755         seq_printf(seq, "present:                 %s\n",
 756                    acpi_battery_present(battery) ? "yes" : "no");
 757         if (!acpi_battery_present(battery))
 758                 goto end;
 759         if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
 760                 seq_printf(seq, "design capacity:         unknown\n");
 761         else
 762                 seq_printf(seq, "design capacity:         %d %sh\n",
 763                            battery->design_capacity,
 764                            acpi_battery_units(battery));
 765
 766         if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
 767                 seq_printf(seq, "last full capacity:      unknown\n");
 768         else
 769                 seq_printf(seq, "last full capacity:      %d %sh\n",
 770                            battery->full_charge_capacity,
 771                            acpi_battery_units(battery));
 772
 773         seq_printf(seq, "battery technology:      %srechargeable\n",
 774                    (!battery->technology)?"non-":"");
 775
 776         if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
 777                 seq_printf(seq, "design voltage:          unknown\n");
 778         else
 779                 seq_printf(seq, "design voltage:          %d mV\n",
 780                            battery->design_voltage);
 781         seq_printf(seq, "design capacity warning: %d %sh\n",
 782                    battery->design_capacity_warning,
 783                    acpi_battery_units(battery));
 784         seq_printf(seq, "design capacity low:     %d %sh\n",
 785                    battery->design_capacity_low,
 786                    acpi_battery_units(battery));
 787         seq_printf(seq, "cycle count:             %i\n", battery->cycle_count);
 788         seq_printf(seq, "capacity granularity 1:  %d %sh\n",
 789                    battery->capacity_granularity_1,
 790                    acpi_battery_units(battery));
 791         seq_printf(seq, "capacity granularity 2:  %d %sh\n",
 792                    battery->capacity_granularity_2,
 793                    acpi_battery_units(battery));
 794         seq_printf(seq, "model number:            %s\n", battery->model_number);
 795         seq_printf(seq, "serial number:           %s\n", battery->serial_number);
 796         seq_printf(seq, "battery type:            %s\n", battery->type);
 797         seq_printf(seq, "OEM info:                %s\n", battery->oem_info);
 798       end:
 799         if (result)
 800                 seq_printf(seq, "ERROR: Unable to read battery info\n");
 801         return result;
 802 }
 803
 804 static int acpi_battery_print_state(struct seq_file *seq, int result)
 805 {
 806         struct acpi_battery *battery = seq->private;
 807
 808         if (result)
 809                 goto end;
 810
 811         seq_printf(seq, "present:                 %s\n",
 812                    acpi_battery_present(battery) ? "yes" : "no");
 813         if (!acpi_battery_present(battery))
 814                 goto end;
 815
 816         seq_printf(seq, "capacity state:          %s\n",
 817                         (battery->state & 0x04) ? "critical" : "ok");
 818         if ((battery->state & 0x01) && (battery->state & 0x02))
 819                 seq_printf(seq,
 820                            "charging state:          charging/discharging\n");
 821         else if (battery->state & 0x01)
 822                 seq_printf(seq, "charging state:          discharging\n");
 823         else if (battery->state & 0x02)
 824                 seq_printf(seq, "charging state:          charging\n");
 825         else
 826                 seq_printf(seq, "charging state:          charged\n");
 827
 828         if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
 829                 seq_printf(seq, "present rate:            unknown\n");
 830         else
 831                 seq_printf(seq, "present rate:            %d %s\n",
 832                            battery->rate_now, acpi_battery_units(battery));
 833
 834         if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
 835                 seq_printf(seq, "remaining capacity:      unknown\n");
 836         else
 837                 seq_printf(seq, "remaining capacity:      %d %sh\n",
 838                            battery->capacity_now, acpi_battery_units(battery));
 839         if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
 840                 seq_printf(seq, "present voltage:         unknown\n");
 841         else
 842                 seq_printf(seq, "present voltage:         %d mV\n",
 843                            battery->voltage_now);
 844       end:
 845         if (result)
 846                 seq_printf(seq, "ERROR: Unable to read battery state\n");
 847
 848         return result;
 849 }
 850
 851 static int acpi_battery_print_alarm(struct seq_file *seq, int result)
 852 {
 853         struct acpi_battery *battery = seq->private;
 854
 855         if (result)
 856                 goto end;
 857
 858         if (!acpi_battery_present(battery)) {
 859                 seq_printf(seq, "present:                 no\n");
 860                 goto end;
 861         }
 862         seq_printf(seq, "alarm:                   ");
 863         if (!battery->alarm)
 864                 seq_printf(seq, "unsupported\n");
 865         else
 866                 seq_printf(seq, "%u %sh\n", battery->alarm,
 867                                 acpi_battery_units(battery));
 868       end:
 869         if (result)
 870                 seq_printf(seq, "ERROR: Unable to read battery alarm\n");
 871         return result;
 872 }
 873
 874 static ssize_t acpi_battery_write_alarm(struct file *file,
 875                                         const char __user * buffer,
 876                                         size_t count, loff_t * ppos)
 877 {
 878         int result = 0;
 879         char alarm_string[12] = { '\0' };
 880         struct seq_file *m = file->private_data;
 881         struct acpi_battery *battery = m->private;
 882
 883         if (!battery || (count > sizeof(alarm_string) - 1))
 884                 return -EINVAL;
 885         if (!acpi_battery_present(battery)) {
 886                 result = -ENODEV;
 887                 goto end;
 888         }
 889         if (copy_from_user(alarm_string, buffer, count)) {
 890                 result = -EFAULT;
 891                 goto end;
 892         }
 893         alarm_string[count] = '\0';
 894         battery->alarm = simple_strtol(alarm_string, NULL, 0);
 895         result = acpi_battery_set_alarm(battery);
 896       end:
 897         if (!result)
 898                 return count;
 899         return result;
 900 }
 901
 902 typedef int(*print_func)(struct seq_file *seq, int result);
 903
 904 static print_func acpi_print_funcs[ACPI_BATTERY_NUMFILES] = {
 905         acpi_battery_print_info,
 906         acpi_battery_print_state,
 907         acpi_battery_print_alarm,
 908 };
 909
 910 static int acpi_battery_read(int fid, struct seq_file *seq)
 911 {
 912         struct acpi_battery *battery = seq->private;
 913         int result = acpi_battery_update(battery);
 914         return acpi_print_funcs[fid](seq, result);
 915 }
 916
 917 #define DECLARE_FILE_FUNCTIONS(_name) \
 918 static int acpi_battery_read_##_name(struct seq_file *seq, void *offset) \
 919 { \
 920         return acpi_battery_read(_name##_tag, seq); \
 921 } \
 922 static int acpi_battery_##_name##_open_fs(struct inode *inode, struct file *file) \
 923 { \
 924         return single_open(file, acpi_battery_read_##_name, PDE_DATA(inode)); \
 925 }
 926
 927 DECLARE_FILE_FUNCTIONS(info);
 928 DECLARE_FILE_FUNCTIONS(state);
 929 DECLARE_FILE_FUNCTIONS(alarm);
 930
 931 #undef DECLARE_FILE_FUNCTIONS
 932
 933 #define FILE_DESCRIPTION_RO(_name) \
 934         { \
 935         .name = __stringify(_name), \
 936         .mode = S_IRUGO, \
 937         .ops = { \
 938                 .open = acpi_battery_##_name##_open_fs, \
 939                 .read = seq_read, \
 940                 .llseek = seq_lseek, \
 941                 .release = single_release, \
 942                 .owner = THIS_MODULE, \
 943                 }, \
 944         }
 945
 946 #define FILE_DESCRIPTION_RW(_name) \
 947         { \
 948         .name = __stringify(_name), \
 949         .mode = S_IFREG | S_IRUGO | S_IWUSR, \
 950         .ops = { \
 951                 .open = acpi_battery_##_name##_open_fs, \
 952                 .read = seq_read, \
 953                 .llseek = seq_lseek, \
 954                 .write = acpi_battery_write_##_name, \
 955                 .release = single_release, \
 956                 .owner = THIS_MODULE, \
 957                 }, \
 958         }
 959
 960 static const struct battery_file {
 961         struct file_operations ops;
 962         umode_t mode;
 963         const char *name;
 964 } acpi_battery_file[] = {
 965         FILE_DESCRIPTION_RO(info),
 966         FILE_DESCRIPTION_RO(state),
 967         FILE_DESCRIPTION_RW(alarm),
 968 };
 969
 970 #undef FILE_DESCRIPTION_RO
 971 #undef FILE_DESCRIPTION_RW
 972
 973 static int acpi_battery_add_fs(struct acpi_device *device)
 974 {
 975         struct proc_dir_entry *entry = NULL;
 976         int i;
 977
 978         printk(KERN_WARNING PREFIX "Deprecated procfs I/F for battery is loaded,"
 979                         " please retry with CONFIG_ACPI_PROCFS_POWER cleared\n");
 980         if (!acpi_device_dir(device)) {
 981                 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
 982                                                      acpi_battery_dir);
 983                 if (!acpi_device_dir(device))
 984                         return -ENODEV;
 985         }
 986
 987         for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i) {
 988                 entry = proc_create_data(acpi_battery_file[i].name,
 989                                          acpi_battery_file[i].mode,
 990                                          acpi_device_dir(device),
 991                                          &acpi_battery_file[i].ops,
 992                                          acpi_driver_data(device));
 993                 if (!entry)
 994                         return -ENODEV;
 995         }
 996         return 0;
 997 }
 998
 999 static void acpi_battery_remove_fs(struct acpi_device *device)
1000 {
1001         int i;
1002         if (!acpi_device_dir(device))
1003                 return;
1004         for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i)
1005                 remove_proc_entry(acpi_battery_file[i].name,
1006                                   acpi_device_dir(device));
1007
1008         remove_proc_entry(acpi_device_bid(device), acpi_battery_dir);
1009         acpi_device_dir(device) = NULL;
1010 }
1011
1012 #endif
1013
1014 /* --------------------------------------------------------------------------
1015                                  Driver Interface
1016    -------------------------------------------------------------------------- */
1017
1018 static void acpi_battery_notify(struct acpi_device *device, u32 event)
1019 {
1020         struct acpi_battery *battery = acpi_driver_data(device);
1021         struct device *old;
1022
1023         if (!battery)
1024                 return;
1025         old = battery->bat.dev;
1026         if (event == ACPI_BATTERY_NOTIFY_INFO)
1027                 acpi_battery_refresh(battery);
1028         acpi_battery_update(battery);
1029         acpi_bus_generate_proc_event(device, event,
1030                                      acpi_battery_present(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);