Version:  2.0.40 2.2.26 2.4.37 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15

Linux/drivers/acpi/battery.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us