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