drivers/acpi/battery.c

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