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