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