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