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