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  *  You should have received a copy of the GNU General Public License along
  22  *  with this program; if not, write to the Free Software Foundation, Inc.,
  23  *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  24  *
  25  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  26  */
  27
  28 #include <linux/kernel.h>
  29 #include <linux/module.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/slab.h>
  36 #include <linux/suspend.h>
  37 #include <asm/unaligned.h>
  38
  39 #include <linux/acpi.h>
  40 #include <linux/power_supply.h>
  41
  42 #define PREFIX "ACPI: "
  43
  44 #define ACPI_BATTERY_VALUE_UNKNOWN 0xFFFFFFFF
  45
  46 #define ACPI_BATTERY_CLASS              "battery"
  47 #define ACPI_BATTERY_DEVICE_NAME        "Battery"
  48 #define ACPI_BATTERY_NOTIFY_STATUS      0x80
  49 #define ACPI_BATTERY_NOTIFY_INFO        0x81
  50 #define ACPI_BATTERY_NOTIFY_THRESHOLD   0x82
  51
  52 /* Battery power unit: 0 means mW, 1 means mA */
  53 #define ACPI_BATTERY_POWER_UNIT_MA      1
  54
  55 #define _COMPONENT              ACPI_BATTERY_COMPONENT
  56
  57 ACPI_MODULE_NAME("battery");
  58
  59 MODULE_AUTHOR("Paul Diefenbaugh");
  60 MODULE_AUTHOR("Alexey Starikovskiy <astarikovskiy@suse.de>");
  61 MODULE_DESCRIPTION("ACPI Battery Driver");
  62 MODULE_LICENSE("GPL");
  63
  64 static unsigned int cache_time = 1000;
  65 module_param(cache_time, uint, 0644);
  66 MODULE_PARM_DESC(cache_time, "cache time in milliseconds");
  67
  68 static const struct acpi_device_id battery_device_ids[] = {
  69         {"PNP0C0A", 0},
  70         {"", 0},
  71 };
  72
  73 MODULE_DEVICE_TABLE(acpi, battery_device_ids);
  74
  75 enum {
  76         ACPI_BATTERY_ALARM_PRESENT,
  77         ACPI_BATTERY_XINFO_PRESENT,
  78         ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY,
  79         /* On Lenovo Thinkpad models from 2010 and 2011, the power unit
  80            switches between mWh and mAh depending on whether the system
  81            is running on battery or not.  When mAh is the unit, most
  82            reported values are incorrect and need to be adjusted by
  83            10000/design_voltage.  Verified on x201, t410, t410s, and x220.
  84            Pre-2010 and 2012 models appear to always report in mWh and
  85            are thus unaffected (tested with t42, t61, t500, x200, x300,
  86            and x230).  Also, in mid-2012 Lenovo issued a BIOS update for
  87            the 2011 models that fixes the issue (tested on x220 with a
  88            post-1.29 BIOS), but as of Nov. 2012, no such update is
  89            available for the 2010 models.  */
  90         ACPI_BATTERY_QUIRK_THINKPAD_MAH,
  91 };
  92
  93 struct acpi_battery {
  94         struct mutex lock;
  95         struct mutex sysfs_lock;
  96         struct power_supply bat;
  97         struct acpi_device *device;
  98         struct notifier_block pm_nb;
  99         unsigned long update_time;
 100         int revision;
 101         int rate_now;
 102         int capacity_now;
 103         int voltage_now;
 104         int design_capacity;
 105         int full_charge_capacity;
 106         int technology;
 107         int design_voltage;
 108         int design_capacity_warning;
 109         int design_capacity_low;
 110         int cycle_count;
 111         int measurement_accuracy;
 112         int max_sampling_time;
 113         int min_sampling_time;
 114         int max_averaging_interval;
 115         int min_averaging_interval;
 116         int capacity_granularity_1;
 117         int capacity_granularity_2;
 118         int alarm;
 119         char model_number[32];
 120         char serial_number[32];
 121         char type[32];
 122         char oem_info[32];
 123         int state;
 124         int power_unit;
 125         unsigned long flags;
 126 };
 127
 128 #define to_acpi_battery(x) container_of(x, struct acpi_battery, bat)
 129
 130 static inline int acpi_battery_present(struct acpi_battery *battery)
 131 {
 132         return battery->device->status.battery_present;
 133 }
 134
 135 static int acpi_battery_technology(struct acpi_battery *battery)
 136 {
 137         if (!strcasecmp("NiCd", battery->type))
 138                 return POWER_SUPPLY_TECHNOLOGY_NiCd;
 139         if (!strcasecmp("NiMH", battery->type))
 140                 return POWER_SUPPLY_TECHNOLOGY_NiMH;
 141         if (!strcasecmp("LION", battery->type))
 142                 return POWER_SUPPLY_TECHNOLOGY_LION;
 143         if (!strncasecmp("LI-ION", battery->type, 6))
 144                 return POWER_SUPPLY_TECHNOLOGY_LION;
 145         if (!strcasecmp("LiP", battery->type))
 146                 return POWER_SUPPLY_TECHNOLOGY_LIPO;
 147         return POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
 148 }
 149
 150 static int acpi_battery_get_state(struct acpi_battery *battery);
 151
 152 static int acpi_battery_is_charged(struct acpi_battery *battery)
 153 {
 154         /* either charging or discharging */
 155         if (battery->state != 0)
 156                 return 0;
 157
 158         /* battery not reporting charge */
 159         if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN ||
 160             battery->capacity_now == 0)
 161                 return 0;
 162
 163         /* good batteries update full_charge as the batteries degrade */
 164         if (battery->full_charge_capacity == battery->capacity_now)
 165                 return 1;
 166
 167         /* fallback to using design values for broken batteries */
 168         if (battery->design_capacity == battery->capacity_now)
 169                 return 1;
 170
 171         /* we don't do any sort of metric based on percentages */
 172         return 0;
 173 }
 174
 175 static int acpi_battery_get_property(struct power_supply *psy,
 176                                      enum power_supply_property psp,
 177                                      union power_supply_propval *val)
 178 {
 179         int ret = 0;
 180         struct acpi_battery *battery = to_acpi_battery(psy);
 181
 182         if (acpi_battery_present(battery)) {
 183                 /* run battery update only if it is present */
 184                 acpi_battery_get_state(battery);
 185         } else if (psp != POWER_SUPPLY_PROP_PRESENT)
 186                 return -ENODEV;
 187         switch (psp) {
 188         case POWER_SUPPLY_PROP_STATUS:
 189                 if (battery->state & 0x01)
 190                         val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
 191                 else if (battery->state & 0x02)
 192                         val->intval = POWER_SUPPLY_STATUS_CHARGING;
 193                 else if (acpi_battery_is_charged(battery))
 194                         val->intval = POWER_SUPPLY_STATUS_FULL;
 195                 else
 196                         val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
 197                 break;
 198         case POWER_SUPPLY_PROP_PRESENT:
 199                 val->intval = acpi_battery_present(battery);
 200                 break;
 201         case POWER_SUPPLY_PROP_TECHNOLOGY:
 202                 val->intval = acpi_battery_technology(battery);
 203                 break;
 204         case POWER_SUPPLY_PROP_CYCLE_COUNT:
 205                 val->intval = battery->cycle_count;
 206                 break;
 207         case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
 208                 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
 209                         ret = -ENODEV;
 210                 else
 211                         val->intval = battery->design_voltage * 1000;
 212                 break;
 213         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 214                 if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
 215                         ret = -ENODEV;
 216                 else
 217                         val->intval = battery->voltage_now * 1000;
 218                 break;
 219         case POWER_SUPPLY_PROP_CURRENT_NOW:
 220         case POWER_SUPPLY_PROP_POWER_NOW:
 221                 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
 222                         ret = -ENODEV;
 223                 else
 224                         val->intval = battery->rate_now * 1000;
 225                 break;
 226         case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
 227         case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
 228                 if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
 229                         ret = -ENODEV;
 230                 else
 231                         val->intval = battery->design_capacity * 1000;
 232                 break;
 233         case POWER_SUPPLY_PROP_CHARGE_FULL:
 234         case POWER_SUPPLY_PROP_ENERGY_FULL:
 235                 if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
 236                         ret = -ENODEV;
 237                 else
 238                         val->intval = battery->full_charge_capacity * 1000;
 239                 break;
 240         case POWER_SUPPLY_PROP_CHARGE_NOW:
 241         case POWER_SUPPLY_PROP_ENERGY_NOW:
 242                 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
 243                         ret = -ENODEV;
 244                 else
 245                         val->intval = battery->capacity_now * 1000;
 246                 break;
 247         case POWER_SUPPLY_PROP_CAPACITY:
 248                 if (battery->capacity_now && battery->full_charge_capacity)
 249                         val->intval = battery->capacity_now * 100/
 250                                         battery->full_charge_capacity;
 251                 else
 252                         val->intval = 0;
 253                 break;
 254         case POWER_SUPPLY_PROP_MODEL_NAME:
 255                 val->strval = battery->model_number;
 256                 break;
 257         case POWER_SUPPLY_PROP_MANUFACTURER:
 258                 val->strval = battery->oem_info;
 259                 break;
 260         case POWER_SUPPLY_PROP_SERIAL_NUMBER:
 261                 val->strval = battery->serial_number;
 262                 break;
 263         default:
 264                 ret = -EINVAL;
 265         }
 266         return ret;
 267 }
 268
 269 static enum power_supply_property charge_battery_props[] = {
 270         POWER_SUPPLY_PROP_STATUS,
 271         POWER_SUPPLY_PROP_PRESENT,
 272         POWER_SUPPLY_PROP_TECHNOLOGY,
 273         POWER_SUPPLY_PROP_CYCLE_COUNT,
 274         POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
 275         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 276         POWER_SUPPLY_PROP_CURRENT_NOW,
 277         POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
 278         POWER_SUPPLY_PROP_CHARGE_FULL,
 279         POWER_SUPPLY_PROP_CHARGE_NOW,
 280         POWER_SUPPLY_PROP_CAPACITY,
 281         POWER_SUPPLY_PROP_MODEL_NAME,
 282         POWER_SUPPLY_PROP_MANUFACTURER,
 283         POWER_SUPPLY_PROP_SERIAL_NUMBER,
 284 };
 285
 286 static enum power_supply_property energy_battery_props[] = {
 287         POWER_SUPPLY_PROP_STATUS,
 288         POWER_SUPPLY_PROP_PRESENT,
 289         POWER_SUPPLY_PROP_TECHNOLOGY,
 290         POWER_SUPPLY_PROP_CYCLE_COUNT,
 291         POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
 292         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 293         POWER_SUPPLY_PROP_POWER_NOW,
 294         POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
 295         POWER_SUPPLY_PROP_ENERGY_FULL,
 296         POWER_SUPPLY_PROP_ENERGY_NOW,
 297         POWER_SUPPLY_PROP_CAPACITY,
 298         POWER_SUPPLY_PROP_MODEL_NAME,
 299         POWER_SUPPLY_PROP_MANUFACTURER,
 300         POWER_SUPPLY_PROP_SERIAL_NUMBER,
 301 };
 302
 303 /* --------------------------------------------------------------------------
 304                                Battery Management
 305    -------------------------------------------------------------------------- */
 306 struct acpi_offsets {
 307         size_t offset;          /* offset inside struct acpi_sbs_battery */
 308         u8 mode;                /* int or string? */
 309 };
 310
 311 static struct acpi_offsets state_offsets[] = {
 312         {offsetof(struct acpi_battery, state), 0},
 313         {offsetof(struct acpi_battery, rate_now), 0},
 314         {offsetof(struct acpi_battery, capacity_now), 0},
 315         {offsetof(struct acpi_battery, voltage_now), 0},
 316 };
 317
 318 static struct acpi_offsets info_offsets[] = {
 319         {offsetof(struct acpi_battery, power_unit), 0},
 320         {offsetof(struct acpi_battery, design_capacity), 0},
 321         {offsetof(struct acpi_battery, full_charge_capacity), 0},
 322         {offsetof(struct acpi_battery, technology), 0},
 323         {offsetof(struct acpi_battery, design_voltage), 0},
 324         {offsetof(struct acpi_battery, design_capacity_warning), 0},
 325         {offsetof(struct acpi_battery, design_capacity_low), 0},
 326         {offsetof(struct acpi_battery, capacity_granularity_1), 0},
 327         {offsetof(struct acpi_battery, capacity_granularity_2), 0},
 328         {offsetof(struct acpi_battery, model_number), 1},
 329         {offsetof(struct acpi_battery, serial_number), 1},
 330         {offsetof(struct acpi_battery, type), 1},
 331         {offsetof(struct acpi_battery, oem_info), 1},
 332 };
 333
 334 static struct acpi_offsets extended_info_offsets[] = {
 335         {offsetof(struct acpi_battery, revision), 0},
 336         {offsetof(struct acpi_battery, power_unit), 0},
 337         {offsetof(struct acpi_battery, design_capacity), 0},
 338         {offsetof(struct acpi_battery, full_charge_capacity), 0},
 339         {offsetof(struct acpi_battery, technology), 0},
 340         {offsetof(struct acpi_battery, design_voltage), 0},
 341         {offsetof(struct acpi_battery, design_capacity_warning), 0},
 342         {offsetof(struct acpi_battery, design_capacity_low), 0},
 343         {offsetof(struct acpi_battery, cycle_count), 0},
 344         {offsetof(struct acpi_battery, measurement_accuracy), 0},
 345         {offsetof(struct acpi_battery, max_sampling_time), 0},
 346         {offsetof(struct acpi_battery, min_sampling_time), 0},
 347         {offsetof(struct acpi_battery, max_averaging_interval), 0},
 348         {offsetof(struct acpi_battery, min_averaging_interval), 0},
 349         {offsetof(struct acpi_battery, capacity_granularity_1), 0},
 350         {offsetof(struct acpi_battery, capacity_granularity_2), 0},
 351         {offsetof(struct acpi_battery, model_number), 1},
 352         {offsetof(struct acpi_battery, serial_number), 1},
 353         {offsetof(struct acpi_battery, type), 1},
 354         {offsetof(struct acpi_battery, oem_info), 1},
 355 };
 356
 357 static int extract_package(struct acpi_battery *battery,
 358                            union acpi_object *package,
 359                            struct acpi_offsets *offsets, int num)
 360 {
 361         int i;
 362         union acpi_object *element;
 363         if (package->type != ACPI_TYPE_PACKAGE)
 364                 return -EFAULT;
 365         for (i = 0; i < num; ++i) {
 366                 if (package->package.count <= i)
 367                         return -EFAULT;
 368                 element = &package->package.elements[i];
 369                 if (offsets[i].mode) {
 370                         u8 *ptr = (u8 *)battery + offsets[i].offset;
 371                         if (element->type == ACPI_TYPE_STRING ||
 372                             element->type == ACPI_TYPE_BUFFER)
 373                                 strncpy(ptr, element->string.pointer, 32);
 374                         else if (element->type == ACPI_TYPE_INTEGER) {
 375                                 strncpy(ptr, (u8 *)&element->integer.value,
 376                                         sizeof(u64));
 377                                 ptr[sizeof(u64)] = 0;
 378                         } else
 379                                 *ptr = 0; /* don't have value */
 380                 } else {
 381                         int *x = (int *)((u8 *)battery + offsets[i].offset);
 382                         *x = (element->type == ACPI_TYPE_INTEGER) ?
 383                                 element->integer.value : -1;
 384                 }
 385         }
 386         return 0;
 387 }
 388
 389 static int acpi_battery_get_status(struct acpi_battery *battery)
 390 {
 391         if (acpi_bus_get_status(battery->device)) {
 392                 ACPI_EXCEPTION((AE_INFO, AE_ERROR, "Evaluating _STA"));
 393                 return -ENODEV;
 394         }
 395         return 0;
 396 }
 397
 398 static int acpi_battery_get_info(struct acpi_battery *battery)
 399 {
 400         int result = -EFAULT;
 401         acpi_status status = 0;
 402         char *name = test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags) ?
 403                         "_BIX" : "_BIF";
 404
 405         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 406
 407         if (!acpi_battery_present(battery))
 408                 return 0;
 409         mutex_lock(&battery->lock);
 410         status = acpi_evaluate_object(battery->device->handle, name,
 411                                                 NULL, &buffer);
 412         mutex_unlock(&battery->lock);
 413
 414         if (ACPI_FAILURE(status)) {
 415                 ACPI_EXCEPTION((AE_INFO, status, "Evaluating %s", name));
 416                 return -ENODEV;
 417         }
 418         if (test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags))
 419                 result = extract_package(battery, buffer.pointer,
 420                                 extended_info_offsets,
 421                                 ARRAY_SIZE(extended_info_offsets));
 422         else
 423                 result = extract_package(battery, buffer.pointer,
 424                                 info_offsets, ARRAY_SIZE(info_offsets));
 425         kfree(buffer.pointer);
 426         if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
 427                 battery->full_charge_capacity = battery->design_capacity;
 428         if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
 429             battery->power_unit && battery->design_voltage) {
 430                 battery->design_capacity = battery->design_capacity *
 431                     10000 / battery->design_voltage;
 432                 battery->full_charge_capacity = battery->full_charge_capacity *
 433                     10000 / battery->design_voltage;
 434                 battery->design_capacity_warning =
 435                     battery->design_capacity_warning *
 436                     10000 / battery->design_voltage;
 437                 /* Curiously, design_capacity_low, unlike the rest of them,
 438                    is correct.  */
 439                 /* capacity_granularity_* equal 1 on the systems tested, so
 440                    it's impossible to tell if they would need an adjustment
 441                    or not if their values were higher.  */
 442         }
 443         return result;
 444 }
 445
 446 static int acpi_battery_get_state(struct acpi_battery *battery)
 447 {
 448         int result = 0;
 449         acpi_status status = 0;
 450         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 451
 452         if (!acpi_battery_present(battery))
 453                 return 0;
 454
 455         if (battery->update_time &&
 456             time_before(jiffies, battery->update_time +
 457                         msecs_to_jiffies(cache_time)))
 458                 return 0;
 459
 460         mutex_lock(&battery->lock);
 461         status = acpi_evaluate_object(battery->device->handle, "_BST",
 462                                       NULL, &buffer);
 463         mutex_unlock(&battery->lock);
 464
 465         if (ACPI_FAILURE(status)) {
 466                 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BST"));
 467                 return -ENODEV;
 468         }
 469
 470         result = extract_package(battery, buffer.pointer,
 471                                  state_offsets, ARRAY_SIZE(state_offsets));
 472         battery->update_time = jiffies;
 473         kfree(buffer.pointer);
 474
 475         /* For buggy DSDTs that report negative 16-bit values for either
 476          * charging or discharging current and/or report 0 as 65536
 477          * due to bad math.
 478          */
 479         if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA &&
 480                 battery->rate_now != ACPI_BATTERY_VALUE_UNKNOWN &&
 481                 (s16)(battery->rate_now) < 0) {
 482                 battery->rate_now = abs((s16)battery->rate_now);
 483                 printk_once(KERN_WARNING FW_BUG "battery: (dis)charge rate"
 484                         " invalid.\n");
 485         }
 486
 487         if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags)
 488             && battery->capacity_now >= 0 && battery->capacity_now <= 100)
 489                 battery->capacity_now = (battery->capacity_now *
 490                                 battery->full_charge_capacity) / 100;
 491         if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
 492             battery->power_unit && battery->design_voltage) {
 493                 battery->capacity_now = battery->capacity_now *
 494                     10000 / battery->design_voltage;
 495         }
 496         return result;
 497 }
 498
 499 static int acpi_battery_set_alarm(struct acpi_battery *battery)
 500 {
 501         acpi_status status = 0;
 502
 503         if (!acpi_battery_present(battery) ||
 504             !test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags))
 505                 return -ENODEV;
 506
 507         mutex_lock(&battery->lock);
 508         status = acpi_execute_simple_method(battery->device->handle, "_BTP",
 509                                             battery->alarm);
 510         mutex_unlock(&battery->lock);
 511
 512         if (ACPI_FAILURE(status))
 513                 return -ENODEV;
 514
 515         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Alarm set to %d\n", battery->alarm));
 516         return 0;
 517 }
 518
 519 static int acpi_battery_init_alarm(struct acpi_battery *battery)
 520 {
 521         /* See if alarms are supported, and if so, set default */
 522         if (!acpi_has_method(battery->device->handle, "_BTP")) {
 523                 clear_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
 524                 return 0;
 525         }
 526         set_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
 527         if (!battery->alarm)
 528                 battery->alarm = battery->design_capacity_warning;
 529         return acpi_battery_set_alarm(battery);
 530 }
 531
 532 static ssize_t acpi_battery_alarm_show(struct device *dev,
 533                                         struct device_attribute *attr,
 534                                         char *buf)
 535 {
 536         struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
 537         return sprintf(buf, "%d\n", battery->alarm * 1000);
 538 }
 539
 540 static ssize_t acpi_battery_alarm_store(struct device *dev,
 541                                         struct device_attribute *attr,
 542                                         const char *buf, size_t count)
 543 {
 544         unsigned long x;
 545         struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
 546         if (sscanf(buf, "%ld\n", &x) == 1)
 547                 battery->alarm = x/1000;
 548         if (acpi_battery_present(battery))
 549                 acpi_battery_set_alarm(battery);
 550         return count;
 551 }
 552
 553 static struct device_attribute alarm_attr = {
 554         .attr = {.name = "alarm", .mode = 0644},
 555         .show = acpi_battery_alarm_show,
 556         .store = acpi_battery_alarm_store,
 557 };
 558
 559 static int sysfs_add_battery(struct acpi_battery *battery)
 560 {
 561         int result;
 562
 563         if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) {
 564                 battery->bat.properties = charge_battery_props;
 565                 battery->bat.num_properties =
 566                         ARRAY_SIZE(charge_battery_props);
 567         } else {
 568                 battery->bat.properties = energy_battery_props;
 569                 battery->bat.num_properties =
 570                         ARRAY_SIZE(energy_battery_props);
 571         }
 572
 573         battery->bat.name = acpi_device_bid(battery->device);
 574         battery->bat.type = POWER_SUPPLY_TYPE_BATTERY;
 575         battery->bat.get_property = acpi_battery_get_property;
 576
 577         result = power_supply_register(&battery->device->dev, &battery->bat);
 578         if (result)
 579                 return result;
 580         return device_create_file(battery->bat.dev, &alarm_attr);
 581 }
 582
 583 static void sysfs_remove_battery(struct acpi_battery *battery)
 584 {
 585         mutex_lock(&battery->sysfs_lock);
 586         if (!battery->bat.dev) {
 587                 mutex_unlock(&battery->sysfs_lock);
 588                 return;
 589         }
 590
 591         device_remove_file(battery->bat.dev, &alarm_attr);
 592         power_supply_unregister(&battery->bat);
 593         battery->bat.dev = NULL;
 594         mutex_unlock(&battery->sysfs_lock);
 595 }
 596
 597 static void find_battery(const struct dmi_header *dm, void *private)
 598 {
 599         struct acpi_battery *battery = (struct acpi_battery *)private;
 600         /* Note: the hardcoded offsets below have been extracted from
 601            the source code of dmidecode.  */
 602         if (dm->type == DMI_ENTRY_PORTABLE_BATTERY && dm->length >= 8) {
 603                 const u8 *dmi_data = (const u8 *)(dm + 1);
 604                 int dmi_capacity = get_unaligned((const u16 *)(dmi_data + 6));
 605                 if (dm->length >= 18)
 606                         dmi_capacity *= dmi_data[17];
 607                 if (battery->design_capacity * battery->design_voltage / 1000
 608                     != dmi_capacity &&
 609                     battery->design_capacity * 10 == dmi_capacity)
 610                         set_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
 611                                 &battery->flags);
 612         }
 613 }
 614
 615 /*
 616  * According to the ACPI spec, some kinds of primary batteries can
 617  * report percentage battery remaining capacity directly to OS.
 618  * In this case, it reports the Last Full Charged Capacity == 100
 619  * and BatteryPresentRate == 0xFFFFFFFF.
 620  *
 621  * Now we found some battery reports percentage remaining capacity
 622  * even if it's rechargeable.
 623  * https://bugzilla.kernel.org/show_bug.cgi?id=15979
 624  *
 625  * Handle this correctly so that they won't break userspace.
 626  */
 627 static void acpi_battery_quirks(struct acpi_battery *battery)
 628 {
 629         if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
 630                 return;
 631
 632         if (battery->full_charge_capacity == 100 &&
 633                 battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN &&
 634                 battery->capacity_now >= 0 && battery->capacity_now <= 100) {
 635                 set_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags);
 636                 battery->full_charge_capacity = battery->design_capacity;
 637                 battery->capacity_now = (battery->capacity_now *
 638                                 battery->full_charge_capacity) / 100;
 639         }
 640
 641         if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags))
 642                 return;
 643
 644         if (battery->power_unit && dmi_name_in_vendors("LENOVO")) {
 645                 const char *s;
 646                 s = dmi_get_system_info(DMI_PRODUCT_VERSION);
 647                 if (s && !strnicmp(s, "ThinkPad", 8)) {
 648                         dmi_walk(find_battery, battery);
 649                         if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
 650                                      &battery->flags) &&
 651                             battery->design_voltage) {
 652                                 battery->design_capacity =
 653                                     battery->design_capacity *
 654                                     10000 / battery->design_voltage;
 655                                 battery->full_charge_capacity =
 656                                     battery->full_charge_capacity *
 657                                     10000 / battery->design_voltage;
 658                                 battery->design_capacity_warning =
 659                                     battery->design_capacity_warning *
 660                                     10000 / battery->design_voltage;
 661                                 battery->capacity_now = battery->capacity_now *
 662                                     10000 / battery->design_voltage;
 663                         }
 664                 }
 665         }
 666 }
 667
 668 static int acpi_battery_update(struct acpi_battery *battery)
 669 {
 670         int result, old_present = acpi_battery_present(battery);
 671         result = acpi_battery_get_status(battery);
 672         if (result)
 673                 return result;
 674         if (!acpi_battery_present(battery)) {
 675                 sysfs_remove_battery(battery);
 676                 battery->update_time = 0;
 677                 return 0;
 678         }
 679         if (!battery->update_time ||
 680             old_present != acpi_battery_present(battery)) {
 681                 result = acpi_battery_get_info(battery);
 682                 if (result)
 683                         return result;
 684                 acpi_battery_init_alarm(battery);
 685         }
 686         if (!battery->bat.dev) {
 687                 result = sysfs_add_battery(battery);
 688                 if (result)
 689                         return result;
 690         }
 691         result = acpi_battery_get_state(battery);
 692         acpi_battery_quirks(battery);
 693         return result;
 694 }
 695
 696 static void acpi_battery_refresh(struct acpi_battery *battery)
 697 {
 698         int power_unit;
 699
 700         if (!battery->bat.dev)
 701                 return;
 702
 703         power_unit = battery->power_unit;
 704
 705         acpi_battery_get_info(battery);
 706
 707         if (power_unit == battery->power_unit)
 708                 return;
 709
 710         /* The battery has changed its reporting units. */
 711         sysfs_remove_battery(battery);
 712         sysfs_add_battery(battery);
 713 }
 714
 715 /* --------------------------------------------------------------------------
 716                                  Driver Interface
 717    -------------------------------------------------------------------------- */
 718
 719 static void acpi_battery_notify(struct acpi_device *device, u32 event)
 720 {
 721         struct acpi_battery *battery = acpi_driver_data(device);
 722         struct device *old;
 723
 724         if (!battery)
 725                 return;
 726         old = battery->bat.dev;
 727         if (event == ACPI_BATTERY_NOTIFY_INFO)
 728                 acpi_battery_refresh(battery);
 729         acpi_battery_update(battery);
 730         acpi_bus_generate_netlink_event(device->pnp.device_class,
 731                                         dev_name(&device->dev), event,
 732                                         acpi_battery_present(battery));
 733         /* acpi_battery_update could remove power_supply object */
 734         if (old && battery->bat.dev)
 735                 power_supply_changed(&battery->bat);
 736 }
 737
 738 static int battery_notify(struct notifier_block *nb,
 739                                unsigned long mode, void *_unused)
 740 {
 741         struct acpi_battery *battery = container_of(nb, struct acpi_battery,
 742                                                     pm_nb);
 743         switch (mode) {
 744         case PM_POST_HIBERNATION:
 745         case PM_POST_SUSPEND:
 746                 if (battery->bat.dev) {
 747                         sysfs_remove_battery(battery);
 748                         sysfs_add_battery(battery);
 749                 }
 750                 break;
 751         }
 752
 753         return 0;
 754 }
 755
 756 static int acpi_battery_add(struct acpi_device *device)
 757 {
 758         int result = 0;
 759         struct acpi_battery *battery = NULL;
 760
 761         if (!device)
 762                 return -EINVAL;
 763         battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL);
 764         if (!battery)
 765                 return -ENOMEM;
 766         battery->device = device;
 767         strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME);
 768         strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS);
 769         device->driver_data = battery;
 770         mutex_init(&battery->lock);
 771         mutex_init(&battery->sysfs_lock);
 772         if (acpi_has_method(battery->device->handle, "_BIX"))
 773                 set_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags);
 774         result = acpi_battery_update(battery);
 775         if (result)
 776                 goto fail;
 777
 778         printk(KERN_INFO PREFIX "%s Slot [%s] (battery %s)\n",
 779                 ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device),
 780                 device->status.battery_present ? "present" : "absent");
 781
 782         battery->pm_nb.notifier_call = battery_notify;
 783         register_pm_notifier(&battery->pm_nb);
 784
 785         return result;
 786
 787 fail:
 788         sysfs_remove_battery(battery);
 789         mutex_destroy(&battery->lock);
 790         mutex_destroy(&battery->sysfs_lock);
 791         kfree(battery);
 792         return result;
 793 }
 794
 795 static int acpi_battery_remove(struct acpi_device *device)
 796 {
 797         struct acpi_battery *battery = NULL;
 798
 799         if (!device || !acpi_driver_data(device))
 800                 return -EINVAL;
 801         battery = acpi_driver_data(device);
 802         unregister_pm_notifier(&battery->pm_nb);
 803         sysfs_remove_battery(battery);
 804         mutex_destroy(&battery->lock);
 805         mutex_destroy(&battery->sysfs_lock);
 806         kfree(battery);
 807         return 0;
 808 }
 809
 810 #ifdef CONFIG_PM_SLEEP
 811 /* this is needed to learn about changes made in suspended state */
 812 static int acpi_battery_resume(struct device *dev)
 813 {
 814         struct acpi_battery *battery;
 815
 816         if (!dev)
 817                 return -EINVAL;
 818
 819         battery = acpi_driver_data(to_acpi_device(dev));
 820         if (!battery)
 821                 return -EINVAL;
 822
 823         battery->update_time = 0;
 824         acpi_battery_update(battery);
 825         return 0;
 826 }
 827 #endif
 828
 829 static SIMPLE_DEV_PM_OPS(acpi_battery_pm, NULL, acpi_battery_resume);
 830
 831 static struct acpi_driver acpi_battery_driver = {
 832         .name = "battery",
 833         .class = ACPI_BATTERY_CLASS,
 834         .ids = battery_device_ids,
 835         .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
 836         .ops = {
 837                 .add = acpi_battery_add,
 838                 .remove = acpi_battery_remove,
 839                 .notify = acpi_battery_notify,
 840                 },
 841         .drv.pm = &acpi_battery_pm,
 842 };
 843
 844 static void __init acpi_battery_init_async(void *unused, async_cookie_t cookie)
 845 {
 846         if (acpi_disabled)
 847                 return;
 848         acpi_bus_register_driver(&acpi_battery_driver);
 849 }
 850
 851 static int __init acpi_battery_init(void)
 852 {
 853         async_schedule(acpi_battery_init_async, NULL);
 854         return 0;
 855 }
 856
 857 static void __exit acpi_battery_exit(void)
 858 {
 859         acpi_bus_unregister_driver(&acpi_battery_driver);
 860 }
 861
 862 module_init(acpi_battery_init);
 863 module_exit(acpi_battery_exit);