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