drivers/acpi/battery.c

   1 /*
   2  *  battery.c - ACPI Battery Driver (Revision: 2.0)
   3  *
   4  *  Copyright (C) 2007 Alexey Starikovskiy <astarikovskiy@suse.de>
   5  *  Copyright (C) 2004-2007 Vladimir Lebedev <vladimir.p.lebedev@intel.com>
   6  *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
   7  *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
   8  *
   9  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  10  *
  11  *  This program is free software; you can redistribute it and/or modify
  12  *  it under the terms of the GNU General Public License as published by
  13  *  the Free Software Foundation; either version 2 of the License, or (at
  14  *  your option) any later version.
  15  *
  16  *  This program is distributed in the hope that it will be useful, but
  17  *  WITHOUT ANY WARRANTY; without even the implied warranty of
  18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  *  General Public License for more details.
  20  *
  21  *  You should have received a copy of the GNU General Public License along
  22  *  with this program; if not, write to the Free Software Foundation, Inc.,
  23  *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  24  *
  25  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  26  */
  27
  28 #include <linux/kernel.h>
  29 #include <linux/module.h>
  30 #include <linux/init.h>
  31 #include <linux/types.h>
  32 #include <linux/jiffies.h>
  33 #include <linux/async.h>
  34 #include <linux/dmi.h>
  35 #include <linux/slab.h>
  36 #include <linux/suspend.h>
  37 #include <asm/unaligned.h>
  38
  39 #ifdef CONFIG_ACPI_PROCFS_POWER
  40 #include <linux/proc_fs.h>
  41 #include <linux/seq_file.h>
  42 #include <asm/uaccess.h>
  43 #endif
  44
  45 #include <acpi/acpi_bus.h>
  46 #include <acpi/acpi_drivers.h>
  47 #include <linux/power_supply.h>
  48
  49 #define PREFIX "ACPI: "
  50
  51 #define ACPI_BATTERY_VALUE_UNKNOWN 0xFFFFFFFF
  52
  53 #define ACPI_BATTERY_CLASS              "battery"
  54 #define ACPI_BATTERY_DEVICE_NAME        "Battery"
  55 #define ACPI_BATTERY_NOTIFY_STATUS      0x80
  56 #define ACPI_BATTERY_NOTIFY_INFO        0x81
  57 #define ACPI_BATTERY_NOTIFY_THRESHOLD   0x82
  58
  59 /* Battery power unit: 0 means mW, 1 means mA */
  60 #define ACPI_BATTERY_POWER_UNIT_MA      1
  61
  62 #define _COMPONENT              ACPI_BATTERY_COMPONENT
  63
  64 ACPI_MODULE_NAME("battery");
  65
  66 MODULE_AUTHOR("Paul Diefenbaugh");
  67 MODULE_AUTHOR("Alexey Starikovskiy <astarikovskiy@suse.de>");
  68 MODULE_DESCRIPTION("ACPI Battery Driver");
  69 MODULE_LICENSE("GPL");
  70
  71 static 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         union acpi_object arg0 = { .type = ACPI_TYPE_INTEGER };
 537         struct acpi_object_list arg_list = { 1, &arg0 };
 538
 539         if (!acpi_battery_present(battery) ||
 540             !test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags))
 541                 return -ENODEV;
 542
 543         arg0.integer.value = battery->alarm;
 544
 545         mutex_lock(&battery->lock);
 546         status = acpi_evaluate_object(battery->device->handle, "_BTP",
 547                                  &arg_list, NULL);
 548         mutex_unlock(&battery->lock);
 549
 550         if (ACPI_FAILURE(status))
 551                 return -ENODEV;
 552
 553         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Alarm set to %d\n", battery->alarm));
 554         return 0;
 555 }
 556
 557 static int acpi_battery_init_alarm(struct acpi_battery *battery)
 558 {
 559         acpi_status status = AE_OK;
 560         acpi_handle handle = NULL;
 561
 562         /* See if alarms are supported, and if so, set default */
 563         status = acpi_get_handle(battery->device->handle, "_BTP", &handle);
 564         if (ACPI_FAILURE(status)) {
 565                 clear_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
 566                 return 0;
 567         }
 568         set_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
 569         if (!battery->alarm)
 570                 battery->alarm = battery->design_capacity_warning;
 571         return acpi_battery_set_alarm(battery);
 572 }
 573
 574 static ssize_t acpi_battery_alarm_show(struct device *dev,
 575                                         struct device_attribute *attr,
 576                                         char *buf)
 577 {
 578         struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
 579         return sprintf(buf, "%d\n", battery->alarm * 1000);
 580 }
 581
 582 static ssize_t acpi_battery_alarm_store(struct device *dev,
 583                                         struct device_attribute *attr,
 584                                         const char *buf, size_t count)
 585 {
 586         unsigned long x;
 587         struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
 588         if (sscanf(buf, "%ld\n", &x) == 1)
 589                 battery->alarm = x/1000;
 590         if (acpi_battery_present(battery))
 591                 acpi_battery_set_alarm(battery);
 592         return count;
 593 }
 594
 595 static struct device_attribute alarm_attr = {
 596         .attr = {.name = "alarm", .mode = 0644},
 597         .show = acpi_battery_alarm_show,
 598         .store = acpi_battery_alarm_store,
 599 };
 600
 601 static int sysfs_add_battery(struct acpi_battery *battery)
 602 {
 603         int result;
 604
 605         if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) {
 606                 battery->bat.properties = charge_battery_props;
 607                 battery->bat.num_properties =
 608                         ARRAY_SIZE(charge_battery_props);
 609         } else {
 610                 battery->bat.properties = energy_battery_props;
 611                 battery->bat.num_properties =
 612                         ARRAY_SIZE(energy_battery_props);
 613         }
 614
 615         battery->bat.name = acpi_device_bid(battery->device);
 616         battery->bat.type = POWER_SUPPLY_TYPE_BATTERY;
 617         battery->bat.get_property = acpi_battery_get_property;
 618
 619         result = power_supply_register(&battery->device->dev, &battery->bat);
 620         if (result)
 621                 return result;
 622         return device_create_file(battery->bat.dev, &alarm_attr);
 623 }
 624
 625 static void sysfs_remove_battery(struct acpi_battery *battery)
 626 {
 627         mutex_lock(&battery->sysfs_lock);
 628         if (!battery->bat.dev) {
 629                 mutex_unlock(&battery->sysfs_lock);
 630                 return;
 631         }
 632
 633         device_remove_file(battery->bat.dev, &alarm_attr);
 634         power_supply_unregister(&battery->bat);
 635         battery->bat.dev = NULL;
 636         mutex_unlock(&battery->sysfs_lock);
 637 }
 638
 639 static void find_battery(const struct dmi_header *dm, void *private)
 640 {
 641         struct acpi_battery *battery = (struct acpi_battery *)private;
 642         /* Note: the hardcoded offsets below have been extracted from
 643            the source code of dmidecode.  */
 644         if (dm->type == DMI_ENTRY_PORTABLE_BATTERY && dm->length >= 8) {
 645                 const u8 *dmi_data = (const u8 *)(dm + 1);
 646                 int dmi_capacity = get_unaligned((const u16 *)(dmi_data + 6));
 647                 if (dm->length >= 18)
 648                         dmi_capacity *= dmi_data[17];
 649                 if (battery->design_capacity * battery->design_voltage / 1000
 650                     != dmi_capacity &&
 651                     battery->design_capacity * 10 == dmi_capacity)
 652                         set_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
 653                                 &battery->flags);
 654         }
 655 }
 656
 657 /*
 658  * According to the ACPI spec, some kinds of primary batteries can
 659  * report percentage battery remaining capacity directly to OS.
 660  * In this case, it reports the Last Full Charged Capacity == 100
 661  * and BatteryPresentRate == 0xFFFFFFFF.
 662  *
 663  * Now we found some battery reports percentage remaining capacity
 664  * even if it's rechargeable.
 665  * https://bugzilla.kernel.org/show_bug.cgi?id=15979
 666  *
 667  * Handle this correctly so that they won't break userspace.
 668  */
 669 static void acpi_battery_quirks(struct acpi_battery *battery)
 670 {
 671         if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
 672                 return ;
 673
 674         if (battery->full_charge_capacity == 100 &&
 675             battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN &&
 676             battery->capacity_now >=0 && battery->capacity_now <= 100) {
 677                 set_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags);
 678                 battery->full_charge_capacity = battery->design_capacity;
 679                 battery->capacity_now = (battery->capacity_now *
 680                                 battery->full_charge_capacity) / 100;
 681         }
 682
 683         if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags))
 684                 return ;
 685
 686         if (battery->power_unit && dmi_name_in_vendors("LENOVO")) {
 687                 const char *s;
 688                 s = dmi_get_system_info(DMI_PRODUCT_VERSION);
 689                 if (s && !strnicmp(s, "ThinkPad", 8)) {
 690                         dmi_walk(find_battery, battery);
 691                         if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
 692                                      &battery->flags) &&
 693                             battery->design_voltage) {
 694                                 battery->design_capacity =
 695                                     battery->design_capacity *
 696                                     10000 / battery->design_voltage;
 697                                 battery->full_charge_capacity =
 698                                     battery->full_charge_capacity *
 699                                     10000 / battery->design_voltage;
 700                                 battery->design_capacity_warning =
 701                                     battery->design_capacity_warning *
 702                                     10000 / battery->design_voltage;
 703                                 battery->capacity_now = battery->capacity_now *
 704                                     10000 / battery->design_voltage;
 705                         }
 706                 }
 707         }
 708 }
 709
 710 static int acpi_battery_update(struct acpi_battery *battery)
 711 {
 712         int result, old_present = acpi_battery_present(battery);
 713         result = acpi_battery_get_status(battery);
 714         if (result)
 715                 return result;
 716         if (!acpi_battery_present(battery)) {
 717                 sysfs_remove_battery(battery);
 718                 battery->update_time = 0;
 719                 return 0;
 720         }
 721         if (!battery->update_time ||
 722             old_present != acpi_battery_present(battery)) {
 723                 result = acpi_battery_get_info(battery);
 724                 if (result)
 725                         return result;
 726                 acpi_battery_init_alarm(battery);
 727         }
 728         if (!battery->bat.dev) {
 729                 result = sysfs_add_battery(battery);
 730                 if (result)
 731                         return result;
 732         }
 733         result = acpi_battery_get_state(battery);
 734         acpi_battery_quirks(battery);
 735         return result;
 736 }
 737
 738 static void acpi_battery_refresh(struct acpi_battery *battery)
 739 {
 740         int power_unit;
 741
 742         if (!battery->bat.dev)
 743                 return;
 744
 745         power_unit = battery->power_unit;
 746
 747         acpi_battery_get_info(battery);
 748
 749         if (power_unit == battery->power_unit)
 750                 return;
 751
 752         /* The battery has changed its reporting units. */
 753         sysfs_remove_battery(battery);
 754         sysfs_add_battery(battery);
 755 }
 756
 757 /* --------------------------------------------------------------------------
 758                               FS Interface (/proc)
 759    -------------------------------------------------------------------------- */
 760
 761 #ifdef CONFIG_ACPI_PROCFS_POWER
 762 static struct proc_dir_entry *acpi_battery_dir;
 763
 764 static int acpi_battery_print_info(struct seq_file *seq, int result)
 765 {
 766         struct acpi_battery *battery = seq->private;
 767
 768         if (result)
 769                 goto end;
 770
 771         seq_printf(seq, "present:                 %s\n",
 772                    acpi_battery_present(battery)?"yes":"no");
 773         if (!acpi_battery_present(battery))
 774                 goto end;
 775         if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
 776                 seq_printf(seq, "design capacity:         unknown\n");
 777         else
 778                 seq_printf(seq, "design capacity:         %d %sh\n",
 779                            battery->design_capacity,
 780                            acpi_battery_units(battery));
 781
 782         if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
 783                 seq_printf(seq, "last full capacity:      unknown\n");
 784         else
 785                 seq_printf(seq, "last full capacity:      %d %sh\n",
 786                            battery->full_charge_capacity,
 787                            acpi_battery_units(battery));
 788
 789         seq_printf(seq, "battery technology:      %srechargeable\n",
 790                    (!battery->technology)?"non-":"");
 791
 792         if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
 793                 seq_printf(seq, "design voltage:          unknown\n");
 794         else
 795                 seq_printf(seq, "design voltage:          %d mV\n",
 796                            battery->design_voltage);
 797         seq_printf(seq, "design capacity warning: %d %sh\n",
 798                    battery->design_capacity_warning,
 799                    acpi_battery_units(battery));
 800         seq_printf(seq, "design capacity low:     %d %sh\n",
 801                    battery->design_capacity_low,
 802                    acpi_battery_units(battery));
 803         seq_printf(seq, "cycle count:             %i\n", battery->cycle_count);
 804         seq_printf(seq, "capacity granularity 1:  %d %sh\n",
 805                    battery->capacity_granularity_1,
 806                    acpi_battery_units(battery));
 807         seq_printf(seq, "capacity granularity 2:  %d %sh\n",
 808                    battery->capacity_granularity_2,
 809                    acpi_battery_units(battery));
 810         seq_printf(seq, "model number:            %s\n", battery->model_number);
 811         seq_printf(seq, "serial number:           %s\n", battery->serial_number);
 812         seq_printf(seq, "battery type:            %s\n", battery->type);
 813         seq_printf(seq, "OEM info:                %s\n", battery->oem_info);
 814       end:
 815         if (result)
 816                 seq_printf(seq, "ERROR: Unable to read battery info\n");
 817         return result;
 818 }
 819
 820 static int acpi_battery_print_state(struct seq_file *seq, int result)
 821 {
 822         struct acpi_battery *battery = seq->private;
 823
 824         if (result)
 825                 goto end;
 826
 827         seq_printf(seq, "present:                 %s\n",
 828                    acpi_battery_present(battery)?"yes":"no");
 829         if (!acpi_battery_present(battery))
 830                 goto end;
 831
 832         seq_printf(seq, "capacity state:          %s\n",
 833                         (battery->state & 0x04)?"critical":"ok");
 834         if ((battery->state & 0x01) && (battery->state & 0x02))
 835                 seq_printf(seq,
 836                            "charging state:          charging/discharging\n");
 837         else if (battery->state & 0x01)
 838                 seq_printf(seq, "charging state:          discharging\n");
 839         else if (battery->state & 0x02)
 840                 seq_printf(seq, "charging state:          charging\n");
 841         else
 842                 seq_printf(seq, "charging state:          charged\n");
 843
 844         if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
 845                 seq_printf(seq, "present rate:            unknown\n");
 846         else
 847                 seq_printf(seq, "present rate:            %d %s\n",
 848                            battery->rate_now, acpi_battery_units(battery));
 849
 850         if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
 851                 seq_printf(seq, "remaining capacity:      unknown\n");
 852         else
 853                 seq_printf(seq, "remaining capacity:      %d %sh\n",
 854                            battery->capacity_now, acpi_battery_units(battery));
 855         if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
 856                 seq_printf(seq, "present voltage:         unknown\n");
 857         else
 858                 seq_printf(seq, "present voltage:         %d mV\n",
 859                            battery->voltage_now);
 860       end:
 861         if (result)
 862                 seq_printf(seq, "ERROR: Unable to read battery state\n");
 863
 864         return result;
 865 }
 866
 867 static int acpi_battery_print_alarm(struct seq_file *seq, int result)
 868 {
 869         struct acpi_battery *battery = seq->private;
 870
 871         if (result)
 872                 goto end;
 873
 874         if (!acpi_battery_present(battery)) {
 875                 seq_printf(seq, "present:                 no\n");
 876                 goto end;
 877         }
 878         seq_printf(seq, "alarm:                   ");
 879         if (!battery->alarm)
 880                 seq_printf(seq, "unsupported\n");
 881         else
 882                 seq_printf(seq, "%u %sh\n", battery->alarm,
 883                                 acpi_battery_units(battery));
 884       end:
 885         if (result)
 886                 seq_printf(seq, "ERROR: Unable to read battery alarm\n");
 887         return result;
 888 }
 889
 890 static ssize_t acpi_battery_write_alarm(struct file *file,
 891                                         const char __user * buffer,
 892                                         size_t count, loff_t * ppos)
 893 {
 894         int result = 0;
 895         char alarm_string[12] = { '\0' };
 896         struct seq_file *m = file->private_data;
 897         struct acpi_battery *battery = m->private;
 898
 899         if (!battery || (count > sizeof(alarm_string) - 1))
 900                 return -EINVAL;
 901         if (!acpi_battery_present(battery)) {
 902                 result = -ENODEV;
 903                 goto end;
 904         }
 905         if (copy_from_user(alarm_string, buffer, count)) {
 906                 result = -EFAULT;
 907                 goto end;
 908         }
 909         alarm_string[count] = '\0';
 910         battery->alarm = simple_strtol(alarm_string, NULL, 0);
 911         result = acpi_battery_set_alarm(battery);
 912       end:
 913         if (!result)
 914                 return count;
 915         return result;
 916 }
 917
 918 typedef int(*print_func)(struct seq_file *seq, int result);
 919
 920 static print_func acpi_print_funcs[ACPI_BATTERY_NUMFILES] = {
 921         acpi_battery_print_info,
 922         acpi_battery_print_state,
 923         acpi_battery_print_alarm,
 924 };
 925
 926 static int acpi_battery_read(int fid, struct seq_file *seq)
 927 {
 928         struct acpi_battery *battery = seq->private;
 929         int result = acpi_battery_update(battery);
 930         return acpi_print_funcs[fid](seq, result);
 931 }
 932
 933 #define DECLARE_FILE_FUNCTIONS(_name) \
 934 static int acpi_battery_read_##_name(struct seq_file *seq, void *offset) \
 935 { \
 936         return acpi_battery_read(_name##_tag, seq); \
 937 } \
 938 static int acpi_battery_##_name##_open_fs(struct inode *inode, struct file *file) \
 939 { \
 940         return single_open(file, acpi_battery_read_##_name, PDE_DATA(inode)); \
 941 }
 942
 943 DECLARE_FILE_FUNCTIONS(info);
 944 DECLARE_FILE_FUNCTIONS(state);
 945 DECLARE_FILE_FUNCTIONS(alarm);
 946
 947 #undef DECLARE_FILE_FUNCTIONS
 948
 949 #define FILE_DESCRIPTION_RO(_name) \
 950         { \
 951         .name = __stringify(_name), \
 952         .mode = S_IRUGO, \
 953         .ops = { \
 954                 .open = acpi_battery_##_name##_open_fs, \
 955                 .read = seq_read, \
 956                 .llseek = seq_lseek, \
 957                 .release = single_release, \
 958                 .owner = THIS_MODULE, \
 959                 }, \
 960         }
 961
 962 #define FILE_DESCRIPTION_RW(_name) \
 963         { \
 964         .name = __stringify(_name), \
 965         .mode = S_IFREG | S_IRUGO | S_IWUSR, \
 966         .ops = { \
 967                 .open = acpi_battery_##_name##_open_fs, \
 968                 .read = seq_read, \
 969                 .llseek = seq_lseek, \
 970                 .write = acpi_battery_write_##_name, \
 971                 .release = single_release, \
 972                 .owner = THIS_MODULE, \
 973                 }, \
 974         }
 975
 976 static const struct battery_file {
 977         struct file_operations ops;
 978         umode_t mode;
 979         const char *name;
 980 } acpi_battery_file[] = {
 981         FILE_DESCRIPTION_RO(info),
 982         FILE_DESCRIPTION_RO(state),
 983         FILE_DESCRIPTION_RW(alarm),
 984 };
 985
 986 #undef FILE_DESCRIPTION_RO
 987 #undef FILE_DESCRIPTION_RW
 988
 989 static int acpi_battery_add_fs(struct acpi_device *device)
 990 {
 991         struct proc_dir_entry *entry = NULL;
 992         int i;
 993
 994         printk(KERN_WARNING PREFIX "Deprecated procfs I/F for battery is loaded,"
 995                         " please retry with CONFIG_ACPI_PROCFS_POWER cleared\n");
 996         if (!acpi_device_dir(device)) {
 997                 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
 998                                                      acpi_battery_dir);
 999                 if (!acpi_device_dir(device))
1000                         return -ENODEV;
1001         }
1002
1003         for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i) {
1004                 entry = proc_create_data(acpi_battery_file[i].name,
1005                                          acpi_battery_file[i].mode,
1006                                          acpi_device_dir(device),
1007                                          &acpi_battery_file[i].ops,
1008                                          acpi_driver_data(device));
1009                 if (!entry)
1010                         return -ENODEV;
1011         }
1012         return 0;
1013 }
1014
1015 static void acpi_battery_remove_fs(struct acpi_device *device)
1016 {
1017         int i;
1018         if (!acpi_device_dir(device))
1019                 return;
1020         for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i)
1021                 remove_proc_entry(acpi_battery_file[i].name,
1022                                   acpi_device_dir(device));
1023
1024         remove_proc_entry(acpi_device_bid(device), acpi_battery_dir);
1025         acpi_device_dir(device) = NULL;
1026 }
1027
1028 #endif
1029
1030 /* --------------------------------------------------------------------------
1031                                  Driver Interface
1032    -------------------------------------------------------------------------- */
1033
1034 static void acpi_battery_notify(struct acpi_device *device, u32 event)
1035 {
1036         struct acpi_battery *battery = acpi_driver_data(device);
1037         struct device *old;
1038
1039         if (!battery)
1040                 return;
1041         old = battery->bat.dev;
1042         if (event == ACPI_BATTERY_NOTIFY_INFO)
1043                 acpi_battery_refresh(battery);
1044         acpi_battery_update(battery);
1045         acpi_bus_generate_proc_event(device, event,
1046                                      acpi_battery_present(battery));
1047         acpi_bus_generate_netlink_event(device->pnp.device_class,
1048                                         dev_name(&device->dev), event,
1049                                         acpi_battery_present(battery));
1050         /* acpi_battery_update could remove power_supply object */
1051         if (old && battery->bat.dev)
1052                 power_supply_changed(&battery->bat);
1053 }
1054
1055 static int battery_notify(struct notifier_block *nb,
1056                                unsigned long mode, void *_unused)
1057 {
1058         struct acpi_battery *battery = container_of(nb, struct acpi_battery,
1059                                                     pm_nb);
1060         switch (mode) {
1061         case PM_POST_HIBERNATION:
1062         case PM_POST_SUSPEND:
1063                 if (battery->bat.dev) {
1064                         sysfs_remove_battery(battery);
1065                         sysfs_add_battery(battery);
1066                 }
1067                 break;
1068         }
1069
1070         return 0;
1071 }
1072
1073 static struct dmi_system_id bat_dmi_table[] = {
1074         {
1075                 .ident = "NEC LZ750/LS",
1076                 .matches = {
1077                         DMI_MATCH(DMI_SYS_VENDOR, "NEC"),
1078                         DMI_MATCH(DMI_PRODUCT_NAME, "PC-LZ750LS"),
1079                 },
1080         },
1081         {},
1082 };
1083
1084 static int acpi_battery_add(struct acpi_device *device)
1085 {
1086         int result = 0;
1087         struct acpi_battery *battery = NULL;
1088         acpi_handle handle;
1089         if (!device)
1090                 return -EINVAL;
1091         battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL);
1092         if (!battery)
1093                 return -ENOMEM;
1094         battery->device = device;
1095         strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME);
1096         strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS);
1097         device->driver_data = battery;
1098         mutex_init(&battery->lock);
1099         mutex_init(&battery->sysfs_lock);
1100         if (ACPI_SUCCESS(acpi_get_handle(battery->device->handle,
1101                         "_BIX", &handle)))
1102                 set_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags);
1103         result = acpi_battery_update(battery);
1104         if (result)
1105                 goto fail;
1106 #ifdef CONFIG_ACPI_PROCFS_POWER
1107         result = acpi_battery_add_fs(device);
1108 #endif
1109         if (result) {
1110 #ifdef CONFIG_ACPI_PROCFS_POWER
1111                 acpi_battery_remove_fs(device);
1112 #endif
1113                 goto fail;
1114         }
1115
1116         printk(KERN_INFO PREFIX "%s Slot [%s] (battery %s)\n",
1117                 ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device),
1118                 device->status.battery_present ? "present" : "absent");
1119
1120         battery->pm_nb.notifier_call = battery_notify;
1121         register_pm_notifier(&battery->pm_nb);
1122
1123         return result;
1124
1125 fail:
1126         sysfs_remove_battery(battery);
1127         mutex_destroy(&battery->lock);
1128         mutex_destroy(&battery->sysfs_lock);
1129         kfree(battery);
1130         return result;
1131 }
1132
1133 static int acpi_battery_remove(struct acpi_device *device)
1134 {
1135         struct acpi_battery *battery = NULL;
1136
1137         if (!device || !acpi_driver_data(device))
1138                 return -EINVAL;
1139         battery = acpi_driver_data(device);
1140         unregister_pm_notifier(&battery->pm_nb);
1141 #ifdef CONFIG_ACPI_PROCFS_POWER
1142         acpi_battery_remove_fs(device);
1143 #endif
1144         sysfs_remove_battery(battery);
1145         mutex_destroy(&battery->lock);
1146         mutex_destroy(&battery->sysfs_lock);
1147         kfree(battery);
1148         return 0;
1149 }
1150
1151 #ifdef CONFIG_PM_SLEEP
1152 /* this is needed to learn about changes made in suspended state */
1153 static int acpi_battery_resume(struct device *dev)
1154 {
1155         struct acpi_battery *battery;
1156
1157         if (!dev)
1158                 return -EINVAL;
1159
1160         battery = acpi_driver_data(to_acpi_device(dev));
1161         if (!battery)
1162                 return -EINVAL;
1163
1164         battery->update_time = 0;
1165         acpi_battery_update(battery);
1166         return 0;
1167 }
1168 #endif
1169
1170 static SIMPLE_DEV_PM_OPS(acpi_battery_pm, NULL, acpi_battery_resume);
1171
1172 static struct acpi_driver acpi_battery_driver = {
1173         .name = "battery",
1174         .class = ACPI_BATTERY_CLASS,
1175         .ids = battery_device_ids,
1176         .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
1177         .ops = {
1178                 .add = acpi_battery_add,
1179                 .remove = acpi_battery_remove,
1180                 .notify = acpi_battery_notify,
1181                 },
1182         .drv.pm = &acpi_battery_pm,
1183 };
1184
1185 static void __init acpi_battery_init_async(void *unused, async_cookie_t cookie)
1186 {
1187         if (acpi_disabled)
1188                 return;
1189 #ifdef CONFIG_ACPI_PROCFS_POWER
1190         acpi_battery_dir = acpi_lock_battery_dir();
1191         if (!acpi_battery_dir)
1192                 return;
1193 #endif
1194         if (dmi_check_system(bat_dmi_table))
1195                 battery_bix_broken_package = 1;
1196         if (acpi_bus_register_driver(&acpi_battery_driver) < 0) {
1197 #ifdef CONFIG_ACPI_PROCFS_POWER
1198                 acpi_unlock_battery_dir(acpi_battery_dir);
1199 #endif
1200                 return;
1201         }
1202         return;
1203 }
1204
1205 static int __init acpi_battery_init(void)
1206 {
1207         async_schedule(acpi_battery_init_async, NULL);
1208         return 0;
1209 }
1210
1211 static void __exit acpi_battery_exit(void)
1212 {
1213         acpi_bus_unregister_driver(&acpi_battery_driver);
1214 #ifdef CONFIG_ACPI_PROCFS_POWER
1215         acpi_unlock_battery_dir(acpi_battery_dir);
1216 #endif
1217 }
1218
1219 module_init(acpi_battery_init);
1220 module_exit(acpi_battery_exit);