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