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