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