drivers/acpi/battery.c

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