drivers/acpi/battery.c

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