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