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