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