]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blame - drivers/acpi/battery.c
projects / mirror_ubuntu-artful-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ACPI / AC: fix AC driver compile error when CONFIG_PM_SLEEP is undefined
[mirror_ubuntu-artful-kernel.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 *
21 * You should have received a copy of the GNU General Public License along
22 * with this program; if not, write to the Free Software Foundation, Inc.,
23 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
24 *
25 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
26 */
27
28#include <linux/kernel.h>
29#include <linux/module.h>
30#include <linux/init.h>
31#include <linux/types.h>
f1d4661a 32#include <linux/jiffies.h>
0f66af53 33#include <linux/async.h>
bc76f90b 34#include <linux/dmi.h>
5a0e3ad6 35#include <linux/slab.h>
25be5821 36#include <linux/suspend.h>
4000e626 37#include <asm/unaligned.h>
d7380965 38
8b48463f 39#include <linux/acpi.h>
d7380965
AS		 40#include <linux/power_supply.h>
41
a192a958
LB		 42#define PREFIX "ACPI: "
43
1da177e4
LT		 44#define ACPI_BATTERY_VALUE_UNKNOWN 0xFFFFFFFF
45
1da177e4 46#define ACPI_BATTERY_CLASS "battery"
1da177e4 47#define ACPI_BATTERY_DEVICE_NAME "Battery"
1da177e4
LT		 48#define ACPI_BATTERY_NOTIFY_STATUS 0x80
49#define ACPI_BATTERY_NOTIFY_INFO 0x81
c67fcd67 50#define ACPI_BATTERY_NOTIFY_THRESHOLD 0x82
1da177e4 51
ae6f6187
LT		 52/* Battery power unit: 0 means mW, 1 means mA */
53#define ACPI_BATTERY_POWER_UNIT_MA 1
54
1da177e4 55#define _COMPONENT ACPI_BATTERY_COMPONENT
b6ce4083 56
f52fd66d 57ACPI_MODULE_NAME("battery");
1da177e4 58
f52fd66d 59MODULE_AUTHOR("Paul Diefenbaugh");
aa650bbd 60MODULE_AUTHOR("Alexey Starikovskiy <astarikovskiy@suse.de>");
7cda93e0 61MODULE_DESCRIPTION("ACPI Battery Driver");
1da177e4
LT		 62MODULE_LICENSE("GPL");
63
a90b4038 64static int battery_bix_broken_package;
f1d4661a
AS		 65static unsigned int cache_time = 1000;
66module_param(cache_time, uint, 0644);
67MODULE_PARM_DESC(cache_time, "cache time in milliseconds");
b6ce4083 68
1ba90e3a
TR		 69static const struct acpi_device_id battery_device_ids[] = {
70 {"PNP0C0A", 0},
71 {"", 0},
72};
1ba90e3a 73
aa650bbd 74MODULE_DEVICE_TABLE(acpi, battery_device_ids);
1da177e4 75
7b3bcc4a
AS		 76enum {
77 ACPI_BATTERY_ALARM_PRESENT,
c67fcd67 78 ACPI_BATTERY_XINFO_PRESENT,
557d5868 79 ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY,
4000e626
KI		 80 /* On Lenovo Thinkpad models from 2010 and 2011, the power unit
81 switches between mWh and mAh depending on whether the system
82 is running on battery or not. When mAh is the unit, most
83 reported values are incorrect and need to be adjusted by
84 10000/design_voltage. Verified on x201, t410, t410s, and x220.
85 Pre-2010 and 2012 models appear to always report in mWh and
86 are thus unaffected (tested with t42, t61, t500, x200, x300,
87 and x230). Also, in mid-2012 Lenovo issued a BIOS update for
88 the 2011 models that fixes the issue (tested on x220 with a
89 post-1.29 BIOS), but as of Nov. 2012, no such update is
90 available for the 2010 models. */
91 ACPI_BATTERY_QUIRK_THINKPAD_MAH,
7b3bcc4a 92};
78490d82 93
1da177e4 94struct acpi_battery {
038fdea2 95 struct mutex lock;
69d94ec6 96 struct mutex sysfs_lock;
d7380965 97 struct power_supply bat;
f1d4661a 98 struct acpi_device *device;
25be5821 99 struct notifier_block pm_nb;
f1d4661a 100 unsigned long update_time;
016d5baa 101 int revision;
7faa144a 102 int rate_now;
d7380965
AS		 103 int capacity_now;
104 int voltage_now;
038fdea2 105 int design_capacity;
d7380965 106 int full_charge_capacity;
038fdea2
AS		 107 int technology;
108 int design_voltage;
109 int design_capacity_warning;
110 int design_capacity_low;
c67fcd67
AS		 111 int cycle_count;
112 int measurement_accuracy;
113 int max_sampling_time;
114 int min_sampling_time;
115 int max_averaging_interval;
116 int min_averaging_interval;
038fdea2
AS		 117 int capacity_granularity_1;
118 int capacity_granularity_2;
f1d4661a 119 int alarm;
038fdea2
AS		 120 char model_number[32];
121 char serial_number[32];
122 char type[32];
123 char oem_info[32];
f1d4661a
AS		 124 int state;
125 int power_unit;
7b3bcc4a 126 unsigned long flags;
1da177e4
LT		 127};
128
497888cf 129#define to_acpi_battery(x) container_of(x, struct acpi_battery, bat)
d7380965 130
efd941f1 131static inline int acpi_battery_present(struct acpi_battery *battery)
b6ce4083 132{
78490d82
AS		 133 return battery->device->status.battery_present;
134}
038fdea2 135
d7380965
AS		 136static int acpi_battery_technology(struct acpi_battery *battery)
137{
138 if (!strcasecmp("NiCd", battery->type))
139 return POWER_SUPPLY_TECHNOLOGY_NiCd;
140 if (!strcasecmp("NiMH", battery->type))
141 return POWER_SUPPLY_TECHNOLOGY_NiMH;
142 if (!strcasecmp("LION", battery->type))
143 return POWER_SUPPLY_TECHNOLOGY_LION;
ad40e68b 144 if (!strncasecmp("LI-ION", battery->type, 6))
0bde7eee 145 return POWER_SUPPLY_TECHNOLOGY_LION;
d7380965
AS		 146 if (!strcasecmp("LiP", battery->type))
147 return POWER_SUPPLY_TECHNOLOGY_LIPO;
148 return POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
149}
150
9104476e 151static int acpi_battery_get_state(struct acpi_battery *battery);
b19073a0 152
56f382a0
RH		 153static int acpi_battery_is_charged(struct acpi_battery *battery)
154{
155 /* either charging or discharging */
156 if (battery->state != 0)
157 return 0;
158
159 /* battery not reporting charge */
160 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN ||
161 battery->capacity_now == 0)
162 return 0;
163
164 /* good batteries update full_charge as the batteries degrade */
165 if (battery->full_charge_capacity == battery->capacity_now)
166 return 1;
167
168 /* fallback to using design values for broken batteries */
169 if (battery->design_capacity == battery->capacity_now)
170 return 1;
171
172 /* we don't do any sort of metric based on percentages */
173 return 0;
174}
175
d7380965
AS		 176static int acpi_battery_get_property(struct power_supply *psy,
177 enum power_supply_property psp,
178 union power_supply_propval *val)
179{
a1b4bd69 180 int ret = 0;
d7380965
AS		 181 struct acpi_battery *battery = to_acpi_battery(psy);
182
9104476e
AS		 183 if (acpi_battery_present(battery)) {
184 /* run battery update only if it is present */
185 acpi_battery_get_state(battery);
186 } else if (psp != POWER_SUPPLY_PROP_PRESENT)
d7380965
AS		 187 return -ENODEV;
188 switch (psp) {
189 case POWER_SUPPLY_PROP_STATUS:
190 if (battery->state & 0x01)
191 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
192 else if (battery->state & 0x02)
193 val->intval = POWER_SUPPLY_STATUS_CHARGING;
56f382a0 194 else if (acpi_battery_is_charged(battery))
d7380965 195 val->intval = POWER_SUPPLY_STATUS_FULL;
4c41d3ad
RD		 196 else
197 val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
d7380965
AS		 198 break;
199 case POWER_SUPPLY_PROP_PRESENT:
200 val->intval = acpi_battery_present(battery);
201 break;
202 case POWER_SUPPLY_PROP_TECHNOLOGY:
203 val->intval = acpi_battery_technology(battery);
204 break;
c67fcd67
AS		 205 case POWER_SUPPLY_PROP_CYCLE_COUNT:
206 val->intval = battery->cycle_count;
207 break;
d7380965 208 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
a1b4bd69
RW		 209 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
210 ret = -ENODEV;
211 else
212 val->intval = battery->design_voltage * 1000;
d7380965
AS		 213 break;
214 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
a1b4bd69
RW		 215 if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
216 ret = -ENODEV;
217 else
218 val->intval = battery->voltage_now * 1000;
d7380965
AS		 219 break;
220 case POWER_SUPPLY_PROP_CURRENT_NOW:
7faa144a 221 case POWER_SUPPLY_PROP_POWER_NOW:
a1b4bd69
RW		 222 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
223 ret = -ENODEV;
224 else
225 val->intval = battery->rate_now * 1000;
d7380965
AS		 226 break;
227 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
228 case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
a1b4bd69
RW		 229 if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
230 ret = -ENODEV;
231 else
232 val->intval = battery->design_capacity * 1000;
d7380965
AS		 233 break;
234 case POWER_SUPPLY_PROP_CHARGE_FULL:
235 case POWER_SUPPLY_PROP_ENERGY_FULL:
a1b4bd69
RW		 236 if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
237 ret = -ENODEV;
238 else
239 val->intval = battery->full_charge_capacity * 1000;
d7380965
AS		 240 break;
241 case POWER_SUPPLY_PROP_CHARGE_NOW:
242 case POWER_SUPPLY_PROP_ENERGY_NOW:
a1b4bd69
RW		 243 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
244 ret = -ENODEV;
245 else
246 val->intval = battery->capacity_now * 1000;
d7380965 247 break;
a58e1150 248 case POWER_SUPPLY_PROP_CAPACITY:
249 if (battery->capacity_now && battery->full_charge_capacity)
250 val->intval = battery->capacity_now * 100/
251 battery->full_charge_capacity;
252 else
253 val->intval = 0;
254 break;
d7380965
AS		 255 case POWER_SUPPLY_PROP_MODEL_NAME:
256 val->strval = battery->model_number;
257 break;
258 case POWER_SUPPLY_PROP_MANUFACTURER:
259 val->strval = battery->oem_info;
260 break;
7c2670bb 261 case POWER_SUPPLY_PROP_SERIAL_NUMBER:
262 val->strval = battery->serial_number;
263 break;
d7380965 264 default:
a1b4bd69 265 ret = -EINVAL;
d7380965 266 }
a1b4bd69 267 return ret;
d7380965
AS		 268}
269
270static enum power_supply_property charge_battery_props[] = {
271 POWER_SUPPLY_PROP_STATUS,
272 POWER_SUPPLY_PROP_PRESENT,
273 POWER_SUPPLY_PROP_TECHNOLOGY,
c67fcd67 274 POWER_SUPPLY_PROP_CYCLE_COUNT,
d7380965
AS		 275 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
276 POWER_SUPPLY_PROP_VOLTAGE_NOW,
277 POWER_SUPPLY_PROP_CURRENT_NOW,
278 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
279 POWER_SUPPLY_PROP_CHARGE_FULL,
280 POWER_SUPPLY_PROP_CHARGE_NOW,
a58e1150 281 POWER_SUPPLY_PROP_CAPACITY,
d7380965
AS		 282 POWER_SUPPLY_PROP_MODEL_NAME,
283 POWER_SUPPLY_PROP_MANUFACTURER,
7c2670bb 284 POWER_SUPPLY_PROP_SERIAL_NUMBER,
d7380965
AS		 285};
286
287static enum power_supply_property energy_battery_props[] = {
288 POWER_SUPPLY_PROP_STATUS,
289 POWER_SUPPLY_PROP_PRESENT,
290 POWER_SUPPLY_PROP_TECHNOLOGY,
c67fcd67 291 POWER_SUPPLY_PROP_CYCLE_COUNT,
d7380965
AS		 292 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
293 POWER_SUPPLY_PROP_VOLTAGE_NOW,
7faa144a 294 POWER_SUPPLY_PROP_POWER_NOW,
d7380965
AS		 295 POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
296 POWER_SUPPLY_PROP_ENERGY_FULL,
297 POWER_SUPPLY_PROP_ENERGY_NOW,
a58e1150 298 POWER_SUPPLY_PROP_CAPACITY,
d7380965
AS		 299 POWER_SUPPLY_PROP_MODEL_NAME,
300 POWER_SUPPLY_PROP_MANUFACTURER,
7c2670bb 301 POWER_SUPPLY_PROP_SERIAL_NUMBER,
d7380965
AS		 302};
303
78490d82
AS		 304/* --------------------------------------------------------------------------
305 Battery Management
306 -------------------------------------------------------------------------- */
038fdea2
AS		 307struct acpi_offsets {
308 size_t offset; /* offset inside struct acpi_sbs_battery */
309 u8 mode; /* int or string? */
310};
b6ce4083 311
038fdea2
AS		 312static struct acpi_offsets state_offsets[] = {
313 {offsetof(struct acpi_battery, state), 0},
7faa144a 314 {offsetof(struct acpi_battery, rate_now), 0},
d7380965
AS		 315 {offsetof(struct acpi_battery, capacity_now), 0},
316 {offsetof(struct acpi_battery, voltage_now), 0},
038fdea2 317};
b6ce4083 318
038fdea2
AS		 319static struct acpi_offsets info_offsets[] = {
320 {offsetof(struct acpi_battery, power_unit), 0},
321 {offsetof(struct acpi_battery, design_capacity), 0},
d7380965 322 {offsetof(struct acpi_battery, full_charge_capacity), 0},
038fdea2
AS		 323 {offsetof(struct acpi_battery, technology), 0},
324 {offsetof(struct acpi_battery, design_voltage), 0},
325 {offsetof(struct acpi_battery, design_capacity_warning), 0},
326 {offsetof(struct acpi_battery, design_capacity_low), 0},
327 {offsetof(struct acpi_battery, capacity_granularity_1), 0},
328 {offsetof(struct acpi_battery, capacity_granularity_2), 0},
329 {offsetof(struct acpi_battery, model_number), 1},
330 {offsetof(struct acpi_battery, serial_number), 1},
331 {offsetof(struct acpi_battery, type), 1},
332 {offsetof(struct acpi_battery, oem_info), 1},
333};
b6ce4083 334
c67fcd67 335static struct acpi_offsets extended_info_offsets[] = {
016d5baa 336 {offsetof(struct acpi_battery, revision), 0},
c67fcd67
AS		 337 {offsetof(struct acpi_battery, power_unit), 0},
338 {offsetof(struct acpi_battery, design_capacity), 0},
339 {offsetof(struct acpi_battery, full_charge_capacity), 0},
340 {offsetof(struct acpi_battery, technology), 0},
341 {offsetof(struct acpi_battery, design_voltage), 0},
342 {offsetof(struct acpi_battery, design_capacity_warning), 0},
343 {offsetof(struct acpi_battery, design_capacity_low), 0},
344 {offsetof(struct acpi_battery, cycle_count), 0},
345 {offsetof(struct acpi_battery, measurement_accuracy), 0},
346 {offsetof(struct acpi_battery, max_sampling_time), 0},
347 {offsetof(struct acpi_battery, min_sampling_time), 0},
348 {offsetof(struct acpi_battery, max_averaging_interval), 0},
349 {offsetof(struct acpi_battery, min_averaging_interval), 0},
350 {offsetof(struct acpi_battery, capacity_granularity_1), 0},
351 {offsetof(struct acpi_battery, capacity_granularity_2), 0},
352 {offsetof(struct acpi_battery, model_number), 1},
353 {offsetof(struct acpi_battery, serial_number), 1},
354 {offsetof(struct acpi_battery, type), 1},
355 {offsetof(struct acpi_battery, oem_info), 1},
356};
357
038fdea2
AS		 358static int extract_package(struct acpi_battery *battery,
359 union acpi_object *package,
360 struct acpi_offsets *offsets, int num)
361{
106449e8 362 int i;
038fdea2
AS		 363 union acpi_object *element;
364 if (package->type != ACPI_TYPE_PACKAGE)
365 return -EFAULT;
366 for (i = 0; i < num; ++i) {
367 if (package->package.count <= i)
368 return -EFAULT;
369 element = &package->package.elements[i];
370 if (offsets[i].mode) {
106449e8
AS		 371 u8 *ptr = (u8 *)battery + offsets[i].offset;
372 if (element->type == ACPI_TYPE_STRING ||
373 element->type == ACPI_TYPE_BUFFER)
374 strncpy(ptr, element->string.pointer, 32);
375 else if (element->type == ACPI_TYPE_INTEGER) {
376 strncpy(ptr, (u8 *)&element->integer.value,
439913ff
LM		 377 sizeof(u64));
378 ptr[sizeof(u64)] = 0;
b8a1bdb1
AS		 379 } else
380 *ptr = 0; /* don't have value */
038fdea2 381 } else {
b8a1bdb1
AS		 382 int *x = (int *)((u8 *)battery + offsets[i].offset);
383 *x = (element->type == ACPI_TYPE_INTEGER) ?
384 element->integer.value : -1;
038fdea2 385 }
b6ce4083 386 }
b6ce4083
VL		 387 return 0;
388}
389
390static int acpi_battery_get_status(struct acpi_battery *battery)
391{
aa650bbd 392 if (acpi_bus_get_status(battery->device)) {
b6ce4083
VL		 393 ACPI_EXCEPTION((AE_INFO, AE_ERROR, "Evaluating _STA"));
394 return -ENODEV;
395 }
aa650bbd 396 return 0;
b6ce4083
VL		 397}
398
399static int acpi_battery_get_info(struct acpi_battery *battery)
1da177e4 400{
aa650bbd 401 int result = -EFAULT;
4be44fcd 402 acpi_status status = 0;
0f4c6547 403 char *name = test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags) ?
c67fcd67
AS		 404 "_BIX" : "_BIF";
405
4be44fcd 406 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
1da177e4 407
b6ce4083
VL		 408 if (!acpi_battery_present(battery))
409 return 0;
038fdea2 410 mutex_lock(&battery->lock);
c67fcd67
AS		 411 status = acpi_evaluate_object(battery->device->handle, name,
412 NULL, &buffer);
038fdea2 413 mutex_unlock(&battery->lock);
aa650bbd 414
1da177e4 415 if (ACPI_FAILURE(status)) {
c67fcd67 416 ACPI_EXCEPTION((AE_INFO, status, "Evaluating %s", name));
d550d98d 417 return -ENODEV;
1da177e4 418 }
a90b4038
LT		 419
420 if (battery_bix_broken_package)
421 result = extract_package(battery, buffer.pointer,
422 extended_info_offsets + 1,
423 ARRAY_SIZE(extended_info_offsets) - 1);
424 else if (test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags))
c67fcd67
AS		 425 result = extract_package(battery, buffer.pointer,
426 extended_info_offsets,
427 ARRAY_SIZE(extended_info_offsets));
428 else
429 result = extract_package(battery, buffer.pointer,
430 info_offsets, ARRAY_SIZE(info_offsets));
78490d82 431 kfree(buffer.pointer);
557d5868
ZR		 432 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
433 battery->full_charge_capacity = battery->design_capacity;
4000e626
KI		 434 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
435 battery->power_unit && battery->design_voltage) {
436 battery->design_capacity = battery->design_capacity *
437 10000 / battery->design_voltage;
438 battery->full_charge_capacity = battery->full_charge_capacity *
439 10000 / battery->design_voltage;
440 battery->design_capacity_warning =
441 battery->design_capacity_warning *
442 10000 / battery->design_voltage;
443 /* Curiously, design_capacity_low, unlike the rest of them,
444 is correct. */
445 /* capacity_granularity_* equal 1 on the systems tested, so
446 it's impossible to tell if they would need an adjustment
447 or not if their values were higher. */
448 }
d550d98d 449 return result;
1da177e4
LT		 450}
451
b6ce4083 452static int acpi_battery_get_state(struct acpi_battery *battery)
1da177e4 453{
4be44fcd
LB		 454 int result = 0;
455 acpi_status status = 0;
456 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
1da177e4 457
b6ce4083
VL		 458 if (!acpi_battery_present(battery))
459 return 0;
1da177e4 460
f1d4661a
AS		 461 if (battery->update_time &&
462 time_before(jiffies, battery->update_time +
463 msecs_to_jiffies(cache_time)))
464 return 0;
465
038fdea2 466 mutex_lock(&battery->lock);
f1d4661a 467 status = acpi_evaluate_object(battery->device->handle, "_BST",
038fdea2
AS		 468 NULL, &buffer);
469 mutex_unlock(&battery->lock);
5b31d895 470
1da177e4 471 if (ACPI_FAILURE(status)) {
a6fc6720 472 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BST"));
d550d98d 473 return -ENODEV;
1da177e4 474 }
aa650bbd 475
038fdea2
AS		 476 result = extract_package(battery, buffer.pointer,
477 state_offsets, ARRAY_SIZE(state_offsets));
f1d4661a 478 battery->update_time = jiffies;
78490d82 479 kfree(buffer.pointer);
bc76f90b 480
55003b21
LT		 481 /* For buggy DSDTs that report negative 16-bit values for either
482 * charging or discharging current and/or report 0 as 65536
483 * due to bad math.
484 */
485 if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA &&
486 battery->rate_now != ACPI_BATTERY_VALUE_UNKNOWN &&
487 (s16)(battery->rate_now) < 0) {
bc76f90b 488 battery->rate_now = abs((s16)battery->rate_now);
55003b21
LT		 489 printk_once(KERN_WARNING FW_BUG "battery: (dis)charge rate"
490 " invalid.\n");
491 }
bc76f90b 492
557d5868
ZR		 493 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags)
494 && battery->capacity_now >= 0 && battery->capacity_now <= 100)
495 battery->capacity_now = (battery->capacity_now *
496 battery->full_charge_capacity) / 100;
4000e626
KI		 497 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
498 battery->power_unit && battery->design_voltage) {
499 battery->capacity_now = battery->capacity_now *
500 10000 / battery->design_voltage;
501 }
b6ce4083
VL		 502 return result;
503}
1da177e4 504
aa650bbd 505static int acpi_battery_set_alarm(struct acpi_battery *battery)
1da177e4 506{
4be44fcd 507 acpi_status status = 0;
1da177e4 508
c67fcd67 509 if (!acpi_battery_present(battery) ||
7b3bcc4a 510 !test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags))
d550d98d 511 return -ENODEV;
1da177e4 512
038fdea2 513 mutex_lock(&battery->lock);
0db98202
JL		 514 status = acpi_execute_simple_method(battery->device->handle, "_BTP",
515 battery->alarm);
038fdea2 516 mutex_unlock(&battery->lock);
aa650bbd 517
1da177e4 518 if (ACPI_FAILURE(status))
d550d98d 519 return -ENODEV;
1da177e4 520
aa650bbd 521 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Alarm set to %d\n", battery->alarm));
d550d98d 522 return 0;
1da177e4
LT		 523}
524
b6ce4083 525static int acpi_battery_init_alarm(struct acpi_battery *battery)
1da177e4 526{
b6ce4083 527 /* See if alarms are supported, and if so, set default */
952c63e9 528 if (!acpi_has_method(battery->device->handle, "_BTP")) {
7b3bcc4a 529 clear_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
f1d4661a 530 return 0;
b6ce4083 531 }
7b3bcc4a 532 set_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
f1d4661a
AS		 533 if (!battery->alarm)
534 battery->alarm = battery->design_capacity_warning;
aa650bbd 535 return acpi_battery_set_alarm(battery);
b6ce4083 536}
1da177e4 537
508df92d
AB		 538static ssize_t acpi_battery_alarm_show(struct device *dev,
539 struct device_attribute *attr,
540 char *buf)
541{
542 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
543 return sprintf(buf, "%d\n", battery->alarm * 1000);
544}
545
546static ssize_t acpi_battery_alarm_store(struct device *dev,
547 struct device_attribute *attr,
548 const char *buf, size_t count)
549{
550 unsigned long x;
551 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
47a08c85 552 if (sscanf(buf, "%lu\n", &x) == 1)
508df92d
AB		 553 battery->alarm = x/1000;
554 if (acpi_battery_present(battery))
555 acpi_battery_set_alarm(battery);
556 return count;
557}
558
559static struct device_attribute alarm_attr = {
01e8ef11 560 .attr = {.name = "alarm", .mode = 0644},
508df92d
AB		 561 .show = acpi_battery_alarm_show,
562 .store = acpi_battery_alarm_store,
563};
564
565static int sysfs_add_battery(struct acpi_battery *battery)
566{
567 int result;
568
ae6f6187 569 if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) {
508df92d
AB		 570 battery->bat.properties = charge_battery_props;
571 battery->bat.num_properties =
572 ARRAY_SIZE(charge_battery_props);
573 } else {
574 battery->bat.properties = energy_battery_props;
575 battery->bat.num_properties =
576 ARRAY_SIZE(energy_battery_props);
577 }
578
579 battery->bat.name = acpi_device_bid(battery->device);
580 battery->bat.type = POWER_SUPPLY_TYPE_BATTERY;
581 battery->bat.get_property = acpi_battery_get_property;
582
583 result = power_supply_register(&battery->device->dev, &battery->bat);
584 if (result)
585 return result;
586 return device_create_file(battery->bat.dev, &alarm_attr);
587}
588
589static void sysfs_remove_battery(struct acpi_battery *battery)
590{
69d94ec6 591 mutex_lock(&battery->sysfs_lock);
9c921c22 592 if (!battery->bat.dev) {
69d94ec6 593 mutex_unlock(&battery->sysfs_lock);
508df92d 594 return;
9c921c22
LT		 595 }
596
508df92d
AB		 597 device_remove_file(battery->bat.dev, &alarm_attr);
598 power_supply_unregister(&battery->bat);
9104476e 599 battery->bat.dev = NULL;
69d94ec6 600 mutex_unlock(&battery->sysfs_lock);
bc76f90b
HM		 601}
602
4000e626
KI		 603static void find_battery(const struct dmi_header *dm, void *private)
604{
605 struct acpi_battery *battery = (struct acpi_battery *)private;
606 /* Note: the hardcoded offsets below have been extracted from
607 the source code of dmidecode. */
608 if (dm->type == DMI_ENTRY_PORTABLE_BATTERY && dm->length >= 8) {
609 const u8 *dmi_data = (const u8 *)(dm + 1);
610 int dmi_capacity = get_unaligned((const u16 *)(dmi_data + 6));
611 if (dm->length >= 18)
612 dmi_capacity *= dmi_data[17];
613 if (battery->design_capacity * battery->design_voltage / 1000
614 != dmi_capacity &&
615 battery->design_capacity * 10 == dmi_capacity)
616 set_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
617 &battery->flags);
618 }
619}
620
557d5868
ZR		 621/*
622 * According to the ACPI spec, some kinds of primary batteries can
623 * report percentage battery remaining capacity directly to OS.
624 * In this case, it reports the Last Full Charged Capacity == 100
625 * and BatteryPresentRate == 0xFFFFFFFF.
626 *
627 * Now we found some battery reports percentage remaining capacity
628 * even if it's rechargeable.
629 * https://bugzilla.kernel.org/show_bug.cgi?id=15979
630 *
631 * Handle this correctly so that they won't break userspace.
632 */
7b78622d 633static void acpi_battery_quirks(struct acpi_battery *battery)
557d5868
ZR		 634{
635 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
0f4c6547 636 return;
557d5868 637
0f4c6547
NM		 638 if (battery->full_charge_capacity == 100 &&
639 battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN &&
640 battery->capacity_now >= 0 && battery->capacity_now <= 100) {
557d5868
ZR		 641 set_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags);
642 battery->full_charge_capacity = battery->design_capacity;
643 battery->capacity_now = (battery->capacity_now *
644 battery->full_charge_capacity) / 100;
645 }
4000e626
KI		 646
647 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags))
0f4c6547 648 return;
4000e626
KI		 649
650 if (battery->power_unit && dmi_name_in_vendors("LENOVO")) {
651 const char *s;
652 s = dmi_get_system_info(DMI_PRODUCT_VERSION);
653 if (s && !strnicmp(s, "ThinkPad", 8)) {
654 dmi_walk(find_battery, battery);
655 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
656 &battery->flags) &&
657 battery->design_voltage) {
658 battery->design_capacity =
659 battery->design_capacity *
660 10000 / battery->design_voltage;
661 battery->full_charge_capacity =
662 battery->full_charge_capacity *
663 10000 / battery->design_voltage;
664 battery->design_capacity_warning =
665 battery->design_capacity_warning *
666 10000 / battery->design_voltage;
667 battery->capacity_now = battery->capacity_now *
668 10000 / battery->design_voltage;
669 }
670 }
671 }
557d5868
ZR		 672}
673
f1d4661a 674static int acpi_battery_update(struct acpi_battery *battery)
b6ce4083 675{
50b17851 676 int result, old_present = acpi_battery_present(battery);
97749cd9 677 result = acpi_battery_get_status(battery);
508df92d 678 if (result)
b6ce4083 679 return result;
508df92d
AB		 680 if (!acpi_battery_present(battery)) {
681 sysfs_remove_battery(battery);
97749cd9 682 battery->update_time = 0;
508df92d 683 return 0;
b6ce4083 684 }
50b17851
AS		 685 if (!battery->update_time ||
686 old_present != acpi_battery_present(battery)) {
97749cd9
AS		 687 result = acpi_battery_get_info(battery);
688 if (result)
689 return result;
690 acpi_battery_init_alarm(battery);
691 }
eb03cb02
SH		 692 if (!battery->bat.dev) {
693 result = sysfs_add_battery(battery);
694 if (result)
695 return result;
696 }
557d5868 697 result = acpi_battery_get_state(battery);
7b78622d 698 acpi_battery_quirks(battery);
557d5868 699 return result;
4bd35cdb
VL		 700}
701
da8aeb92
RW		 702static void acpi_battery_refresh(struct acpi_battery *battery)
703{
c5971456
AW		 704 int power_unit;
705
da8aeb92
RW		 706 if (!battery->bat.dev)
707 return;
708
c5971456
AW		 709 power_unit = battery->power_unit;
710
da8aeb92 711 acpi_battery_get_info(battery);
c5971456
AW		 712
713 if (power_unit == battery->power_unit)
714 return;
715
716 /* The battery has changed its reporting units. */
da8aeb92
RW		 717 sysfs_remove_battery(battery);
718 sysfs_add_battery(battery);
719}
720
1da177e4
LT		 721/* --------------------------------------------------------------------------
722 Driver Interface
723 -------------------------------------------------------------------------- */
724
d9406691 725static void acpi_battery_notify(struct acpi_device *device, u32 event)
1da177e4 726{
d9406691 727 struct acpi_battery *battery = acpi_driver_data(device);
153e500f 728 struct device *old;
d9406691 729
1da177e4 730 if (!battery)
d550d98d 731 return;
153e500f 732 old = battery->bat.dev;
da8aeb92
RW		 733 if (event == ACPI_BATTERY_NOTIFY_INFO)
734 acpi_battery_refresh(battery);
f1d4661a 735 acpi_battery_update(battery);
f1d4661a 736 acpi_bus_generate_netlink_event(device->pnp.device_class,
0794469d 737 dev_name(&device->dev), event,
9ea7d575 738 acpi_battery_present(battery));
2345baf4 739 /* acpi_battery_update could remove power_supply object */
153e500f 740 if (old && battery->bat.dev)
f79e1cec 741 power_supply_changed(&battery->bat);
1da177e4
LT		 742}
743
25be5821
KM		 744static int battery_notify(struct notifier_block *nb,
745 unsigned long mode, void *_unused)
746{
747 struct acpi_battery *battery = container_of(nb, struct acpi_battery,
748 pm_nb);
749 switch (mode) {
d5a5911b 750 case PM_POST_HIBERNATION:
25be5821 751 case PM_POST_SUSPEND:
6e17fb6a
LT		 752 if (battery->bat.dev) {
753 sysfs_remove_battery(battery);
754 sysfs_add_battery(battery);
755 }
25be5821
KM		 756 break;
757 }
758
759 return 0;
760}
761
a90b4038
LT		 762static struct dmi_system_id bat_dmi_table[] = {
763 {
764 .ident = "NEC LZ750/LS",
765 .matches = {
766 DMI_MATCH(DMI_SYS_VENDOR, "NEC"),
767 DMI_MATCH(DMI_PRODUCT_NAME, "PC-LZ750LS"),
768 },
769 },
770 {},
771};
772
4be44fcd 773static int acpi_battery_add(struct acpi_device *device)
1da177e4 774{
4be44fcd 775 int result = 0;
4be44fcd 776 struct acpi_battery *battery = NULL;
952c63e9 777
1da177e4 778 if (!device)
d550d98d 779 return -EINVAL;
36bcbec7 780 battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL);
1da177e4 781 if (!battery)
d550d98d 782 return -ENOMEM;
145def84 783 battery->device = device;
1da177e4
LT		 784 strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME);
785 strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS);
db89b4f0 786 device->driver_data = battery;
038fdea2 787 mutex_init(&battery->lock);
69d94ec6 788 mutex_init(&battery->sysfs_lock);
952c63e9 789 if (acpi_has_method(battery->device->handle, "_BIX"))
c67fcd67 790 set_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags);
eb03cb02
SH		 791 result = acpi_battery_update(battery);
792 if (result)
793 goto fail;
25be5821 794
e80bba4b
SH		 795 printk(KERN_INFO PREFIX "%s Slot [%s] (battery %s)\n",
796 ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device),
797 device->status.battery_present ? "present" : "absent");
798
25be5821
KM		 799 battery->pm_nb.notifier_call = battery_notify;
800 register_pm_notifier(&battery->pm_nb);
801
d550d98d 802 return result;
e80bba4b
SH		 803
804fail:
805 sysfs_remove_battery(battery);
806 mutex_destroy(&battery->lock);
69d94ec6 807 mutex_destroy(&battery->sysfs_lock);
e80bba4b
SH		 808 kfree(battery);
809 return result;
1da177e4
LT		 810}
811
51fac838 812static int acpi_battery_remove(struct acpi_device *device)
1da177e4 813{
4be44fcd 814 struct acpi_battery *battery = NULL;
1da177e4 815
1da177e4 816 if (!device || !acpi_driver_data(device))
d550d98d 817 return -EINVAL;
50dd0969 818 battery = acpi_driver_data(device);
25be5821 819 unregister_pm_notifier(&battery->pm_nb);
508df92d 820 sysfs_remove_battery(battery);
038fdea2 821 mutex_destroy(&battery->lock);
69d94ec6 822 mutex_destroy(&battery->sysfs_lock);
1da177e4 823 kfree(battery);
d550d98d 824 return 0;
1da177e4
LT		 825}
826
90692404 827#ifdef CONFIG_PM_SLEEP
34c4415a 828/* this is needed to learn about changes made in suspended state */
a6f50dc8 829static int acpi_battery_resume(struct device *dev)
34c4415a
JK		 830{
831 struct acpi_battery *battery;
a6f50dc8
RW		 832
833 if (!dev)
34c4415a 834 return -EINVAL;
a6f50dc8
RW		 835
836 battery = acpi_driver_data(to_acpi_device(dev));
837 if (!battery)
838 return -EINVAL;
839
f1d4661a 840 battery->update_time = 0;
508df92d 841 acpi_battery_update(battery);
b6ce4083 842 return 0;
34c4415a 843}
90692404 844#endif
34c4415a 845
a6f50dc8
RW		 846static SIMPLE_DEV_PM_OPS(acpi_battery_pm, NULL, acpi_battery_resume);
847
aa650bbd
AS		 848static struct acpi_driver acpi_battery_driver = {
849 .name = "battery",
850 .class = ACPI_BATTERY_CLASS,
851 .ids = battery_device_ids,
d9406691 852 .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
aa650bbd
AS		 853 .ops = {
854 .add = acpi_battery_add,
aa650bbd 855 .remove = acpi_battery_remove,
d9406691 856 .notify = acpi_battery_notify,
aa650bbd 857 },
a6f50dc8 858 .drv.pm = &acpi_battery_pm,
aa650bbd
AS		 859};
860
b0cbc861 861static void __init acpi_battery_init_async(void *unused, async_cookie_t cookie)
1da177e4 862{
4d8316d5 863 if (acpi_disabled)
0f66af53 864 return;
a90b4038
LT		 865
866 if (dmi_check_system(bat_dmi_table))
867 battery_bix_broken_package = 1;
1e2d9cdf 868 acpi_bus_register_driver(&acpi_battery_driver);
0f66af53
AV		 869}
870
871static int __init acpi_battery_init(void)
872{
873 async_schedule(acpi_battery_init_async, NULL);
d550d98d 874 return 0;
1da177e4
LT		 875}
876
4be44fcd 877static void __exit acpi_battery_exit(void)
1da177e4 878{
1da177e4 879 acpi_bus_unregister_driver(&acpi_battery_driver);
1da177e4
LT		 880}
881
1da177e4
LT		 882module_init(acpi_battery_init);
883module_exit(acpi_battery_exit);
Ubuntu Artful kernel mirror