Root/drivers/acpi/battery.c

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

Archive Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9



interactive