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