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