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