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  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  22  */
  23
  24 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  25
  26 #include <linux/kernel.h>
  27 #include <linux/list.h>
  28 #include <linux/module.h>
  29 #include <linux/mutex.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/delay.h>
  36 #include <linux/slab.h>
  37 #include <linux/suspend.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 <linux/uaccess.h>
  44 #endif
  45
  46 #include <linux/acpi.h>
  47 #include <linux/power_supply.h>
  48
  49 #include <acpi/battery.h>
  50
  51 #define PREFIX "ACPI: "
  52
  53 #define ACPI_BATTERY_VALUE_UNKNOWN 0xFFFFFFFF
  54
  55 #define ACPI_BATTERY_DEVICE_NAME        "Battery"
  56
  57 /* Battery power unit: 0 means mW, 1 means mA */
  58 #define ACPI_BATTERY_POWER_UNIT_MA      1
  59
  60 #define ACPI_BATTERY_STATE_DISCHARGING  0x1
  61 #define ACPI_BATTERY_STATE_CHARGING     0x2
  62 #define ACPI_BATTERY_STATE_CRITICAL     0x4
  63
  64 #define _COMPONENT              ACPI_BATTERY_COMPONENT
  65
  66 ACPI_MODULE_NAME("battery");
  67
  68 MODULE_AUTHOR("Paul Diefenbaugh");
  69 MODULE_AUTHOR("Alexey Starikovskiy <astarikovskiy@suse.de>");
  70 MODULE_DESCRIPTION("ACPI Battery Driver");
  71 MODULE_LICENSE("GPL");
  72
  73 static async_cookie_t async_cookie;
  74 static bool battery_driver_registered;
  75 static int battery_bix_broken_package;
  76 static int battery_notification_delay_ms;
  77 static int battery_ac_is_broken;
  78 static int battery_check_pmic = 1;
  79 static unsigned int cache_time = 1000;
  80 module_param(cache_time, uint, 0644);
  81 MODULE_PARM_DESC(cache_time, "cache time in milliseconds");
  82
  83 #ifdef CONFIG_ACPI_PROCFS_POWER
  84 extern struct proc_dir_entry *acpi_lock_battery_dir(void);
  85 extern void *acpi_unlock_battery_dir(struct proc_dir_entry *acpi_battery_dir);
  86 #endif
  87
  88 static const struct acpi_device_id battery_device_ids[] = {
  89         {"PNP0C0A", 0},
  90         {"", 0},
  91 };
  92
  93 MODULE_DEVICE_TABLE(acpi, battery_device_ids);
  94
  95 /* Lists of PMIC ACPI HIDs with an (often better) native battery driver */
  96 static const char * const acpi_battery_blacklist[] = {
  97         "INT33F4", /* X-Powers AXP288 PMIC */
  98 };
  99
 100 enum {
 101         ACPI_BATTERY_ALARM_PRESENT,
 102         ACPI_BATTERY_XINFO_PRESENT,
 103         ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY,
 104         /* On Lenovo Thinkpad models from 2010 and 2011, the power unit
 105            switches between mWh and mAh depending on whether the system
 106            is running on battery or not.  When mAh is the unit, most
 107            reported values are incorrect and need to be adjusted by
 108            10000/design_voltage.  Verified on x201, t410, t410s, and x220.
 109            Pre-2010 and 2012 models appear to always report in mWh and
 110            are thus unaffected (tested with t42, t61, t500, x200, x300,
 111            and x230).  Also, in mid-2012 Lenovo issued a BIOS update for
 112            the 2011 models that fixes the issue (tested on x220 with a
 113            post-1.29 BIOS), but as of Nov. 2012, no such update is
 114            available for the 2010 models.  */
 115         ACPI_BATTERY_QUIRK_THINKPAD_MAH,
 116         /* for batteries reporting current capacity with design capacity
 117          * on a full charge, but showing degradation in full charge cap.
 118          */
 119         ACPI_BATTERY_QUIRK_DEGRADED_FULL_CHARGE,
 120 };
 121
 122 struct acpi_battery {
 123         struct mutex lock;
 124         struct mutex sysfs_lock;
 125         struct power_supply *bat;
 126         struct power_supply_desc bat_desc;
 127         struct acpi_device *device;
 128         struct notifier_block pm_nb;
 129         struct list_head list;
 130         unsigned long update_time;
 131         int revision;
 132         int rate_now;
 133         int capacity_now;
 134         int voltage_now;
 135         int design_capacity;
 136         int full_charge_capacity;
 137         int technology;
 138         int design_voltage;
 139         int design_capacity_warning;
 140         int design_capacity_low;
 141         int cycle_count;
 142         int measurement_accuracy;
 143         int max_sampling_time;
 144         int min_sampling_time;
 145         int max_averaging_interval;
 146         int min_averaging_interval;
 147         int capacity_granularity_1;
 148         int capacity_granularity_2;
 149         int alarm;
 150         char model_number[32];
 151         char serial_number[32];
 152         char type[32];
 153         char oem_info[32];
 154         int state;
 155         int power_unit;
 156         unsigned long flags;
 157 };
 158
 159 #define to_acpi_battery(x) power_supply_get_drvdata(x)
 160
 161 static inline int acpi_battery_present(struct acpi_battery *battery)
 162 {
 163         return battery->device->status.battery_present;
 164 }
 165
 166 static int acpi_battery_technology(struct acpi_battery *battery)
 167 {
 168         if (!strcasecmp("NiCd", battery->type))
 169                 return POWER_SUPPLY_TECHNOLOGY_NiCd;
 170         if (!strcasecmp("NiMH", battery->type))
 171                 return POWER_SUPPLY_TECHNOLOGY_NiMH;
 172         if (!strcasecmp("LION", battery->type))
 173                 return POWER_SUPPLY_TECHNOLOGY_LION;
 174         if (!strncasecmp("LI-ION", battery->type, 6))
 175                 return POWER_SUPPLY_TECHNOLOGY_LION;
 176         if (!strcasecmp("LiP", battery->type))
 177                 return POWER_SUPPLY_TECHNOLOGY_LIPO;
 178         return POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
 179 }
 180
 181 static int acpi_battery_get_state(struct acpi_battery *battery);
 182
 183 static int acpi_battery_is_charged(struct acpi_battery *battery)
 184 {
 185         /* charging, discharging or critical low */
 186         if (battery->state != 0)
 187                 return 0;
 188
 189         /* battery not reporting charge */
 190         if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN ||
 191             battery->capacity_now == 0)
 192                 return 0;
 193
 194         /* good batteries update full_charge as the batteries degrade */
 195         if (battery->full_charge_capacity == battery->capacity_now)
 196                 return 1;
 197
 198         /* fallback to using design values for broken batteries */
 199         if (battery->design_capacity == battery->capacity_now)
 200                 return 1;
 201
 202         /* we don't do any sort of metric based on percentages */
 203         return 0;
 204 }
 205
 206 static bool acpi_battery_is_degraded(struct acpi_battery *battery)
 207 {
 208         return battery->full_charge_capacity && battery->design_capacity &&
 209                 battery->full_charge_capacity < battery->design_capacity;
 210 }
 211
 212 static int acpi_battery_handle_discharging(struct acpi_battery *battery)
 213 {
 214         /*
 215          * Some devices wrongly report discharging if the battery's charge level
 216          * was above the device's start charging threshold atm the AC adapter
 217          * was plugged in and the device thus did not start a new charge cycle.
 218          */
 219         if ((battery_ac_is_broken || power_supply_is_system_supplied()) &&
 220             battery->rate_now == 0)
 221                 return POWER_SUPPLY_STATUS_NOT_CHARGING;
 222
 223         return POWER_SUPPLY_STATUS_DISCHARGING;
 224 }
 225
 226 static int acpi_battery_get_property(struct power_supply *psy,
 227                                      enum power_supply_property psp,
 228                                      union power_supply_propval *val)
 229 {
 230         int ret = 0;
 231         struct acpi_battery *battery = to_acpi_battery(psy);
 232
 233         if (acpi_battery_present(battery)) {
 234                 /* run battery update only if it is present */
 235                 acpi_battery_get_state(battery);
 236         } else if (psp != POWER_SUPPLY_PROP_PRESENT)
 237                 return -ENODEV;
 238         switch (psp) {
 239         case POWER_SUPPLY_PROP_STATUS:
 240                 if (battery->state & ACPI_BATTERY_STATE_DISCHARGING)
 241                         val->intval = acpi_battery_handle_discharging(battery);
 242                 else if (battery->state & ACPI_BATTERY_STATE_CHARGING)
 243                         val->intval = POWER_SUPPLY_STATUS_CHARGING;
 244                 else if (acpi_battery_is_charged(battery))
 245                         val->intval = POWER_SUPPLY_STATUS_FULL;
 246                 else
 247                         val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
 248                 break;
 249         case POWER_SUPPLY_PROP_PRESENT:
 250                 val->intval = acpi_battery_present(battery);
 251                 break;
 252         case POWER_SUPPLY_PROP_TECHNOLOGY:
 253                 val->intval = acpi_battery_technology(battery);
 254                 break;
 255         case POWER_SUPPLY_PROP_CYCLE_COUNT:
 256                 val->intval = battery->cycle_count;
 257                 break;
 258         case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
 259                 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
 260                         ret = -ENODEV;
 261                 else
 262                         val->intval = battery->design_voltage * 1000;
 263                 break;
 264         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 265                 if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
 266                         ret = -ENODEV;
 267                 else
 268                         val->intval = battery->voltage_now * 1000;
 269                 break;
 270         case POWER_SUPPLY_PROP_CURRENT_NOW:
 271         case POWER_SUPPLY_PROP_POWER_NOW:
 272                 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
 273                         ret = -ENODEV;
 274                 else
 275                         val->intval = battery->rate_now * 1000;
 276                 break;
 277         case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
 278         case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
 279                 if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
 280                         ret = -ENODEV;
 281                 else
 282                         val->intval = battery->design_capacity * 1000;
 283                 break;
 284         case POWER_SUPPLY_PROP_CHARGE_FULL:
 285         case POWER_SUPPLY_PROP_ENERGY_FULL:
 286                 if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
 287                         ret = -ENODEV;
 288                 else
 289                         val->intval = battery->full_charge_capacity * 1000;
 290                 break;
 291         case POWER_SUPPLY_PROP_CHARGE_NOW:
 292         case POWER_SUPPLY_PROP_ENERGY_NOW:
 293                 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
 294                         ret = -ENODEV;
 295                 else
 296                         val->intval = battery->capacity_now * 1000;
 297                 break;
 298         case POWER_SUPPLY_PROP_CAPACITY:
 299                 if (battery->capacity_now && battery->full_charge_capacity)
 300                         val->intval = battery->capacity_now * 100/
 301                                         battery->full_charge_capacity;
 302                 else
 303                         val->intval = 0;
 304                 break;
 305         case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
 306                 if (battery->state & ACPI_BATTERY_STATE_CRITICAL)
 307                         val->intval = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
 308                 else if (test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags) &&
 309                         (battery->capacity_now <= battery->alarm))
 310                         val->intval = POWER_SUPPLY_CAPACITY_LEVEL_LOW;
 311                 else if (acpi_battery_is_charged(battery))
 312                         val->intval = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
 313                 else
 314                         val->intval = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
 315                 break;
 316         case POWER_SUPPLY_PROP_MODEL_NAME:
 317                 val->strval = battery->model_number;
 318                 break;
 319         case POWER_SUPPLY_PROP_MANUFACTURER:
 320                 val->strval = battery->oem_info;
 321                 break;
 322         case POWER_SUPPLY_PROP_SERIAL_NUMBER:
 323                 val->strval = battery->serial_number;
 324                 break;
 325         default:
 326                 ret = -EINVAL;
 327         }
 328         return ret;
 329 }
 330
 331 static enum power_supply_property charge_battery_props[] = {
 332         POWER_SUPPLY_PROP_STATUS,
 333         POWER_SUPPLY_PROP_PRESENT,
 334         POWER_SUPPLY_PROP_TECHNOLOGY,
 335         POWER_SUPPLY_PROP_CYCLE_COUNT,
 336         POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
 337         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 338         POWER_SUPPLY_PROP_CURRENT_NOW,
 339         POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
 340         POWER_SUPPLY_PROP_CHARGE_FULL,
 341         POWER_SUPPLY_PROP_CHARGE_NOW,
 342         POWER_SUPPLY_PROP_CAPACITY,
 343         POWER_SUPPLY_PROP_CAPACITY_LEVEL,
 344         POWER_SUPPLY_PROP_MODEL_NAME,
 345         POWER_SUPPLY_PROP_MANUFACTURER,
 346         POWER_SUPPLY_PROP_SERIAL_NUMBER,
 347 };
 348
 349 static enum power_supply_property energy_battery_props[] = {
 350         POWER_SUPPLY_PROP_STATUS,
 351         POWER_SUPPLY_PROP_PRESENT,
 352         POWER_SUPPLY_PROP_TECHNOLOGY,
 353         POWER_SUPPLY_PROP_CYCLE_COUNT,
 354         POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
 355         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 356         POWER_SUPPLY_PROP_POWER_NOW,
 357         POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
 358         POWER_SUPPLY_PROP_ENERGY_FULL,
 359         POWER_SUPPLY_PROP_ENERGY_NOW,
 360         POWER_SUPPLY_PROP_CAPACITY,
 361         POWER_SUPPLY_PROP_CAPACITY_LEVEL,
 362         POWER_SUPPLY_PROP_MODEL_NAME,
 363         POWER_SUPPLY_PROP_MANUFACTURER,
 364         POWER_SUPPLY_PROP_SERIAL_NUMBER,
 365 };
 366
 367 /* --------------------------------------------------------------------------
 368                                Battery Management
 369    -------------------------------------------------------------------------- */
 370 struct acpi_offsets {
 371         size_t offset;          /* offset inside struct acpi_sbs_battery */
 372         u8 mode;                /* int or string? */
 373 };
 374
 375 static const struct acpi_offsets state_offsets[] = {
 376         {offsetof(struct acpi_battery, state), 0},
 377         {offsetof(struct acpi_battery, rate_now), 0},
 378         {offsetof(struct acpi_battery, capacity_now), 0},
 379         {offsetof(struct acpi_battery, voltage_now), 0},
 380 };
 381
 382 static const struct acpi_offsets info_offsets[] = {
 383         {offsetof(struct acpi_battery, power_unit), 0},
 384         {offsetof(struct acpi_battery, design_capacity), 0},
 385         {offsetof(struct acpi_battery, full_charge_capacity), 0},
 386         {offsetof(struct acpi_battery, technology), 0},
 387         {offsetof(struct acpi_battery, design_voltage), 0},
 388         {offsetof(struct acpi_battery, design_capacity_warning), 0},
 389         {offsetof(struct acpi_battery, design_capacity_low), 0},
 390         {offsetof(struct acpi_battery, capacity_granularity_1), 0},
 391         {offsetof(struct acpi_battery, capacity_granularity_2), 0},
 392         {offsetof(struct acpi_battery, model_number), 1},
 393         {offsetof(struct acpi_battery, serial_number), 1},
 394         {offsetof(struct acpi_battery, type), 1},
 395         {offsetof(struct acpi_battery, oem_info), 1},
 396 };
 397
 398 static const struct acpi_offsets extended_info_offsets[] = {
 399         {offsetof(struct acpi_battery, revision), 0},
 400         {offsetof(struct acpi_battery, power_unit), 0},
 401         {offsetof(struct acpi_battery, design_capacity), 0},
 402         {offsetof(struct acpi_battery, full_charge_capacity), 0},
 403         {offsetof(struct acpi_battery, technology), 0},
 404         {offsetof(struct acpi_battery, design_voltage), 0},
 405         {offsetof(struct acpi_battery, design_capacity_warning), 0},
 406         {offsetof(struct acpi_battery, design_capacity_low), 0},
 407         {offsetof(struct acpi_battery, cycle_count), 0},
 408         {offsetof(struct acpi_battery, measurement_accuracy), 0},
 409         {offsetof(struct acpi_battery, max_sampling_time), 0},
 410         {offsetof(struct acpi_battery, min_sampling_time), 0},
 411         {offsetof(struct acpi_battery, max_averaging_interval), 0},
 412         {offsetof(struct acpi_battery, min_averaging_interval), 0},
 413         {offsetof(struct acpi_battery, capacity_granularity_1), 0},
 414         {offsetof(struct acpi_battery, capacity_granularity_2), 0},
 415         {offsetof(struct acpi_battery, model_number), 1},
 416         {offsetof(struct acpi_battery, serial_number), 1},
 417         {offsetof(struct acpi_battery, type), 1},
 418         {offsetof(struct acpi_battery, oem_info), 1},
 419 };
 420
 421 static int extract_package(struct acpi_battery *battery,
 422                            union acpi_object *package,
 423                            const struct acpi_offsets *offsets, int num)
 424 {
 425         int i;
 426         union acpi_object *element;
 427         if (package->type != ACPI_TYPE_PACKAGE)
 428                 return -EFAULT;
 429         for (i = 0; i < num; ++i) {
 430                 if (package->package.count <= i)
 431                         return -EFAULT;
 432                 element = &package->package.elements[i];
 433                 if (offsets[i].mode) {
 434                         u8 *ptr = (u8 *)battery + offsets[i].offset;
 435                         if (element->type == ACPI_TYPE_STRING ||
 436                             element->type == ACPI_TYPE_BUFFER)
 437                                 strncpy(ptr, element->string.pointer, 32);
 438                         else if (element->type == ACPI_TYPE_INTEGER) {
 439                                 strncpy(ptr, (u8 *)&element->integer.value,
 440                                         sizeof(u64));
 441                                 ptr[sizeof(u64)] = 0;
 442                         } else
 443                                 *ptr = 0; /* don't have value */
 444                 } else {
 445                         int *x = (int *)((u8 *)battery + offsets[i].offset);
 446                         *x = (element->type == ACPI_TYPE_INTEGER) ?
 447                                 element->integer.value : -1;
 448                 }
 449         }
 450         return 0;
 451 }
 452
 453 static int acpi_battery_get_status(struct acpi_battery *battery)
 454 {
 455         if (acpi_bus_get_status(battery->device)) {
 456                 ACPI_EXCEPTION((AE_INFO, AE_ERROR, "Evaluating _STA"));
 457                 return -ENODEV;
 458         }
 459         return 0;
 460 }
 461
 462
 463 static int extract_battery_info(const int use_bix,
 464                          struct acpi_battery *battery,
 465                          const struct acpi_buffer *buffer)
 466 {
 467         int result = -EFAULT;
 468
 469         if (use_bix && battery_bix_broken_package)
 470                 result = extract_package(battery, buffer->pointer,
 471                                 extended_info_offsets + 1,
 472                                 ARRAY_SIZE(extended_info_offsets) - 1);
 473         else if (use_bix)
 474                 result = extract_package(battery, buffer->pointer,
 475                                 extended_info_offsets,
 476                                 ARRAY_SIZE(extended_info_offsets));
 477         else
 478                 result = extract_package(battery, buffer->pointer,
 479                                 info_offsets, ARRAY_SIZE(info_offsets));
 480         if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
 481                 battery->full_charge_capacity = battery->design_capacity;
 482         if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
 483             battery->power_unit && battery->design_voltage) {
 484                 battery->design_capacity = battery->design_capacity *
 485                     10000 / battery->design_voltage;
 486                 battery->full_charge_capacity = battery->full_charge_capacity *
 487                     10000 / battery->design_voltage;
 488                 battery->design_capacity_warning =
 489                     battery->design_capacity_warning *
 490                     10000 / battery->design_voltage;
 491                 /* Curiously, design_capacity_low, unlike the rest of them,
 492                    is correct.  */
 493                 /* capacity_granularity_* equal 1 on the systems tested, so
 494                    it's impossible to tell if they would need an adjustment
 495                    or not if their values were higher.  */
 496         }
 497         if (test_bit(ACPI_BATTERY_QUIRK_DEGRADED_FULL_CHARGE, &battery->flags) &&
 498             battery->capacity_now > battery->full_charge_capacity)
 499                 battery->capacity_now = battery->full_charge_capacity;
 500
 501         return result;
 502 }
 503
 504 static int acpi_battery_get_info(struct acpi_battery *battery)
 505 {
 506         const int xinfo = test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags);
 507         int use_bix;
 508         int result = -ENODEV;
 509
 510         if (!acpi_battery_present(battery))
 511                 return 0;
 512
 513
 514         for (use_bix = xinfo ? 1 : 0; use_bix >= 0; use_bix--) {
 515                 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 516                 acpi_status status = AE_ERROR;
 517
 518                 mutex_lock(&battery->lock);
 519                 status = acpi_evaluate_object(battery->device->handle,
 520                                               use_bix ? "_BIX":"_BIF",
 521                                               NULL, &buffer);
 522                 mutex_unlock(&battery->lock);
 523
 524                 if (ACPI_FAILURE(status)) {
 525                         ACPI_EXCEPTION((AE_INFO, status, "Evaluating %s",
 526                                         use_bix ? "_BIX":"_BIF"));
 527                 } else {
 528                         result = extract_battery_info(use_bix,
 529                                                       battery,
 530                                                       &buffer);
 531
 532                         kfree(buffer.pointer);
 533                         break;
 534                 }
 535         }
 536
 537         if (!result && !use_bix && xinfo)
 538                 pr_warn(FW_BUG "The _BIX method is broken, using _BIF.\n");
 539
 540         return result;
 541 }
 542
 543 static int acpi_battery_get_state(struct acpi_battery *battery)
 544 {
 545         int result = 0;
 546         acpi_status status = 0;
 547         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 548
 549         if (!acpi_battery_present(battery))
 550                 return 0;
 551
 552         if (battery->update_time &&
 553             time_before(jiffies, battery->update_time +
 554                         msecs_to_jiffies(cache_time)))
 555                 return 0;
 556
 557         mutex_lock(&battery->lock);
 558         status = acpi_evaluate_object(battery->device->handle, "_BST",
 559                                       NULL, &buffer);
 560         mutex_unlock(&battery->lock);
 561
 562         if (ACPI_FAILURE(status)) {
 563                 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BST"));
 564                 return -ENODEV;
 565         }
 566
 567         result = extract_package(battery, buffer.pointer,
 568                                  state_offsets, ARRAY_SIZE(state_offsets));
 569         battery->update_time = jiffies;
 570         kfree(buffer.pointer);
 571
 572         /* For buggy DSDTs that report negative 16-bit values for either
 573          * charging or discharging current and/or report 0 as 65536
 574          * due to bad math.
 575          */
 576         if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA &&
 577                 battery->rate_now != ACPI_BATTERY_VALUE_UNKNOWN &&
 578                 (s16)(battery->rate_now) < 0) {
 579                 battery->rate_now = abs((s16)battery->rate_now);
 580                 printk_once(KERN_WARNING FW_BUG
 581                             "battery: (dis)charge rate invalid.\n");
 582         }
 583
 584         if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags)
 585             && battery->capacity_now >= 0 && battery->capacity_now <= 100)
 586                 battery->capacity_now = (battery->capacity_now *
 587                                 battery->full_charge_capacity) / 100;
 588         if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
 589             battery->power_unit && battery->design_voltage) {
 590                 battery->capacity_now = battery->capacity_now *
 591                     10000 / battery->design_voltage;
 592         }
 593         if (test_bit(ACPI_BATTERY_QUIRK_DEGRADED_FULL_CHARGE, &battery->flags) &&
 594             battery->capacity_now > battery->full_charge_capacity)
 595                 battery->capacity_now = battery->full_charge_capacity;
 596
 597         return result;
 598 }
 599
 600 static int acpi_battery_set_alarm(struct acpi_battery *battery)
 601 {
 602         acpi_status status = 0;
 603
 604         if (!acpi_battery_present(battery) ||
 605             !test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags))
 606                 return -ENODEV;
 607
 608         mutex_lock(&battery->lock);
 609         status = acpi_execute_simple_method(battery->device->handle, "_BTP",
 610                                             battery->alarm);
 611         mutex_unlock(&battery->lock);
 612
 613         if (ACPI_FAILURE(status))
 614                 return -ENODEV;
 615
 616         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Alarm set to %d\n", battery->alarm));
 617         return 0;
 618 }
 619
 620 static int acpi_battery_init_alarm(struct acpi_battery *battery)
 621 {
 622         /* See if alarms are supported, and if so, set default */
 623         if (!acpi_has_method(battery->device->handle, "_BTP")) {
 624                 clear_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
 625                 return 0;
 626         }
 627         set_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
 628         if (!battery->alarm)
 629                 battery->alarm = battery->design_capacity_warning;
 630         return acpi_battery_set_alarm(battery);
 631 }
 632
 633 static ssize_t acpi_battery_alarm_show(struct device *dev,
 634                                         struct device_attribute *attr,
 635                                         char *buf)
 636 {
 637         struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
 638         return sprintf(buf, "%d\n", battery->alarm * 1000);
 639 }
 640
 641 static ssize_t acpi_battery_alarm_store(struct device *dev,
 642                                         struct device_attribute *attr,
 643                                         const char *buf, size_t count)
 644 {
 645         unsigned long x;
 646         struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
 647         if (sscanf(buf, "%lu\n", &x) == 1)
 648                 battery->alarm = x/1000;
 649         if (acpi_battery_present(battery))
 650                 acpi_battery_set_alarm(battery);
 651         return count;
 652 }
 653
 654 static const struct device_attribute alarm_attr = {
 655         .attr = {.name = "alarm", .mode = 0644},
 656         .show = acpi_battery_alarm_show,
 657         .store = acpi_battery_alarm_store,
 658 };
 659
 660 /*
 661  * The Battery Hooking API
 662  *
 663  * This API is used inside other drivers that need to expose
 664  * platform-specific behaviour within the generic driver in a
 665  * generic way.
 666  *
 667  */
 668
 669 static LIST_HEAD(acpi_battery_list);
 670 static LIST_HEAD(battery_hook_list);
 671 static DEFINE_MUTEX(hook_mutex);
 672
 673 static void __battery_hook_unregister(struct acpi_battery_hook *hook, int lock)
 674 {
 675         struct acpi_battery *battery;
 676         /*
 677          * In order to remove a hook, we first need to
 678          * de-register all the batteries that are registered.
 679          */
 680         if (lock)
 681                 mutex_lock(&hook_mutex);
 682         list_for_each_entry(battery, &acpi_battery_list, list) {
 683                 hook->remove_battery(battery->bat);
 684         }
 685         list_del(&hook->list);
 686         if (lock)
 687                 mutex_unlock(&hook_mutex);
 688         pr_info("extension unregistered: %s\n", hook->name);
 689 }
 690
 691 void battery_hook_unregister(struct acpi_battery_hook *hook)
 692 {
 693         __battery_hook_unregister(hook, 1);
 694 }
 695 EXPORT_SYMBOL_GPL(battery_hook_unregister);
 696
 697 void battery_hook_register(struct acpi_battery_hook *hook)
 698 {
 699         struct acpi_battery *battery;
 700
 701         mutex_lock(&hook_mutex);
 702         INIT_LIST_HEAD(&hook->list);
 703         list_add(&hook->list, &battery_hook_list);
 704         /*
 705          * Now that the driver is registered, we need
 706          * to notify the hook that a battery is available
 707          * for each battery, so that the driver may add
 708          * its attributes.
 709          */
 710         list_for_each_entry(battery, &acpi_battery_list, list) {
 711                 if (hook->add_battery(battery->bat)) {
 712                         /*
 713                          * If a add-battery returns non-zero,
 714                          * the registration of the extension has failed,
 715                          * and we will not add it to the list of loaded
 716                          * hooks.
 717                          */
 718                         pr_err("extension failed to load: %s", hook->name);
 719                         __battery_hook_unregister(hook, 0);
 720                         goto end;
 721                 }
 722         }
 723         pr_info("new extension: %s\n", hook->name);
 724 end:
 725         mutex_unlock(&hook_mutex);
 726 }
 727 EXPORT_SYMBOL_GPL(battery_hook_register);
 728
 729 /*
 730  * This function gets called right after the battery sysfs
 731  * attributes have been added, so that the drivers that
 732  * define custom sysfs attributes can add their own.
 733 */
 734 static void battery_hook_add_battery(struct acpi_battery *battery)
 735 {
 736         struct acpi_battery_hook *hook_node, *tmp;
 737
 738         mutex_lock(&hook_mutex);
 739         INIT_LIST_HEAD(&battery->list);
 740         list_add(&battery->list, &acpi_battery_list);
 741         /*
 742          * Since we added a new battery to the list, we need to
 743          * iterate over the hooks and call add_battery for each
 744          * hook that was registered. This usually happens
 745          * when a battery gets hotplugged or initialized
 746          * during the battery module initialization.
 747          */
 748         list_for_each_entry_safe(hook_node, tmp, &battery_hook_list, list) {
 749                 if (hook_node->add_battery(battery->bat)) {
 750                         /*
 751                          * The notification of the extensions has failed, to
 752                          * prevent further errors we will unload the extension.
 753                          */
 754                         pr_err("error in extension, unloading: %s",
 755                                         hook_node->name);
 756                         __battery_hook_unregister(hook_node, 0);
 757                 }
 758         }
 759         mutex_unlock(&hook_mutex);
 760 }
 761
 762 static void battery_hook_remove_battery(struct acpi_battery *battery)
 763 {
 764         struct acpi_battery_hook *hook;
 765
 766         mutex_lock(&hook_mutex);
 767         /*
 768          * Before removing the hook, we need to remove all
 769          * custom attributes from the battery.
 770          */
 771         list_for_each_entry(hook, &battery_hook_list, list) {
 772                 hook->remove_battery(battery->bat);
 773         }
 774         /* Then, just remove the battery from the list */
 775         list_del(&battery->list);
 776         mutex_unlock(&hook_mutex);
 777 }
 778
 779 static void __exit battery_hook_exit(void)
 780 {
 781         struct acpi_battery_hook *hook;
 782         struct acpi_battery_hook *ptr;
 783         /*
 784          * At this point, the acpi_bus_unregister_driver()
 785          * has called remove for all batteries. We just
 786          * need to remove the hooks.
 787          */
 788         list_for_each_entry_safe(hook, ptr, &battery_hook_list, list) {
 789                 __battery_hook_unregister(hook, 1);
 790         }
 791         mutex_destroy(&hook_mutex);
 792 }
 793
 794 static int sysfs_add_battery(struct acpi_battery *battery)
 795 {
 796         struct power_supply_config psy_cfg = { .drv_data = battery, };
 797
 798         if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) {
 799                 battery->bat_desc.properties = charge_battery_props;
 800                 battery->bat_desc.num_properties =
 801                         ARRAY_SIZE(charge_battery_props);
 802         } else {
 803                 battery->bat_desc.properties = energy_battery_props;
 804                 battery->bat_desc.num_properties =
 805                         ARRAY_SIZE(energy_battery_props);
 806         }
 807
 808         battery->bat_desc.name = acpi_device_bid(battery->device);
 809         battery->bat_desc.type = POWER_SUPPLY_TYPE_BATTERY;
 810         battery->bat_desc.get_property = acpi_battery_get_property;
 811
 812         battery->bat = power_supply_register_no_ws(&battery->device->dev,
 813                                 &battery->bat_desc, &psy_cfg);
 814
 815         if (IS_ERR(battery->bat)) {
 816                 int result = PTR_ERR(battery->bat);
 817
 818                 battery->bat = NULL;
 819                 return result;
 820         }
 821         battery_hook_add_battery(battery);
 822         return device_create_file(&battery->bat->dev, &alarm_attr);
 823 }
 824
 825 static void sysfs_remove_battery(struct acpi_battery *battery)
 826 {
 827         mutex_lock(&battery->sysfs_lock);
 828         if (!battery->bat) {
 829                 mutex_unlock(&battery->sysfs_lock);
 830                 return;
 831         }
 832         battery_hook_remove_battery(battery);
 833         device_remove_file(&battery->bat->dev, &alarm_attr);
 834         power_supply_unregister(battery->bat);
 835         battery->bat = NULL;
 836         mutex_unlock(&battery->sysfs_lock);
 837 }
 838
 839 static void find_battery(const struct dmi_header *dm, void *private)
 840 {
 841         struct acpi_battery *battery = (struct acpi_battery *)private;
 842         /* Note: the hardcoded offsets below have been extracted from
 843            the source code of dmidecode.  */
 844         if (dm->type == DMI_ENTRY_PORTABLE_BATTERY && dm->length >= 8) {
 845                 const u8 *dmi_data = (const u8 *)(dm + 1);
 846                 int dmi_capacity = get_unaligned((const u16 *)(dmi_data + 6));
 847                 if (dm->length >= 18)
 848                         dmi_capacity *= dmi_data[17];
 849                 if (battery->design_capacity * battery->design_voltage / 1000
 850                     != dmi_capacity &&
 851                     battery->design_capacity * 10 == dmi_capacity)
 852                         set_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
 853                                 &battery->flags);
 854         }
 855 }
 856
 857 /*
 858  * According to the ACPI spec, some kinds of primary batteries can
 859  * report percentage battery remaining capacity directly to OS.
 860  * In this case, it reports the Last Full Charged Capacity == 100
 861  * and BatteryPresentRate == 0xFFFFFFFF.
 862  *
 863  * Now we found some battery reports percentage remaining capacity
 864  * even if it's rechargeable.
 865  * https://bugzilla.kernel.org/show_bug.cgi?id=15979
 866  *
 867  * Handle this correctly so that they won't break userspace.
 868  */
 869 static void acpi_battery_quirks(struct acpi_battery *battery)
 870 {
 871         if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
 872                 return;
 873
 874         if (battery->full_charge_capacity == 100 &&
 875                 battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN &&
 876                 battery->capacity_now >= 0 && battery->capacity_now <= 100) {
 877                 set_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags);
 878                 battery->full_charge_capacity = battery->design_capacity;
 879                 battery->capacity_now = (battery->capacity_now *
 880                                 battery->full_charge_capacity) / 100;
 881         }
 882
 883         if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags))
 884                 return;
 885
 886         if (battery->power_unit && dmi_name_in_vendors("LENOVO")) {
 887                 const char *s;
 888                 s = dmi_get_system_info(DMI_PRODUCT_VERSION);
 889                 if (s && !strncasecmp(s, "ThinkPad", 8)) {
 890                         dmi_walk(find_battery, battery);
 891                         if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
 892                                      &battery->flags) &&
 893                             battery->design_voltage) {
 894                                 battery->design_capacity =
 895                                     battery->design_capacity *
 896                                     10000 / battery->design_voltage;
 897                                 battery->full_charge_capacity =
 898                                     battery->full_charge_capacity *
 899                                     10000 / battery->design_voltage;
 900                                 battery->design_capacity_warning =
 901                                     battery->design_capacity_warning *
 902                                     10000 / battery->design_voltage;
 903                                 battery->capacity_now = battery->capacity_now *
 904                                     10000 / battery->design_voltage;
 905                         }
 906                 }
 907         }
 908
 909         if (test_bit(ACPI_BATTERY_QUIRK_DEGRADED_FULL_CHARGE, &battery->flags))
 910                 return;
 911
 912         if (acpi_battery_is_degraded(battery) &&
 913             battery->capacity_now > battery->full_charge_capacity) {
 914                 set_bit(ACPI_BATTERY_QUIRK_DEGRADED_FULL_CHARGE, &battery->flags);
 915                 battery->capacity_now = battery->full_charge_capacity;
 916         }
 917 }
 918
 919 static int acpi_battery_update(struct acpi_battery *battery, bool resume)
 920 {
 921         int result, old_present = acpi_battery_present(battery);
 922         result = acpi_battery_get_status(battery);
 923         if (result)
 924                 return result;
 925         if (!acpi_battery_present(battery)) {
 926                 sysfs_remove_battery(battery);
 927                 battery->update_time = 0;
 928                 return 0;
 929         }
 930
 931         if (resume)
 932                 return 0;
 933
 934         if (!battery->update_time ||
 935             old_present != acpi_battery_present(battery)) {
 936                 result = acpi_battery_get_info(battery);
 937                 if (result)
 938                         return result;
 939                 acpi_battery_init_alarm(battery);
 940         }
 941
 942         result = acpi_battery_get_state(battery);
 943         if (result)
 944                 return result;
 945         acpi_battery_quirks(battery);
 946
 947         if (!battery->bat) {
 948                 result = sysfs_add_battery(battery);
 949                 if (result)
 950                         return result;
 951         }
 952
 953         /*
 954          * Wakeup the system if battery is critical low
 955          * or lower than the alarm level
 956          */
 957         if ((battery->state & ACPI_BATTERY_STATE_CRITICAL) ||
 958             (test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags) &&
 959             (battery->capacity_now <= battery->alarm)))
 960                 acpi_pm_wakeup_event(&battery->device->dev);
 961
 962         return result;
 963 }
 964
 965 static void acpi_battery_refresh(struct acpi_battery *battery)
 966 {
 967         int power_unit;
 968
 969         if (!battery->bat)
 970                 return;
 971
 972         power_unit = battery->power_unit;
 973
 974         acpi_battery_get_info(battery);
 975
 976         if (power_unit == battery->power_unit)
 977                 return;
 978
 979         /* The battery has changed its reporting units. */
 980         sysfs_remove_battery(battery);
 981         sysfs_add_battery(battery);
 982 }
 983
 984 /* --------------------------------------------------------------------------
 985                               FS Interface (/proc)
 986    -------------------------------------------------------------------------- */
 987
 988 #ifdef CONFIG_ACPI_PROCFS_POWER
 989 static struct proc_dir_entry *acpi_battery_dir;
 990
 991 static const char *acpi_battery_units(const struct acpi_battery *battery)
 992 {
 993         return (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) ?
 994                 "mA" : "mW";
 995 }
 996
 997 static int acpi_battery_info_proc_show(struct seq_file *seq, void *offset)
 998 {
 999         struct acpi_battery *battery = seq->private;
1000         int result = acpi_battery_update(battery, false);
1001
1002         if (result)
1003                 goto end;
1004
1005         seq_printf(seq, "present:                 %s\n",
1006                    acpi_battery_present(battery) ? "yes" : "no");
1007         if (!acpi_battery_present(battery))
1008                 goto end;
1009         if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
1010                 seq_printf(seq, "design capacity:         unknown\n");
1011         else
1012                 seq_printf(seq, "design capacity:         %d %sh\n",
1013                            battery->design_capacity,
1014                            acpi_battery_units(battery));
1015
1016         if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
1017                 seq_printf(seq, "last full capacity:      unknown\n");
1018         else
1019                 seq_printf(seq, "last full capacity:      %d %sh\n",
1020                            battery->full_charge_capacity,
1021                            acpi_battery_units(battery));
1022
1023         seq_printf(seq, "battery technology:      %srechargeable\n",
1024                    (!battery->technology)?"non-":"");
1025
1026         if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
1027                 seq_printf(seq, "design voltage:          unknown\n");
1028         else
1029                 seq_printf(seq, "design voltage:          %d mV\n",
1030                            battery->design_voltage);
1031         seq_printf(seq, "design capacity warning: %d %sh\n",
1032                    battery->design_capacity_warning,
1033                    acpi_battery_units(battery));
1034         seq_printf(seq, "design capacity low:     %d %sh\n",
1035                    battery->design_capacity_low,
1036                    acpi_battery_units(battery));
1037         seq_printf(seq, "cycle count:             %i\n", battery->cycle_count);
1038         seq_printf(seq, "capacity granularity 1:  %d %sh\n",
1039                    battery->capacity_granularity_1,
1040                    acpi_battery_units(battery));
1041         seq_printf(seq, "capacity granularity 2:  %d %sh\n",
1042                    battery->capacity_granularity_2,
1043                    acpi_battery_units(battery));
1044         seq_printf(seq, "model number:            %s\n", battery->model_number);
1045         seq_printf(seq, "serial number:           %s\n", battery->serial_number);
1046         seq_printf(seq, "battery type:            %s\n", battery->type);
1047         seq_printf(seq, "OEM info:                %s\n", battery->oem_info);
1048       end:
1049         if (result)
1050                 seq_printf(seq, "ERROR: Unable to read battery info\n");
1051         return result;
1052 }
1053
1054 static int acpi_battery_state_proc_show(struct seq_file *seq, void *offset)
1055 {
1056         struct acpi_battery *battery = seq->private;
1057         int result = acpi_battery_update(battery, false);
1058
1059         if (result)
1060                 goto end;
1061
1062         seq_printf(seq, "present:                 %s\n",
1063                    acpi_battery_present(battery) ? "yes" : "no");
1064         if (!acpi_battery_present(battery))
1065                 goto end;
1066
1067         seq_printf(seq, "capacity state:          %s\n",
1068                         (battery->state & 0x04) ? "critical" : "ok");
1069         if ((battery->state & 0x01) && (battery->state & 0x02))
1070                 seq_printf(seq,
1071                            "charging state:          charging/discharging\n");
1072         else if (battery->state & 0x01)
1073                 seq_printf(seq, "charging state:          discharging\n");
1074         else if (battery->state & 0x02)
1075                 seq_printf(seq, "charging state:          charging\n");
1076         else
1077                 seq_printf(seq, "charging state:          charged\n");
1078
1079         if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
1080                 seq_printf(seq, "present rate:            unknown\n");
1081         else
1082                 seq_printf(seq, "present rate:            %d %s\n",
1083                            battery->rate_now, acpi_battery_units(battery));
1084
1085         if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
1086                 seq_printf(seq, "remaining capacity:      unknown\n");
1087         else
1088                 seq_printf(seq, "remaining capacity:      %d %sh\n",
1089                            battery->capacity_now, acpi_battery_units(battery));
1090         if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
1091                 seq_printf(seq, "present voltage:         unknown\n");
1092         else
1093                 seq_printf(seq, "present voltage:         %d mV\n",
1094                            battery->voltage_now);
1095       end:
1096         if (result)
1097                 seq_printf(seq, "ERROR: Unable to read battery state\n");
1098
1099         return result;
1100 }
1101
1102 static int acpi_battery_alarm_proc_show(struct seq_file *seq, void *offset)
1103 {
1104         struct acpi_battery *battery = seq->private;
1105         int result = acpi_battery_update(battery, false);
1106
1107         if (result)
1108                 goto end;
1109
1110         if (!acpi_battery_present(battery)) {
1111                 seq_printf(seq, "present:                 no\n");
1112                 goto end;
1113         }
1114         seq_printf(seq, "alarm:                   ");
1115         if (!battery->alarm)
1116                 seq_printf(seq, "unsupported\n");
1117         else
1118                 seq_printf(seq, "%u %sh\n", battery->alarm,
1119                                 acpi_battery_units(battery));
1120       end:
1121         if (result)
1122                 seq_printf(seq, "ERROR: Unable to read battery alarm\n");
1123         return result;
1124 }
1125
1126 static ssize_t acpi_battery_write_alarm(struct file *file,
1127                                         const char __user * buffer,
1128                                         size_t count, loff_t * ppos)
1129 {
1130         int result = 0;
1131         char alarm_string[12] = { '\0' };
1132         struct seq_file *m = file->private_data;
1133         struct acpi_battery *battery = m->private;
1134
1135         if (!battery || (count > sizeof(alarm_string) - 1))
1136                 return -EINVAL;
1137         if (!acpi_battery_present(battery)) {
1138                 result = -ENODEV;
1139                 goto end;
1140         }
1141         if (copy_from_user(alarm_string, buffer, count)) {
1142                 result = -EFAULT;
1143                 goto end;
1144         }
1145         alarm_string[count] = '\0';
1146         if (kstrtoint(alarm_string, 0, &battery->alarm)) {
1147                 result = -EINVAL;
1148                 goto end;
1149         }
1150         result = acpi_battery_set_alarm(battery);
1151       end:
1152         if (!result)
1153                 return count;
1154         return result;
1155 }
1156
1157 static int acpi_battery_alarm_proc_open(struct inode *inode, struct file *file)
1158 {
1159         return single_open(file, acpi_battery_alarm_proc_show, PDE_DATA(inode));
1160 }
1161
1162 static const struct file_operations acpi_battery_alarm_fops = {
1163         .owner          = THIS_MODULE,
1164         .open           = acpi_battery_alarm_proc_open,
1165         .read           = seq_read,
1166         .write          = acpi_battery_write_alarm,
1167         .llseek         = seq_lseek,
1168         .release        = single_release,
1169 };
1170
1171 static int acpi_battery_add_fs(struct acpi_device *device)
1172 {
1173         printk(KERN_WARNING PREFIX "Deprecated procfs I/F for battery is loaded,"
1174                         " please retry with CONFIG_ACPI_PROCFS_POWER cleared\n");
1175         if (!acpi_device_dir(device)) {
1176                 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
1177                                                      acpi_battery_dir);
1178                 if (!acpi_device_dir(device))
1179                         return -ENODEV;
1180         }
1181
1182         if (!proc_create_single_data("info", S_IRUGO, acpi_device_dir(device),
1183                         acpi_battery_info_proc_show, acpi_driver_data(device)))
1184                 return -ENODEV;
1185         if (!proc_create_single_data("state", S_IRUGO, acpi_device_dir(device),
1186                         acpi_battery_state_proc_show, acpi_driver_data(device)))
1187                 return -ENODEV;
1188         if (!proc_create_data("alarm", S_IFREG | S_IRUGO | S_IWUSR,
1189                         acpi_device_dir(device), &acpi_battery_alarm_fops,
1190                         acpi_driver_data(device)))
1191                 return -ENODEV;
1192         return 0;
1193 }
1194
1195 static void acpi_battery_remove_fs(struct acpi_device *device)
1196 {
1197         if (!acpi_device_dir(device))
1198                 return;
1199         remove_proc_subtree(acpi_device_bid(device), acpi_battery_dir);
1200         acpi_device_dir(device) = NULL;
1201 }
1202
1203 #endif
1204
1205 /* --------------------------------------------------------------------------
1206                                  Driver Interface
1207    -------------------------------------------------------------------------- */
1208
1209 static void acpi_battery_notify(struct acpi_device *device, u32 event)
1210 {
1211         struct acpi_battery *battery = acpi_driver_data(device);
1212         struct power_supply *old;
1213
1214         if (!battery)
1215                 return;
1216         old = battery->bat;
1217         /*
1218         * On Acer Aspire V5-573G notifications are sometimes triggered too
1219         * early. For example, when AC is unplugged and notification is
1220         * triggered, battery state is still reported as "Full", and changes to
1221         * "Discharging" only after short delay, without any notification.
1222         */
1223         if (battery_notification_delay_ms > 0)
1224                 msleep(battery_notification_delay_ms);
1225         if (event == ACPI_BATTERY_NOTIFY_INFO)
1226                 acpi_battery_refresh(battery);
1227         acpi_battery_update(battery, false);
1228         acpi_bus_generate_netlink_event(device->pnp.device_class,
1229                                         dev_name(&device->dev), event,
1230                                         acpi_battery_present(battery));
1231         acpi_notifier_call_chain(device, event, acpi_battery_present(battery));
1232         /* acpi_battery_update could remove power_supply object */
1233         if (old && battery->bat)
1234                 power_supply_changed(battery->bat);
1235 }
1236
1237 static int battery_notify(struct notifier_block *nb,
1238                                unsigned long mode, void *_unused)
1239 {
1240         struct acpi_battery *battery = container_of(nb, struct acpi_battery,
1241                                                     pm_nb);
1242         int result;
1243
1244         switch (mode) {
1245         case PM_POST_HIBERNATION:
1246         case PM_POST_SUSPEND:
1247                 if (!acpi_battery_present(battery))
1248                         return 0;
1249
1250                 if (!battery->bat) {
1251                         result = acpi_battery_get_info(battery);
1252                         if (result)
1253                                 return result;
1254
1255                         result = sysfs_add_battery(battery);
1256                         if (result)
1257                                 return result;
1258                 } else
1259                         acpi_battery_refresh(battery);
1260
1261                 acpi_battery_init_alarm(battery);
1262                 acpi_battery_get_state(battery);
1263                 break;
1264         }
1265
1266         return 0;
1267 }
1268
1269 static int __init
1270 battery_bix_broken_package_quirk(const struct dmi_system_id *d)
1271 {
1272         battery_bix_broken_package = 1;
1273         return 0;
1274 }
1275
1276 static int __init
1277 battery_notification_delay_quirk(const struct dmi_system_id *d)
1278 {
1279         battery_notification_delay_ms = 1000;
1280         return 0;
1281 }
1282
1283 static int __init
1284 battery_ac_is_broken_quirk(const struct dmi_system_id *d)
1285 {
1286         battery_ac_is_broken = 1;
1287         return 0;
1288 }
1289
1290 static int __init
1291 battery_do_not_check_pmic_quirk(const struct dmi_system_id *d)
1292 {
1293         battery_check_pmic = 0;
1294         return 0;
1295 }
1296
1297 static const struct dmi_system_id bat_dmi_table[] __initconst = {
1298         {
1299                 /* NEC LZ750/LS */
1300                 .callback = battery_bix_broken_package_quirk,
1301                 .matches = {
1302                         DMI_MATCH(DMI_SYS_VENDOR, "NEC"),
1303                         DMI_MATCH(DMI_PRODUCT_NAME, "PC-LZ750LS"),
1304                 },
1305         },
1306         {
1307                 /* Acer Aspire V5-573G */
1308                 .callback = battery_notification_delay_quirk,
1309                 .matches = {
1310                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
1311                         DMI_MATCH(DMI_PRODUCT_NAME, "Aspire V5-573G"),
1312                 },
1313         },
1314         {
1315                 /* Point of View mobii wintab p800w */
1316                 .callback = battery_ac_is_broken_quirk,
1317                 .matches = {
1318                         DMI_MATCH(DMI_BOARD_VENDOR, "AMI Corporation"),
1319                         DMI_MATCH(DMI_BOARD_NAME, "Aptio CRB"),
1320                         DMI_MATCH(DMI_BIOS_VERSION, "3BAIR1013"),
1321                         /* Above matches are too generic, add bios-date match */
1322                         DMI_MATCH(DMI_BIOS_DATE, "08/22/2014"),
1323                 },
1324         },
1325         {
1326                 /* ECS EF20EA */
1327                 .callback = battery_do_not_check_pmic_quirk,
1328                 .matches = {
1329                         DMI_MATCH(DMI_PRODUCT_NAME, "EF20EA"),
1330                 },
1331         },
1332         {
1333                 /* Lenovo Ideapad Miix 320 */
1334                 .callback = battery_do_not_check_pmic_quirk,
1335                 .matches = {
1336                   DMI_EXACT_MATCH(DMI_SYS_VENDOR, "LENOVO"),
1337                   DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "80XF"),
1338                   DMI_EXACT_MATCH(DMI_PRODUCT_VERSION, "Lenovo MIIX 320-10ICR"),
1339                 },
1340         },
1341         {},
1342 };
1343
1344 /*
1345  * Some machines'(E,G Lenovo Z480) ECs are not stable
1346  * during boot up and this causes battery driver fails to be
1347  * probed due to failure of getting battery information
1348  * from EC sometimes. After several retries, the operation
1349  * may work. So add retry code here and 20ms sleep between
1350  * every retries.
1351  */
1352 static int acpi_battery_update_retry(struct acpi_battery *battery)
1353 {
1354         int retry, ret;
1355
1356         for (retry = 5; retry; retry--) {
1357                 ret = acpi_battery_update(battery, false);
1358                 if (!ret)
1359                         break;
1360
1361                 msleep(20);
1362         }
1363         return ret;
1364 }
1365
1366 static int acpi_battery_add(struct acpi_device *device)
1367 {
1368         int result = 0;
1369         struct acpi_battery *battery = NULL;
1370
1371         if (!device)
1372                 return -EINVAL;
1373
1374         if (device->dep_unmet)
1375                 return -EPROBE_DEFER;
1376
1377         battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL);
1378         if (!battery)
1379                 return -ENOMEM;
1380         battery->device = device;
1381         strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME);
1382         strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS);
1383         device->driver_data = battery;
1384         mutex_init(&battery->lock);
1385         mutex_init(&battery->sysfs_lock);
1386         if (acpi_has_method(battery->device->handle, "_BIX"))
1387                 set_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags);
1388
1389         result = acpi_battery_update_retry(battery);
1390         if (result)
1391                 goto fail;
1392
1393 #ifdef CONFIG_ACPI_PROCFS_POWER
1394         result = acpi_battery_add_fs(device);
1395         if (result) {
1396                 acpi_battery_remove_fs(device);
1397                 goto fail;
1398         }
1399 #endif
1400
1401         printk(KERN_INFO PREFIX "%s Slot [%s] (battery %s)\n",
1402                 ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device),
1403                 device->status.battery_present ? "present" : "absent");
1404
1405         battery->pm_nb.notifier_call = battery_notify;
1406         register_pm_notifier(&battery->pm_nb);
1407
1408         device_init_wakeup(&device->dev, 1);
1409
1410         return result;
1411
1412 fail:
1413         sysfs_remove_battery(battery);
1414         mutex_destroy(&battery->lock);
1415         mutex_destroy(&battery->sysfs_lock);
1416         kfree(battery);
1417         return result;
1418 }
1419
1420 static int acpi_battery_remove(struct acpi_device *device)
1421 {
1422         struct acpi_battery *battery = NULL;
1423
1424         if (!device || !acpi_driver_data(device))
1425                 return -EINVAL;
1426         device_init_wakeup(&device->dev, 0);
1427         battery = acpi_driver_data(device);
1428         unregister_pm_notifier(&battery->pm_nb);
1429 #ifdef CONFIG_ACPI_PROCFS_POWER
1430         acpi_battery_remove_fs(device);
1431 #endif
1432         sysfs_remove_battery(battery);
1433         mutex_destroy(&battery->lock);
1434         mutex_destroy(&battery->sysfs_lock);
1435         kfree(battery);
1436         return 0;
1437 }
1438
1439 #ifdef CONFIG_PM_SLEEP
1440 /* this is needed to learn about changes made in suspended state */
1441 static int acpi_battery_resume(struct device *dev)
1442 {
1443         struct acpi_battery *battery;
1444
1445         if (!dev)
1446                 return -EINVAL;
1447
1448         battery = acpi_driver_data(to_acpi_device(dev));
1449         if (!battery)
1450                 return -EINVAL;
1451
1452         battery->update_time = 0;
1453         acpi_battery_update(battery, true);
1454         return 0;
1455 }
1456 #else
1457 #define acpi_battery_resume NULL
1458 #endif
1459
1460 static SIMPLE_DEV_PM_OPS(acpi_battery_pm, NULL, acpi_battery_resume);
1461
1462 static struct acpi_driver acpi_battery_driver = {
1463         .name = "battery",
1464         .class = ACPI_BATTERY_CLASS,
1465         .ids = battery_device_ids,
1466         .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
1467         .ops = {
1468                 .add = acpi_battery_add,
1469                 .remove = acpi_battery_remove,
1470                 .notify = acpi_battery_notify,
1471                 },
1472         .drv.pm = &acpi_battery_pm,
1473 };
1474
1475 static void __init acpi_battery_init_async(void *unused, async_cookie_t cookie)
1476 {
1477         unsigned int i;
1478         int result;
1479
1480         dmi_check_system(bat_dmi_table);
1481
1482         if (battery_check_pmic) {
1483                 for (i = 0; i < ARRAY_SIZE(acpi_battery_blacklist); i++)
1484                         if (acpi_dev_present(acpi_battery_blacklist[i], "1", -1)) {
1485                                 pr_info(PREFIX ACPI_BATTERY_DEVICE_NAME
1486                                         ": found native %s PMIC, not loading\n",
1487                                         acpi_battery_blacklist[i]);
1488                                 return;
1489                         }
1490         }
1491
1492 #ifdef CONFIG_ACPI_PROCFS_POWER
1493         acpi_battery_dir = acpi_lock_battery_dir();
1494         if (!acpi_battery_dir)
1495                 return;
1496 #endif
1497         result = acpi_bus_register_driver(&acpi_battery_driver);
1498 #ifdef CONFIG_ACPI_PROCFS_POWER
1499         if (result < 0)
1500                 acpi_unlock_battery_dir(acpi_battery_dir);
1501 #endif
1502         battery_driver_registered = (result == 0);
1503 }
1504
1505 static int __init acpi_battery_init(void)
1506 {
1507         if (acpi_disabled)
1508                 return -ENODEV;
1509
1510         async_cookie = async_schedule(acpi_battery_init_async, NULL);
1511         return 0;
1512 }
1513
1514 static void __exit acpi_battery_exit(void)
1515 {
1516         async_synchronize_cookie(async_cookie + 1);
1517         if (battery_driver_registered) {
1518                 acpi_bus_unregister_driver(&acpi_battery_driver);
1519                 battery_hook_exit();
1520         }
1521 #ifdef CONFIG_ACPI_PROCFS_POWER
1522         if (acpi_battery_dir)
1523                 acpi_unlock_battery_dir(acpi_battery_dir);
1524 #endif
1525 }
1526
1527 module_init(acpi_battery_init);
1528 module_exit(acpi_battery_exit);