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