Pileus Git - ~andy/linux/blob - drivers/acpi/battery.c

   1 /*
   2  *  battery.c - ACPI Battery Driver (Revision: 2.0)
   3  *
   4  *  Copyright (C) 2007 Alexey Starikovskiy <astarikovskiy@suse.de>
   5  *  Copyright (C) 2004-2007 Vladimir Lebedev <vladimir.p.lebedev@intel.com>
   6  *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
   7  *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
   8  *
   9  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  10  *
  11  *  This program is free software; you can redistribute it and/or modify
  12  *  it under the terms of the GNU General Public License as published by
  13  *  the Free Software Foundation; either version 2 of the License, or (at
  14  *  your option) any later version.
  15  *
  16  *  This program is distributed in the hope that it will be useful, but
  17  *  WITHOUT ANY WARRANTY; without even the implied warranty of
  18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  *  General Public License for more details.
  20  *
  21  *  You should have received a copy of the GNU General Public License along
  22  *  with this program; if not, write to the Free Software Foundation, Inc.,
  23  *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  24  *
  25  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  26  */
  27
  28 #include <linux/kernel.h>
  29 #include <linux/module.h>
  30 #include <linux/init.h>
  31 #include <linux/types.h>
  32 #include <linux/jiffies.h>
  33 #include <linux/async.h>
  34 #include <linux/dmi.h>
  35 #include <linux/slab.h>
  36 #include <linux/suspend.h>
  37 #include <asm/unaligned.h>
  38
  39 #include <linux/acpi.h>
  40 #include <linux/power_supply.h>
  41
  42 #define PREFIX "ACPI: "
  43
  44 #define ACPI_BATTERY_VALUE_UNKNOWN 0xFFFFFFFF
  45
  46 #define ACPI_BATTERY_CLASS              "battery"
  47 #define ACPI_BATTERY_DEVICE_NAME        "Battery"
  48 #define ACPI_BATTERY_NOTIFY_STATUS      0x80
  49 #define ACPI_BATTERY_NOTIFY_INFO        0x81
  50 #define ACPI_BATTERY_NOTIFY_THRESHOLD   0x82
  51
  52 /* Battery power unit: 0 means mW, 1 means mA */
  53 #define ACPI_BATTERY_POWER_UNIT_MA      1
  54
  55 #define _COMPONENT              ACPI_BATTERY_COMPONENT
  56
  57 ACPI_MODULE_NAME("battery");
  58
  59 MODULE_AUTHOR("Paul Diefenbaugh");
  60 MODULE_AUTHOR("Alexey Starikovskiy <astarikovskiy@suse.de>");
  61 MODULE_DESCRIPTION("ACPI Battery Driver");
  62 MODULE_LICENSE("GPL");
  63
  64 static int battery_bix_broken_package;
  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
 420         if (battery_bix_broken_package)
 421                 result = extract_package(battery, buffer.pointer,
 422                                 extended_info_offsets + 1,
 423                                 ARRAY_SIZE(extended_info_offsets) - 1);
 424         else if (test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags))
 425                 result = extract_package(battery, buffer.pointer,
 426                                 extended_info_offsets,
 427                                 ARRAY_SIZE(extended_info_offsets));
 428         else
 429                 result = extract_package(battery, buffer.pointer,
 430                                 info_offsets, ARRAY_SIZE(info_offsets));
 431         kfree(buffer.pointer);
 432         if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
 433                 battery->full_charge_capacity = battery->design_capacity;
 434         if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
 435             battery->power_unit && battery->design_voltage) {
 436                 battery->design_capacity = battery->design_capacity *
 437                     10000 / battery->design_voltage;
 438                 battery->full_charge_capacity = battery->full_charge_capacity *
 439                     10000 / battery->design_voltage;
 440                 battery->design_capacity_warning =
 441                     battery->design_capacity_warning *
 442                     10000 / battery->design_voltage;
 443                 /* Curiously, design_capacity_low, unlike the rest of them,
 444                    is correct.  */
 445                 /* capacity_granularity_* equal 1 on the systems tested, so
 446                    it's impossible to tell if they would need an adjustment
 447                    or not if their values were higher.  */
 448         }
 449         return result;
 450 }
 451
 452 static int acpi_battery_get_state(struct acpi_battery *battery)
 453 {
 454         int result = 0;
 455         acpi_status status = 0;
 456         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 457
 458         if (!acpi_battery_present(battery))
 459                 return 0;
 460
 461         if (battery->update_time &&
 462             time_before(jiffies, battery->update_time +
 463                         msecs_to_jiffies(cache_time)))
 464                 return 0;
 465
 466         mutex_lock(&battery->lock);
 467         status = acpi_evaluate_object(battery->device->handle, "_BST",
 468                                       NULL, &buffer);
 469         mutex_unlock(&battery->lock);
 470
 471         if (ACPI_FAILURE(status)) {
 472                 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BST"));
 473                 return -ENODEV;
 474         }
 475
 476         result = extract_package(battery, buffer.pointer,
 477                                  state_offsets, ARRAY_SIZE(state_offsets));
 478         battery->update_time = jiffies;
 479         kfree(buffer.pointer);
 480
 481         /* For buggy DSDTs that report negative 16-bit values for either
 482          * charging or discharging current and/or report 0 as 65536
 483          * due to bad math.
 484          */
 485         if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA &&
 486                 battery->rate_now != ACPI_BATTERY_VALUE_UNKNOWN &&
 487                 (s16)(battery->rate_now) < 0) {
 488                 battery->rate_now = abs((s16)battery->rate_now);
 489                 printk_once(KERN_WARNING FW_BUG "battery: (dis)charge rate"
 490                         " invalid.\n");
 491         }
 492
 493         if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags)
 494             && battery->capacity_now >= 0 && battery->capacity_now <= 100)
 495                 battery->capacity_now = (battery->capacity_now *
 496                                 battery->full_charge_capacity) / 100;
 497         if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
 498             battery->power_unit && battery->design_voltage) {
 499                 battery->capacity_now = battery->capacity_now *
 500                     10000 / battery->design_voltage;
 501         }
 502         return result;
 503 }
 504
 505 static int acpi_battery_set_alarm(struct acpi_battery *battery)
 506 {
 507         acpi_status status = 0;
 508
 509         if (!acpi_battery_present(battery) ||
 510             !test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags))
 511                 return -ENODEV;
 512
 513         mutex_lock(&battery->lock);
 514         status = acpi_execute_simple_method(battery->device->handle, "_BTP",
 515                                             battery->alarm);
 516         mutex_unlock(&battery->lock);
 517
 518         if (ACPI_FAILURE(status))
 519                 return -ENODEV;
 520
 521         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Alarm set to %d\n", battery->alarm));
 522         return 0;
 523 }
 524
 525 static int acpi_battery_init_alarm(struct acpi_battery *battery)
 526 {
 527         /* See if alarms are supported, and if so, set default */
 528         if (!acpi_has_method(battery->device->handle, "_BTP")) {
 529                 clear_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
 530                 return 0;
 531         }
 532         set_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
 533         if (!battery->alarm)
 534                 battery->alarm = battery->design_capacity_warning;
 535         return acpi_battery_set_alarm(battery);
 536 }
 537
 538 static ssize_t acpi_battery_alarm_show(struct device *dev,
 539                                         struct device_attribute *attr,
 540                                         char *buf)
 541 {
 542         struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
 543         return sprintf(buf, "%d\n", battery->alarm * 1000);
 544 }
 545
 546 static ssize_t acpi_battery_alarm_store(struct device *dev,
 547                                         struct device_attribute *attr,
 548                                         const char *buf, size_t count)
 549 {
 550         unsigned long x;
 551         struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
 552         if (sscanf(buf, "%lu\n", &x) == 1)
 553                 battery->alarm = x/1000;
 554         if (acpi_battery_present(battery))
 555                 acpi_battery_set_alarm(battery);
 556         return count;
 557 }
 558
 559 static struct device_attribute alarm_attr = {
 560         .attr = {.name = "alarm", .mode = 0644},
 561         .show = acpi_battery_alarm_show,
 562         .store = acpi_battery_alarm_store,
 563 };
 564
 565 static int sysfs_add_battery(struct acpi_battery *battery)
 566 {
 567         int result;
 568
 569         if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) {
 570                 battery->bat.properties = charge_battery_props;
 571                 battery->bat.num_properties =
 572                         ARRAY_SIZE(charge_battery_props);
 573         } else {
 574                 battery->bat.properties = energy_battery_props;
 575                 battery->bat.num_properties =
 576                         ARRAY_SIZE(energy_battery_props);
 577         }
 578
 579         battery->bat.name = acpi_device_bid(battery->device);
 580         battery->bat.type = POWER_SUPPLY_TYPE_BATTERY;
 581         battery->bat.get_property = acpi_battery_get_property;
 582
 583         result = power_supply_register(&battery->device->dev, &battery->bat);
 584         if (result)
 585                 return result;
 586         return device_create_file(battery->bat.dev, &alarm_attr);
 587 }
 588
 589 static void sysfs_remove_battery(struct acpi_battery *battery)
 590 {
 591         mutex_lock(&battery->sysfs_lock);
 592         if (!battery->bat.dev) {
 593                 mutex_unlock(&battery->sysfs_lock);
 594                 return;
 595         }
 596
 597         device_remove_file(battery->bat.dev, &alarm_attr);
 598         power_supply_unregister(&battery->bat);
 599         battery->bat.dev = NULL;
 600         mutex_unlock(&battery->sysfs_lock);
 601 }
 602
 603 static void find_battery(const struct dmi_header *dm, void *private)
 604 {
 605         struct acpi_battery *battery = (struct acpi_battery *)private;
 606         /* Note: the hardcoded offsets below have been extracted from
 607            the source code of dmidecode.  */
 608         if (dm->type == DMI_ENTRY_PORTABLE_BATTERY && dm->length >= 8) {
 609                 const u8 *dmi_data = (const u8 *)(dm + 1);
 610                 int dmi_capacity = get_unaligned((const u16 *)(dmi_data + 6));
 611                 if (dm->length >= 18)
 612                         dmi_capacity *= dmi_data[17];
 613                 if (battery->design_capacity * battery->design_voltage / 1000
 614                     != dmi_capacity &&
 615                     battery->design_capacity * 10 == dmi_capacity)
 616                         set_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
 617                                 &battery->flags);
 618         }
 619 }
 620
 621 /*
 622  * According to the ACPI spec, some kinds of primary batteries can
 623  * report percentage battery remaining capacity directly to OS.
 624  * In this case, it reports the Last Full Charged Capacity == 100
 625  * and BatteryPresentRate == 0xFFFFFFFF.
 626  *
 627  * Now we found some battery reports percentage remaining capacity
 628  * even if it's rechargeable.
 629  * https://bugzilla.kernel.org/show_bug.cgi?id=15979
 630  *
 631  * Handle this correctly so that they won't break userspace.
 632  */
 633 static void acpi_battery_quirks(struct acpi_battery *battery)
 634 {
 635         if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
 636                 return;
 637
 638         if (battery->full_charge_capacity == 100 &&
 639                 battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN &&
 640                 battery->capacity_now >= 0 && battery->capacity_now <= 100) {
 641                 set_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags);
 642                 battery->full_charge_capacity = battery->design_capacity;
 643                 battery->capacity_now = (battery->capacity_now *
 644                                 battery->full_charge_capacity) / 100;
 645         }
 646
 647         if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags))
 648                 return;
 649
 650         if (battery->power_unit && dmi_name_in_vendors("LENOVO")) {
 651                 const char *s;
 652                 s = dmi_get_system_info(DMI_PRODUCT_VERSION);
 653                 if (s && !strnicmp(s, "ThinkPad", 8)) {
 654                         dmi_walk(find_battery, battery);
 655                         if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
 656                                      &battery->flags) &&
 657                             battery->design_voltage) {
 658                                 battery->design_capacity =
 659                                     battery->design_capacity *
 660                                     10000 / battery->design_voltage;
 661                                 battery->full_charge_capacity =
 662                                     battery->full_charge_capacity *
 663                                     10000 / battery->design_voltage;
 664                                 battery->design_capacity_warning =
 665                                     battery->design_capacity_warning *
 666                                     10000 / battery->design_voltage;
 667                                 battery->capacity_now = battery->capacity_now *
 668                                     10000 / battery->design_voltage;
 669                         }
 670                 }
 671         }
 672 }
 673
 674 static int acpi_battery_update(struct acpi_battery *battery)
 675 {
 676         int result, old_present = acpi_battery_present(battery);
 677         result = acpi_battery_get_status(battery);
 678         if (result)
 679                 return result;
 680         if (!acpi_battery_present(battery)) {
 681                 sysfs_remove_battery(battery);
 682                 battery->update_time = 0;
 683                 return 0;
 684         }
 685         if (!battery->update_time ||
 686             old_present != acpi_battery_present(battery)) {
 687                 result = acpi_battery_get_info(battery);
 688                 if (result)
 689                         return result;
 690                 acpi_battery_init_alarm(battery);
 691         }
 692         if (!battery->bat.dev) {
 693                 result = sysfs_add_battery(battery);
 694                 if (result)
 695                         return result;
 696         }
 697         result = acpi_battery_get_state(battery);
 698         acpi_battery_quirks(battery);
 699         return result;
 700 }
 701
 702 static void acpi_battery_refresh(struct acpi_battery *battery)
 703 {
 704         int power_unit;
 705
 706         if (!battery->bat.dev)
 707                 return;
 708
 709         power_unit = battery->power_unit;
 710
 711         acpi_battery_get_info(battery);
 712
 713         if (power_unit == battery->power_unit)
 714                 return;
 715
 716         /* The battery has changed its reporting units. */
 717         sysfs_remove_battery(battery);
 718         sysfs_add_battery(battery);
 719 }
 720
 721 /* --------------------------------------------------------------------------
 722                                  Driver Interface
 723    -------------------------------------------------------------------------- */
 724
 725 static void acpi_battery_notify(struct acpi_device *device, u32 event)
 726 {
 727         struct acpi_battery *battery = acpi_driver_data(device);
 728         struct device *old;
 729
 730         if (!battery)
 731                 return;
 732         old = battery->bat.dev;
 733         if (event == ACPI_BATTERY_NOTIFY_INFO)
 734                 acpi_battery_refresh(battery);
 735         acpi_battery_update(battery);
 736         acpi_bus_generate_netlink_event(device->pnp.device_class,
 737                                         dev_name(&device->dev), event,
 738                                         acpi_battery_present(battery));
 739         /* acpi_battery_update could remove power_supply object */
 740         if (old && battery->bat.dev)
 741                 power_supply_changed(&battery->bat);
 742 }
 743
 744 static int battery_notify(struct notifier_block *nb,
 745                                unsigned long mode, void *_unused)
 746 {
 747         struct acpi_battery *battery = container_of(nb, struct acpi_battery,
 748                                                     pm_nb);
 749         switch (mode) {
 750         case PM_POST_HIBERNATION:
 751         case PM_POST_SUSPEND:
 752                 if (battery->bat.dev) {
 753                         sysfs_remove_battery(battery);
 754                         sysfs_add_battery(battery);
 755                 }
 756                 break;
 757         }
 758
 759         return 0;
 760 }
 761
 762 static struct dmi_system_id bat_dmi_table[] = {
 763         {
 764                 .ident = "NEC LZ750/LS",
 765                 .matches = {
 766                         DMI_MATCH(DMI_SYS_VENDOR, "NEC"),
 767                         DMI_MATCH(DMI_PRODUCT_NAME, "PC-LZ750LS"),
 768                 },
 769         },
 770         {},
 771 };
 772
 773 static int acpi_battery_add(struct acpi_device *device)
 774 {
 775         int result = 0;
 776         struct acpi_battery *battery = NULL;
 777
 778         if (!device)
 779                 return -EINVAL;
 780         battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL);
 781         if (!battery)
 782                 return -ENOMEM;
 783         battery->device = device;
 784         strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME);
 785         strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS);
 786         device->driver_data = battery;
 787         mutex_init(&battery->lock);
 788         mutex_init(&battery->sysfs_lock);
 789         if (acpi_has_method(battery->device->handle, "_BIX"))
 790                 set_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags);
 791         result = acpi_battery_update(battery);
 792         if (result)
 793                 goto fail;
 794
 795         printk(KERN_INFO PREFIX "%s Slot [%s] (battery %s)\n",
 796                 ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device),
 797                 device->status.battery_present ? "present" : "absent");
 798
 799         battery->pm_nb.notifier_call = battery_notify;
 800         register_pm_notifier(&battery->pm_nb);
 801
 802         return result;
 803
 804 fail:
 805         sysfs_remove_battery(battery);
 806         mutex_destroy(&battery->lock);
 807         mutex_destroy(&battery->sysfs_lock);
 808         kfree(battery);
 809         return result;
 810 }
 811
 812 static int acpi_battery_remove(struct acpi_device *device)
 813 {
 814         struct acpi_battery *battery = NULL;
 815
 816         if (!device || !acpi_driver_data(device))
 817                 return -EINVAL;
 818         battery = acpi_driver_data(device);
 819         unregister_pm_notifier(&battery->pm_nb);
 820         sysfs_remove_battery(battery);
 821         mutex_destroy(&battery->lock);
 822         mutex_destroy(&battery->sysfs_lock);
 823         kfree(battery);
 824         return 0;
 825 }
 826
 827 #ifdef CONFIG_PM_SLEEP
 828 /* this is needed to learn about changes made in suspended state */
 829 static int acpi_battery_resume(struct device *dev)
 830 {
 831         struct acpi_battery *battery;
 832
 833         if (!dev)
 834                 return -EINVAL;
 835
 836         battery = acpi_driver_data(to_acpi_device(dev));
 837         if (!battery)
 838                 return -EINVAL;
 839
 840         battery->update_time = 0;
 841         acpi_battery_update(battery);
 842         return 0;
 843 }
 844 #else
 845 #define acpi_battery_resume NULL
 846 #endif
 847
 848 static SIMPLE_DEV_PM_OPS(acpi_battery_pm, NULL, acpi_battery_resume);
 849
 850 static struct acpi_driver acpi_battery_driver = {
 851         .name = "battery",
 852         .class = ACPI_BATTERY_CLASS,
 853         .ids = battery_device_ids,
 854         .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
 855         .ops = {
 856                 .add = acpi_battery_add,
 857                 .remove = acpi_battery_remove,
 858                 .notify = acpi_battery_notify,
 859                 },
 860         .drv.pm = &acpi_battery_pm,
 861 };
 862
 863 static void __init acpi_battery_init_async(void *unused, async_cookie_t cookie)
 864 {
 865         if (acpi_disabled)
 866                 return;
 867
 868         if (dmi_check_system(bat_dmi_table))
 869                 battery_bix_broken_package = 1;
 870         acpi_bus_register_driver(&acpi_battery_driver);
 871 }
 872
 873 static int __init acpi_battery_init(void)
 874 {
 875         async_schedule(acpi_battery_init_async, NULL);
 876         return 0;
 877 }
 878
 879 static void __exit acpi_battery_exit(void)
 880 {
 881         acpi_bus_unregister_driver(&acpi_battery_driver);
 882 }
 883
 884 module_init(acpi_battery_init);
 885 module_exit(acpi_battery_exit);