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