?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
PM / sleep: Asynchronous threads for suspend_noirq
[linux/fpc-iii.git] / drivers / acpi / battery.c
blob018a4288370630cb40203ecd43cc2809851288ae
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 #include <linux/acpi.h>
40 #include <linux/power_supply.h>
41
42 #define PREFIX "ACPI: "
43
44 #define ACPI_BATTERY_VALUE_UNKNOWN 0xFFFFFFFF
45
46 #define ACPI_BATTERY_CLASS "battery"
47 #define ACPI_BATTERY_DEVICE_NAME "Battery"
48 #define ACPI_BATTERY_NOTIFY_STATUS 0x80
49 #define ACPI_BATTERY_NOTIFY_INFO 0x81
50 #define ACPI_BATTERY_NOTIFY_THRESHOLD 0x82
51
52 /* Battery power unit: 0 means mW, 1 means mA */
53 #define ACPI_BATTERY_POWER_UNIT_MA 1
54
55 #define _COMPONENT ACPI_BATTERY_COMPONENT
56
57 ACPI_MODULE_NAME("battery");
58
59 MODULE_AUTHOR("Paul Diefenbaugh");
60 MODULE_AUTHOR("Alexey Starikovskiy <astarikovskiy@suse.de>");
61 MODULE_DESCRIPTION("ACPI Battery Driver");
62 MODULE_LICENSE("GPL");
63
64 static int battery_bix_broken_package;
65 static unsigned int cache_time = 1000;
66 module_param(cache_time, uint, 0644);
67 MODULE_PARM_DESC(cache_time, "cache time in milliseconds");
68
69 static const struct acpi_device_id battery_device_ids[] = {
70 {"PNP0C0A", 0},
71 {"", 0},
72 };
73
74 MODULE_DEVICE_TABLE(acpi, battery_device_ids);
75
76 enum {
77 ACPI_BATTERY_ALARM_PRESENT,
78 ACPI_BATTERY_XINFO_PRESENT,
79 ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY,
80 /* On Lenovo Thinkpad models from 2010 and 2011, the power unit
81 switches between mWh and mAh depending on whether the system
82 is running on battery or not. When mAh is the unit, most
83 reported values are incorrect and need to be adjusted by
84 10000/design_voltage. Verified on x201, t410, t410s, and x220.
85 Pre-2010 and 2012 models appear to always report in mWh and
86 are thus unaffected (tested with t42, t61, t500, x200, x300,
87 and x230). Also, in mid-2012 Lenovo issued a BIOS update for
88 the 2011 models that fixes the issue (tested on x220 with a
89 post-1.29 BIOS), but as of Nov. 2012, no such update is
90 available for the 2010 models. */
91 ACPI_BATTERY_QUIRK_THINKPAD_MAH,
92 };
93
94 struct acpi_battery {
95 struct mutex lock;
96 struct mutex sysfs_lock;
97 struct power_supply bat;
98 struct acpi_device *device;
99 struct notifier_block pm_nb;
100 unsigned long update_time;
101 int revision;
102 int rate_now;
103 int capacity_now;
104 int voltage_now;
105 int design_capacity;
106 int full_charge_capacity;
107 int technology;
108 int design_voltage;
109 int design_capacity_warning;
110 int design_capacity_low;
111 int cycle_count;
112 int measurement_accuracy;
113 int max_sampling_time;
114 int min_sampling_time;
115 int max_averaging_interval;
116 int min_averaging_interval;
117 int capacity_granularity_1;
118 int capacity_granularity_2;
119 int alarm;
120 char model_number[32];
121 char serial_number[32];
122 char type[32];
123 char oem_info[32];
124 int state;
125 int power_unit;
126 unsigned long flags;
127 };
128
129 #define to_acpi_battery(x) container_of(x, struct acpi_battery, bat)
130
131 static inline int acpi_battery_present(struct acpi_battery *battery)
132 {
133 return battery->device->status.battery_present;
134 }
135
136 static int acpi_battery_technology(struct acpi_battery *battery)
137 {
138 if (!strcasecmp("NiCd", battery->type))
139 return POWER_SUPPLY_TECHNOLOGY_NiCd;
140 if (!strcasecmp("NiMH", battery->type))
141 return POWER_SUPPLY_TECHNOLOGY_NiMH;
142 if (!strcasecmp("LION", battery->type))
143 return POWER_SUPPLY_TECHNOLOGY_LION;
144 if (!strncasecmp("LI-ION", battery->type, 6))
145 return POWER_SUPPLY_TECHNOLOGY_LION;
146 if (!strcasecmp("LiP", battery->type))
147 return POWER_SUPPLY_TECHNOLOGY_LIPO;
148 return POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
149 }
150
151 static int acpi_battery_get_state(struct acpi_battery *battery);
152
153 static int acpi_battery_is_charged(struct acpi_battery *battery)
154 {
155 /* either charging or discharging */
156 if (battery->state != 0)
157 return 0;
158
159 /* battery not reporting charge */
160 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN ||
161 battery->capacity_now == 0)
162 return 0;
163
164 /* good batteries update full_charge as the batteries degrade */
165 if (battery->full_charge_capacity == battery->capacity_now)
166 return 1;
167
168 /* fallback to using design values for broken batteries */
169 if (battery->design_capacity == battery->capacity_now)
170 return 1;
171
172 /* we don't do any sort of metric based on percentages */
173 return 0;
174 }
175
176 static int acpi_battery_get_property(struct power_supply *psy,
177 enum power_supply_property psp,
178 union power_supply_propval *val)
179 {
180 int ret = 0;
181 struct acpi_battery *battery = to_acpi_battery(psy);
182
183 if (acpi_battery_present(battery)) {
184 /* run battery update only if it is present */
185 acpi_battery_get_state(battery);
186 } else if (psp != POWER_SUPPLY_PROP_PRESENT)
187 return -ENODEV;
188 switch (psp) {
189 case POWER_SUPPLY_PROP_STATUS:
190 if (battery->state & 0x01)
191 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
192 else if (battery->state & 0x02)
193 val->intval = POWER_SUPPLY_STATUS_CHARGING;
194 else if (acpi_battery_is_charged(battery))
195 val->intval = POWER_SUPPLY_STATUS_FULL;
196 else
197 val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
198 break;
199 case POWER_SUPPLY_PROP_PRESENT:
200 val->intval = acpi_battery_present(battery);
201 break;
202 case POWER_SUPPLY_PROP_TECHNOLOGY:
203 val->intval = acpi_battery_technology(battery);
204 break;
205 case POWER_SUPPLY_PROP_CYCLE_COUNT:
206 val->intval = battery->cycle_count;
207 break;
208 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
209 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
210 ret = -ENODEV;
211 else
212 val->intval = battery->design_voltage * 1000;
213 break;
214 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
215 if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
216 ret = -ENODEV;
217 else
218 val->intval = battery->voltage_now * 1000;
219 break;
220 case POWER_SUPPLY_PROP_CURRENT_NOW:
221 case POWER_SUPPLY_PROP_POWER_NOW:
222 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
223 ret = -ENODEV;
224 else
225 val->intval = battery->rate_now * 1000;
226 break;
227 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
228 case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
229 if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
230 ret = -ENODEV;
231 else
232 val->intval = battery->design_capacity * 1000;
233 break;
234 case POWER_SUPPLY_PROP_CHARGE_FULL:
235 case POWER_SUPPLY_PROP_ENERGY_FULL:
236 if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
237 ret = -ENODEV;
238 else
239 val->intval = battery->full_charge_capacity * 1000;
240 break;
241 case POWER_SUPPLY_PROP_CHARGE_NOW:
242 case POWER_SUPPLY_PROP_ENERGY_NOW:
243 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
244 ret = -ENODEV;
245 else
246 val->intval = battery->capacity_now * 1000;
247 break;
248 case POWER_SUPPLY_PROP_CAPACITY:
249 if (battery->capacity_now && battery->full_charge_capacity)
250 val->intval = battery->capacity_now * 100/
251 battery->full_charge_capacity;
252 else
253 val->intval = 0;
254 break;
255 case POWER_SUPPLY_PROP_MODEL_NAME:
256 val->strval = battery->model_number;
257 break;
258 case POWER_SUPPLY_PROP_MANUFACTURER:
259 val->strval = battery->oem_info;
260 break;
261 case POWER_SUPPLY_PROP_SERIAL_NUMBER:
262 val->strval = battery->serial_number;
263 break;
264 default:
265 ret = -EINVAL;
266 }
267 return ret;
268 }
269
270 static enum power_supply_property charge_battery_props[] = {
271 POWER_SUPPLY_PROP_STATUS,
272 POWER_SUPPLY_PROP_PRESENT,
273 POWER_SUPPLY_PROP_TECHNOLOGY,
274 POWER_SUPPLY_PROP_CYCLE_COUNT,
275 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
276 POWER_SUPPLY_PROP_VOLTAGE_NOW,
277 POWER_SUPPLY_PROP_CURRENT_NOW,
278 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
279 POWER_SUPPLY_PROP_CHARGE_FULL,
280 POWER_SUPPLY_PROP_CHARGE_NOW,
281 POWER_SUPPLY_PROP_CAPACITY,
282 POWER_SUPPLY_PROP_MODEL_NAME,
283 POWER_SUPPLY_PROP_MANUFACTURER,
284 POWER_SUPPLY_PROP_SERIAL_NUMBER,
285 };
286
287 static enum power_supply_property energy_battery_props[] = {
288 POWER_SUPPLY_PROP_STATUS,
289 POWER_SUPPLY_PROP_PRESENT,
290 POWER_SUPPLY_PROP_TECHNOLOGY,
291 POWER_SUPPLY_PROP_CYCLE_COUNT,
292 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
293 POWER_SUPPLY_PROP_VOLTAGE_NOW,
294 POWER_SUPPLY_PROP_POWER_NOW,
295 POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
296 POWER_SUPPLY_PROP_ENERGY_FULL,
297 POWER_SUPPLY_PROP_ENERGY_NOW,
298 POWER_SUPPLY_PROP_CAPACITY,
299 POWER_SUPPLY_PROP_MODEL_NAME,
300 POWER_SUPPLY_PROP_MANUFACTURER,
301 POWER_SUPPLY_PROP_SERIAL_NUMBER,
302 };
303
304 /* --------------------------------------------------------------------------
305 Battery Management
306 -------------------------------------------------------------------------- */
307 struct acpi_offsets {
308 size_t offset; /* offset inside struct acpi_sbs_battery */
309 u8 mode; /* int or string? */
310 };
311
312 static struct acpi_offsets state_offsets[] = {
313 {offsetof(struct acpi_battery, state), 0},
314 {offsetof(struct acpi_battery, rate_now), 0},
315 {offsetof(struct acpi_battery, capacity_now), 0},
316 {offsetof(struct acpi_battery, voltage_now), 0},
317 };
318
319 static struct acpi_offsets info_offsets[] = {
320 {offsetof(struct acpi_battery, power_unit), 0},
321 {offsetof(struct acpi_battery, design_capacity), 0},
322 {offsetof(struct acpi_battery, full_charge_capacity), 0},
323 {offsetof(struct acpi_battery, technology), 0},
324 {offsetof(struct acpi_battery, design_voltage), 0},
325 {offsetof(struct acpi_battery, design_capacity_warning), 0},
326 {offsetof(struct acpi_battery, design_capacity_low), 0},
327 {offsetof(struct acpi_battery, capacity_granularity_1), 0},
328 {offsetof(struct acpi_battery, capacity_granularity_2), 0},
329 {offsetof(struct acpi_battery, model_number), 1},
330 {offsetof(struct acpi_battery, serial_number), 1},
331 {offsetof(struct acpi_battery, type), 1},
332 {offsetof(struct acpi_battery, oem_info), 1},
333 };
334
335 static struct acpi_offsets extended_info_offsets[] = {
336 {offsetof(struct acpi_battery, revision), 0},
337 {offsetof(struct acpi_battery, power_unit), 0},
338 {offsetof(struct acpi_battery, design_capacity), 0},
339 {offsetof(struct acpi_battery, full_charge_capacity), 0},
340 {offsetof(struct acpi_battery, technology), 0},
341 {offsetof(struct acpi_battery, design_voltage), 0},
342 {offsetof(struct acpi_battery, design_capacity_warning), 0},
343 {offsetof(struct acpi_battery, design_capacity_low), 0},
344 {offsetof(struct acpi_battery, cycle_count), 0},
345 {offsetof(struct acpi_battery, measurement_accuracy), 0},
346 {offsetof(struct acpi_battery, max_sampling_time), 0},
347 {offsetof(struct acpi_battery, min_sampling_time), 0},
348 {offsetof(struct acpi_battery, max_averaging_interval), 0},
349 {offsetof(struct acpi_battery, min_averaging_interval), 0},
350 {offsetof(struct acpi_battery, capacity_granularity_1), 0},
351 {offsetof(struct acpi_battery, capacity_granularity_2), 0},
352 {offsetof(struct acpi_battery, model_number), 1},
353 {offsetof(struct acpi_battery, serial_number), 1},
354 {offsetof(struct acpi_battery, type), 1},
355 {offsetof(struct acpi_battery, oem_info), 1},
356 };
357
358 static int extract_package(struct acpi_battery *battery,
359 union acpi_object *package,
360 struct acpi_offsets *offsets, int num)
361 {
362 int i;
363 union acpi_object *element;
364 if (package->type != ACPI_TYPE_PACKAGE)
365 return -EFAULT;
366 for (i = 0; i < num; ++i) {
367 if (package->package.count <= i)
368 return -EFAULT;
369 element = &package->package.elements[i];
370 if (offsets[i].mode) {
371 u8 *ptr = (u8 *)battery + offsets[i].offset;
372 if (element->type == ACPI_TYPE_STRING ||
373 element->type == ACPI_TYPE_BUFFER)
374 strncpy(ptr, element->string.pointer, 32);
375 else if (element->type == ACPI_TYPE_INTEGER) {
376 strncpy(ptr, (u8 *)&element->integer.value,
377 sizeof(u64));
378 ptr[sizeof(u64)] = 0;
379 } else
380 *ptr = 0; /* don't have value */
381 } else {
382 int *x = (int *)((u8 *)battery + offsets[i].offset);
383 *x = (element->type == ACPI_TYPE_INTEGER) ?
384 element->integer.value : -1;
385 }
386 }
387 return 0;
388 }
389
390 static int acpi_battery_get_status(struct acpi_battery *battery)
391 {
392 if (acpi_bus_get_status(battery->device)) {
393 ACPI_EXCEPTION((AE_INFO, AE_ERROR, "Evaluating _STA"));
394 return -ENODEV;
395 }
396 return 0;
397 }
398
399 static int acpi_battery_get_info(struct acpi_battery *battery)
400 {
401 int result = -EFAULT;
402 acpi_status status = 0;
403 char *name = test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags) ?
404 "_BIX" : "_BIF";
405
406 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
407
408 if (!acpi_battery_present(battery))
409 return 0;
410 mutex_lock(&battery->lock);
411 status = acpi_evaluate_object(battery->device->handle, name,
412 NULL, &buffer);
413 mutex_unlock(&battery->lock);
414
415 if (ACPI_FAILURE(status)) {
416 ACPI_EXCEPTION((AE_INFO, status, "Evaluating %s", name));
417 return -ENODEV;
418 }
419
420 if (battery_bix_broken_package)
421 result = extract_package(battery, buffer.pointer,
422 extended_info_offsets + 1,
423 ARRAY_SIZE(extended_info_offsets) - 1);
424 else if (test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags))
425 result = extract_package(battery, buffer.pointer,
426 extended_info_offsets,
427 ARRAY_SIZE(extended_info_offsets));
428 else
429 result = extract_package(battery, buffer.pointer,
430 info_offsets, ARRAY_SIZE(info_offsets));
431 kfree(buffer.pointer);
432 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
433 battery->full_charge_capacity = battery->design_capacity;
434 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
435 battery->power_unit && battery->design_voltage) {
436 battery->design_capacity = battery->design_capacity *
437 10000 / battery->design_voltage;
438 battery->full_charge_capacity = battery->full_charge_capacity *
439 10000 / battery->design_voltage;
440 battery->design_capacity_warning =
441 battery->design_capacity_warning *
442 10000 / battery->design_voltage;
443 /* Curiously, design_capacity_low, unlike the rest of them,
444 is correct. */
445 /* capacity_granularity_* equal 1 on the systems tested, so
446 it's impossible to tell if they would need an adjustment
447 or not if their values were higher. */
448 }
449 return result;
450 }
451
452 static int acpi_battery_get_state(struct acpi_battery *battery)
453 {
454 int result = 0;
455 acpi_status status = 0;
456 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
457
458 if (!acpi_battery_present(battery))
459 return 0;
460
461 if (battery->update_time &&
462 time_before(jiffies, battery->update_time +
463 msecs_to_jiffies(cache_time)))
464 return 0;
465
466 mutex_lock(&battery->lock);
467 status = acpi_evaluate_object(battery->device->handle, "_BST",
468 NULL, &buffer);
469 mutex_unlock(&battery->lock);
470
471 if (ACPI_FAILURE(status)) {
472 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BST"));
473 return -ENODEV;
474 }
475
476 result = extract_package(battery, buffer.pointer,
477 state_offsets, ARRAY_SIZE(state_offsets));
478 battery->update_time = jiffies;
479 kfree(buffer.pointer);
480
481 /* For buggy DSDTs that report negative 16-bit values for either
482 * charging or discharging current and/or report 0 as 65536
483 * due to bad math.
484 */
485 if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA &&
486 battery->rate_now != ACPI_BATTERY_VALUE_UNKNOWN &&
487 (s16)(battery->rate_now) < 0) {
488 battery->rate_now = abs((s16)battery->rate_now);
489 printk_once(KERN_WARNING FW_BUG "battery: (dis)charge rate"
490 " invalid.\n");
491 }
492
493 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags)
494 && battery->capacity_now >= 0 && battery->capacity_now <= 100)
495 battery->capacity_now = (battery->capacity_now *
496 battery->full_charge_capacity) / 100;
497 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
498 battery->power_unit && battery->design_voltage) {
499 battery->capacity_now = battery->capacity_now *
500 10000 / battery->design_voltage;
501 }
502 return result;
503 }
504
505 static int acpi_battery_set_alarm(struct acpi_battery *battery)
506 {
507 acpi_status status = 0;
508
509 if (!acpi_battery_present(battery) ||
510 !test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags))
511 return -ENODEV;
512
513 mutex_lock(&battery->lock);
514 status = acpi_execute_simple_method(battery->device->handle, "_BTP",
515 battery->alarm);
516 mutex_unlock(&battery->lock);
517
518 if (ACPI_FAILURE(status))
519 return -ENODEV;
520
521 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Alarm set to %d\n", battery->alarm));
522 return 0;
523 }
524
525 static int acpi_battery_init_alarm(struct acpi_battery *battery)
526 {
527 /* See if alarms are supported, and if so, set default */
528 if (!acpi_has_method(battery->device->handle, "_BTP")) {
529 clear_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
530 return 0;
531 }
532 set_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
533 if (!battery->alarm)
534 battery->alarm = battery->design_capacity_warning;
535 return acpi_battery_set_alarm(battery);
536 }
537
538 static ssize_t acpi_battery_alarm_show(struct device *dev,
539 struct device_attribute *attr,
540 char *buf)
541 {
542 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
543 return sprintf(buf, "%d\n", battery->alarm * 1000);
544 }
545
546 static ssize_t acpi_battery_alarm_store(struct device *dev,
547 struct device_attribute *attr,
548 const char *buf, size_t count)
549 {
550 unsigned long x;
551 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
552 if (sscanf(buf, "%lu\n", &x) == 1)
553 battery->alarm = x/1000;
554 if (acpi_battery_present(battery))
555 acpi_battery_set_alarm(battery);
556 return count;
557 }
558
559 static struct device_attribute alarm_attr = {
560 .attr = {.name = "alarm", .mode = 0644},
561 .show = acpi_battery_alarm_show,
562 .store = acpi_battery_alarm_store,
563 };
564
565 static int sysfs_add_battery(struct acpi_battery *battery)
566 {
567 int result;
568
569 if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) {
570 battery->bat.properties = charge_battery_props;
571 battery->bat.num_properties =
572 ARRAY_SIZE(charge_battery_props);
573 } else {
574 battery->bat.properties = energy_battery_props;
575 battery->bat.num_properties =
576 ARRAY_SIZE(energy_battery_props);
577 }
578
579 battery->bat.name = acpi_device_bid(battery->device);
580 battery->bat.type = POWER_SUPPLY_TYPE_BATTERY;
581 battery->bat.get_property = acpi_battery_get_property;
582
583 result = power_supply_register(&battery->device->dev, &battery->bat);
584 if (result)
585 return result;
586 return device_create_file(battery->bat.dev, &alarm_attr);
587 }
588
589 static void sysfs_remove_battery(struct acpi_battery *battery)
590 {
591 mutex_lock(&battery->sysfs_lock);
592 if (!battery->bat.dev) {
593 mutex_unlock(&battery->sysfs_lock);
594 return;
595 }
596
597 device_remove_file(battery->bat.dev, &alarm_attr);
598 power_supply_unregister(&battery->bat);
599 battery->bat.dev = NULL;
600 mutex_unlock(&battery->sysfs_lock);
601 }
602
603 static void find_battery(const struct dmi_header *dm, void *private)
604 {
605 struct acpi_battery *battery = (struct acpi_battery *)private;
606 /* Note: the hardcoded offsets below have been extracted from
607 the source code of dmidecode. */
608 if (dm->type == DMI_ENTRY_PORTABLE_BATTERY && dm->length >= 8) {
609 const u8 *dmi_data = (const u8 *)(dm + 1);
610 int dmi_capacity = get_unaligned((const u16 *)(dmi_data + 6));
611 if (dm->length >= 18)
612 dmi_capacity *= dmi_data[17];
613 if (battery->design_capacity * battery->design_voltage / 1000
614 != dmi_capacity &&
615 battery->design_capacity * 10 == dmi_capacity)
616 set_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
617 &battery->flags);
618 }
619 }
620
621 /*
622 * According to the ACPI spec, some kinds of primary batteries can
623 * report percentage battery remaining capacity directly to OS.
624 * In this case, it reports the Last Full Charged Capacity == 100
625 * and BatteryPresentRate == 0xFFFFFFFF.
626 *
627 * Now we found some battery reports percentage remaining capacity
628 * even if it's rechargeable.
629 * https://bugzilla.kernel.org/show_bug.cgi?id=15979
630 *
631 * Handle this correctly so that they won't break userspace.
632 */
633 static void acpi_battery_quirks(struct acpi_battery *battery)
634 {
635 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
636 return;
637
638 if (battery->full_charge_capacity == 100 &&
639 battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN &&
640 battery->capacity_now >= 0 && battery->capacity_now <= 100) {
641 set_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags);
642 battery->full_charge_capacity = battery->design_capacity;
643 battery->capacity_now = (battery->capacity_now *
644 battery->full_charge_capacity) / 100;
645 }
646
647 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags))
648 return;
649
650 if (battery->power_unit && dmi_name_in_vendors("LENOVO")) {
651 const char *s;
652 s = dmi_get_system_info(DMI_PRODUCT_VERSION);
653 if (s && !strnicmp(s, "ThinkPad", 8)) {
654 dmi_walk(find_battery, battery);
655 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
656 &battery->flags) &&
657 battery->design_voltage) {
658 battery->design_capacity =
659 battery->design_capacity *
660 10000 / battery->design_voltage;
661 battery->full_charge_capacity =
662 battery->full_charge_capacity *
663 10000 / battery->design_voltage;
664 battery->design_capacity_warning =
665 battery->design_capacity_warning *
666 10000 / battery->design_voltage;
667 battery->capacity_now = battery->capacity_now *
668 10000 / battery->design_voltage;
669 }
670 }
671 }
672 }
673
674 static int acpi_battery_update(struct acpi_battery *battery)
675 {
676 int result, old_present = acpi_battery_present(battery);
677 result = acpi_battery_get_status(battery);
678 if (result)
679 return result;
680 if (!acpi_battery_present(battery)) {
681 sysfs_remove_battery(battery);
682 battery->update_time = 0;
683 return 0;
684 }
685 if (!battery->update_time ||
686 old_present != acpi_battery_present(battery)) {
687 result = acpi_battery_get_info(battery);
688 if (result)
689 return result;
690 acpi_battery_init_alarm(battery);
691 }
692 if (!battery->bat.dev) {
693 result = sysfs_add_battery(battery);
694 if (result)
695 return result;
696 }
697 result = acpi_battery_get_state(battery);
698 acpi_battery_quirks(battery);
699 return result;
700 }
701
702 static void acpi_battery_refresh(struct acpi_battery *battery)
703 {
704 int power_unit;
705
706 if (!battery->bat.dev)
707 return;
708
709 power_unit = battery->power_unit;
710
711 acpi_battery_get_info(battery);
712
713 if (power_unit == battery->power_unit)
714 return;
715
716 /* The battery has changed its reporting units. */
717 sysfs_remove_battery(battery);
718 sysfs_add_battery(battery);
719 }
720
721 /* --------------------------------------------------------------------------
722 Driver Interface
723 -------------------------------------------------------------------------- */
724
725 static void acpi_battery_notify(struct acpi_device *device, u32 event)
726 {
727 struct acpi_battery *battery = acpi_driver_data(device);
728 struct device *old;
729
730 if (!battery)
731 return;
732 old = battery->bat.dev;
733 if (event == ACPI_BATTERY_NOTIFY_INFO)
734 acpi_battery_refresh(battery);
735 acpi_battery_update(battery);
736 acpi_bus_generate_netlink_event(device->pnp.device_class,
737 dev_name(&device->dev), event,
738 acpi_battery_present(battery));
739 /* acpi_battery_update could remove power_supply object */
740 if (old && battery->bat.dev)
741 power_supply_changed(&battery->bat);
742 }
743
744 static int battery_notify(struct notifier_block *nb,
745 unsigned long mode, void *_unused)
746 {
747 struct acpi_battery *battery = container_of(nb, struct acpi_battery,
748 pm_nb);
749 switch (mode) {
750 case PM_POST_HIBERNATION:
751 case PM_POST_SUSPEND:
752 if (battery->bat.dev) {
753 sysfs_remove_battery(battery);
754 sysfs_add_battery(battery);
755 }
756 break;
757 }
758
759 return 0;
760 }
761
762 static struct dmi_system_id bat_dmi_table[] = {
763 {
764 .ident = "NEC LZ750/LS",
765 .matches = {
766 DMI_MATCH(DMI_SYS_VENDOR, "NEC"),
767 DMI_MATCH(DMI_PRODUCT_NAME, "PC-LZ750LS"),
768 },
769 },
770 {},
771 };
772
773 static int acpi_battery_add(struct acpi_device *device)
774 {
775 int result = 0;
776 struct acpi_battery *battery = NULL;
777
778 if (!device)
779 return -EINVAL;
780 battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL);
781 if (!battery)
782 return -ENOMEM;
783 battery->device = device;
784 strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME);
785 strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS);
786 device->driver_data = battery;
787 mutex_init(&battery->lock);
788 mutex_init(&battery->sysfs_lock);
789 if (acpi_has_method(battery->device->handle, "_BIX"))
790 set_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags);
791 result = acpi_battery_update(battery);
792 if (result)
793 goto fail;
794
795 printk(KERN_INFO PREFIX "%s Slot [%s] (battery %s)\n",
796 ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device),
797 device->status.battery_present ? "present" : "absent");
798
799 battery->pm_nb.notifier_call = battery_notify;
800 register_pm_notifier(&battery->pm_nb);
801
802 return result;
803
804 fail:
805 sysfs_remove_battery(battery);
806 mutex_destroy(&battery->lock);
807 mutex_destroy(&battery->sysfs_lock);
808 kfree(battery);
809 return result;
810 }
811
812 static int acpi_battery_remove(struct acpi_device *device)
813 {
814 struct acpi_battery *battery = NULL;
815
816 if (!device || !acpi_driver_data(device))
817 return -EINVAL;
818 battery = acpi_driver_data(device);
819 unregister_pm_notifier(&battery->pm_nb);
820 sysfs_remove_battery(battery);
821 mutex_destroy(&battery->lock);
822 mutex_destroy(&battery->sysfs_lock);
823 kfree(battery);
824 return 0;
825 }
826
827 #ifdef CONFIG_PM_SLEEP
828 /* this is needed to learn about changes made in suspended state */
829 static int acpi_battery_resume(struct device *dev)
830 {
831 struct acpi_battery *battery;
832
833 if (!dev)
834 return -EINVAL;
835
836 battery = acpi_driver_data(to_acpi_device(dev));
837 if (!battery)
838 return -EINVAL;
839
840 battery->update_time = 0;
841 acpi_battery_update(battery);
842 return 0;
843 }
844 #endif
845
846 static SIMPLE_DEV_PM_OPS(acpi_battery_pm, NULL, acpi_battery_resume);
847
848 static struct acpi_driver acpi_battery_driver = {
849 .name = "battery",
850 .class = ACPI_BATTERY_CLASS,
851 .ids = battery_device_ids,
852 .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
853 .ops = {
854 .add = acpi_battery_add,
855 .remove = acpi_battery_remove,
856 .notify = acpi_battery_notify,
857 },
858 .drv.pm = &acpi_battery_pm,
859 };
860
861 static void __init acpi_battery_init_async(void *unused, async_cookie_t cookie)
862 {
863 if (acpi_disabled)
864 return;
865
866 if (dmi_check_system(bat_dmi_table))
867 battery_bix_broken_package = 1;
868 acpi_bus_register_driver(&acpi_battery_driver);
869 }
870
871 static int __init acpi_battery_init(void)
872 {
873 async_schedule(acpi_battery_init_async, NULL);
874 return 0;
875 }
876
877 static void __exit acpi_battery_exit(void)
878 {
879 acpi_bus_unregister_driver(&acpi_battery_driver);
880 }
881
882 module_init(acpi_battery_init);
883 module_exit(acpi_battery_exit);
Linux with added FPC-III support