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