Loading...
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * battery.c - ACPI Battery Driver (Revision: 2.0)
4 *
5 * Copyright (C) 2007 Alexey Starikovskiy <astarikovskiy@suse.de>
6 * Copyright (C) 2004-2007 Vladimir Lebedev <vladimir.p.lebedev@intel.com>
7 * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
8 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
9 */
10
11#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
12
13#include <linux/async.h>
14#include <linux/delay.h>
15#include <linux/dmi.h>
16#include <linux/jiffies.h>
17#include <linux/kernel.h>
18#include <linux/list.h>
19#include <linux/module.h>
20#include <linux/mutex.h>
21#include <linux/slab.h>
22#include <linux/suspend.h>
23#include <linux/types.h>
24
25#include <asm/unaligned.h>
26
27#ifdef CONFIG_ACPI_PROCFS_POWER
28#include <linux/proc_fs.h>
29#include <linux/seq_file.h>
30#include <linux/uaccess.h>
31#endif
32
33#include <linux/acpi.h>
34#include <linux/power_supply.h>
35
36#include <acpi/battery.h>
37
38#define PREFIX "ACPI: "
39
40#define ACPI_BATTERY_VALUE_UNKNOWN 0xFFFFFFFF
41
42#define ACPI_BATTERY_DEVICE_NAME "Battery"
43
44/* Battery power unit: 0 means mW, 1 means mA */
45#define ACPI_BATTERY_POWER_UNIT_MA 1
46
47#define ACPI_BATTERY_STATE_DISCHARGING 0x1
48#define ACPI_BATTERY_STATE_CHARGING 0x2
49#define ACPI_BATTERY_STATE_CRITICAL 0x4
50
51#define _COMPONENT ACPI_BATTERY_COMPONENT
52
53ACPI_MODULE_NAME("battery");
54
55MODULE_AUTHOR("Paul Diefenbaugh");
56MODULE_AUTHOR("Alexey Starikovskiy <astarikovskiy@suse.de>");
57MODULE_DESCRIPTION("ACPI Battery Driver");
58MODULE_LICENSE("GPL");
59
60static async_cookie_t async_cookie;
61static bool battery_driver_registered;
62static int battery_bix_broken_package;
63static int battery_notification_delay_ms;
64static int battery_ac_is_broken;
65static int battery_check_pmic = 1;
66static unsigned int cache_time = 1000;
67module_param(cache_time, uint, 0644);
68MODULE_PARM_DESC(cache_time, "cache time in milliseconds");
69
70#ifdef CONFIG_ACPI_PROCFS_POWER
71extern struct proc_dir_entry *acpi_lock_battery_dir(void);
72extern void *acpi_unlock_battery_dir(struct proc_dir_entry *acpi_battery_dir);
73#endif
74
75static const struct acpi_device_id battery_device_ids[] = {
76 {"PNP0C0A", 0},
77 {"", 0},
78};
79
80MODULE_DEVICE_TABLE(acpi, battery_device_ids);
81
82/* Lists of PMIC ACPI HIDs with an (often better) native battery driver */
83static const char * const acpi_battery_blacklist[] = {
84 "INT33F4", /* X-Powers AXP288 PMIC */
85};
86
87enum {
88 ACPI_BATTERY_ALARM_PRESENT,
89 ACPI_BATTERY_XINFO_PRESENT,
90 ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY,
91 /* On Lenovo Thinkpad models from 2010 and 2011, the power unit
92 switches between mWh and mAh depending on whether the system
93 is running on battery or not. When mAh is the unit, most
94 reported values are incorrect and need to be adjusted by
95 10000/design_voltage. Verified on x201, t410, t410s, and x220.
96 Pre-2010 and 2012 models appear to always report in mWh and
97 are thus unaffected (tested with t42, t61, t500, x200, x300,
98 and x230). Also, in mid-2012 Lenovo issued a BIOS update for
99 the 2011 models that fixes the issue (tested on x220 with a
100 post-1.29 BIOS), but as of Nov. 2012, no such update is
101 available for the 2010 models. */
102 ACPI_BATTERY_QUIRK_THINKPAD_MAH,
103 /* for batteries reporting current capacity with design capacity
104 * on a full charge, but showing degradation in full charge cap.
105 */
106 ACPI_BATTERY_QUIRK_DEGRADED_FULL_CHARGE,
107};
108
109struct acpi_battery {
110 struct mutex lock;
111 struct mutex sysfs_lock;
112 struct power_supply *bat;
113 struct power_supply_desc bat_desc;
114 struct acpi_device *device;
115 struct notifier_block pm_nb;
116 struct list_head list;
117 unsigned long update_time;
118 int revision;
119 int rate_now;
120 int capacity_now;
121 int voltage_now;
122 int design_capacity;
123 int full_charge_capacity;
124 int technology;
125 int design_voltage;
126 int design_capacity_warning;
127 int design_capacity_low;
128 int cycle_count;
129 int measurement_accuracy;
130 int max_sampling_time;
131 int min_sampling_time;
132 int max_averaging_interval;
133 int min_averaging_interval;
134 int capacity_granularity_1;
135 int capacity_granularity_2;
136 int alarm;
137 char model_number[32];
138 char serial_number[32];
139 char type[32];
140 char oem_info[32];
141 int state;
142 int power_unit;
143 unsigned long flags;
144};
145
146#define to_acpi_battery(x) power_supply_get_drvdata(x)
147
148static inline int acpi_battery_present(struct acpi_battery *battery)
149{
150 return battery->device->status.battery_present;
151}
152
153static int acpi_battery_technology(struct acpi_battery *battery)
154{
155 if (!strcasecmp("NiCd", battery->type))
156 return POWER_SUPPLY_TECHNOLOGY_NiCd;
157 if (!strcasecmp("NiMH", battery->type))
158 return POWER_SUPPLY_TECHNOLOGY_NiMH;
159 if (!strcasecmp("LION", battery->type))
160 return POWER_SUPPLY_TECHNOLOGY_LION;
161 if (!strncasecmp("LI-ION", battery->type, 6))
162 return POWER_SUPPLY_TECHNOLOGY_LION;
163 if (!strcasecmp("LiP", battery->type))
164 return POWER_SUPPLY_TECHNOLOGY_LIPO;
165 return POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
166}
167
168static int acpi_battery_get_state(struct acpi_battery *battery);
169
170static int acpi_battery_is_charged(struct acpi_battery *battery)
171{
172 /* charging, discharging or critical low */
173 if (battery->state != 0)
174 return 0;
175
176 /* battery not reporting charge */
177 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN ||
178 battery->capacity_now == 0)
179 return 0;
180
181 /* good batteries update full_charge as the batteries degrade */
182 if (battery->full_charge_capacity == battery->capacity_now)
183 return 1;
184
185 /* fallback to using design values for broken batteries */
186 if (battery->design_capacity == battery->capacity_now)
187 return 1;
188
189 /* we don't do any sort of metric based on percentages */
190 return 0;
191}
192
193static bool acpi_battery_is_degraded(struct acpi_battery *battery)
194{
195 return battery->full_charge_capacity && battery->design_capacity &&
196 battery->full_charge_capacity < battery->design_capacity;
197}
198
199static int acpi_battery_handle_discharging(struct acpi_battery *battery)
200{
201 /*
202 * Some devices wrongly report discharging if the battery's charge level
203 * was above the device's start charging threshold atm the AC adapter
204 * was plugged in and the device thus did not start a new charge cycle.
205 */
206 if ((battery_ac_is_broken || power_supply_is_system_supplied()) &&
207 battery->rate_now == 0)
208 return POWER_SUPPLY_STATUS_NOT_CHARGING;
209
210 return POWER_SUPPLY_STATUS_DISCHARGING;
211}
212
213static int acpi_battery_get_property(struct power_supply *psy,
214 enum power_supply_property psp,
215 union power_supply_propval *val)
216{
217 int ret = 0;
218 struct acpi_battery *battery = to_acpi_battery(psy);
219
220 if (acpi_battery_present(battery)) {
221 /* run battery update only if it is present */
222 acpi_battery_get_state(battery);
223 } else if (psp != POWER_SUPPLY_PROP_PRESENT)
224 return -ENODEV;
225 switch (psp) {
226 case POWER_SUPPLY_PROP_STATUS:
227 if (battery->state & ACPI_BATTERY_STATE_DISCHARGING)
228 val->intval = acpi_battery_handle_discharging(battery);
229 else if (battery->state & ACPI_BATTERY_STATE_CHARGING)
230 val->intval = POWER_SUPPLY_STATUS_CHARGING;
231 else if (acpi_battery_is_charged(battery))
232 val->intval = POWER_SUPPLY_STATUS_FULL;
233 else
234 val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
235 break;
236 case POWER_SUPPLY_PROP_PRESENT:
237 val->intval = acpi_battery_present(battery);
238 break;
239 case POWER_SUPPLY_PROP_TECHNOLOGY:
240 val->intval = acpi_battery_technology(battery);
241 break;
242 case POWER_SUPPLY_PROP_CYCLE_COUNT:
243 val->intval = battery->cycle_count;
244 break;
245 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
246 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
247 ret = -ENODEV;
248 else
249 val->intval = battery->design_voltage * 1000;
250 break;
251 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
252 if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
253 ret = -ENODEV;
254 else
255 val->intval = battery->voltage_now * 1000;
256 break;
257 case POWER_SUPPLY_PROP_CURRENT_NOW:
258 case POWER_SUPPLY_PROP_POWER_NOW:
259 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
260 ret = -ENODEV;
261 else
262 val->intval = battery->rate_now * 1000;
263 break;
264 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
265 case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
266 if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
267 ret = -ENODEV;
268 else
269 val->intval = battery->design_capacity * 1000;
270 break;
271 case POWER_SUPPLY_PROP_CHARGE_FULL:
272 case POWER_SUPPLY_PROP_ENERGY_FULL:
273 if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
274 ret = -ENODEV;
275 else
276 val->intval = battery->full_charge_capacity * 1000;
277 break;
278 case POWER_SUPPLY_PROP_CHARGE_NOW:
279 case POWER_SUPPLY_PROP_ENERGY_NOW:
280 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
281 ret = -ENODEV;
282 else
283 val->intval = battery->capacity_now * 1000;
284 break;
285 case POWER_SUPPLY_PROP_CAPACITY:
286 if (battery->capacity_now && battery->full_charge_capacity)
287 val->intval = battery->capacity_now * 100/
288 battery->full_charge_capacity;
289 else
290 val->intval = 0;
291 break;
292 case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
293 if (battery->state & ACPI_BATTERY_STATE_CRITICAL)
294 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
295 else if (test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags) &&
296 (battery->capacity_now <= battery->alarm))
297 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_LOW;
298 else if (acpi_battery_is_charged(battery))
299 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
300 else
301 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
302 break;
303 case POWER_SUPPLY_PROP_MODEL_NAME:
304 val->strval = battery->model_number;
305 break;
306 case POWER_SUPPLY_PROP_MANUFACTURER:
307 val->strval = battery->oem_info;
308 break;
309 case POWER_SUPPLY_PROP_SERIAL_NUMBER:
310 val->strval = battery->serial_number;
311 break;
312 default:
313 ret = -EINVAL;
314 }
315 return ret;
316}
317
318static enum power_supply_property charge_battery_props[] = {
319 POWER_SUPPLY_PROP_STATUS,
320 POWER_SUPPLY_PROP_PRESENT,
321 POWER_SUPPLY_PROP_TECHNOLOGY,
322 POWER_SUPPLY_PROP_CYCLE_COUNT,
323 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
324 POWER_SUPPLY_PROP_VOLTAGE_NOW,
325 POWER_SUPPLY_PROP_CURRENT_NOW,
326 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
327 POWER_SUPPLY_PROP_CHARGE_FULL,
328 POWER_SUPPLY_PROP_CHARGE_NOW,
329 POWER_SUPPLY_PROP_CAPACITY,
330 POWER_SUPPLY_PROP_CAPACITY_LEVEL,
331 POWER_SUPPLY_PROP_MODEL_NAME,
332 POWER_SUPPLY_PROP_MANUFACTURER,
333 POWER_SUPPLY_PROP_SERIAL_NUMBER,
334};
335
336static enum power_supply_property energy_battery_props[] = {
337 POWER_SUPPLY_PROP_STATUS,
338 POWER_SUPPLY_PROP_PRESENT,
339 POWER_SUPPLY_PROP_TECHNOLOGY,
340 POWER_SUPPLY_PROP_CYCLE_COUNT,
341 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
342 POWER_SUPPLY_PROP_VOLTAGE_NOW,
343 POWER_SUPPLY_PROP_POWER_NOW,
344 POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
345 POWER_SUPPLY_PROP_ENERGY_FULL,
346 POWER_SUPPLY_PROP_ENERGY_NOW,
347 POWER_SUPPLY_PROP_CAPACITY,
348 POWER_SUPPLY_PROP_CAPACITY_LEVEL,
349 POWER_SUPPLY_PROP_MODEL_NAME,
350 POWER_SUPPLY_PROP_MANUFACTURER,
351 POWER_SUPPLY_PROP_SERIAL_NUMBER,
352};
353
354static enum power_supply_property energy_battery_full_cap_broken_props[] = {
355 POWER_SUPPLY_PROP_STATUS,
356 POWER_SUPPLY_PROP_PRESENT,
357 POWER_SUPPLY_PROP_TECHNOLOGY,
358 POWER_SUPPLY_PROP_CYCLE_COUNT,
359 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
360 POWER_SUPPLY_PROP_VOLTAGE_NOW,
361 POWER_SUPPLY_PROP_POWER_NOW,
362 POWER_SUPPLY_PROP_ENERGY_NOW,
363 POWER_SUPPLY_PROP_MODEL_NAME,
364 POWER_SUPPLY_PROP_MANUFACTURER,
365 POWER_SUPPLY_PROP_SERIAL_NUMBER,
366};
367
368/* --------------------------------------------------------------------------
369 Battery Management
370 -------------------------------------------------------------------------- */
371struct acpi_offsets {
372 size_t offset; /* offset inside struct acpi_sbs_battery */
373 u8 mode; /* int or string? */
374};
375
376static const struct acpi_offsets state_offsets[] = {
377 {offsetof(struct acpi_battery, state), 0},
378 {offsetof(struct acpi_battery, rate_now), 0},
379 {offsetof(struct acpi_battery, capacity_now), 0},
380 {offsetof(struct acpi_battery, voltage_now), 0},
381};
382
383static const struct acpi_offsets info_offsets[] = {
384 {offsetof(struct acpi_battery, power_unit), 0},
385 {offsetof(struct acpi_battery, design_capacity), 0},
386 {offsetof(struct acpi_battery, full_charge_capacity), 0},
387 {offsetof(struct acpi_battery, technology), 0},
388 {offsetof(struct acpi_battery, design_voltage), 0},
389 {offsetof(struct acpi_battery, design_capacity_warning), 0},
390 {offsetof(struct acpi_battery, design_capacity_low), 0},
391 {offsetof(struct acpi_battery, capacity_granularity_1), 0},
392 {offsetof(struct acpi_battery, capacity_granularity_2), 0},
393 {offsetof(struct acpi_battery, model_number), 1},
394 {offsetof(struct acpi_battery, serial_number), 1},
395 {offsetof(struct acpi_battery, type), 1},
396 {offsetof(struct acpi_battery, oem_info), 1},
397};
398
399static const struct acpi_offsets extended_info_offsets[] = {
400 {offsetof(struct acpi_battery, revision), 0},
401 {offsetof(struct acpi_battery, power_unit), 0},
402 {offsetof(struct acpi_battery, design_capacity), 0},
403 {offsetof(struct acpi_battery, full_charge_capacity), 0},
404 {offsetof(struct acpi_battery, technology), 0},
405 {offsetof(struct acpi_battery, design_voltage), 0},
406 {offsetof(struct acpi_battery, design_capacity_warning), 0},
407 {offsetof(struct acpi_battery, design_capacity_low), 0},
408 {offsetof(struct acpi_battery, cycle_count), 0},
409 {offsetof(struct acpi_battery, measurement_accuracy), 0},
410 {offsetof(struct acpi_battery, max_sampling_time), 0},
411 {offsetof(struct acpi_battery, min_sampling_time), 0},
412 {offsetof(struct acpi_battery, max_averaging_interval), 0},
413 {offsetof(struct acpi_battery, min_averaging_interval), 0},
414 {offsetof(struct acpi_battery, capacity_granularity_1), 0},
415 {offsetof(struct acpi_battery, capacity_granularity_2), 0},
416 {offsetof(struct acpi_battery, model_number), 1},
417 {offsetof(struct acpi_battery, serial_number), 1},
418 {offsetof(struct acpi_battery, type), 1},
419 {offsetof(struct acpi_battery, oem_info), 1},
420};
421
422static int extract_package(struct acpi_battery *battery,
423 union acpi_object *package,
424 const struct acpi_offsets *offsets, int num)
425{
426 int i;
427 union acpi_object *element;
428 if (package->type != ACPI_TYPE_PACKAGE)
429 return -EFAULT;
430 for (i = 0; i < num; ++i) {
431 if (package->package.count <= i)
432 return -EFAULT;
433 element = &package->package.elements[i];
434 if (offsets[i].mode) {
435 u8 *ptr = (u8 *)battery + offsets[i].offset;
436 if (element->type == ACPI_TYPE_STRING ||
437 element->type == ACPI_TYPE_BUFFER)
438 strncpy(ptr, element->string.pointer, 32);
439 else if (element->type == ACPI_TYPE_INTEGER) {
440 strncpy(ptr, (u8 *)&element->integer.value,
441 sizeof(u64));
442 ptr[sizeof(u64)] = 0;
443 } else
444 *ptr = 0; /* don't have value */
445 } else {
446 int *x = (int *)((u8 *)battery + offsets[i].offset);
447 *x = (element->type == ACPI_TYPE_INTEGER) ?
448 element->integer.value : -1;
449 }
450 }
451 return 0;
452}
453
454static int acpi_battery_get_status(struct acpi_battery *battery)
455{
456 if (acpi_bus_get_status(battery->device)) {
457 ACPI_EXCEPTION((AE_INFO, AE_ERROR, "Evaluating _STA"));
458 return -ENODEV;
459 }
460 return 0;
461}
462
463
464static int extract_battery_info(const int use_bix,
465 struct acpi_battery *battery,
466 const struct acpi_buffer *buffer)
467{
468 int result = -EFAULT;
469
470 if (use_bix && battery_bix_broken_package)
471 result = extract_package(battery, buffer->pointer,
472 extended_info_offsets + 1,
473 ARRAY_SIZE(extended_info_offsets) - 1);
474 else if (use_bix)
475 result = extract_package(battery, buffer->pointer,
476 extended_info_offsets,
477 ARRAY_SIZE(extended_info_offsets));
478 else
479 result = extract_package(battery, buffer->pointer,
480 info_offsets, ARRAY_SIZE(info_offsets));
481 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
482 battery->full_charge_capacity = battery->design_capacity;
483 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
484 battery->power_unit && battery->design_voltage) {
485 battery->design_capacity = battery->design_capacity *
486 10000 / battery->design_voltage;
487 battery->full_charge_capacity = battery->full_charge_capacity *
488 10000 / battery->design_voltage;
489 battery->design_capacity_warning =
490 battery->design_capacity_warning *
491 10000 / battery->design_voltage;
492 /* Curiously, design_capacity_low, unlike the rest of them,
493 is correct. */
494 /* capacity_granularity_* equal 1 on the systems tested, so
495 it's impossible to tell if they would need an adjustment
496 or not if their values were higher. */
497 }
498 if (test_bit(ACPI_BATTERY_QUIRK_DEGRADED_FULL_CHARGE, &battery->flags) &&
499 battery->capacity_now > battery->full_charge_capacity)
500 battery->capacity_now = battery->full_charge_capacity;
501
502 return result;
503}
504
505static int acpi_battery_get_info(struct acpi_battery *battery)
506{
507 const int xinfo = test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags);
508 int use_bix;
509 int result = -ENODEV;
510
511 if (!acpi_battery_present(battery))
512 return 0;
513
514
515 for (use_bix = xinfo ? 1 : 0; use_bix >= 0; use_bix--) {
516 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
517 acpi_status status = AE_ERROR;
518
519 mutex_lock(&battery->lock);
520 status = acpi_evaluate_object(battery->device->handle,
521 use_bix ? "_BIX":"_BIF",
522 NULL, &buffer);
523 mutex_unlock(&battery->lock);
524
525 if (ACPI_FAILURE(status)) {
526 ACPI_EXCEPTION((AE_INFO, status, "Evaluating %s",
527 use_bix ? "_BIX":"_BIF"));
528 } else {
529 result = extract_battery_info(use_bix,
530 battery,
531 &buffer);
532
533 kfree(buffer.pointer);
534 break;
535 }
536 }
537
538 if (!result && !use_bix && xinfo)
539 pr_warn(FW_BUG "The _BIX method is broken, using _BIF.\n");
540
541 return result;
542}
543
544static int acpi_battery_get_state(struct acpi_battery *battery)
545{
546 int result = 0;
547 acpi_status status = 0;
548 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
549
550 if (!acpi_battery_present(battery))
551 return 0;
552
553 if (battery->update_time &&
554 time_before(jiffies, battery->update_time +
555 msecs_to_jiffies(cache_time)))
556 return 0;
557
558 mutex_lock(&battery->lock);
559 status = acpi_evaluate_object(battery->device->handle, "_BST",
560 NULL, &buffer);
561 mutex_unlock(&battery->lock);
562
563 if (ACPI_FAILURE(status)) {
564 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BST"));
565 return -ENODEV;
566 }
567
568 result = extract_package(battery, buffer.pointer,
569 state_offsets, ARRAY_SIZE(state_offsets));
570 battery->update_time = jiffies;
571 kfree(buffer.pointer);
572
573 /* For buggy DSDTs that report negative 16-bit values for either
574 * charging or discharging current and/or report 0 as 65536
575 * due to bad math.
576 */
577 if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA &&
578 battery->rate_now != ACPI_BATTERY_VALUE_UNKNOWN &&
579 (s16)(battery->rate_now) < 0) {
580 battery->rate_now = abs((s16)battery->rate_now);
581 pr_warn_once(FW_BUG "battery: (dis)charge rate invalid.\n");
582 }
583
584 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags)
585 && battery->capacity_now >= 0 && battery->capacity_now <= 100)
586 battery->capacity_now = (battery->capacity_now *
587 battery->full_charge_capacity) / 100;
588 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
589 battery->power_unit && battery->design_voltage) {
590 battery->capacity_now = battery->capacity_now *
591 10000 / battery->design_voltage;
592 }
593 if (test_bit(ACPI_BATTERY_QUIRK_DEGRADED_FULL_CHARGE, &battery->flags) &&
594 battery->capacity_now > battery->full_charge_capacity)
595 battery->capacity_now = battery->full_charge_capacity;
596
597 return result;
598}
599
600static int acpi_battery_set_alarm(struct acpi_battery *battery)
601{
602 acpi_status status = 0;
603
604 if (!acpi_battery_present(battery) ||
605 !test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags))
606 return -ENODEV;
607
608 mutex_lock(&battery->lock);
609 status = acpi_execute_simple_method(battery->device->handle, "_BTP",
610 battery->alarm);
611 mutex_unlock(&battery->lock);
612
613 if (ACPI_FAILURE(status))
614 return -ENODEV;
615
616 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Alarm set to %d\n", battery->alarm));
617 return 0;
618}
619
620static int acpi_battery_init_alarm(struct acpi_battery *battery)
621{
622 /* See if alarms are supported, and if so, set default */
623 if (!acpi_has_method(battery->device->handle, "_BTP")) {
624 clear_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
625 return 0;
626 }
627 set_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
628 if (!battery->alarm)
629 battery->alarm = battery->design_capacity_warning;
630 return acpi_battery_set_alarm(battery);
631}
632
633static ssize_t acpi_battery_alarm_show(struct device *dev,
634 struct device_attribute *attr,
635 char *buf)
636{
637 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
638 return sprintf(buf, "%d\n", battery->alarm * 1000);
639}
640
641static ssize_t acpi_battery_alarm_store(struct device *dev,
642 struct device_attribute *attr,
643 const char *buf, size_t count)
644{
645 unsigned long x;
646 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
647 if (sscanf(buf, "%lu\n", &x) == 1)
648 battery->alarm = x/1000;
649 if (acpi_battery_present(battery))
650 acpi_battery_set_alarm(battery);
651 return count;
652}
653
654static const struct device_attribute alarm_attr = {
655 .attr = {.name = "alarm", .mode = 0644},
656 .show = acpi_battery_alarm_show,
657 .store = acpi_battery_alarm_store,
658};
659
660/*
661 * The Battery Hooking API
662 *
663 * This API is used inside other drivers that need to expose
664 * platform-specific behaviour within the generic driver in a
665 * generic way.
666 *
667 */
668
669static LIST_HEAD(acpi_battery_list);
670static LIST_HEAD(battery_hook_list);
671static DEFINE_MUTEX(hook_mutex);
672
673static void __battery_hook_unregister(struct acpi_battery_hook *hook, int lock)
674{
675 struct acpi_battery *battery;
676 /*
677 * In order to remove a hook, we first need to
678 * de-register all the batteries that are registered.
679 */
680 if (lock)
681 mutex_lock(&hook_mutex);
682 list_for_each_entry(battery, &acpi_battery_list, list) {
683 hook->remove_battery(battery->bat);
684 }
685 list_del(&hook->list);
686 if (lock)
687 mutex_unlock(&hook_mutex);
688 pr_info("extension unregistered: %s\n", hook->name);
689}
690
691void battery_hook_unregister(struct acpi_battery_hook *hook)
692{
693 __battery_hook_unregister(hook, 1);
694}
695EXPORT_SYMBOL_GPL(battery_hook_unregister);
696
697void battery_hook_register(struct acpi_battery_hook *hook)
698{
699 struct acpi_battery *battery;
700
701 mutex_lock(&hook_mutex);
702 INIT_LIST_HEAD(&hook->list);
703 list_add(&hook->list, &battery_hook_list);
704 /*
705 * Now that the driver is registered, we need
706 * to notify the hook that a battery is available
707 * for each battery, so that the driver may add
708 * its attributes.
709 */
710 list_for_each_entry(battery, &acpi_battery_list, list) {
711 if (hook->add_battery(battery->bat)) {
712 /*
713 * If a add-battery returns non-zero,
714 * the registration of the extension has failed,
715 * and we will not add it to the list of loaded
716 * hooks.
717 */
718 pr_err("extension failed to load: %s", hook->name);
719 __battery_hook_unregister(hook, 0);
720 goto end;
721 }
722 }
723 pr_info("new extension: %s\n", hook->name);
724end:
725 mutex_unlock(&hook_mutex);
726}
727EXPORT_SYMBOL_GPL(battery_hook_register);
728
729/*
730 * This function gets called right after the battery sysfs
731 * attributes have been added, so that the drivers that
732 * define custom sysfs attributes can add their own.
733*/
734static void battery_hook_add_battery(struct acpi_battery *battery)
735{
736 struct acpi_battery_hook *hook_node, *tmp;
737
738 mutex_lock(&hook_mutex);
739 INIT_LIST_HEAD(&battery->list);
740 list_add(&battery->list, &acpi_battery_list);
741 /*
742 * Since we added a new battery to the list, we need to
743 * iterate over the hooks and call add_battery for each
744 * hook that was registered. This usually happens
745 * when a battery gets hotplugged or initialized
746 * during the battery module initialization.
747 */
748 list_for_each_entry_safe(hook_node, tmp, &battery_hook_list, list) {
749 if (hook_node->add_battery(battery->bat)) {
750 /*
751 * The notification of the extensions has failed, to
752 * prevent further errors we will unload the extension.
753 */
754 pr_err("error in extension, unloading: %s",
755 hook_node->name);
756 __battery_hook_unregister(hook_node, 0);
757 }
758 }
759 mutex_unlock(&hook_mutex);
760}
761
762static void battery_hook_remove_battery(struct acpi_battery *battery)
763{
764 struct acpi_battery_hook *hook;
765
766 mutex_lock(&hook_mutex);
767 /*
768 * Before removing the hook, we need to remove all
769 * custom attributes from the battery.
770 */
771 list_for_each_entry(hook, &battery_hook_list, list) {
772 hook->remove_battery(battery->bat);
773 }
774 /* Then, just remove the battery from the list */
775 list_del(&battery->list);
776 mutex_unlock(&hook_mutex);
777}
778
779static void __exit battery_hook_exit(void)
780{
781 struct acpi_battery_hook *hook;
782 struct acpi_battery_hook *ptr;
783 /*
784 * At this point, the acpi_bus_unregister_driver()
785 * has called remove for all batteries. We just
786 * need to remove the hooks.
787 */
788 list_for_each_entry_safe(hook, ptr, &battery_hook_list, list) {
789 __battery_hook_unregister(hook, 1);
790 }
791 mutex_destroy(&hook_mutex);
792}
793
794static int sysfs_add_battery(struct acpi_battery *battery)
795{
796 struct power_supply_config psy_cfg = { .drv_data = battery, };
797
798 if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) {
799 battery->bat_desc.properties = charge_battery_props;
800 battery->bat_desc.num_properties =
801 ARRAY_SIZE(charge_battery_props);
802 } else if (battery->full_charge_capacity == 0) {
803 battery->bat_desc.properties =
804 energy_battery_full_cap_broken_props;
805 battery->bat_desc.num_properties =
806 ARRAY_SIZE(energy_battery_full_cap_broken_props);
807 } else {
808 battery->bat_desc.properties = energy_battery_props;
809 battery->bat_desc.num_properties =
810 ARRAY_SIZE(energy_battery_props);
811 }
812
813 battery->bat_desc.name = acpi_device_bid(battery->device);
814 battery->bat_desc.type = POWER_SUPPLY_TYPE_BATTERY;
815 battery->bat_desc.get_property = acpi_battery_get_property;
816
817 battery->bat = power_supply_register_no_ws(&battery->device->dev,
818 &battery->bat_desc, &psy_cfg);
819
820 if (IS_ERR(battery->bat)) {
821 int result = PTR_ERR(battery->bat);
822
823 battery->bat = NULL;
824 return result;
825 }
826 battery_hook_add_battery(battery);
827 return device_create_file(&battery->bat->dev, &alarm_attr);
828}
829
830static void sysfs_remove_battery(struct acpi_battery *battery)
831{
832 mutex_lock(&battery->sysfs_lock);
833 if (!battery->bat) {
834 mutex_unlock(&battery->sysfs_lock);
835 return;
836 }
837 battery_hook_remove_battery(battery);
838 device_remove_file(&battery->bat->dev, &alarm_attr);
839 power_supply_unregister(battery->bat);
840 battery->bat = NULL;
841 mutex_unlock(&battery->sysfs_lock);
842}
843
844static void find_battery(const struct dmi_header *dm, void *private)
845{
846 struct acpi_battery *battery = (struct acpi_battery *)private;
847 /* Note: the hardcoded offsets below have been extracted from
848 the source code of dmidecode. */
849 if (dm->type == DMI_ENTRY_PORTABLE_BATTERY && dm->length >= 8) {
850 const u8 *dmi_data = (const u8 *)(dm + 1);
851 int dmi_capacity = get_unaligned((const u16 *)(dmi_data + 6));
852 if (dm->length >= 18)
853 dmi_capacity *= dmi_data[17];
854 if (battery->design_capacity * battery->design_voltage / 1000
855 != dmi_capacity &&
856 battery->design_capacity * 10 == dmi_capacity)
857 set_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
858 &battery->flags);
859 }
860}
861
862/*
863 * According to the ACPI spec, some kinds of primary batteries can
864 * report percentage battery remaining capacity directly to OS.
865 * In this case, it reports the Last Full Charged Capacity == 100
866 * and BatteryPresentRate == 0xFFFFFFFF.
867 *
868 * Now we found some battery reports percentage remaining capacity
869 * even if it's rechargeable.
870 * https://bugzilla.kernel.org/show_bug.cgi?id=15979
871 *
872 * Handle this correctly so that they won't break userspace.
873 */
874static void acpi_battery_quirks(struct acpi_battery *battery)
875{
876 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
877 return;
878
879 if (battery->full_charge_capacity == 100 &&
880 battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN &&
881 battery->capacity_now >= 0 && battery->capacity_now <= 100) {
882 set_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags);
883 battery->full_charge_capacity = battery->design_capacity;
884 battery->capacity_now = (battery->capacity_now *
885 battery->full_charge_capacity) / 100;
886 }
887
888 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags))
889 return;
890
891 if (battery->power_unit && dmi_name_in_vendors("LENOVO")) {
892 const char *s;
893 s = dmi_get_system_info(DMI_PRODUCT_VERSION);
894 if (s && !strncasecmp(s, "ThinkPad", 8)) {
895 dmi_walk(find_battery, battery);
896 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
897 &battery->flags) &&
898 battery->design_voltage) {
899 battery->design_capacity =
900 battery->design_capacity *
901 10000 / battery->design_voltage;
902 battery->full_charge_capacity =
903 battery->full_charge_capacity *
904 10000 / battery->design_voltage;
905 battery->design_capacity_warning =
906 battery->design_capacity_warning *
907 10000 / battery->design_voltage;
908 battery->capacity_now = battery->capacity_now *
909 10000 / battery->design_voltage;
910 }
911 }
912 }
913
914 if (test_bit(ACPI_BATTERY_QUIRK_DEGRADED_FULL_CHARGE, &battery->flags))
915 return;
916
917 if (acpi_battery_is_degraded(battery) &&
918 battery->capacity_now > battery->full_charge_capacity) {
919 set_bit(ACPI_BATTERY_QUIRK_DEGRADED_FULL_CHARGE, &battery->flags);
920 battery->capacity_now = battery->full_charge_capacity;
921 }
922}
923
924static int acpi_battery_update(struct acpi_battery *battery, bool resume)
925{
926 int result = acpi_battery_get_status(battery);
927
928 if (result)
929 return result;
930
931 if (!acpi_battery_present(battery)) {
932 sysfs_remove_battery(battery);
933 battery->update_time = 0;
934 return 0;
935 }
936
937 if (resume)
938 return 0;
939
940 if (!battery->update_time) {
941 result = acpi_battery_get_info(battery);
942 if (result)
943 return result;
944 acpi_battery_init_alarm(battery);
945 }
946
947 result = acpi_battery_get_state(battery);
948 if (result)
949 return result;
950 acpi_battery_quirks(battery);
951
952 if (!battery->bat) {
953 result = sysfs_add_battery(battery);
954 if (result)
955 return result;
956 }
957
958 /*
959 * Wakeup the system if battery is critical low
960 * or lower than the alarm level
961 */
962 if ((battery->state & ACPI_BATTERY_STATE_CRITICAL) ||
963 (test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags) &&
964 (battery->capacity_now <= battery->alarm)))
965 acpi_pm_wakeup_event(&battery->device->dev);
966
967 return result;
968}
969
970static void acpi_battery_refresh(struct acpi_battery *battery)
971{
972 int power_unit;
973
974 if (!battery->bat)
975 return;
976
977 power_unit = battery->power_unit;
978
979 acpi_battery_get_info(battery);
980
981 if (power_unit == battery->power_unit)
982 return;
983
984 /* The battery has changed its reporting units. */
985 sysfs_remove_battery(battery);
986 sysfs_add_battery(battery);
987}
988
989/* --------------------------------------------------------------------------
990 FS Interface (/proc)
991 -------------------------------------------------------------------------- */
992
993#ifdef CONFIG_ACPI_PROCFS_POWER
994static struct proc_dir_entry *acpi_battery_dir;
995
996static const char *acpi_battery_units(const struct acpi_battery *battery)
997{
998 return (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) ?
999 "mA" : "mW";
1000}
1001
1002static int acpi_battery_info_proc_show(struct seq_file *seq, void *offset)
1003{
1004 struct acpi_battery *battery = seq->private;
1005 int result = acpi_battery_update(battery, false);
1006
1007 if (result)
1008 goto end;
1009
1010 seq_printf(seq, "present: %s\n",
1011 acpi_battery_present(battery) ? "yes" : "no");
1012 if (!acpi_battery_present(battery))
1013 goto end;
1014 if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
1015 seq_printf(seq, "design capacity: unknown\n");
1016 else
1017 seq_printf(seq, "design capacity: %d %sh\n",
1018 battery->design_capacity,
1019 acpi_battery_units(battery));
1020
1021 if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
1022 seq_printf(seq, "last full capacity: unknown\n");
1023 else
1024 seq_printf(seq, "last full capacity: %d %sh\n",
1025 battery->full_charge_capacity,
1026 acpi_battery_units(battery));
1027
1028 seq_printf(seq, "battery technology: %srechargeable\n",
1029 battery->technology ? "" : "non-");
1030
1031 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
1032 seq_printf(seq, "design voltage: unknown\n");
1033 else
1034 seq_printf(seq, "design voltage: %d mV\n",
1035 battery->design_voltage);
1036 seq_printf(seq, "design capacity warning: %d %sh\n",
1037 battery->design_capacity_warning,
1038 acpi_battery_units(battery));
1039 seq_printf(seq, "design capacity low: %d %sh\n",
1040 battery->design_capacity_low,
1041 acpi_battery_units(battery));
1042 seq_printf(seq, "cycle count: %i\n", battery->cycle_count);
1043 seq_printf(seq, "capacity granularity 1: %d %sh\n",
1044 battery->capacity_granularity_1,
1045 acpi_battery_units(battery));
1046 seq_printf(seq, "capacity granularity 2: %d %sh\n",
1047 battery->capacity_granularity_2,
1048 acpi_battery_units(battery));
1049 seq_printf(seq, "model number: %s\n", battery->model_number);
1050 seq_printf(seq, "serial number: %s\n", battery->serial_number);
1051 seq_printf(seq, "battery type: %s\n", battery->type);
1052 seq_printf(seq, "OEM info: %s\n", battery->oem_info);
1053 end:
1054 if (result)
1055 seq_printf(seq, "ERROR: Unable to read battery info\n");
1056 return result;
1057}
1058
1059static int acpi_battery_state_proc_show(struct seq_file *seq, void *offset)
1060{
1061 struct acpi_battery *battery = seq->private;
1062 int result = acpi_battery_update(battery, false);
1063
1064 if (result)
1065 goto end;
1066
1067 seq_printf(seq, "present: %s\n",
1068 acpi_battery_present(battery) ? "yes" : "no");
1069 if (!acpi_battery_present(battery))
1070 goto end;
1071
1072 seq_printf(seq, "capacity state: %s\n",
1073 (battery->state & 0x04) ? "critical" : "ok");
1074 if ((battery->state & 0x01) && (battery->state & 0x02))
1075 seq_printf(seq,
1076 "charging state: charging/discharging\n");
1077 else if (battery->state & 0x01)
1078 seq_printf(seq, "charging state: discharging\n");
1079 else if (battery->state & 0x02)
1080 seq_printf(seq, "charging state: charging\n");
1081 else
1082 seq_printf(seq, "charging state: charged\n");
1083
1084 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
1085 seq_printf(seq, "present rate: unknown\n");
1086 else
1087 seq_printf(seq, "present rate: %d %s\n",
1088 battery->rate_now, acpi_battery_units(battery));
1089
1090 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
1091 seq_printf(seq, "remaining capacity: unknown\n");
1092 else
1093 seq_printf(seq, "remaining capacity: %d %sh\n",
1094 battery->capacity_now, acpi_battery_units(battery));
1095 if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
1096 seq_printf(seq, "present voltage: unknown\n");
1097 else
1098 seq_printf(seq, "present voltage: %d mV\n",
1099 battery->voltage_now);
1100 end:
1101 if (result)
1102 seq_printf(seq, "ERROR: Unable to read battery state\n");
1103
1104 return result;
1105}
1106
1107static int acpi_battery_alarm_proc_show(struct seq_file *seq, void *offset)
1108{
1109 struct acpi_battery *battery = seq->private;
1110 int result = acpi_battery_update(battery, false);
1111
1112 if (result)
1113 goto end;
1114
1115 if (!acpi_battery_present(battery)) {
1116 seq_printf(seq, "present: no\n");
1117 goto end;
1118 }
1119 seq_printf(seq, "alarm: ");
1120 if (battery->alarm) {
1121 seq_printf(seq, "%u %sh\n", battery->alarm,
1122 acpi_battery_units(battery));
1123 } else {
1124 seq_printf(seq, "unsupported\n");
1125 }
1126 end:
1127 if (result)
1128 seq_printf(seq, "ERROR: Unable to read battery alarm\n");
1129 return result;
1130}
1131
1132static ssize_t acpi_battery_write_alarm(struct file *file,
1133 const char __user * buffer,
1134 size_t count, loff_t * ppos)
1135{
1136 int result = 0;
1137 char alarm_string[12] = { '\0' };
1138 struct seq_file *m = file->private_data;
1139 struct acpi_battery *battery = m->private;
1140
1141 if (!battery || (count > sizeof(alarm_string) - 1))
1142 return -EINVAL;
1143 if (!acpi_battery_present(battery)) {
1144 result = -ENODEV;
1145 goto end;
1146 }
1147 if (copy_from_user(alarm_string, buffer, count)) {
1148 result = -EFAULT;
1149 goto end;
1150 }
1151 alarm_string[count] = '\0';
1152 if (kstrtoint(alarm_string, 0, &battery->alarm)) {
1153 result = -EINVAL;
1154 goto end;
1155 }
1156 result = acpi_battery_set_alarm(battery);
1157 end:
1158 if (result)
1159 return result;
1160 return count;
1161}
1162
1163static int acpi_battery_alarm_proc_open(struct inode *inode, struct file *file)
1164{
1165 return single_open(file, acpi_battery_alarm_proc_show, PDE_DATA(inode));
1166}
1167
1168static const struct file_operations acpi_battery_alarm_fops = {
1169 .owner = THIS_MODULE,
1170 .open = acpi_battery_alarm_proc_open,
1171 .read = seq_read,
1172 .write = acpi_battery_write_alarm,
1173 .llseek = seq_lseek,
1174 .release = single_release,
1175};
1176
1177static int acpi_battery_add_fs(struct acpi_device *device)
1178{
1179 pr_warning(PREFIX "Deprecated procfs I/F for battery is loaded, please retry with CONFIG_ACPI_PROCFS_POWER cleared\n");
1180 if (!acpi_device_dir(device)) {
1181 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
1182 acpi_battery_dir);
1183 if (!acpi_device_dir(device))
1184 return -ENODEV;
1185 }
1186
1187 if (!proc_create_single_data("info", S_IRUGO, acpi_device_dir(device),
1188 acpi_battery_info_proc_show, acpi_driver_data(device)))
1189 return -ENODEV;
1190 if (!proc_create_single_data("state", S_IRUGO, acpi_device_dir(device),
1191 acpi_battery_state_proc_show, acpi_driver_data(device)))
1192 return -ENODEV;
1193 if (!proc_create_data("alarm", S_IFREG | S_IRUGO | S_IWUSR,
1194 acpi_device_dir(device), &acpi_battery_alarm_fops,
1195 acpi_driver_data(device)))
1196 return -ENODEV;
1197 return 0;
1198}
1199
1200static void acpi_battery_remove_fs(struct acpi_device *device)
1201{
1202 if (!acpi_device_dir(device))
1203 return;
1204 remove_proc_subtree(acpi_device_bid(device), acpi_battery_dir);
1205 acpi_device_dir(device) = NULL;
1206}
1207
1208#endif
1209
1210/* --------------------------------------------------------------------------
1211 Driver Interface
1212 -------------------------------------------------------------------------- */
1213
1214static void acpi_battery_notify(struct acpi_device *device, u32 event)
1215{
1216 struct acpi_battery *battery = acpi_driver_data(device);
1217 struct power_supply *old;
1218
1219 if (!battery)
1220 return;
1221 old = battery->bat;
1222 /*
1223 * On Acer Aspire V5-573G notifications are sometimes triggered too
1224 * early. For example, when AC is unplugged and notification is
1225 * triggered, battery state is still reported as "Full", and changes to
1226 * "Discharging" only after short delay, without any notification.
1227 */
1228 if (battery_notification_delay_ms > 0)
1229 msleep(battery_notification_delay_ms);
1230 if (event == ACPI_BATTERY_NOTIFY_INFO)
1231 acpi_battery_refresh(battery);
1232 acpi_battery_update(battery, false);
1233 acpi_bus_generate_netlink_event(device->pnp.device_class,
1234 dev_name(&device->dev), event,
1235 acpi_battery_present(battery));
1236 acpi_notifier_call_chain(device, event, acpi_battery_present(battery));
1237 /* acpi_battery_update could remove power_supply object */
1238 if (old && battery->bat)
1239 power_supply_changed(battery->bat);
1240}
1241
1242static int battery_notify(struct notifier_block *nb,
1243 unsigned long mode, void *_unused)
1244{
1245 struct acpi_battery *battery = container_of(nb, struct acpi_battery,
1246 pm_nb);
1247 int result;
1248
1249 switch (mode) {
1250 case PM_POST_HIBERNATION:
1251 case PM_POST_SUSPEND:
1252 if (!acpi_battery_present(battery))
1253 return 0;
1254
1255 if (battery->bat) {
1256 acpi_battery_refresh(battery);
1257 } else {
1258 result = acpi_battery_get_info(battery);
1259 if (result)
1260 return result;
1261
1262 result = sysfs_add_battery(battery);
1263 if (result)
1264 return result;
1265 }
1266
1267 acpi_battery_init_alarm(battery);
1268 acpi_battery_get_state(battery);
1269 break;
1270 }
1271
1272 return 0;
1273}
1274
1275static int __init
1276battery_bix_broken_package_quirk(const struct dmi_system_id *d)
1277{
1278 battery_bix_broken_package = 1;
1279 return 0;
1280}
1281
1282static int __init
1283battery_notification_delay_quirk(const struct dmi_system_id *d)
1284{
1285 battery_notification_delay_ms = 1000;
1286 return 0;
1287}
1288
1289static int __init
1290battery_ac_is_broken_quirk(const struct dmi_system_id *d)
1291{
1292 battery_ac_is_broken = 1;
1293 return 0;
1294}
1295
1296static int __init
1297battery_do_not_check_pmic_quirk(const struct dmi_system_id *d)
1298{
1299 battery_check_pmic = 0;
1300 return 0;
1301}
1302
1303static const struct dmi_system_id bat_dmi_table[] __initconst = {
1304 {
1305 /* NEC LZ750/LS */
1306 .callback = battery_bix_broken_package_quirk,
1307 .matches = {
1308 DMI_MATCH(DMI_SYS_VENDOR, "NEC"),
1309 DMI_MATCH(DMI_PRODUCT_NAME, "PC-LZ750LS"),
1310 },
1311 },
1312 {
1313 /* Acer Aspire V5-573G */
1314 .callback = battery_notification_delay_quirk,
1315 .matches = {
1316 DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
1317 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire V5-573G"),
1318 },
1319 },
1320 {
1321 /* Point of View mobii wintab p800w */
1322 .callback = battery_ac_is_broken_quirk,
1323 .matches = {
1324 DMI_MATCH(DMI_BOARD_VENDOR, "AMI Corporation"),
1325 DMI_MATCH(DMI_BOARD_NAME, "Aptio CRB"),
1326 DMI_MATCH(DMI_BIOS_VERSION, "3BAIR1013"),
1327 /* Above matches are too generic, add bios-date match */
1328 DMI_MATCH(DMI_BIOS_DATE, "08/22/2014"),
1329 },
1330 },
1331 {
1332 /* ECS EF20EA */
1333 .callback = battery_do_not_check_pmic_quirk,
1334 .matches = {
1335 DMI_MATCH(DMI_PRODUCT_NAME, "EF20EA"),
1336 },
1337 },
1338 {
1339 /* Lenovo Ideapad Miix 320 */
1340 .callback = battery_do_not_check_pmic_quirk,
1341 .matches = {
1342 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "LENOVO"),
1343 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "80XF"),
1344 DMI_EXACT_MATCH(DMI_PRODUCT_VERSION, "Lenovo MIIX 320-10ICR"),
1345 },
1346 },
1347 {},
1348};
1349
1350/*
1351 * Some machines'(E,G Lenovo Z480) ECs are not stable
1352 * during boot up and this causes battery driver fails to be
1353 * probed due to failure of getting battery information
1354 * from EC sometimes. After several retries, the operation
1355 * may work. So add retry code here and 20ms sleep between
1356 * every retries.
1357 */
1358static int acpi_battery_update_retry(struct acpi_battery *battery)
1359{
1360 int retry, ret;
1361
1362 for (retry = 5; retry; retry--) {
1363 ret = acpi_battery_update(battery, false);
1364 if (!ret)
1365 break;
1366
1367 msleep(20);
1368 }
1369 return ret;
1370}
1371
1372static int acpi_battery_add(struct acpi_device *device)
1373{
1374 int result = 0;
1375 struct acpi_battery *battery = NULL;
1376
1377 if (!device)
1378 return -EINVAL;
1379
1380 if (device->dep_unmet)
1381 return -EPROBE_DEFER;
1382
1383 battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL);
1384 if (!battery)
1385 return -ENOMEM;
1386 battery->device = device;
1387 strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME);
1388 strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS);
1389 device->driver_data = battery;
1390 mutex_init(&battery->lock);
1391 mutex_init(&battery->sysfs_lock);
1392 if (acpi_has_method(battery->device->handle, "_BIX"))
1393 set_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags);
1394
1395 result = acpi_battery_update_retry(battery);
1396 if (result)
1397 goto fail;
1398
1399#ifdef CONFIG_ACPI_PROCFS_POWER
1400 result = acpi_battery_add_fs(device);
1401 if (result) {
1402 acpi_battery_remove_fs(device);
1403 goto fail;
1404 }
1405#endif
1406
1407 pr_info(PREFIX "%s Slot [%s] (battery %s)\n",
1408 ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device),
1409 device->status.battery_present ? "present" : "absent");
1410
1411 battery->pm_nb.notifier_call = battery_notify;
1412 register_pm_notifier(&battery->pm_nb);
1413
1414 device_init_wakeup(&device->dev, 1);
1415
1416 return result;
1417
1418fail:
1419 sysfs_remove_battery(battery);
1420 mutex_destroy(&battery->lock);
1421 mutex_destroy(&battery->sysfs_lock);
1422 kfree(battery);
1423 return result;
1424}
1425
1426static int acpi_battery_remove(struct acpi_device *device)
1427{
1428 struct acpi_battery *battery = NULL;
1429
1430 if (!device || !acpi_driver_data(device))
1431 return -EINVAL;
1432 device_init_wakeup(&device->dev, 0);
1433 battery = acpi_driver_data(device);
1434 unregister_pm_notifier(&battery->pm_nb);
1435#ifdef CONFIG_ACPI_PROCFS_POWER
1436 acpi_battery_remove_fs(device);
1437#endif
1438 sysfs_remove_battery(battery);
1439 mutex_destroy(&battery->lock);
1440 mutex_destroy(&battery->sysfs_lock);
1441 kfree(battery);
1442 return 0;
1443}
1444
1445#ifdef CONFIG_PM_SLEEP
1446/* this is needed to learn about changes made in suspended state */
1447static int acpi_battery_resume(struct device *dev)
1448{
1449 struct acpi_battery *battery;
1450
1451 if (!dev)
1452 return -EINVAL;
1453
1454 battery = acpi_driver_data(to_acpi_device(dev));
1455 if (!battery)
1456 return -EINVAL;
1457
1458 battery->update_time = 0;
1459 acpi_battery_update(battery, true);
1460 return 0;
1461}
1462#else
1463#define acpi_battery_resume NULL
1464#endif
1465
1466static SIMPLE_DEV_PM_OPS(acpi_battery_pm, NULL, acpi_battery_resume);
1467
1468static struct acpi_driver acpi_battery_driver = {
1469 .name = "battery",
1470 .class = ACPI_BATTERY_CLASS,
1471 .ids = battery_device_ids,
1472 .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
1473 .ops = {
1474 .add = acpi_battery_add,
1475 .remove = acpi_battery_remove,
1476 .notify = acpi_battery_notify,
1477 },
1478 .drv.pm = &acpi_battery_pm,
1479};
1480
1481static void __init acpi_battery_init_async(void *unused, async_cookie_t cookie)
1482{
1483 unsigned int i;
1484 int result;
1485
1486 dmi_check_system(bat_dmi_table);
1487
1488 if (battery_check_pmic) {
1489 for (i = 0; i < ARRAY_SIZE(acpi_battery_blacklist); i++)
1490 if (acpi_dev_present(acpi_battery_blacklist[i], "1", -1)) {
1491 pr_info(PREFIX ACPI_BATTERY_DEVICE_NAME
1492 ": found native %s PMIC, not loading\n",
1493 acpi_battery_blacklist[i]);
1494 return;
1495 }
1496 }
1497
1498#ifdef CONFIG_ACPI_PROCFS_POWER
1499 acpi_battery_dir = acpi_lock_battery_dir();
1500 if (!acpi_battery_dir)
1501 return;
1502#endif
1503 result = acpi_bus_register_driver(&acpi_battery_driver);
1504#ifdef CONFIG_ACPI_PROCFS_POWER
1505 if (result < 0)
1506 acpi_unlock_battery_dir(acpi_battery_dir);
1507#endif
1508 battery_driver_registered = (result == 0);
1509}
1510
1511static int __init acpi_battery_init(void)
1512{
1513 if (acpi_disabled)
1514 return -ENODEV;
1515
1516 async_cookie = async_schedule(acpi_battery_init_async, NULL);
1517 return 0;
1518}
1519
1520static void __exit acpi_battery_exit(void)
1521{
1522 async_synchronize_cookie(async_cookie + 1);
1523 if (battery_driver_registered) {
1524 acpi_bus_unregister_driver(&acpi_battery_driver);
1525 battery_hook_exit();
1526 }
1527#ifdef CONFIG_ACPI_PROCFS_POWER
1528 if (acpi_battery_dir)
1529 acpi_unlock_battery_dir(acpi_battery_dir);
1530#endif
1531}
1532
1533module_init(acpi_battery_init);
1534module_exit(acpi_battery_exit);
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 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
22 */
23
24#include <linux/kernel.h>
25#include <linux/module.h>
26#include <linux/init.h>
27#include <linux/types.h>
28#include <linux/jiffies.h>
29#include <linux/async.h>
30#include <linux/dmi.h>
31#include <linux/delay.h>
32#include <linux/slab.h>
33#include <linux/suspend.h>
34#include <asm/unaligned.h>
35
36#ifdef CONFIG_ACPI_PROCFS_POWER
37#include <linux/proc_fs.h>
38#include <linux/seq_file.h>
39#include <asm/uaccess.h>
40#endif
41
42#include <linux/acpi.h>
43#include <linux/power_supply.h>
44
45#include "battery.h"
46
47#define PREFIX "ACPI: "
48
49#define ACPI_BATTERY_VALUE_UNKNOWN 0xFFFFFFFF
50
51#define ACPI_BATTERY_DEVICE_NAME "Battery"
52
53/* Battery power unit: 0 means mW, 1 means mA */
54#define ACPI_BATTERY_POWER_UNIT_MA 1
55
56#define ACPI_BATTERY_STATE_DISCHARGING 0x1
57#define ACPI_BATTERY_STATE_CHARGING 0x2
58#define ACPI_BATTERY_STATE_CRITICAL 0x4
59
60#define _COMPONENT ACPI_BATTERY_COMPONENT
61
62ACPI_MODULE_NAME("battery");
63
64MODULE_AUTHOR("Paul Diefenbaugh");
65MODULE_AUTHOR("Alexey Starikovskiy <astarikovskiy@suse.de>");
66MODULE_DESCRIPTION("ACPI Battery Driver");
67MODULE_LICENSE("GPL");
68
69static async_cookie_t async_cookie;
70static int battery_bix_broken_package;
71static int battery_notification_delay_ms;
72static unsigned int cache_time = 1000;
73module_param(cache_time, uint, 0644);
74MODULE_PARM_DESC(cache_time, "cache time in milliseconds");
75
76#ifdef CONFIG_ACPI_PROCFS_POWER
77extern struct proc_dir_entry *acpi_lock_battery_dir(void);
78extern void *acpi_unlock_battery_dir(struct proc_dir_entry *acpi_battery_dir);
79
80enum acpi_battery_files {
81 info_tag = 0,
82 state_tag,
83 alarm_tag,
84 ACPI_BATTERY_NUMFILES,
85};
86
87#endif
88
89static const struct acpi_device_id battery_device_ids[] = {
90 {"PNP0C0A", 0},
91 {"", 0},
92};
93
94MODULE_DEVICE_TABLE(acpi, battery_device_ids);
95
96enum {
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
114struct acpi_battery {
115 struct mutex lock;
116 struct mutex sysfs_lock;
117 struct power_supply *bat;
118 struct power_supply_desc bat_desc;
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) power_supply_get_drvdata(x)
151
152static inline int acpi_battery_present(struct acpi_battery *battery)
153{
154 return battery->device->status.battery_present;
155}
156
157static 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
172static int acpi_battery_get_state(struct acpi_battery *battery);
173
174static int acpi_battery_is_charged(struct acpi_battery *battery)
175{
176 /* charging, discharging or critical low */
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
197static 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 & ACPI_BATTERY_STATE_DISCHARGING)
212 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
213 else if (battery->state & ACPI_BATTERY_STATE_CHARGING)
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_CAPACITY_LEVEL:
277 if (battery->state & ACPI_BATTERY_STATE_CRITICAL)
278 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
279 else if (test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags) &&
280 (battery->capacity_now <= battery->alarm))
281 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_LOW;
282 else if (acpi_battery_is_charged(battery))
283 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
284 else
285 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
286 break;
287 case POWER_SUPPLY_PROP_MODEL_NAME:
288 val->strval = battery->model_number;
289 break;
290 case POWER_SUPPLY_PROP_MANUFACTURER:
291 val->strval = battery->oem_info;
292 break;
293 case POWER_SUPPLY_PROP_SERIAL_NUMBER:
294 val->strval = battery->serial_number;
295 break;
296 default:
297 ret = -EINVAL;
298 }
299 return ret;
300}
301
302static enum power_supply_property charge_battery_props[] = {
303 POWER_SUPPLY_PROP_STATUS,
304 POWER_SUPPLY_PROP_PRESENT,
305 POWER_SUPPLY_PROP_TECHNOLOGY,
306 POWER_SUPPLY_PROP_CYCLE_COUNT,
307 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
308 POWER_SUPPLY_PROP_VOLTAGE_NOW,
309 POWER_SUPPLY_PROP_CURRENT_NOW,
310 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
311 POWER_SUPPLY_PROP_CHARGE_FULL,
312 POWER_SUPPLY_PROP_CHARGE_NOW,
313 POWER_SUPPLY_PROP_CAPACITY,
314 POWER_SUPPLY_PROP_CAPACITY_LEVEL,
315 POWER_SUPPLY_PROP_MODEL_NAME,
316 POWER_SUPPLY_PROP_MANUFACTURER,
317 POWER_SUPPLY_PROP_SERIAL_NUMBER,
318};
319
320static enum power_supply_property energy_battery_props[] = {
321 POWER_SUPPLY_PROP_STATUS,
322 POWER_SUPPLY_PROP_PRESENT,
323 POWER_SUPPLY_PROP_TECHNOLOGY,
324 POWER_SUPPLY_PROP_CYCLE_COUNT,
325 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
326 POWER_SUPPLY_PROP_VOLTAGE_NOW,
327 POWER_SUPPLY_PROP_POWER_NOW,
328 POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
329 POWER_SUPPLY_PROP_ENERGY_FULL,
330 POWER_SUPPLY_PROP_ENERGY_NOW,
331 POWER_SUPPLY_PROP_CAPACITY,
332 POWER_SUPPLY_PROP_CAPACITY_LEVEL,
333 POWER_SUPPLY_PROP_MODEL_NAME,
334 POWER_SUPPLY_PROP_MANUFACTURER,
335 POWER_SUPPLY_PROP_SERIAL_NUMBER,
336};
337
338/* --------------------------------------------------------------------------
339 Battery Management
340 -------------------------------------------------------------------------- */
341struct acpi_offsets {
342 size_t offset; /* offset inside struct acpi_sbs_battery */
343 u8 mode; /* int or string? */
344};
345
346static const struct acpi_offsets state_offsets[] = {
347 {offsetof(struct acpi_battery, state), 0},
348 {offsetof(struct acpi_battery, rate_now), 0},
349 {offsetof(struct acpi_battery, capacity_now), 0},
350 {offsetof(struct acpi_battery, voltage_now), 0},
351};
352
353static const struct acpi_offsets info_offsets[] = {
354 {offsetof(struct acpi_battery, power_unit), 0},
355 {offsetof(struct acpi_battery, design_capacity), 0},
356 {offsetof(struct acpi_battery, full_charge_capacity), 0},
357 {offsetof(struct acpi_battery, technology), 0},
358 {offsetof(struct acpi_battery, design_voltage), 0},
359 {offsetof(struct acpi_battery, design_capacity_warning), 0},
360 {offsetof(struct acpi_battery, design_capacity_low), 0},
361 {offsetof(struct acpi_battery, capacity_granularity_1), 0},
362 {offsetof(struct acpi_battery, capacity_granularity_2), 0},
363 {offsetof(struct acpi_battery, model_number), 1},
364 {offsetof(struct acpi_battery, serial_number), 1},
365 {offsetof(struct acpi_battery, type), 1},
366 {offsetof(struct acpi_battery, oem_info), 1},
367};
368
369static const struct acpi_offsets extended_info_offsets[] = {
370 {offsetof(struct acpi_battery, revision), 0},
371 {offsetof(struct acpi_battery, power_unit), 0},
372 {offsetof(struct acpi_battery, design_capacity), 0},
373 {offsetof(struct acpi_battery, full_charge_capacity), 0},
374 {offsetof(struct acpi_battery, technology), 0},
375 {offsetof(struct acpi_battery, design_voltage), 0},
376 {offsetof(struct acpi_battery, design_capacity_warning), 0},
377 {offsetof(struct acpi_battery, design_capacity_low), 0},
378 {offsetof(struct acpi_battery, cycle_count), 0},
379 {offsetof(struct acpi_battery, measurement_accuracy), 0},
380 {offsetof(struct acpi_battery, max_sampling_time), 0},
381 {offsetof(struct acpi_battery, min_sampling_time), 0},
382 {offsetof(struct acpi_battery, max_averaging_interval), 0},
383 {offsetof(struct acpi_battery, min_averaging_interval), 0},
384 {offsetof(struct acpi_battery, capacity_granularity_1), 0},
385 {offsetof(struct acpi_battery, capacity_granularity_2), 0},
386 {offsetof(struct acpi_battery, model_number), 1},
387 {offsetof(struct acpi_battery, serial_number), 1},
388 {offsetof(struct acpi_battery, type), 1},
389 {offsetof(struct acpi_battery, oem_info), 1},
390};
391
392static int extract_package(struct acpi_battery *battery,
393 union acpi_object *package,
394 const struct acpi_offsets *offsets, int num)
395{
396 int i;
397 union acpi_object *element;
398 if (package->type != ACPI_TYPE_PACKAGE)
399 return -EFAULT;
400 for (i = 0; i < num; ++i) {
401 if (package->package.count <= i)
402 return -EFAULT;
403 element = &package->package.elements[i];
404 if (offsets[i].mode) {
405 u8 *ptr = (u8 *)battery + offsets[i].offset;
406 if (element->type == ACPI_TYPE_STRING ||
407 element->type == ACPI_TYPE_BUFFER)
408 strncpy(ptr, element->string.pointer, 32);
409 else if (element->type == ACPI_TYPE_INTEGER) {
410 strncpy(ptr, (u8 *)&element->integer.value,
411 sizeof(u64));
412 ptr[sizeof(u64)] = 0;
413 } else
414 *ptr = 0; /* don't have value */
415 } else {
416 int *x = (int *)((u8 *)battery + offsets[i].offset);
417 *x = (element->type == ACPI_TYPE_INTEGER) ?
418 element->integer.value : -1;
419 }
420 }
421 return 0;
422}
423
424static int acpi_battery_get_status(struct acpi_battery *battery)
425{
426 if (acpi_bus_get_status(battery->device)) {
427 ACPI_EXCEPTION((AE_INFO, AE_ERROR, "Evaluating _STA"));
428 return -ENODEV;
429 }
430 return 0;
431}
432
433static int acpi_battery_get_info(struct acpi_battery *battery)
434{
435 int result = -EFAULT;
436 acpi_status status = 0;
437 char *name = test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags) ?
438 "_BIX" : "_BIF";
439
440 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
441
442 if (!acpi_battery_present(battery))
443 return 0;
444 mutex_lock(&battery->lock);
445 status = acpi_evaluate_object(battery->device->handle, name,
446 NULL, &buffer);
447 mutex_unlock(&battery->lock);
448
449 if (ACPI_FAILURE(status)) {
450 ACPI_EXCEPTION((AE_INFO, status, "Evaluating %s", name));
451 return -ENODEV;
452 }
453
454 if (battery_bix_broken_package)
455 result = extract_package(battery, buffer.pointer,
456 extended_info_offsets + 1,
457 ARRAY_SIZE(extended_info_offsets) - 1);
458 else if (test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags))
459 result = extract_package(battery, buffer.pointer,
460 extended_info_offsets,
461 ARRAY_SIZE(extended_info_offsets));
462 else
463 result = extract_package(battery, buffer.pointer,
464 info_offsets, ARRAY_SIZE(info_offsets));
465 kfree(buffer.pointer);
466 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
467 battery->full_charge_capacity = battery->design_capacity;
468 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
469 battery->power_unit && battery->design_voltage) {
470 battery->design_capacity = battery->design_capacity *
471 10000 / battery->design_voltage;
472 battery->full_charge_capacity = battery->full_charge_capacity *
473 10000 / battery->design_voltage;
474 battery->design_capacity_warning =
475 battery->design_capacity_warning *
476 10000 / battery->design_voltage;
477 /* Curiously, design_capacity_low, unlike the rest of them,
478 is correct. */
479 /* capacity_granularity_* equal 1 on the systems tested, so
480 it's impossible to tell if they would need an adjustment
481 or not if their values were higher. */
482 }
483 return result;
484}
485
486static int acpi_battery_get_state(struct acpi_battery *battery)
487{
488 int result = 0;
489 acpi_status status = 0;
490 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
491
492 if (!acpi_battery_present(battery))
493 return 0;
494
495 if (battery->update_time &&
496 time_before(jiffies, battery->update_time +
497 msecs_to_jiffies(cache_time)))
498 return 0;
499
500 mutex_lock(&battery->lock);
501 status = acpi_evaluate_object(battery->device->handle, "_BST",
502 NULL, &buffer);
503 mutex_unlock(&battery->lock);
504
505 if (ACPI_FAILURE(status)) {
506 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BST"));
507 return -ENODEV;
508 }
509
510 result = extract_package(battery, buffer.pointer,
511 state_offsets, ARRAY_SIZE(state_offsets));
512 battery->update_time = jiffies;
513 kfree(buffer.pointer);
514
515 /* For buggy DSDTs that report negative 16-bit values for either
516 * charging or discharging current and/or report 0 as 65536
517 * due to bad math.
518 */
519 if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA &&
520 battery->rate_now != ACPI_BATTERY_VALUE_UNKNOWN &&
521 (s16)(battery->rate_now) < 0) {
522 battery->rate_now = abs((s16)battery->rate_now);
523 printk_once(KERN_WARNING FW_BUG
524 "battery: (dis)charge rate invalid.\n");
525 }
526
527 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags)
528 && battery->capacity_now >= 0 && battery->capacity_now <= 100)
529 battery->capacity_now = (battery->capacity_now *
530 battery->full_charge_capacity) / 100;
531 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
532 battery->power_unit && battery->design_voltage) {
533 battery->capacity_now = battery->capacity_now *
534 10000 / battery->design_voltage;
535 }
536 return result;
537}
538
539static int acpi_battery_set_alarm(struct acpi_battery *battery)
540{
541 acpi_status status = 0;
542
543 if (!acpi_battery_present(battery) ||
544 !test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags))
545 return -ENODEV;
546
547 mutex_lock(&battery->lock);
548 status = acpi_execute_simple_method(battery->device->handle, "_BTP",
549 battery->alarm);
550 mutex_unlock(&battery->lock);
551
552 if (ACPI_FAILURE(status))
553 return -ENODEV;
554
555 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Alarm set to %d\n", battery->alarm));
556 return 0;
557}
558
559static int acpi_battery_init_alarm(struct acpi_battery *battery)
560{
561 /* See if alarms are supported, and if so, set default */
562 if (!acpi_has_method(battery->device->handle, "_BTP")) {
563 clear_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
564 return 0;
565 }
566 set_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
567 if (!battery->alarm)
568 battery->alarm = battery->design_capacity_warning;
569 return acpi_battery_set_alarm(battery);
570}
571
572static ssize_t acpi_battery_alarm_show(struct device *dev,
573 struct device_attribute *attr,
574 char *buf)
575{
576 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
577 return sprintf(buf, "%d\n", battery->alarm * 1000);
578}
579
580static ssize_t acpi_battery_alarm_store(struct device *dev,
581 struct device_attribute *attr,
582 const char *buf, size_t count)
583{
584 unsigned long x;
585 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
586 if (sscanf(buf, "%lu\n", &x) == 1)
587 battery->alarm = x/1000;
588 if (acpi_battery_present(battery))
589 acpi_battery_set_alarm(battery);
590 return count;
591}
592
593static struct device_attribute alarm_attr = {
594 .attr = {.name = "alarm", .mode = 0644},
595 .show = acpi_battery_alarm_show,
596 .store = acpi_battery_alarm_store,
597};
598
599static int sysfs_add_battery(struct acpi_battery *battery)
600{
601 struct power_supply_config psy_cfg = { .drv_data = battery, };
602
603 if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) {
604 battery->bat_desc.properties = charge_battery_props;
605 battery->bat_desc.num_properties =
606 ARRAY_SIZE(charge_battery_props);
607 } else {
608 battery->bat_desc.properties = energy_battery_props;
609 battery->bat_desc.num_properties =
610 ARRAY_SIZE(energy_battery_props);
611 }
612
613 battery->bat_desc.name = acpi_device_bid(battery->device);
614 battery->bat_desc.type = POWER_SUPPLY_TYPE_BATTERY;
615 battery->bat_desc.get_property = acpi_battery_get_property;
616
617 battery->bat = power_supply_register_no_ws(&battery->device->dev,
618 &battery->bat_desc, &psy_cfg);
619
620 if (IS_ERR(battery->bat)) {
621 int result = PTR_ERR(battery->bat);
622
623 battery->bat = NULL;
624 return result;
625 }
626 return device_create_file(&battery->bat->dev, &alarm_attr);
627}
628
629static void sysfs_remove_battery(struct acpi_battery *battery)
630{
631 mutex_lock(&battery->sysfs_lock);
632 if (!battery->bat) {
633 mutex_unlock(&battery->sysfs_lock);
634 return;
635 }
636
637 device_remove_file(&battery->bat->dev, &alarm_attr);
638 power_supply_unregister(battery->bat);
639 battery->bat = NULL;
640 mutex_unlock(&battery->sysfs_lock);
641}
642
643static void find_battery(const struct dmi_header *dm, void *private)
644{
645 struct acpi_battery *battery = (struct acpi_battery *)private;
646 /* Note: the hardcoded offsets below have been extracted from
647 the source code of dmidecode. */
648 if (dm->type == DMI_ENTRY_PORTABLE_BATTERY && dm->length >= 8) {
649 const u8 *dmi_data = (const u8 *)(dm + 1);
650 int dmi_capacity = get_unaligned((const u16 *)(dmi_data + 6));
651 if (dm->length >= 18)
652 dmi_capacity *= dmi_data[17];
653 if (battery->design_capacity * battery->design_voltage / 1000
654 != dmi_capacity &&
655 battery->design_capacity * 10 == dmi_capacity)
656 set_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
657 &battery->flags);
658 }
659}
660
661/*
662 * According to the ACPI spec, some kinds of primary batteries can
663 * report percentage battery remaining capacity directly to OS.
664 * In this case, it reports the Last Full Charged Capacity == 100
665 * and BatteryPresentRate == 0xFFFFFFFF.
666 *
667 * Now we found some battery reports percentage remaining capacity
668 * even if it's rechargeable.
669 * https://bugzilla.kernel.org/show_bug.cgi?id=15979
670 *
671 * Handle this correctly so that they won't break userspace.
672 */
673static void acpi_battery_quirks(struct acpi_battery *battery)
674{
675 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
676 return;
677
678 if (battery->full_charge_capacity == 100 &&
679 battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN &&
680 battery->capacity_now >= 0 && battery->capacity_now <= 100) {
681 set_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags);
682 battery->full_charge_capacity = battery->design_capacity;
683 battery->capacity_now = (battery->capacity_now *
684 battery->full_charge_capacity) / 100;
685 }
686
687 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags))
688 return;
689
690 if (battery->power_unit && dmi_name_in_vendors("LENOVO")) {
691 const char *s;
692 s = dmi_get_system_info(DMI_PRODUCT_VERSION);
693 if (s && !strncasecmp(s, "ThinkPad", 8)) {
694 dmi_walk(find_battery, battery);
695 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
696 &battery->flags) &&
697 battery->design_voltage) {
698 battery->design_capacity =
699 battery->design_capacity *
700 10000 / battery->design_voltage;
701 battery->full_charge_capacity =
702 battery->full_charge_capacity *
703 10000 / battery->design_voltage;
704 battery->design_capacity_warning =
705 battery->design_capacity_warning *
706 10000 / battery->design_voltage;
707 battery->capacity_now = battery->capacity_now *
708 10000 / battery->design_voltage;
709 }
710 }
711 }
712}
713
714static int acpi_battery_update(struct acpi_battery *battery, bool resume)
715{
716 int result, old_present = acpi_battery_present(battery);
717 result = acpi_battery_get_status(battery);
718 if (result)
719 return result;
720 if (!acpi_battery_present(battery)) {
721 sysfs_remove_battery(battery);
722 battery->update_time = 0;
723 return 0;
724 }
725
726 if (resume)
727 return 0;
728
729 if (!battery->update_time ||
730 old_present != acpi_battery_present(battery)) {
731 result = acpi_battery_get_info(battery);
732 if (result)
733 return result;
734 acpi_battery_init_alarm(battery);
735 }
736 if (!battery->bat) {
737 result = sysfs_add_battery(battery);
738 if (result)
739 return result;
740 }
741 result = acpi_battery_get_state(battery);
742 if (result)
743 return result;
744 acpi_battery_quirks(battery);
745
746 /*
747 * Wakeup the system if battery is critical low
748 * or lower than the alarm level
749 */
750 if ((battery->state & ACPI_BATTERY_STATE_CRITICAL) ||
751 (test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags) &&
752 (battery->capacity_now <= battery->alarm)))
753 pm_wakeup_event(&battery->device->dev, 0);
754
755 return result;
756}
757
758static void acpi_battery_refresh(struct acpi_battery *battery)
759{
760 int power_unit;
761
762 if (!battery->bat)
763 return;
764
765 power_unit = battery->power_unit;
766
767 acpi_battery_get_info(battery);
768
769 if (power_unit == battery->power_unit)
770 return;
771
772 /* The battery has changed its reporting units. */
773 sysfs_remove_battery(battery);
774 sysfs_add_battery(battery);
775}
776
777/* --------------------------------------------------------------------------
778 FS Interface (/proc)
779 -------------------------------------------------------------------------- */
780
781#ifdef CONFIG_ACPI_PROCFS_POWER
782static struct proc_dir_entry *acpi_battery_dir;
783
784static const char *acpi_battery_units(const struct acpi_battery *battery)
785{
786 return (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) ?
787 "mA" : "mW";
788}
789
790static int acpi_battery_print_info(struct seq_file *seq, int result)
791{
792 struct acpi_battery *battery = seq->private;
793
794 if (result)
795 goto end;
796
797 seq_printf(seq, "present: %s\n",
798 acpi_battery_present(battery) ? "yes" : "no");
799 if (!acpi_battery_present(battery))
800 goto end;
801 if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
802 seq_printf(seq, "design capacity: unknown\n");
803 else
804 seq_printf(seq, "design capacity: %d %sh\n",
805 battery->design_capacity,
806 acpi_battery_units(battery));
807
808 if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
809 seq_printf(seq, "last full capacity: unknown\n");
810 else
811 seq_printf(seq, "last full capacity: %d %sh\n",
812 battery->full_charge_capacity,
813 acpi_battery_units(battery));
814
815 seq_printf(seq, "battery technology: %srechargeable\n",
816 (!battery->technology)?"non-":"");
817
818 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
819 seq_printf(seq, "design voltage: unknown\n");
820 else
821 seq_printf(seq, "design voltage: %d mV\n",
822 battery->design_voltage);
823 seq_printf(seq, "design capacity warning: %d %sh\n",
824 battery->design_capacity_warning,
825 acpi_battery_units(battery));
826 seq_printf(seq, "design capacity low: %d %sh\n",
827 battery->design_capacity_low,
828 acpi_battery_units(battery));
829 seq_printf(seq, "cycle count: %i\n", battery->cycle_count);
830 seq_printf(seq, "capacity granularity 1: %d %sh\n",
831 battery->capacity_granularity_1,
832 acpi_battery_units(battery));
833 seq_printf(seq, "capacity granularity 2: %d %sh\n",
834 battery->capacity_granularity_2,
835 acpi_battery_units(battery));
836 seq_printf(seq, "model number: %s\n", battery->model_number);
837 seq_printf(seq, "serial number: %s\n", battery->serial_number);
838 seq_printf(seq, "battery type: %s\n", battery->type);
839 seq_printf(seq, "OEM info: %s\n", battery->oem_info);
840 end:
841 if (result)
842 seq_printf(seq, "ERROR: Unable to read battery info\n");
843 return result;
844}
845
846static int acpi_battery_print_state(struct seq_file *seq, int result)
847{
848 struct acpi_battery *battery = seq->private;
849
850 if (result)
851 goto end;
852
853 seq_printf(seq, "present: %s\n",
854 acpi_battery_present(battery) ? "yes" : "no");
855 if (!acpi_battery_present(battery))
856 goto end;
857
858 seq_printf(seq, "capacity state: %s\n",
859 (battery->state & 0x04) ? "critical" : "ok");
860 if ((battery->state & 0x01) && (battery->state & 0x02))
861 seq_printf(seq,
862 "charging state: charging/discharging\n");
863 else if (battery->state & 0x01)
864 seq_printf(seq, "charging state: discharging\n");
865 else if (battery->state & 0x02)
866 seq_printf(seq, "charging state: charging\n");
867 else
868 seq_printf(seq, "charging state: charged\n");
869
870 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
871 seq_printf(seq, "present rate: unknown\n");
872 else
873 seq_printf(seq, "present rate: %d %s\n",
874 battery->rate_now, acpi_battery_units(battery));
875
876 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
877 seq_printf(seq, "remaining capacity: unknown\n");
878 else
879 seq_printf(seq, "remaining capacity: %d %sh\n",
880 battery->capacity_now, acpi_battery_units(battery));
881 if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
882 seq_printf(seq, "present voltage: unknown\n");
883 else
884 seq_printf(seq, "present voltage: %d mV\n",
885 battery->voltage_now);
886 end:
887 if (result)
888 seq_printf(seq, "ERROR: Unable to read battery state\n");
889
890 return result;
891}
892
893static int acpi_battery_print_alarm(struct seq_file *seq, int result)
894{
895 struct acpi_battery *battery = seq->private;
896
897 if (result)
898 goto end;
899
900 if (!acpi_battery_present(battery)) {
901 seq_printf(seq, "present: no\n");
902 goto end;
903 }
904 seq_printf(seq, "alarm: ");
905 if (!battery->alarm)
906 seq_printf(seq, "unsupported\n");
907 else
908 seq_printf(seq, "%u %sh\n", battery->alarm,
909 acpi_battery_units(battery));
910 end:
911 if (result)
912 seq_printf(seq, "ERROR: Unable to read battery alarm\n");
913 return result;
914}
915
916static ssize_t acpi_battery_write_alarm(struct file *file,
917 const char __user * buffer,
918 size_t count, loff_t * ppos)
919{
920 int result = 0;
921 char alarm_string[12] = { '\0' };
922 struct seq_file *m = file->private_data;
923 struct acpi_battery *battery = m->private;
924
925 if (!battery || (count > sizeof(alarm_string) - 1))
926 return -EINVAL;
927 if (!acpi_battery_present(battery)) {
928 result = -ENODEV;
929 goto end;
930 }
931 if (copy_from_user(alarm_string, buffer, count)) {
932 result = -EFAULT;
933 goto end;
934 }
935 alarm_string[count] = '\0';
936 if (kstrtoint(alarm_string, 0, &battery->alarm)) {
937 result = -EINVAL;
938 goto end;
939 }
940 result = acpi_battery_set_alarm(battery);
941 end:
942 if (!result)
943 return count;
944 return result;
945}
946
947typedef int(*print_func)(struct seq_file *seq, int result);
948
949static print_func acpi_print_funcs[ACPI_BATTERY_NUMFILES] = {
950 acpi_battery_print_info,
951 acpi_battery_print_state,
952 acpi_battery_print_alarm,
953};
954
955static int acpi_battery_read(int fid, struct seq_file *seq)
956{
957 struct acpi_battery *battery = seq->private;
958 int result = acpi_battery_update(battery, false);
959 return acpi_print_funcs[fid](seq, result);
960}
961
962#define DECLARE_FILE_FUNCTIONS(_name) \
963static int acpi_battery_read_##_name(struct seq_file *seq, void *offset) \
964{ \
965 return acpi_battery_read(_name##_tag, seq); \
966} \
967static int acpi_battery_##_name##_open_fs(struct inode *inode, struct file *file) \
968{ \
969 return single_open(file, acpi_battery_read_##_name, PDE_DATA(inode)); \
970}
971
972DECLARE_FILE_FUNCTIONS(info);
973DECLARE_FILE_FUNCTIONS(state);
974DECLARE_FILE_FUNCTIONS(alarm);
975
976#undef DECLARE_FILE_FUNCTIONS
977
978#define FILE_DESCRIPTION_RO(_name) \
979 { \
980 .name = __stringify(_name), \
981 .mode = S_IRUGO, \
982 .ops = { \
983 .open = acpi_battery_##_name##_open_fs, \
984 .read = seq_read, \
985 .llseek = seq_lseek, \
986 .release = single_release, \
987 .owner = THIS_MODULE, \
988 }, \
989 }
990
991#define FILE_DESCRIPTION_RW(_name) \
992 { \
993 .name = __stringify(_name), \
994 .mode = S_IFREG | S_IRUGO | S_IWUSR, \
995 .ops = { \
996 .open = acpi_battery_##_name##_open_fs, \
997 .read = seq_read, \
998 .llseek = seq_lseek, \
999 .write = acpi_battery_write_##_name, \
1000 .release = single_release, \
1001 .owner = THIS_MODULE, \
1002 }, \
1003 }
1004
1005static const struct battery_file {
1006 struct file_operations ops;
1007 umode_t mode;
1008 const char *name;
1009} acpi_battery_file[] = {
1010 FILE_DESCRIPTION_RO(info),
1011 FILE_DESCRIPTION_RO(state),
1012 FILE_DESCRIPTION_RW(alarm),
1013};
1014
1015#undef FILE_DESCRIPTION_RO
1016#undef FILE_DESCRIPTION_RW
1017
1018static int acpi_battery_add_fs(struct acpi_device *device)
1019{
1020 struct proc_dir_entry *entry = NULL;
1021 int i;
1022
1023 printk(KERN_WARNING PREFIX "Deprecated procfs I/F for battery is loaded,"
1024 " please retry with CONFIG_ACPI_PROCFS_POWER cleared\n");
1025 if (!acpi_device_dir(device)) {
1026 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
1027 acpi_battery_dir);
1028 if (!acpi_device_dir(device))
1029 return -ENODEV;
1030 }
1031
1032 for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i) {
1033 entry = proc_create_data(acpi_battery_file[i].name,
1034 acpi_battery_file[i].mode,
1035 acpi_device_dir(device),
1036 &acpi_battery_file[i].ops,
1037 acpi_driver_data(device));
1038 if (!entry)
1039 return -ENODEV;
1040 }
1041 return 0;
1042}
1043
1044static void acpi_battery_remove_fs(struct acpi_device *device)
1045{
1046 int i;
1047 if (!acpi_device_dir(device))
1048 return;
1049 for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i)
1050 remove_proc_entry(acpi_battery_file[i].name,
1051 acpi_device_dir(device));
1052
1053 remove_proc_entry(acpi_device_bid(device), acpi_battery_dir);
1054 acpi_device_dir(device) = NULL;
1055}
1056
1057#endif
1058
1059/* --------------------------------------------------------------------------
1060 Driver Interface
1061 -------------------------------------------------------------------------- */
1062
1063static void acpi_battery_notify(struct acpi_device *device, u32 event)
1064{
1065 struct acpi_battery *battery = acpi_driver_data(device);
1066 struct power_supply *old;
1067
1068 if (!battery)
1069 return;
1070 old = battery->bat;
1071 /*
1072 * On Acer Aspire V5-573G notifications are sometimes triggered too
1073 * early. For example, when AC is unplugged and notification is
1074 * triggered, battery state is still reported as "Full", and changes to
1075 * "Discharging" only after short delay, without any notification.
1076 */
1077 if (battery_notification_delay_ms > 0)
1078 msleep(battery_notification_delay_ms);
1079 if (event == ACPI_BATTERY_NOTIFY_INFO)
1080 acpi_battery_refresh(battery);
1081 acpi_battery_update(battery, false);
1082 acpi_bus_generate_netlink_event(device->pnp.device_class,
1083 dev_name(&device->dev), event,
1084 acpi_battery_present(battery));
1085 acpi_notifier_call_chain(device, event, acpi_battery_present(battery));
1086 /* acpi_battery_update could remove power_supply object */
1087 if (old && battery->bat)
1088 power_supply_changed(battery->bat);
1089}
1090
1091static int battery_notify(struct notifier_block *nb,
1092 unsigned long mode, void *_unused)
1093{
1094 struct acpi_battery *battery = container_of(nb, struct acpi_battery,
1095 pm_nb);
1096 int result;
1097
1098 switch (mode) {
1099 case PM_POST_HIBERNATION:
1100 case PM_POST_SUSPEND:
1101 if (!acpi_battery_present(battery))
1102 return 0;
1103
1104 if (!battery->bat) {
1105 result = acpi_battery_get_info(battery);
1106 if (result)
1107 return result;
1108
1109 result = sysfs_add_battery(battery);
1110 if (result)
1111 return result;
1112 } else
1113 acpi_battery_refresh(battery);
1114
1115 acpi_battery_init_alarm(battery);
1116 acpi_battery_get_state(battery);
1117 break;
1118 }
1119
1120 return 0;
1121}
1122
1123static int __init
1124battery_bix_broken_package_quirk(const struct dmi_system_id *d)
1125{
1126 battery_bix_broken_package = 1;
1127 return 0;
1128}
1129
1130static int __init
1131battery_notification_delay_quirk(const struct dmi_system_id *d)
1132{
1133 battery_notification_delay_ms = 1000;
1134 return 0;
1135}
1136
1137static const struct dmi_system_id bat_dmi_table[] __initconst = {
1138 {
1139 .callback = battery_bix_broken_package_quirk,
1140 .ident = "NEC LZ750/LS",
1141 .matches = {
1142 DMI_MATCH(DMI_SYS_VENDOR, "NEC"),
1143 DMI_MATCH(DMI_PRODUCT_NAME, "PC-LZ750LS"),
1144 },
1145 },
1146 {
1147 .callback = battery_notification_delay_quirk,
1148 .ident = "Acer Aspire V5-573G",
1149 .matches = {
1150 DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
1151 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire V5-573G"),
1152 },
1153 },
1154 {},
1155};
1156
1157/*
1158 * Some machines'(E,G Lenovo Z480) ECs are not stable
1159 * during boot up and this causes battery driver fails to be
1160 * probed due to failure of getting battery information
1161 * from EC sometimes. After several retries, the operation
1162 * may work. So add retry code here and 20ms sleep between
1163 * every retries.
1164 */
1165static int acpi_battery_update_retry(struct acpi_battery *battery)
1166{
1167 int retry, ret;
1168
1169 for (retry = 5; retry; retry--) {
1170 ret = acpi_battery_update(battery, false);
1171 if (!ret)
1172 break;
1173
1174 msleep(20);
1175 }
1176 return ret;
1177}
1178
1179static int acpi_battery_add(struct acpi_device *device)
1180{
1181 int result = 0;
1182 struct acpi_battery *battery = NULL;
1183
1184 if (!device)
1185 return -EINVAL;
1186
1187 if (device->dep_unmet)
1188 return -EPROBE_DEFER;
1189
1190 battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL);
1191 if (!battery)
1192 return -ENOMEM;
1193 battery->device = device;
1194 strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME);
1195 strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS);
1196 device->driver_data = battery;
1197 mutex_init(&battery->lock);
1198 mutex_init(&battery->sysfs_lock);
1199 if (acpi_has_method(battery->device->handle, "_BIX"))
1200 set_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags);
1201
1202 result = acpi_battery_update_retry(battery);
1203 if (result)
1204 goto fail;
1205
1206#ifdef CONFIG_ACPI_PROCFS_POWER
1207 result = acpi_battery_add_fs(device);
1208#endif
1209 if (result) {
1210#ifdef CONFIG_ACPI_PROCFS_POWER
1211 acpi_battery_remove_fs(device);
1212#endif
1213 goto fail;
1214 }
1215
1216 printk(KERN_INFO PREFIX "%s Slot [%s] (battery %s)\n",
1217 ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device),
1218 device->status.battery_present ? "present" : "absent");
1219
1220 battery->pm_nb.notifier_call = battery_notify;
1221 register_pm_notifier(&battery->pm_nb);
1222
1223 device_init_wakeup(&device->dev, 1);
1224
1225 return result;
1226
1227fail:
1228 sysfs_remove_battery(battery);
1229 mutex_destroy(&battery->lock);
1230 mutex_destroy(&battery->sysfs_lock);
1231 kfree(battery);
1232 return result;
1233}
1234
1235static int acpi_battery_remove(struct acpi_device *device)
1236{
1237 struct acpi_battery *battery = NULL;
1238
1239 if (!device || !acpi_driver_data(device))
1240 return -EINVAL;
1241 device_init_wakeup(&device->dev, 0);
1242 battery = acpi_driver_data(device);
1243 unregister_pm_notifier(&battery->pm_nb);
1244#ifdef CONFIG_ACPI_PROCFS_POWER
1245 acpi_battery_remove_fs(device);
1246#endif
1247 sysfs_remove_battery(battery);
1248 mutex_destroy(&battery->lock);
1249 mutex_destroy(&battery->sysfs_lock);
1250 kfree(battery);
1251 return 0;
1252}
1253
1254#ifdef CONFIG_PM_SLEEP
1255/* this is needed to learn about changes made in suspended state */
1256static int acpi_battery_resume(struct device *dev)
1257{
1258 struct acpi_battery *battery;
1259
1260 if (!dev)
1261 return -EINVAL;
1262
1263 battery = acpi_driver_data(to_acpi_device(dev));
1264 if (!battery)
1265 return -EINVAL;
1266
1267 battery->update_time = 0;
1268 acpi_battery_update(battery, true);
1269 return 0;
1270}
1271#else
1272#define acpi_battery_resume NULL
1273#endif
1274
1275static SIMPLE_DEV_PM_OPS(acpi_battery_pm, NULL, acpi_battery_resume);
1276
1277static struct acpi_driver acpi_battery_driver = {
1278 .name = "battery",
1279 .class = ACPI_BATTERY_CLASS,
1280 .ids = battery_device_ids,
1281 .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
1282 .ops = {
1283 .add = acpi_battery_add,
1284 .remove = acpi_battery_remove,
1285 .notify = acpi_battery_notify,
1286 },
1287 .drv.pm = &acpi_battery_pm,
1288};
1289
1290static void __init acpi_battery_init_async(void *unused, async_cookie_t cookie)
1291{
1292 int result;
1293
1294 dmi_check_system(bat_dmi_table);
1295
1296#ifdef CONFIG_ACPI_PROCFS_POWER
1297 acpi_battery_dir = acpi_lock_battery_dir();
1298 if (!acpi_battery_dir)
1299 return;
1300#endif
1301 result = acpi_bus_register_driver(&acpi_battery_driver);
1302#ifdef CONFIG_ACPI_PROCFS_POWER
1303 if (result < 0)
1304 acpi_unlock_battery_dir(acpi_battery_dir);
1305#endif
1306}
1307
1308static int __init acpi_battery_init(void)
1309{
1310 if (acpi_disabled)
1311 return -ENODEV;
1312
1313 async_cookie = async_schedule(acpi_battery_init_async, NULL);
1314 return 0;
1315}
1316
1317static void __exit acpi_battery_exit(void)
1318{
1319 async_synchronize_cookie(async_cookie);
1320 acpi_bus_unregister_driver(&acpi_battery_driver);
1321#ifdef CONFIG_ACPI_PROCFS_POWER
1322 acpi_unlock_battery_dir(acpi_battery_dir);
1323#endif
1324}
1325
1326module_init(acpi_battery_init);
1327module_exit(acpi_battery_exit);