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