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