linux/drivers/acpi/battery.c
<<
>>
Prefs
   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 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  22 */
  23
  24#include <linux/kernel.h>
  25#include <linux/module.h>
  26#include <linux/init.h>
  27#include <linux/types.h>
  28#include <linux/jiffies.h>
  29#include <linux/async.h>
  30#include <linux/dmi.h>
  31#include <linux/delay.h>
  32#include <linux/slab.h>
  33#include <linux/suspend.h>
  34#include <asm/unaligned.h>
  35
  36#ifdef CONFIG_ACPI_PROCFS_POWER
  37#include <linux/proc_fs.h>
  38#include <linux/seq_file.h>
  39#include <linux/uaccess.h>
  40#endif
  41
  42#include <linux/acpi.h>
  43#include <linux/power_supply.h>
  44
  45#include "battery.h"
  46
  47#define PREFIX "ACPI: "
  48
  49#define ACPI_BATTERY_VALUE_UNKNOWN 0xFFFFFFFF
  50
  51#define ACPI_BATTERY_DEVICE_NAME        "Battery"
  52
  53/* Battery power unit: 0 means mW, 1 means mA */
  54#define ACPI_BATTERY_POWER_UNIT_MA      1
  55
  56#define ACPI_BATTERY_STATE_DISCHARGING  0x1
  57#define ACPI_BATTERY_STATE_CHARGING     0x2
  58#define ACPI_BATTERY_STATE_CRITICAL     0x4
  59
  60#define _COMPONENT              ACPI_BATTERY_COMPONENT
  61
  62ACPI_MODULE_NAME("battery");
  63
  64MODULE_AUTHOR("Paul Diefenbaugh");
  65MODULE_AUTHOR("Alexey Starikovskiy <astarikovskiy@suse.de>");
  66MODULE_DESCRIPTION("ACPI Battery Driver");
  67MODULE_LICENSE("GPL");
  68
  69static async_cookie_t async_cookie;
  70static int battery_bix_broken_package;
  71static int battery_notification_delay_ms;
  72static unsigned int cache_time = 1000;
  73module_param(cache_time, uint, 0644);
  74MODULE_PARM_DESC(cache_time, "cache time in milliseconds");
  75
  76#ifdef CONFIG_ACPI_PROCFS_POWER
  77extern struct proc_dir_entry *acpi_lock_battery_dir(void);
  78extern void *acpi_unlock_battery_dir(struct proc_dir_entry *acpi_battery_dir);
  79
  80enum acpi_battery_files {
  81        info_tag = 0,
  82        state_tag,
  83        alarm_tag,
  84        ACPI_BATTERY_NUMFILES,
  85};
  86
  87#endif
  88
  89static const struct acpi_device_id battery_device_ids[] = {
  90        {"PNP0C0A", 0},
  91        {"", 0},
  92};
  93
  94MODULE_DEVICE_TABLE(acpi, battery_device_ids);
  95
  96enum {
  97        ACPI_BATTERY_ALARM_PRESENT,
  98        ACPI_BATTERY_XINFO_PRESENT,
  99        ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY,
 100        /* On Lenovo Thinkpad models from 2010 and 2011, the power unit
 101           switches between mWh and mAh depending on whether the system
 102           is running on battery or not.  When mAh is the unit, most
 103           reported values are incorrect and need to be adjusted by
 104           10000/design_voltage.  Verified on x201, t410, t410s, and x220.
 105           Pre-2010 and 2012 models appear to always report in mWh and
 106           are thus unaffected (tested with t42, t61, t500, x200, x300,
 107           and x230).  Also, in mid-2012 Lenovo issued a BIOS update for
 108           the 2011 models that fixes the issue (tested on x220 with a
 109           post-1.29 BIOS), but as of Nov. 2012, no such update is
 110           available for the 2010 models.  */
 111        ACPI_BATTERY_QUIRK_THINKPAD_MAH,
 112};
 113
 114struct acpi_battery {
 115        struct mutex lock;
 116        struct mutex sysfs_lock;
 117        struct power_supply *bat;
 118        struct power_supply_desc bat_desc;
 119        struct acpi_device *device;
 120        struct notifier_block pm_nb;
 121        unsigned long update_time;
 122        int revision;
 123        int rate_now;
 124        int capacity_now;
 125        int voltage_now;
 126        int design_capacity;
 127        int full_charge_capacity;
 128        int technology;
 129        int design_voltage;
 130        int design_capacity_warning;
 131        int design_capacity_low;
 132        int cycle_count;
 133        int measurement_accuracy;
 134        int max_sampling_time;
 135        int min_sampling_time;
 136        int max_averaging_interval;
 137        int min_averaging_interval;
 138        int capacity_granularity_1;
 139        int capacity_granularity_2;
 140        int alarm;
 141        char model_number[32];
 142        char serial_number[32];
 143        char type[32];
 144        char oem_info[32];
 145        int state;
 146        int power_unit;
 147        unsigned long flags;
 148};
 149
 150#define to_acpi_battery(x) power_supply_get_drvdata(x)
 151
 152static inline int acpi_battery_present(struct acpi_battery *battery)
 153{
 154        return battery->device->status.battery_present;
 155}
 156
 157static int acpi_battery_technology(struct acpi_battery *battery)
 158{
 159        if (!strcasecmp("NiCd", battery->type))
 160                return POWER_SUPPLY_TECHNOLOGY_NiCd;
 161        if (!strcasecmp("NiMH", battery->type))
 162                return POWER_SUPPLY_TECHNOLOGY_NiMH;
 163        if (!strcasecmp("LION", battery->type))
 164                return POWER_SUPPLY_TECHNOLOGY_LION;
 165        if (!strncasecmp("LI-ION", battery->type, 6))
 166                return POWER_SUPPLY_TECHNOLOGY_LION;
 167        if (!strcasecmp("LiP", battery->type))
 168                return POWER_SUPPLY_TECHNOLOGY_LIPO;
 169        return POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
 170}
 171
 172static int acpi_battery_get_state(struct acpi_battery *battery);
 173
 174static int acpi_battery_is_charged(struct acpi_battery *battery)
 175{
 176        /* charging, discharging or critical low */
 177        if (battery->state != 0)
 178                return 0;
 179
 180        /* battery not reporting charge */
 181        if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN ||
 182            battery->capacity_now == 0)
 183                return 0;
 184
 185        /* good batteries update full_charge as the batteries degrade */
 186        if (battery->full_charge_capacity == battery->capacity_now)
 187                return 1;
 188
 189        /* fallback to using design values for broken batteries */
 190        if (battery->design_capacity == battery->capacity_now)
 191                return 1;
 192
 193        /* we don't do any sort of metric based on percentages */
 194        return 0;
 195}
 196
 197static int acpi_battery_get_property(struct power_supply *psy,
 198                                     enum power_supply_property psp,
 199                                     union power_supply_propval *val)
 200{
 201        int ret = 0;
 202        struct acpi_battery *battery = to_acpi_battery(psy);
 203
 204        if (acpi_battery_present(battery)) {
 205                /* run battery update only if it is present */
 206                acpi_battery_get_state(battery);
 207        } else if (psp != POWER_SUPPLY_PROP_PRESENT)
 208                return -ENODEV;
 209        switch (psp) {
 210        case POWER_SUPPLY_PROP_STATUS:
 211                if (battery->state & ACPI_BATTERY_STATE_DISCHARGING)
 212                        val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
 213                else if (battery->state & ACPI_BATTERY_STATE_CHARGING)
 214                        val->intval = POWER_SUPPLY_STATUS_CHARGING;
 215                else if (acpi_battery_is_charged(battery))
 216                        val->intval = POWER_SUPPLY_STATUS_FULL;
 217                else
 218                        val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
 219                break;
 220        case POWER_SUPPLY_PROP_PRESENT:
 221                val->intval = acpi_battery_present(battery);
 222                break;
 223        case POWER_SUPPLY_PROP_TECHNOLOGY:
 224                val->intval = acpi_battery_technology(battery);
 225                break;
 226        case POWER_SUPPLY_PROP_CYCLE_COUNT:
 227                val->intval = battery->cycle_count;
 228                break;
 229        case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
 230                if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
 231                        ret = -ENODEV;
 232                else
 233                        val->intval = battery->design_voltage * 1000;
 234                break;
 235        case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 236                if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
 237                        ret = -ENODEV;
 238                else
 239                        val->intval = battery->voltage_now * 1000;
 240                break;
 241        case POWER_SUPPLY_PROP_CURRENT_NOW:
 242        case POWER_SUPPLY_PROP_POWER_NOW:
 243                if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
 244                        ret = -ENODEV;
 245                else
 246                        val->intval = battery->rate_now * 1000;
 247                break;
 248        case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
 249        case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
 250                if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
 251                        ret = -ENODEV;
 252                else
 253                        val->intval = battery->design_capacity * 1000;
 254                break;
 255        case POWER_SUPPLY_PROP_CHARGE_FULL:
 256        case POWER_SUPPLY_PROP_ENERGY_FULL:
 257                if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
 258                        ret = -ENODEV;
 259                else
 260                        val->intval = battery->full_charge_capacity * 1000;
 261                break;
 262        case POWER_SUPPLY_PROP_CHARGE_NOW:
 263        case POWER_SUPPLY_PROP_ENERGY_NOW:
 264                if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
 265                        ret = -ENODEV;
 266                else
 267                        val->intval = battery->capacity_now * 1000;
 268                break;
 269        case POWER_SUPPLY_PROP_CAPACITY:
 270                if (battery->capacity_now && battery->full_charge_capacity)
 271                        val->intval = battery->capacity_now * 100/
 272                                        battery->full_charge_capacity;
 273                else
 274                        val->intval = 0;
 275                break;
 276        case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
 277                if (battery->state & ACPI_BATTERY_STATE_CRITICAL)
 278                        val->intval = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
 279                else if (test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags) &&
 280                        (battery->capacity_now <= battery->alarm))
 281                        val->intval = POWER_SUPPLY_CAPACITY_LEVEL_LOW;
 282                else if (acpi_battery_is_charged(battery))
 283                        val->intval = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
 284                else
 285                        val->intval = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
 286                break;
 287        case POWER_SUPPLY_PROP_MODEL_NAME:
 288                val->strval = battery->model_number;
 289                break;
 290        case POWER_SUPPLY_PROP_MANUFACTURER:
 291                val->strval = battery->oem_info;
 292                break;
 293        case POWER_SUPPLY_PROP_SERIAL_NUMBER:
 294                val->strval = battery->serial_number;
 295                break;
 296        default:
 297                ret = -EINVAL;
 298        }
 299        return ret;
 300}
 301
 302static enum power_supply_property charge_battery_props[] = {
 303        POWER_SUPPLY_PROP_STATUS,
 304        POWER_SUPPLY_PROP_PRESENT,
 305        POWER_SUPPLY_PROP_TECHNOLOGY,
 306        POWER_SUPPLY_PROP_CYCLE_COUNT,
 307        POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
 308        POWER_SUPPLY_PROP_VOLTAGE_NOW,
 309        POWER_SUPPLY_PROP_CURRENT_NOW,
 310        POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
 311        POWER_SUPPLY_PROP_CHARGE_FULL,
 312        POWER_SUPPLY_PROP_CHARGE_NOW,
 313        POWER_SUPPLY_PROP_CAPACITY,
 314        POWER_SUPPLY_PROP_CAPACITY_LEVEL,
 315        POWER_SUPPLY_PROP_MODEL_NAME,
 316        POWER_SUPPLY_PROP_MANUFACTURER,
 317        POWER_SUPPLY_PROP_SERIAL_NUMBER,
 318};
 319
 320static enum power_supply_property energy_battery_props[] = {
 321        POWER_SUPPLY_PROP_STATUS,
 322        POWER_SUPPLY_PROP_PRESENT,
 323        POWER_SUPPLY_PROP_TECHNOLOGY,
 324        POWER_SUPPLY_PROP_CYCLE_COUNT,
 325        POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
 326        POWER_SUPPLY_PROP_VOLTAGE_NOW,
 327        POWER_SUPPLY_PROP_POWER_NOW,
 328        POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
 329        POWER_SUPPLY_PROP_ENERGY_FULL,
 330        POWER_SUPPLY_PROP_ENERGY_NOW,
 331        POWER_SUPPLY_PROP_CAPACITY,
 332        POWER_SUPPLY_PROP_CAPACITY_LEVEL,
 333        POWER_SUPPLY_PROP_MODEL_NAME,
 334        POWER_SUPPLY_PROP_MANUFACTURER,
 335        POWER_SUPPLY_PROP_SERIAL_NUMBER,
 336};
 337
 338/* --------------------------------------------------------------------------
 339                               Battery Management
 340   -------------------------------------------------------------------------- */
 341struct acpi_offsets {
 342        size_t offset;          /* offset inside struct acpi_sbs_battery */
 343        u8 mode;                /* int or string? */
 344};
 345
 346static const struct acpi_offsets state_offsets[] = {
 347        {offsetof(struct acpi_battery, state), 0},
 348        {offsetof(struct acpi_battery, rate_now), 0},
 349        {offsetof(struct acpi_battery, capacity_now), 0},
 350        {offsetof(struct acpi_battery, voltage_now), 0},
 351};
 352
 353static const struct acpi_offsets info_offsets[] = {
 354        {offsetof(struct acpi_battery, power_unit), 0},
 355        {offsetof(struct acpi_battery, design_capacity), 0},
 356        {offsetof(struct acpi_battery, full_charge_capacity), 0},
 357        {offsetof(struct acpi_battery, technology), 0},
 358        {offsetof(struct acpi_battery, design_voltage), 0},
 359        {offsetof(struct acpi_battery, design_capacity_warning), 0},
 360        {offsetof(struct acpi_battery, design_capacity_low), 0},
 361        {offsetof(struct acpi_battery, capacity_granularity_1), 0},
 362        {offsetof(struct acpi_battery, capacity_granularity_2), 0},
 363        {offsetof(struct acpi_battery, model_number), 1},
 364        {offsetof(struct acpi_battery, serial_number), 1},
 365        {offsetof(struct acpi_battery, type), 1},
 366        {offsetof(struct acpi_battery, oem_info), 1},
 367};
 368
 369static const struct acpi_offsets extended_info_offsets[] = {
 370        {offsetof(struct acpi_battery, revision), 0},
 371        {offsetof(struct acpi_battery, power_unit), 0},
 372        {offsetof(struct acpi_battery, design_capacity), 0},
 373        {offsetof(struct acpi_battery, full_charge_capacity), 0},
 374        {offsetof(struct acpi_battery, technology), 0},
 375        {offsetof(struct acpi_battery, design_voltage), 0},
 376        {offsetof(struct acpi_battery, design_capacity_warning), 0},
 377        {offsetof(struct acpi_battery, design_capacity_low), 0},
 378        {offsetof(struct acpi_battery, cycle_count), 0},
 379        {offsetof(struct acpi_battery, measurement_accuracy), 0},
 380        {offsetof(struct acpi_battery, max_sampling_time), 0},
 381        {offsetof(struct acpi_battery, min_sampling_time), 0},
 382        {offsetof(struct acpi_battery, max_averaging_interval), 0},
 383        {offsetof(struct acpi_battery, min_averaging_interval), 0},
 384        {offsetof(struct acpi_battery, capacity_granularity_1), 0},
 385        {offsetof(struct acpi_battery, capacity_granularity_2), 0},
 386        {offsetof(struct acpi_battery, model_number), 1},
 387        {offsetof(struct acpi_battery, serial_number), 1},
 388        {offsetof(struct acpi_battery, type), 1},
 389        {offsetof(struct acpi_battery, oem_info), 1},
 390};
 391
 392static int extract_package(struct acpi_battery *battery,
 393                           union acpi_object *package,
 394                           const struct acpi_offsets *offsets, int num)
 395{
 396        int i;
 397        union acpi_object *element;
 398        if (package->type != ACPI_TYPE_PACKAGE)
 399                return -EFAULT;
 400        for (i = 0; i < num; ++i) {
 401                if (package->package.count <= i)
 402                        return -EFAULT;
 403                element = &package->package.elements[i];
 404                if (offsets[i].mode) {
 405                        u8 *ptr = (u8 *)battery + offsets[i].offset;
 406                        if (element->type == ACPI_TYPE_STRING ||
 407                            element->type == ACPI_TYPE_BUFFER)
 408                                strncpy(ptr, element->string.pointer, 32);
 409                        else if (element->type == ACPI_TYPE_INTEGER) {
 410                                strncpy(ptr, (u8 *)&element->integer.value,
 411                                        sizeof(u64));
 412                                ptr[sizeof(u64)] = 0;
 413                        } else
 414                                *ptr = 0; /* don't have value */
 415                } else {
 416                        int *x = (int *)((u8 *)battery + offsets[i].offset);
 417                        *x = (element->type == ACPI_TYPE_INTEGER) ?
 418                                element->integer.value : -1;
 419                }
 420        }
 421        return 0;
 422}
 423
 424static int acpi_battery_get_status(struct acpi_battery *battery)
 425{
 426        if (acpi_bus_get_status(battery->device)) {
 427                ACPI_EXCEPTION((AE_INFO, AE_ERROR, "Evaluating _STA"));
 428                return -ENODEV;
 429        }
 430        return 0;
 431}
 432
 433
 434static int extract_battery_info(const int use_bix,
 435                         struct acpi_battery *battery,
 436                         const struct acpi_buffer *buffer)
 437{
 438        int result = -EFAULT;
 439
 440        if (use_bix && battery_bix_broken_package)
 441                result = extract_package(battery, buffer->pointer,
 442                                extended_info_offsets + 1,
 443                                ARRAY_SIZE(extended_info_offsets) - 1);
 444        else if (use_bix)
 445                result = extract_package(battery, buffer->pointer,
 446                                extended_info_offsets,
 447                                ARRAY_SIZE(extended_info_offsets));
 448        else
 449                result = extract_package(battery, buffer->pointer,
 450                                info_offsets, ARRAY_SIZE(info_offsets));
 451        if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
 452                battery->full_charge_capacity = battery->design_capacity;
 453        if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
 454            battery->power_unit && battery->design_voltage) {
 455                battery->design_capacity = battery->design_capacity *
 456                    10000 / battery->design_voltage;
 457                battery->full_charge_capacity = battery->full_charge_capacity *
 458                    10000 / battery->design_voltage;
 459                battery->design_capacity_warning =
 460                    battery->design_capacity_warning *
 461                    10000 / battery->design_voltage;
 462                /* Curiously, design_capacity_low, unlike the rest of them,
 463                   is correct.  */
 464                /* capacity_granularity_* equal 1 on the systems tested, so
 465                   it's impossible to tell if they would need an adjustment
 466                   or not if their values were higher.  */
 467        }
 468        return result;
 469}
 470
 471static int acpi_battery_get_info(struct acpi_battery *battery)
 472{
 473        const int xinfo = test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags);
 474        int use_bix;
 475        int result = -ENODEV;
 476
 477        if (!acpi_battery_present(battery))
 478                return 0;
 479
 480
 481        for (use_bix = xinfo ? 1 : 0; use_bix >= 0; use_bix--) {
 482                struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 483                acpi_status status = AE_ERROR;
 484
 485                mutex_lock(&battery->lock);
 486                status = acpi_evaluate_object(battery->device->handle,
 487                                              use_bix ? "_BIX":"_BIF",
 488                                              NULL, &buffer);
 489                mutex_unlock(&battery->lock);
 490
 491                if (ACPI_FAILURE(status)) {
 492                        ACPI_EXCEPTION((AE_INFO, status, "Evaluating %s",
 493                                        use_bix ? "_BIX":"_BIF"));
 494                } else {
 495                        result = extract_battery_info(use_bix,
 496                                                      battery,
 497                                                      &buffer);
 498
 499                        kfree(buffer.pointer);
 500                        break;
 501                }
 502        }
 503
 504        if (!result && !use_bix && xinfo)
 505                pr_warn(FW_BUG "The _BIX method is broken, using _BIF.\n");
 506
 507        return result;
 508}
 509
 510static int acpi_battery_get_state(struct acpi_battery *battery)
 511{
 512        int result = 0;
 513        acpi_status status = 0;
 514        struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 515
 516        if (!acpi_battery_present(battery))
 517                return 0;
 518
 519        if (battery->update_time &&
 520            time_before(jiffies, battery->update_time +
 521                        msecs_to_jiffies(cache_time)))
 522                return 0;
 523
 524        mutex_lock(&battery->lock);
 525        status = acpi_evaluate_object(battery->device->handle, "_BST",
 526                                      NULL, &buffer);
 527        mutex_unlock(&battery->lock);
 528
 529        if (ACPI_FAILURE(status)) {
 530                ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BST"));
 531                return -ENODEV;
 532        }
 533
 534        result = extract_package(battery, buffer.pointer,
 535                                 state_offsets, ARRAY_SIZE(state_offsets));
 536        battery->update_time = jiffies;
 537        kfree(buffer.pointer);
 538
 539        /* For buggy DSDTs that report negative 16-bit values for either
 540         * charging or discharging current and/or report 0 as 65536
 541         * due to bad math.
 542         */
 543        if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA &&
 544                battery->rate_now != ACPI_BATTERY_VALUE_UNKNOWN &&
 545                (s16)(battery->rate_now) < 0) {
 546                battery->rate_now = abs((s16)battery->rate_now);
 547                printk_once(KERN_WARNING FW_BUG
 548                            "battery: (dis)charge rate invalid.\n");
 549        }
 550
 551        if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags)
 552            && battery->capacity_now >= 0 && battery->capacity_now <= 100)
 553                battery->capacity_now = (battery->capacity_now *
 554                                battery->full_charge_capacity) / 100;
 555        if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
 556            battery->power_unit && battery->design_voltage) {
 557                battery->capacity_now = battery->capacity_now *
 558                    10000 / battery->design_voltage;
 559        }
 560        return result;
 561}
 562
 563static int acpi_battery_set_alarm(struct acpi_battery *battery)
 564{
 565        acpi_status status = 0;
 566
 567        if (!acpi_battery_present(battery) ||
 568            !test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags))
 569                return -ENODEV;
 570
 571        mutex_lock(&battery->lock);
 572        status = acpi_execute_simple_method(battery->device->handle, "_BTP",
 573                                            battery->alarm);
 574        mutex_unlock(&battery->lock);
 575
 576        if (ACPI_FAILURE(status))
 577                return -ENODEV;
 578
 579        ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Alarm set to %d\n", battery->alarm));
 580        return 0;
 581}
 582
 583static int acpi_battery_init_alarm(struct acpi_battery *battery)
 584{
 585        /* See if alarms are supported, and if so, set default */
 586        if (!acpi_has_method(battery->device->handle, "_BTP")) {
 587                clear_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
 588                return 0;
 589        }
 590        set_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
 591        if (!battery->alarm)
 592                battery->alarm = battery->design_capacity_warning;
 593        return acpi_battery_set_alarm(battery);
 594}
 595
 596static ssize_t acpi_battery_alarm_show(struct device *dev,
 597                                        struct device_attribute *attr,
 598                                        char *buf)
 599{
 600        struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
 601        return sprintf(buf, "%d\n", battery->alarm * 1000);
 602}
 603
 604static ssize_t acpi_battery_alarm_store(struct device *dev,
 605                                        struct device_attribute *attr,
 606                                        const char *buf, size_t count)
 607{
 608        unsigned long x;
 609        struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
 610        if (sscanf(buf, "%lu\n", &x) == 1)
 611                battery->alarm = x/1000;
 612        if (acpi_battery_present(battery))
 613                acpi_battery_set_alarm(battery);
 614        return count;
 615}
 616
 617static struct device_attribute alarm_attr = {
 618        .attr = {.name = "alarm", .mode = 0644},
 619        .show = acpi_battery_alarm_show,
 620        .store = acpi_battery_alarm_store,
 621};
 622
 623static int sysfs_add_battery(struct acpi_battery *battery)
 624{
 625        struct power_supply_config psy_cfg = { .drv_data = battery, };
 626
 627        if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) {
 628                battery->bat_desc.properties = charge_battery_props;
 629                battery->bat_desc.num_properties =
 630                        ARRAY_SIZE(charge_battery_props);
 631        } else {
 632                battery->bat_desc.properties = energy_battery_props;
 633                battery->bat_desc.num_properties =
 634                        ARRAY_SIZE(energy_battery_props);
 635        }
 636
 637        battery->bat_desc.name = acpi_device_bid(battery->device);
 638        battery->bat_desc.type = POWER_SUPPLY_TYPE_BATTERY;
 639        battery->bat_desc.get_property = acpi_battery_get_property;
 640
 641        battery->bat = power_supply_register_no_ws(&battery->device->dev,
 642                                &battery->bat_desc, &psy_cfg);
 643
 644        if (IS_ERR(battery->bat)) {
 645                int result = PTR_ERR(battery->bat);
 646
 647                battery->bat = NULL;
 648                return result;
 649        }
 650        return device_create_file(&battery->bat->dev, &alarm_attr);
 651}
 652
 653static void sysfs_remove_battery(struct acpi_battery *battery)
 654{
 655        mutex_lock(&battery->sysfs_lock);
 656        if (!battery->bat) {
 657                mutex_unlock(&battery->sysfs_lock);
 658                return;
 659        }
 660
 661        device_remove_file(&battery->bat->dev, &alarm_attr);
 662        power_supply_unregister(battery->bat);
 663        battery->bat = NULL;
 664        mutex_unlock(&battery->sysfs_lock);
 665}
 666
 667static void find_battery(const struct dmi_header *dm, void *private)
 668{
 669        struct acpi_battery *battery = (struct acpi_battery *)private;
 670        /* Note: the hardcoded offsets below have been extracted from
 671           the source code of dmidecode.  */
 672        if (dm->type == DMI_ENTRY_PORTABLE_BATTERY && dm->length >= 8) {
 673                const u8 *dmi_data = (const u8 *)(dm + 1);
 674                int dmi_capacity = get_unaligned((const u16 *)(dmi_data + 6));
 675                if (dm->length >= 18)
 676                        dmi_capacity *= dmi_data[17];
 677                if (battery->design_capacity * battery->design_voltage / 1000
 678                    != dmi_capacity &&
 679                    battery->design_capacity * 10 == dmi_capacity)
 680                        set_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
 681                                &battery->flags);
 682        }
 683}
 684
 685/*
 686 * According to the ACPI spec, some kinds of primary batteries can
 687 * report percentage battery remaining capacity directly to OS.
 688 * In this case, it reports the Last Full Charged Capacity == 100
 689 * and BatteryPresentRate == 0xFFFFFFFF.
 690 *
 691 * Now we found some battery reports percentage remaining capacity
 692 * even if it's rechargeable.
 693 * https://bugzilla.kernel.org/show_bug.cgi?id=15979
 694 *
 695 * Handle this correctly so that they won't break userspace.
 696 */
 697static void acpi_battery_quirks(struct acpi_battery *battery)
 698{
 699        if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
 700                return;
 701
 702        if (battery->full_charge_capacity == 100 &&
 703                battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN &&
 704                battery->capacity_now >= 0 && battery->capacity_now <= 100) {
 705                set_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags);
 706                battery->full_charge_capacity = battery->design_capacity;
 707                battery->capacity_now = (battery->capacity_now *
 708                                battery->full_charge_capacity) / 100;
 709        }
 710
 711        if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags))
 712                return;
 713
 714        if (battery->power_unit && dmi_name_in_vendors("LENOVO")) {
 715                const char *s;
 716                s = dmi_get_system_info(DMI_PRODUCT_VERSION);
 717                if (s && !strncasecmp(s, "ThinkPad", 8)) {
 718                        dmi_walk(find_battery, battery);
 719                        if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
 720                                     &battery->flags) &&
 721                            battery->design_voltage) {
 722                                battery->design_capacity =
 723                                    battery->design_capacity *
 724                                    10000 / battery->design_voltage;
 725                                battery->full_charge_capacity =
 726                                    battery->full_charge_capacity *
 727                                    10000 / battery->design_voltage;
 728                                battery->design_capacity_warning =
 729                                    battery->design_capacity_warning *
 730                                    10000 / battery->design_voltage;
 731                                battery->capacity_now = battery->capacity_now *
 732                                    10000 / battery->design_voltage;
 733                        }
 734                }
 735        }
 736}
 737
 738static int acpi_battery_update(struct acpi_battery *battery, bool resume)
 739{
 740        int result, old_present = acpi_battery_present(battery);
 741        result = acpi_battery_get_status(battery);
 742        if (result)
 743                return result;
 744        if (!acpi_battery_present(battery)) {
 745                sysfs_remove_battery(battery);
 746                battery->update_time = 0;
 747                return 0;
 748        }
 749
 750        if (resume)
 751                return 0;
 752
 753        if (!battery->update_time ||
 754            old_present != acpi_battery_present(battery)) {
 755                result = acpi_battery_get_info(battery);
 756                if (result)
 757                        return result;
 758                acpi_battery_init_alarm(battery);
 759        }
 760
 761        result = acpi_battery_get_state(battery);
 762        if (result)
 763                return result;
 764        acpi_battery_quirks(battery);
 765
 766        if (!battery->bat) {
 767                result = sysfs_add_battery(battery);
 768                if (result)
 769                        return result;
 770        }
 771
 772        /*
 773         * Wakeup the system if battery is critical low
 774         * or lower than the alarm level
 775         */
 776        if ((battery->state & ACPI_BATTERY_STATE_CRITICAL) ||
 777            (test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags) &&
 778            (battery->capacity_now <= battery->alarm)))
 779                pm_wakeup_event(&battery->device->dev, 0);
 780
 781        return result;
 782}
 783
 784static void acpi_battery_refresh(struct acpi_battery *battery)
 785{
 786        int power_unit;
 787
 788        if (!battery->bat)
 789                return;
 790
 791        power_unit = battery->power_unit;
 792
 793        acpi_battery_get_info(battery);
 794
 795        if (power_unit == battery->power_unit)
 796                return;
 797
 798        /* The battery has changed its reporting units. */
 799        sysfs_remove_battery(battery);
 800        sysfs_add_battery(battery);
 801}
 802
 803/* --------------------------------------------------------------------------
 804                              FS Interface (/proc)
 805   -------------------------------------------------------------------------- */
 806
 807#ifdef CONFIG_ACPI_PROCFS_POWER
 808static struct proc_dir_entry *acpi_battery_dir;
 809
 810static const char *acpi_battery_units(const struct acpi_battery *battery)
 811{
 812        return (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) ?
 813                "mA" : "mW";
 814}
 815
 816static int acpi_battery_print_info(struct seq_file *seq, int result)
 817{
 818        struct acpi_battery *battery = seq->private;
 819
 820        if (result)
 821                goto end;
 822
 823        seq_printf(seq, "present:                 %s\n",
 824                   acpi_battery_present(battery) ? "yes" : "no");
 825        if (!acpi_battery_present(battery))
 826                goto end;
 827        if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
 828                seq_printf(seq, "design capacity:         unknown\n");
 829        else
 830                seq_printf(seq, "design capacity:         %d %sh\n",
 831                           battery->design_capacity,
 832                           acpi_battery_units(battery));
 833
 834        if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
 835                seq_printf(seq, "last full capacity:      unknown\n");
 836        else
 837                seq_printf(seq, "last full capacity:      %d %sh\n",
 838                           battery->full_charge_capacity,
 839                           acpi_battery_units(battery));
 840
 841        seq_printf(seq, "battery technology:      %srechargeable\n",
 842                   (!battery->technology)?"non-":"");
 843
 844        if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
 845                seq_printf(seq, "design voltage:          unknown\n");
 846        else
 847                seq_printf(seq, "design voltage:          %d mV\n",
 848                           battery->design_voltage);
 849        seq_printf(seq, "design capacity warning: %d %sh\n",
 850                   battery->design_capacity_warning,
 851                   acpi_battery_units(battery));
 852        seq_printf(seq, "design capacity low:     %d %sh\n",
 853                   battery->design_capacity_low,
 854                   acpi_battery_units(battery));
 855        seq_printf(seq, "cycle count:             %i\n", battery->cycle_count);
 856        seq_printf(seq, "capacity granularity 1:  %d %sh\n",
 857                   battery->capacity_granularity_1,
 858                   acpi_battery_units(battery));
 859        seq_printf(seq, "capacity granularity 2:  %d %sh\n",
 860                   battery->capacity_granularity_2,
 861                   acpi_battery_units(battery));
 862        seq_printf(seq, "model number:            %s\n", battery->model_number);
 863        seq_printf(seq, "serial number:           %s\n", battery->serial_number);
 864        seq_printf(seq, "battery type:            %s\n", battery->type);
 865        seq_printf(seq, "OEM info:                %s\n", battery->oem_info);
 866      end:
 867        if (result)
 868                seq_printf(seq, "ERROR: Unable to read battery info\n");
 869        return result;
 870}
 871
 872static int acpi_battery_print_state(struct seq_file *seq, int result)
 873{
 874        struct acpi_battery *battery = seq->private;
 875
 876        if (result)
 877                goto end;
 878
 879        seq_printf(seq, "present:                 %s\n",
 880                   acpi_battery_present(battery) ? "yes" : "no");
 881        if (!acpi_battery_present(battery))
 882                goto end;
 883
 884        seq_printf(seq, "capacity state:          %s\n",
 885                        (battery->state & 0x04) ? "critical" : "ok");
 886        if ((battery->state & 0x01) && (battery->state & 0x02))
 887                seq_printf(seq,
 888                           "charging state:          charging/discharging\n");
 889        else if (battery->state & 0x01)
 890                seq_printf(seq, "charging state:          discharging\n");
 891        else if (battery->state & 0x02)
 892                seq_printf(seq, "charging state:          charging\n");
 893        else
 894                seq_printf(seq, "charging state:          charged\n");
 895
 896        if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
 897                seq_printf(seq, "present rate:            unknown\n");
 898        else
 899                seq_printf(seq, "present rate:            %d %s\n",
 900                           battery->rate_now, acpi_battery_units(battery));
 901
 902        if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
 903                seq_printf(seq, "remaining capacity:      unknown\n");
 904        else
 905                seq_printf(seq, "remaining capacity:      %d %sh\n",
 906                           battery->capacity_now, acpi_battery_units(battery));
 907        if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
 908                seq_printf(seq, "present voltage:         unknown\n");
 909        else
 910                seq_printf(seq, "present voltage:         %d mV\n",
 911                           battery->voltage_now);
 912      end:
 913        if (result)
 914                seq_printf(seq, "ERROR: Unable to read battery state\n");
 915
 916        return result;
 917}
 918
 919static int acpi_battery_print_alarm(struct seq_file *seq, int result)
 920{
 921        struct acpi_battery *battery = seq->private;
 922
 923        if (result)
 924                goto end;
 925
 926        if (!acpi_battery_present(battery)) {
 927                seq_printf(seq, "present:                 no\n");
 928                goto end;
 929        }
 930        seq_printf(seq, "alarm:                   ");
 931        if (!battery->alarm)
 932                seq_printf(seq, "unsupported\n");
 933        else
 934                seq_printf(seq, "%u %sh\n", battery->alarm,
 935                                acpi_battery_units(battery));
 936      end:
 937        if (result)
 938                seq_printf(seq, "ERROR: Unable to read battery alarm\n");
 939        return result;
 940}
 941
 942static ssize_t acpi_battery_write_alarm(struct file *file,
 943                                        const char __user * buffer,
 944                                        size_t count, loff_t * ppos)
 945{
 946        int result = 0;
 947        char alarm_string[12] = { '\0' };
 948        struct seq_file *m = file->private_data;
 949        struct acpi_battery *battery = m->private;
 950
 951        if (!battery || (count > sizeof(alarm_string) - 1))
 952                return -EINVAL;
 953        if (!acpi_battery_present(battery)) {
 954                result = -ENODEV;
 955                goto end;
 956        }
 957        if (copy_from_user(alarm_string, buffer, count)) {
 958                result = -EFAULT;
 959                goto end;
 960        }
 961        alarm_string[count] = '\0';
 962        if (kstrtoint(alarm_string, 0, &battery->alarm)) {
 963                result = -EINVAL;
 964                goto end;
 965        }
 966        result = acpi_battery_set_alarm(battery);
 967      end:
 968        if (!result)
 969                return count;
 970        return result;
 971}
 972
 973typedef int(*print_func)(struct seq_file *seq, int result);
 974
 975static print_func acpi_print_funcs[ACPI_BATTERY_NUMFILES] = {
 976        acpi_battery_print_info,
 977        acpi_battery_print_state,
 978        acpi_battery_print_alarm,
 979};
 980
 981static int acpi_battery_read(int fid, struct seq_file *seq)
 982{
 983        struct acpi_battery *battery = seq->private;
 984        int result = acpi_battery_update(battery, false);
 985        return acpi_print_funcs[fid](seq, result);
 986}
 987
 988#define DECLARE_FILE_FUNCTIONS(_name) \
 989static int acpi_battery_read_##_name(struct seq_file *seq, void *offset) \
 990{ \
 991        return acpi_battery_read(_name##_tag, seq); \
 992} \
 993static int acpi_battery_##_name##_open_fs(struct inode *inode, struct file *file) \
 994{ \
 995        return single_open(file, acpi_battery_read_##_name, PDE_DATA(inode)); \
 996}
 997
 998DECLARE_FILE_FUNCTIONS(info);
 999DECLARE_FILE_FUNCTIONS(state);
1000DECLARE_FILE_FUNCTIONS(alarm);
1001
1002#undef DECLARE_FILE_FUNCTIONS
1003
1004#define FILE_DESCRIPTION_RO(_name) \
1005        { \
1006        .name = __stringify(_name), \
1007        .mode = S_IRUGO, \
1008        .ops = { \
1009                .open = acpi_battery_##_name##_open_fs, \
1010                .read = seq_read, \
1011                .llseek = seq_lseek, \
1012                .release = single_release, \
1013                .owner = THIS_MODULE, \
1014                }, \
1015        }
1016
1017#define FILE_DESCRIPTION_RW(_name) \
1018        { \
1019        .name = __stringify(_name), \
1020        .mode = S_IFREG | S_IRUGO | S_IWUSR, \
1021        .ops = { \
1022                .open = acpi_battery_##_name##_open_fs, \
1023                .read = seq_read, \
1024                .llseek = seq_lseek, \
1025                .write = acpi_battery_write_##_name, \
1026                .release = single_release, \
1027                .owner = THIS_MODULE, \
1028                }, \
1029        }
1030
1031static const struct battery_file {
1032        struct file_operations ops;
1033        umode_t mode;
1034        const char *name;
1035} acpi_battery_file[] = {
1036        FILE_DESCRIPTION_RO(info),
1037        FILE_DESCRIPTION_RO(state),
1038        FILE_DESCRIPTION_RW(alarm),
1039};
1040
1041#undef FILE_DESCRIPTION_RO
1042#undef FILE_DESCRIPTION_RW
1043
1044static int acpi_battery_add_fs(struct acpi_device *device)
1045{
1046        struct proc_dir_entry *entry = NULL;
1047        int i;
1048
1049        printk(KERN_WARNING PREFIX "Deprecated procfs I/F for battery is loaded,"
1050                        " please retry with CONFIG_ACPI_PROCFS_POWER cleared\n");
1051        if (!acpi_device_dir(device)) {
1052                acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
1053                                                     acpi_battery_dir);
1054                if (!acpi_device_dir(device))
1055                        return -ENODEV;
1056        }
1057
1058        for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i) {
1059                entry = proc_create_data(acpi_battery_file[i].name,
1060                                         acpi_battery_file[i].mode,
1061                                         acpi_device_dir(device),
1062                                         &acpi_battery_file[i].ops,
1063                                         acpi_driver_data(device));
1064                if (!entry)
1065                        return -ENODEV;
1066        }
1067        return 0;
1068}
1069
1070static void acpi_battery_remove_fs(struct acpi_device *device)
1071{
1072        int i;
1073        if (!acpi_device_dir(device))
1074                return;
1075        for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i)
1076                remove_proc_entry(acpi_battery_file[i].name,
1077                                  acpi_device_dir(device));
1078
1079        remove_proc_entry(acpi_device_bid(device), acpi_battery_dir);
1080        acpi_device_dir(device) = NULL;
1081}
1082
1083#endif
1084
1085/* --------------------------------------------------------------------------
1086                                 Driver Interface
1087   -------------------------------------------------------------------------- */
1088
1089static void acpi_battery_notify(struct acpi_device *device, u32 event)
1090{
1091        struct acpi_battery *battery = acpi_driver_data(device);
1092        struct power_supply *old;
1093
1094        if (!battery)
1095                return;
1096        old = battery->bat;
1097        /*
1098        * On Acer Aspire V5-573G notifications are sometimes triggered too
1099        * early. For example, when AC is unplugged and notification is
1100        * triggered, battery state is still reported as "Full", and changes to
1101        * "Discharging" only after short delay, without any notification.
1102        */
1103        if (battery_notification_delay_ms > 0)
1104                msleep(battery_notification_delay_ms);
1105        if (event == ACPI_BATTERY_NOTIFY_INFO)
1106                acpi_battery_refresh(battery);
1107        acpi_battery_update(battery, false);
1108        acpi_bus_generate_netlink_event(device->pnp.device_class,
1109                                        dev_name(&device->dev), event,
1110                                        acpi_battery_present(battery));
1111        acpi_notifier_call_chain(device, event, acpi_battery_present(battery));
1112        /* acpi_battery_update could remove power_supply object */
1113        if (old && battery->bat)
1114                power_supply_changed(battery->bat);
1115}
1116
1117static int battery_notify(struct notifier_block *nb,
1118                               unsigned long mode, void *_unused)
1119{
1120        struct acpi_battery *battery = container_of(nb, struct acpi_battery,
1121                                                    pm_nb);
1122        int result;
1123
1124        switch (mode) {
1125        case PM_POST_HIBERNATION:
1126        case PM_POST_SUSPEND:
1127                if (!acpi_battery_present(battery))
1128                        return 0;
1129
1130                if (!battery->bat) {
1131                        result = acpi_battery_get_info(battery);
1132                        if (result)
1133                                return result;
1134
1135                        result = sysfs_add_battery(battery);
1136                        if (result)
1137                                return result;
1138                } else
1139                        acpi_battery_refresh(battery);
1140
1141                acpi_battery_init_alarm(battery);
1142                acpi_battery_get_state(battery);
1143                break;
1144        }
1145
1146        return 0;
1147}
1148
1149static int __init
1150battery_bix_broken_package_quirk(const struct dmi_system_id *d)
1151{
1152        battery_bix_broken_package = 1;
1153        return 0;
1154}
1155
1156static int __init
1157battery_notification_delay_quirk(const struct dmi_system_id *d)
1158{
1159        battery_notification_delay_ms = 1000;
1160        return 0;
1161}
1162
1163static const struct dmi_system_id bat_dmi_table[] __initconst = {
1164        {
1165                .callback = battery_bix_broken_package_quirk,
1166                .ident = "NEC LZ750/LS",
1167                .matches = {
1168                        DMI_MATCH(DMI_SYS_VENDOR, "NEC"),
1169                        DMI_MATCH(DMI_PRODUCT_NAME, "PC-LZ750LS"),
1170                },
1171        },
1172        {
1173                .callback = battery_notification_delay_quirk,
1174                .ident = "Acer Aspire V5-573G",
1175                .matches = {
1176                        DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
1177                        DMI_MATCH(DMI_PRODUCT_NAME, "Aspire V5-573G"),
1178                },
1179        },
1180        {},
1181};
1182
1183/*
1184 * Some machines'(E,G Lenovo Z480) ECs are not stable
1185 * during boot up and this causes battery driver fails to be
1186 * probed due to failure of getting battery information
1187 * from EC sometimes. After several retries, the operation
1188 * may work. So add retry code here and 20ms sleep between
1189 * every retries.
1190 */
1191static int acpi_battery_update_retry(struct acpi_battery *battery)
1192{
1193        int retry, ret;
1194
1195        for (retry = 5; retry; retry--) {
1196                ret = acpi_battery_update(battery, false);
1197                if (!ret)
1198                        break;
1199
1200                msleep(20);
1201        }
1202        return ret;
1203}
1204
1205static int acpi_battery_add(struct acpi_device *device)
1206{
1207        int result = 0;
1208        struct acpi_battery *battery = NULL;
1209
1210        if (!device)
1211                return -EINVAL;
1212
1213        if (device->dep_unmet)
1214                return -EPROBE_DEFER;
1215
1216        battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL);
1217        if (!battery)
1218                return -ENOMEM;
1219        battery->device = device;
1220        strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME);
1221        strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS);
1222        device->driver_data = battery;
1223        mutex_init(&battery->lock);
1224        mutex_init(&battery->sysfs_lock);
1225        if (acpi_has_method(battery->device->handle, "_BIX"))
1226                set_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags);
1227
1228        result = acpi_battery_update_retry(battery);
1229        if (result)
1230                goto fail;
1231
1232#ifdef CONFIG_ACPI_PROCFS_POWER
1233        result = acpi_battery_add_fs(device);
1234#endif
1235        if (result) {
1236#ifdef CONFIG_ACPI_PROCFS_POWER
1237                acpi_battery_remove_fs(device);
1238#endif
1239                goto fail;
1240        }
1241
1242        printk(KERN_INFO PREFIX "%s Slot [%s] (battery %s)\n",
1243                ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device),
1244                device->status.battery_present ? "present" : "absent");
1245
1246        battery->pm_nb.notifier_call = battery_notify;
1247        register_pm_notifier(&battery->pm_nb);
1248
1249        device_init_wakeup(&device->dev, 1);
1250
1251        return result;
1252
1253fail:
1254        sysfs_remove_battery(battery);
1255        mutex_destroy(&battery->lock);
1256        mutex_destroy(&battery->sysfs_lock);
1257        kfree(battery);
1258        return result;
1259}
1260
1261static int acpi_battery_remove(struct acpi_device *device)
1262{
1263        struct acpi_battery *battery = NULL;
1264
1265        if (!device || !acpi_driver_data(device))
1266                return -EINVAL;
1267        device_init_wakeup(&device->dev, 0);
1268        battery = acpi_driver_data(device);
1269        unregister_pm_notifier(&battery->pm_nb);
1270#ifdef CONFIG_ACPI_PROCFS_POWER
1271        acpi_battery_remove_fs(device);
1272#endif
1273        sysfs_remove_battery(battery);
1274        mutex_destroy(&battery->lock);
1275        mutex_destroy(&battery->sysfs_lock);
1276        kfree(battery);
1277        return 0;
1278}
1279
1280#ifdef CONFIG_PM_SLEEP
1281/* this is needed to learn about changes made in suspended state */
1282static int acpi_battery_resume(struct device *dev)
1283{
1284        struct acpi_battery *battery;
1285
1286        if (!dev)
1287                return -EINVAL;
1288
1289        battery = acpi_driver_data(to_acpi_device(dev));
1290        if (!battery)
1291                return -EINVAL;
1292
1293        battery->update_time = 0;
1294        acpi_battery_update(battery, true);
1295        return 0;
1296}
1297#else
1298#define acpi_battery_resume NULL
1299#endif
1300
1301static SIMPLE_DEV_PM_OPS(acpi_battery_pm, NULL, acpi_battery_resume);
1302
1303static struct acpi_driver acpi_battery_driver = {
1304        .name = "battery",
1305        .class = ACPI_BATTERY_CLASS,
1306        .ids = battery_device_ids,
1307        .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
1308        .ops = {
1309                .add = acpi_battery_add,
1310                .remove = acpi_battery_remove,
1311                .notify = acpi_battery_notify,
1312                },
1313        .drv.pm = &acpi_battery_pm,
1314};
1315
1316static void __init acpi_battery_init_async(void *unused, async_cookie_t cookie)
1317{
1318        int result;
1319
1320        dmi_check_system(bat_dmi_table);
1321
1322#ifdef CONFIG_ACPI_PROCFS_POWER
1323        acpi_battery_dir = acpi_lock_battery_dir();
1324        if (!acpi_battery_dir)
1325                return;
1326#endif
1327        result = acpi_bus_register_driver(&acpi_battery_driver);
1328#ifdef CONFIG_ACPI_PROCFS_POWER
1329        if (result < 0)
1330                acpi_unlock_battery_dir(acpi_battery_dir);
1331#endif
1332}
1333
1334static int __init acpi_battery_init(void)
1335{
1336        if (acpi_disabled)
1337                return -ENODEV;
1338
1339        async_cookie = async_schedule(acpi_battery_init_async, NULL);
1340        return 0;
1341}
1342
1343static void __exit acpi_battery_exit(void)
1344{
1345        async_synchronize_cookie(async_cookie + 1);
1346        acpi_bus_unregister_driver(&acpi_battery_driver);
1347#ifdef CONFIG_ACPI_PROCFS_POWER
1348        acpi_unlock_battery_dir(acpi_battery_dir);
1349#endif
1350}
1351
1352module_init(acpi_battery_init);
1353module_exit(acpi_battery_exit);
1354
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.