Version:  2.0.40 2.2.26 2.4.37 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10

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

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