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