blob: ab234791a0ba6101eaff16798a0c425dd347a4bd [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +04002 * battery.c - ACPI Battery Driver (Revision: 2.0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 *
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +04004 * Copyright (C) 2007 Alexey Starikovskiy <astarikovskiy@suse.de>
5 * Copyright (C) 2004-2007 Vladimir Lebedev <vladimir.p.lebedev@intel.com>
Linus Torvalds1da177e2005-04-16 15:20:36 -07006 * 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 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070021 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
22 */
23
24#include <linux/kernel.h>
25#include <linux/module.h>
26#include <linux/init.h>
27#include <linux/types.h>
Alexey Starikovskiyf1d46612007-09-26 19:42:52 +040028#include <linux/jiffies.h>
Arjan van de Ven0f66af52009-01-10 14:19:05 -050029#include <linux/async.h>
Hector Martinbc76f902009-08-06 15:57:48 -070030#include <linux/dmi.h>
Alexander Mezinf43691c2014-06-04 02:01:23 +070031#include <linux/delay.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090032#include <linux/slab.h>
Kyle McMartin25be5822011-03-22 16:19:50 -040033#include <linux/suspend.h>
Kamil Iskra4000e622012-11-16 22:28:58 +010034#include <asm/unaligned.h>
Alexey Starikovskiyd7380962007-09-26 19:43:04 +040035
Lan Tianyu3a670cc2014-05-04 11:07:25 +080036#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
Lv Zheng8b484632013-12-03 08:49:16 +080042#include <linux/acpi.h>
Alexey Starikovskiyd7380962007-09-26 19:43:04 +040043#include <linux/power_supply.h>
44
Alexander Mezinf03be352014-03-12 00:58:46 +070045#include "battery.h"
46
Len Browna192a952009-07-28 16:45:54 -040047#define PREFIX "ACPI: "
48
Linus Torvalds1da177e2005-04-16 15:20:36 -070049#define ACPI_BATTERY_VALUE_UNKNOWN 0xFFFFFFFF
50
Linus Torvalds1da177e2005-04-16 15:20:36 -070051#define ACPI_BATTERY_DEVICE_NAME "Battery"
Linus Torvalds1da177e2005-04-16 15:20:36 -070052
Lan Tianyuae6f6182011-06-30 11:32:40 +080053/* Battery power unit: 0 means mW, 1 means mA */
54#define ACPI_BATTERY_POWER_UNIT_MA 1
55
Zhang Rui1ac5aaa2014-05-28 15:23:36 +080056#define ACPI_BATTERY_STATE_DISCHARGING 0x1
57#define ACPI_BATTERY_STATE_CHARGING 0x2
58#define ACPI_BATTERY_STATE_CRITICAL 0x4
59
Linus Torvalds1da177e2005-04-16 15:20:36 -070060#define _COMPONENT ACPI_BATTERY_COMPONENT
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +030061
Len Brownf52fd662007-02-12 22:42:12 -050062ACPI_MODULE_NAME("battery");
Linus Torvalds1da177e2005-04-16 15:20:36 -070063
Len Brownf52fd662007-02-12 22:42:12 -050064MODULE_AUTHOR("Paul Diefenbaugh");
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +040065MODULE_AUTHOR("Alexey Starikovskiy <astarikovskiy@suse.de>");
Len Brown7cda93e2007-02-12 23:50:02 -050066MODULE_DESCRIPTION("ACPI Battery Driver");
Linus Torvalds1da177e2005-04-16 15:20:36 -070067MODULE_LICENSE("GPL");
68
Luis Henriqueseca21d912015-05-11 22:49:05 +010069static async_cookie_t async_cookie;
Lan Tianyua90b4032014-01-06 22:50:37 +080070static int battery_bix_broken_package;
Alexander Mezinf43691c2014-06-04 02:01:23 +070071static int battery_notification_delay_ms;
Alexey Starikovskiyf1d46612007-09-26 19:42:52 +040072static unsigned int cache_time = 1000;
73module_param(cache_time, uint, 0644);
74MODULE_PARM_DESC(cache_time, "cache time in milliseconds");
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +030075
Lan Tianyu3a670cc2014-05-04 11:07:25 +080076#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
Alexey Starikovskiyd7380962007-09-26 19:43:04 +040089static const struct acpi_device_id battery_device_ids[] = {
90 {"PNP0C0A", 0},
91 {"", 0},
92};
93
94MODULE_DEVICE_TABLE(acpi, battery_device_ids);
95
Alexey Starikovskiy7b3bcc42009-10-15 14:31:24 +040096enum {
97 ACPI_BATTERY_ALARM_PRESENT,
Alexey Starikovskiyc67fcd62009-10-15 14:31:44 +040098 ACPI_BATTERY_XINFO_PRESENT,
Zhang Rui557d5862010-10-22 10:02:06 +080099 ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY,
Kamil Iskra4000e622012-11-16 22:28:58 +0100100 /* 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,
Alexey Starikovskiy7b3bcc42009-10-15 14:31:24 +0400112};
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400113
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400114struct acpi_battery {
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400115 struct mutex lock;
Sergey Senozhatsky69d94ec2011-08-06 01:34:08 +0300116 struct mutex sysfs_lock;
Krzysztof Kozlowski297d7162015-03-12 08:44:11 +0100117 struct power_supply *bat;
118 struct power_supply_desc bat_desc;
Alexey Starikovskiyf1d46612007-09-26 19:42:52 +0400119 struct acpi_device *device;
Kyle McMartin25be5822011-03-22 16:19:50 -0400120 struct notifier_block pm_nb;
Alexey Starikovskiyf1d46612007-09-26 19:42:52 +0400121 unsigned long update_time;
Lan Tianyu016d5ba2013-07-30 14:00:42 +0200122 int revision;
Alexey Starikovskiy7faa1442009-03-27 22:23:52 -0400123 int rate_now;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400124 int capacity_now;
125 int voltage_now;
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400126 int design_capacity;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400127 int full_charge_capacity;
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400128 int technology;
129 int design_voltage;
130 int design_capacity_warning;
131 int design_capacity_low;
Alexey Starikovskiyc67fcd62009-10-15 14:31:44 +0400132 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;
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400138 int capacity_granularity_1;
139 int capacity_granularity_2;
Alexey Starikovskiyf1d46612007-09-26 19:42:52 +0400140 int alarm;
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400141 char model_number[32];
142 char serial_number[32];
143 char type[32];
144 char oem_info[32];
Alexey Starikovskiyf1d46612007-09-26 19:42:52 +0400145 int state;
146 int power_unit;
Alexey Starikovskiy7b3bcc42009-10-15 14:31:24 +0400147 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148};
149
Krzysztof Kozlowski297d7162015-03-12 08:44:11 +0100150#define to_acpi_battery(x) power_supply_get_drvdata(x)
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400151
Andy Shevchenkoefd941f2013-03-11 09:17:06 +0000152static inline int acpi_battery_present(struct acpi_battery *battery)
Alexey Starikovskiy78490d82007-05-11 13:18:55 -0400153{
154 return battery->device->status.battery_present;
155}
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400156
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400157static 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;
Andrey Borzenkovad40e682007-11-10 20:02:49 +0300165 if (!strncasecmp("LI-ION", battery->type, 6))
Alexey Starikovskiy0bde7ee2007-10-28 15:33:10 +0300166 return POWER_SUPPLY_TECHNOLOGY_LION;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400167 if (!strcasecmp("LiP", battery->type))
168 return POWER_SUPPLY_TECHNOLOGY_LIPO;
169 return POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
170}
171
Alexey Starikovskiy91044762007-11-13 12:23:06 +0300172static int acpi_battery_get_state(struct acpi_battery *battery);
Alexey Starikovskiyb19073a2007-10-25 17:10:47 -0400173
Richard Hughes56f382a2009-01-25 15:05:50 +0000174static int acpi_battery_is_charged(struct acpi_battery *battery)
175{
Zhang Rui1ac5aaa2014-05-28 15:23:36 +0800176 /* charging, discharging or critical low */
Richard Hughes56f382a2009-01-25 15:05:50 +0000177 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
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400197static int acpi_battery_get_property(struct power_supply *psy,
198 enum power_supply_property psp,
199 union power_supply_propval *val)
200{
Rafael J. Wysockia1b4bd62010-10-23 19:35:15 +0200201 int ret = 0;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400202 struct acpi_battery *battery = to_acpi_battery(psy);
203
Alexey Starikovskiy91044762007-11-13 12:23:06 +0300204 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)
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400208 return -ENODEV;
209 switch (psp) {
210 case POWER_SUPPLY_PROP_STATUS:
Zhang Rui1ac5aaa2014-05-28 15:23:36 +0800211 if (battery->state & ACPI_BATTERY_STATE_DISCHARGING)
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400212 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
Zhang Rui1ac5aaa2014-05-28 15:23:36 +0800213 else if (battery->state & ACPI_BATTERY_STATE_CHARGING)
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400214 val->intval = POWER_SUPPLY_STATUS_CHARGING;
Richard Hughes56f382a2009-01-25 15:05:50 +0000215 else if (acpi_battery_is_charged(battery))
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400216 val->intval = POWER_SUPPLY_STATUS_FULL;
Roland Dreier4c41d3a2007-11-07 15:09:09 -0800217 else
218 val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400219 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;
Alexey Starikovskiyc67fcd62009-10-15 14:31:44 +0400226 case POWER_SUPPLY_PROP_CYCLE_COUNT:
227 val->intval = battery->cycle_count;
228 break;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400229 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
Rafael J. Wysockia1b4bd62010-10-23 19:35:15 +0200230 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
231 ret = -ENODEV;
232 else
233 val->intval = battery->design_voltage * 1000;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400234 break;
235 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
Rafael J. Wysockia1b4bd62010-10-23 19:35:15 +0200236 if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
237 ret = -ENODEV;
238 else
239 val->intval = battery->voltage_now * 1000;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400240 break;
241 case POWER_SUPPLY_PROP_CURRENT_NOW:
Alexey Starikovskiy7faa1442009-03-27 22:23:52 -0400242 case POWER_SUPPLY_PROP_POWER_NOW:
Rafael J. Wysockia1b4bd62010-10-23 19:35:15 +0200243 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
244 ret = -ENODEV;
245 else
246 val->intval = battery->rate_now * 1000;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400247 break;
248 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
249 case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
Rafael J. Wysockia1b4bd62010-10-23 19:35:15 +0200250 if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
251 ret = -ENODEV;
252 else
253 val->intval = battery->design_capacity * 1000;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400254 break;
255 case POWER_SUPPLY_PROP_CHARGE_FULL:
256 case POWER_SUPPLY_PROP_ENERGY_FULL:
Rafael J. Wysockia1b4bd62010-10-23 19:35:15 +0200257 if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
258 ret = -ENODEV;
259 else
260 val->intval = battery->full_charge_capacity * 1000;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400261 break;
262 case POWER_SUPPLY_PROP_CHARGE_NOW:
263 case POWER_SUPPLY_PROP_ENERGY_NOW:
Rafael J. Wysockia1b4bd62010-10-23 19:35:15 +0200264 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
265 ret = -ENODEV;
266 else
267 val->intval = battery->capacity_now * 1000;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400268 break;
srinivas pandruvadaa58e1152012-04-05 17:38:54 -0700269 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;
Zhang Rui1ac5aaa2014-05-28 15:23:36 +0800276 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;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400287 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;
maximilian attems7c2670b2008-01-22 18:46:50 +0100293 case POWER_SUPPLY_PROP_SERIAL_NUMBER:
294 val->strval = battery->serial_number;
295 break;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400296 default:
Rafael J. Wysockia1b4bd62010-10-23 19:35:15 +0200297 ret = -EINVAL;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400298 }
Rafael J. Wysockia1b4bd62010-10-23 19:35:15 +0200299 return ret;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400300}
301
302static enum power_supply_property charge_battery_props[] = {
303 POWER_SUPPLY_PROP_STATUS,
304 POWER_SUPPLY_PROP_PRESENT,
305 POWER_SUPPLY_PROP_TECHNOLOGY,
Alexey Starikovskiyc67fcd62009-10-15 14:31:44 +0400306 POWER_SUPPLY_PROP_CYCLE_COUNT,
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400307 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,
srinivas pandruvadaa58e1152012-04-05 17:38:54 -0700313 POWER_SUPPLY_PROP_CAPACITY,
Zhang Rui1ac5aaa2014-05-28 15:23:36 +0800314 POWER_SUPPLY_PROP_CAPACITY_LEVEL,
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400315 POWER_SUPPLY_PROP_MODEL_NAME,
316 POWER_SUPPLY_PROP_MANUFACTURER,
maximilian attems7c2670b2008-01-22 18:46:50 +0100317 POWER_SUPPLY_PROP_SERIAL_NUMBER,
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400318};
319
320static enum power_supply_property energy_battery_props[] = {
321 POWER_SUPPLY_PROP_STATUS,
322 POWER_SUPPLY_PROP_PRESENT,
323 POWER_SUPPLY_PROP_TECHNOLOGY,
Alexey Starikovskiyc67fcd62009-10-15 14:31:44 +0400324 POWER_SUPPLY_PROP_CYCLE_COUNT,
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400325 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
326 POWER_SUPPLY_PROP_VOLTAGE_NOW,
Alexey Starikovskiy7faa1442009-03-27 22:23:52 -0400327 POWER_SUPPLY_PROP_POWER_NOW,
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400328 POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
329 POWER_SUPPLY_PROP_ENERGY_FULL,
330 POWER_SUPPLY_PROP_ENERGY_NOW,
srinivas pandruvadaa58e1152012-04-05 17:38:54 -0700331 POWER_SUPPLY_PROP_CAPACITY,
Zhang Rui1ac5aaa2014-05-28 15:23:36 +0800332 POWER_SUPPLY_PROP_CAPACITY_LEVEL,
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400333 POWER_SUPPLY_PROP_MODEL_NAME,
334 POWER_SUPPLY_PROP_MANUFACTURER,
maximilian attems7c2670b2008-01-22 18:46:50 +0100335 POWER_SUPPLY_PROP_SERIAL_NUMBER,
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400336};
337
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338/* --------------------------------------------------------------------------
339 Battery Management
340 -------------------------------------------------------------------------- */
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400341struct acpi_offsets {
342 size_t offset; /* offset inside struct acpi_sbs_battery */
343 u8 mode; /* int or string? */
344};
345
Mathias Krausea4658782015-06-13 14:26:53 +0200346static const struct acpi_offsets state_offsets[] = {
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400347 {offsetof(struct acpi_battery, state), 0},
Alexey Starikovskiy7faa1442009-03-27 22:23:52 -0400348 {offsetof(struct acpi_battery, rate_now), 0},
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400349 {offsetof(struct acpi_battery, capacity_now), 0},
350 {offsetof(struct acpi_battery, voltage_now), 0},
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400351};
352
Mathias Krausea4658782015-06-13 14:26:53 +0200353static const struct acpi_offsets info_offsets[] = {
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400354 {offsetof(struct acpi_battery, power_unit), 0},
355 {offsetof(struct acpi_battery, design_capacity), 0},
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400356 {offsetof(struct acpi_battery, full_charge_capacity), 0},
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400357 {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};
368
Mathias Krausea4658782015-06-13 14:26:53 +0200369static const struct acpi_offsets extended_info_offsets[] = {
Lan Tianyu016d5ba2013-07-30 14:00:42 +0200370 {offsetof(struct acpi_battery, revision), 0},
Alexey Starikovskiyc67fcd62009-10-15 14:31:44 +0400371 {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
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400392static int extract_package(struct acpi_battery *battery,
393 union acpi_object *package,
Mathias Krausea4658782015-06-13 14:26:53 +0200394 const struct acpi_offsets *offsets, int num)
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300395{
Alexey Starikovskiy106449e2007-10-29 23:29:40 +0300396 int i;
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400397 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) {
Alexey Starikovskiy106449e2007-10-29 23:29:40 +0300405 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,
Lin Ming439913f2010-01-28 10:53:19 +0800411 sizeof(u64));
412 ptr[sizeof(u64)] = 0;
Alexey Starikovskiyb8a1bdb2008-03-17 22:37:42 -0400413 } else
414 *ptr = 0; /* don't have value */
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400415 } else {
Alexey Starikovskiyb8a1bdb2008-03-17 22:37:42 -0400416 int *x = (int *)((u8 *)battery + offsets[i].offset);
417 *x = (element->type == ACPI_TYPE_INTEGER) ?
418 element->integer.value : -1;
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300419 }
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300420 }
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300421 return 0;
422}
423
424static int acpi_battery_get_status(struct acpi_battery *battery)
425{
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400426 if (acpi_bus_get_status(battery->device)) {
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300427 ACPI_EXCEPTION((AE_INFO, AE_ERROR, "Evaluating _STA"));
428 return -ENODEV;
429 }
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400430 return 0;
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300431}
432
433static int acpi_battery_get_info(struct acpi_battery *battery)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434{
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400435 int result = -EFAULT;
Len Brown4be44fc2005-08-05 00:44:28 -0400436 acpi_status status = 0;
Nicholas Mazzuca0f4c6542013-05-08 23:11:15 +0000437 char *name = test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags) ?
Alexey Starikovskiyc67fcd62009-10-15 14:31:44 +0400438 "_BIX" : "_BIF";
439
Len Brown4be44fc2005-08-05 00:44:28 -0400440 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300442 if (!acpi_battery_present(battery))
443 return 0;
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400444 mutex_lock(&battery->lock);
Alexey Starikovskiyc67fcd62009-10-15 14:31:44 +0400445 status = acpi_evaluate_object(battery->device->handle, name,
446 NULL, &buffer);
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400447 mutex_unlock(&battery->lock);
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400448
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 if (ACPI_FAILURE(status)) {
Alexey Starikovskiyc67fcd62009-10-15 14:31:44 +0400450 ACPI_EXCEPTION((AE_INFO, status, "Evaluating %s", name));
Patrick Mocheld550d982006-06-27 00:41:40 -0400451 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 }
Lan Tianyua90b4032014-01-06 22:50:37 +0800453
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))
Alexey Starikovskiyc67fcd62009-10-15 14:31:44 +0400459 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));
Alexey Starikovskiy78490d82007-05-11 13:18:55 -0400465 kfree(buffer.pointer);
Zhang Rui557d5862010-10-22 10:02:06 +0800466 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
467 battery->full_charge_capacity = battery->design_capacity;
Kamil Iskra4000e622012-11-16 22:28:58 +0100468 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 }
Patrick Mocheld550d982006-06-27 00:41:40 -0400483 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484}
485
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300486static int acpi_battery_get_state(struct acpi_battery *battery)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487{
Len Brown4be44fc2005-08-05 00:44:28 -0400488 int result = 0;
489 acpi_status status = 0;
490 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300492 if (!acpi_battery_present(battery))
493 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494
Alexey Starikovskiyf1d46612007-09-26 19:42:52 +0400495 if (battery->update_time &&
496 time_before(jiffies, battery->update_time +
497 msecs_to_jiffies(cache_time)))
498 return 0;
499
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400500 mutex_lock(&battery->lock);
Alexey Starikovskiyf1d46612007-09-26 19:42:52 +0400501 status = acpi_evaluate_object(battery->device->handle, "_BST",
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400502 NULL, &buffer);
503 mutex_unlock(&battery->lock);
Len Brown5b31d892007-08-15 00:19:26 -0400504
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505 if (ACPI_FAILURE(status)) {
Thomas Renningera6fc6722006-06-26 23:58:43 -0400506 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BST"));
Patrick Mocheld550d982006-06-27 00:41:40 -0400507 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508 }
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400509
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400510 result = extract_package(battery, buffer.pointer,
511 state_offsets, ARRAY_SIZE(state_offsets));
Alexey Starikovskiyf1d46612007-09-26 19:42:52 +0400512 battery->update_time = jiffies;
Alexey Starikovskiy78490d82007-05-11 13:18:55 -0400513 kfree(buffer.pointer);
Hector Martinbc76f902009-08-06 15:57:48 -0700514
Lan Tianyu55003b22011-06-30 11:33:12 +0800515 /* 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) {
Hector Martinbc76f902009-08-06 15:57:48 -0700522 battery->rate_now = abs((s16)battery->rate_now);
Martin Kepplinger92375162015-03-13 00:48:17 +0100523 printk_once(KERN_WARNING FW_BUG
524 "battery: (dis)charge rate invalid.\n");
Lan Tianyu55003b22011-06-30 11:33:12 +0800525 }
Hector Martinbc76f902009-08-06 15:57:48 -0700526
Zhang Rui557d5862010-10-22 10:02:06 +0800527 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;
Kamil Iskra4000e622012-11-16 22:28:58 +0100531 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 }
Patrick Mocheld550d982006-06-27 00:41:40 -0400536 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537}
538
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400539static int acpi_battery_set_alarm(struct acpi_battery *battery)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540{
Len Brown4be44fc2005-08-05 00:44:28 -0400541 acpi_status status = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542
Alexey Starikovskiyc67fcd62009-10-15 14:31:44 +0400543 if (!acpi_battery_present(battery) ||
Alexey Starikovskiy7b3bcc42009-10-15 14:31:24 +0400544 !test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags))
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300545 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400547 mutex_lock(&battery->lock);
Jiang Liu0db98202013-06-29 00:24:39 +0800548 status = acpi_execute_simple_method(battery->device->handle, "_BTP",
549 battery->alarm);
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400550 mutex_unlock(&battery->lock);
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400551
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552 if (ACPI_FAILURE(status))
Patrick Mocheld550d982006-06-27 00:41:40 -0400553 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400555 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Alarm set to %d\n", battery->alarm));
Patrick Mocheld550d982006-06-27 00:41:40 -0400556 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557}
558
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300559static int acpi_battery_init_alarm(struct acpi_battery *battery)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560{
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300561 /* See if alarms are supported, and if so, set default */
Jiang Liu952c63e2013-06-29 00:24:38 +0800562 if (!acpi_has_method(battery->device->handle, "_BTP")) {
Alexey Starikovskiy7b3bcc42009-10-15 14:31:24 +0400563 clear_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
Alexey Starikovskiyf1d46612007-09-26 19:42:52 +0400564 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565 }
Alexey Starikovskiy7b3bcc42009-10-15 14:31:24 +0400566 set_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
Alexey Starikovskiyf1d46612007-09-26 19:42:52 +0400567 if (!battery->alarm)
568 battery->alarm = battery->design_capacity_warning;
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400569 return acpi_battery_set_alarm(battery);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570}
571
Andrey Borzenkov508df922007-10-28 12:50:09 +0300572static 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));
Luis G.F47a08c82014-01-21 15:40:43 +0100586 if (sscanf(buf, "%lu\n", &x) == 1)
Andrey Borzenkov508df922007-10-28 12:50:09 +0300587 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 = {
Parag Warudkar01e8ef12008-10-18 20:28:50 -0700594 .attr = {.name = "alarm", .mode = 0644},
Andrey Borzenkov508df922007-10-28 12:50:09 +0300595 .show = acpi_battery_alarm_show,
596 .store = acpi_battery_alarm_store,
597};
598
599static int sysfs_add_battery(struct acpi_battery *battery)
600{
Krzysztof Kozlowski297d7162015-03-12 08:44:11 +0100601 struct power_supply_config psy_cfg = { .drv_data = battery, };
Andrey Borzenkov508df922007-10-28 12:50:09 +0300602
Lan Tianyuae6f6182011-06-30 11:32:40 +0800603 if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) {
Krzysztof Kozlowski297d7162015-03-12 08:44:11 +0100604 battery->bat_desc.properties = charge_battery_props;
605 battery->bat_desc.num_properties =
Andrey Borzenkov508df922007-10-28 12:50:09 +0300606 ARRAY_SIZE(charge_battery_props);
607 } else {
Krzysztof Kozlowski297d7162015-03-12 08:44:11 +0100608 battery->bat_desc.properties = energy_battery_props;
609 battery->bat_desc.num_properties =
Andrey Borzenkov508df922007-10-28 12:50:09 +0300610 ARRAY_SIZE(energy_battery_props);
611 }
612
Krzysztof Kozlowski297d7162015-03-12 08:44:11 +0100613 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;
Andrey Borzenkov508df922007-10-28 12:50:09 +0300616
Krzysztof Kozlowski297d7162015-03-12 08:44:11 +0100617 battery->bat = power_supply_register_no_ws(&battery->device->dev,
618 &battery->bat_desc, &psy_cfg);
Zhang Ruie0d1f092014-05-28 15:23:38 +0800619
Krzysztof Kozlowski297d7162015-03-12 08:44:11 +0100620 if (IS_ERR(battery->bat)) {
621 int result = PTR_ERR(battery->bat);
622
623 battery->bat = NULL;
Andrey Borzenkov508df922007-10-28 12:50:09 +0300624 return result;
Krzysztof Kozlowski297d7162015-03-12 08:44:11 +0100625 }
626 return device_create_file(&battery->bat->dev, &alarm_attr);
Andrey Borzenkov508df922007-10-28 12:50:09 +0300627}
628
629static void sysfs_remove_battery(struct acpi_battery *battery)
630{
Sergey Senozhatsky69d94ec2011-08-06 01:34:08 +0300631 mutex_lock(&battery->sysfs_lock);
Krzysztof Kozlowski297d7162015-03-12 08:44:11 +0100632 if (!battery->bat) {
Sergey Senozhatsky69d94ec2011-08-06 01:34:08 +0300633 mutex_unlock(&battery->sysfs_lock);
Andrey Borzenkov508df922007-10-28 12:50:09 +0300634 return;
Lan Tianyu9c921c222011-06-30 11:34:12 +0800635 }
636
Krzysztof Kozlowski297d7162015-03-12 08:44:11 +0100637 device_remove_file(&battery->bat->dev, &alarm_attr);
638 power_supply_unregister(battery->bat);
639 battery->bat = NULL;
Sergey Senozhatsky69d94ec2011-08-06 01:34:08 +0300640 mutex_unlock(&battery->sysfs_lock);
Hector Martinbc76f902009-08-06 15:57:48 -0700641}
642
Kamil Iskra4000e622012-11-16 22:28:58 +0100643static 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
Zhang Rui557d5862010-10-22 10:02:06 +0800661/*
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 */
Lan Tianyu7b786222011-06-30 11:33:27 +0800673static void acpi_battery_quirks(struct acpi_battery *battery)
Zhang Rui557d5862010-10-22 10:02:06 +0800674{
675 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
Nicholas Mazzuca0f4c6542013-05-08 23:11:15 +0000676 return;
Zhang Rui557d5862010-10-22 10:02:06 +0800677
Nicholas Mazzuca0f4c6542013-05-08 23:11:15 +0000678 if (battery->full_charge_capacity == 100 &&
679 battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN &&
680 battery->capacity_now >= 0 && battery->capacity_now <= 100) {
Zhang Rui557d5862010-10-22 10:02:06 +0800681 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 }
Kamil Iskra4000e622012-11-16 22:28:58 +0100686
687 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags))
Nicholas Mazzuca0f4c6542013-05-08 23:11:15 +0000688 return;
Kamil Iskra4000e622012-11-16 22:28:58 +0100689
690 if (battery->power_unit && dmi_name_in_vendors("LENOVO")) {
691 const char *s;
692 s = dmi_get_system_info(DMI_PRODUCT_VERSION);
Rasmus Villemoesffd8a732014-09-16 22:51:24 +0200693 if (s && !strncasecmp(s, "ThinkPad", 8)) {
Kamil Iskra4000e622012-11-16 22:28:58 +0100694 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 }
Zhang Rui557d5862010-10-22 10:02:06 +0800712}
713
Lan Tianyu9e50bc12014-05-04 14:07:06 +0800714static int acpi_battery_update(struct acpi_battery *battery, bool resume)
Vladimir Lebedev4bd35cd2007-02-10 01:43:48 -0500715{
Alexey Starikovskiy50b17852008-12-23 02:44:54 +0300716 int result, old_present = acpi_battery_present(battery);
Alexey Starikovskiy97749cd2008-01-01 14:27:24 -0500717 result = acpi_battery_get_status(battery);
Andrey Borzenkov508df922007-10-28 12:50:09 +0300718 if (result)
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300719 return result;
Andrey Borzenkov508df922007-10-28 12:50:09 +0300720 if (!acpi_battery_present(battery)) {
721 sysfs_remove_battery(battery);
Alexey Starikovskiy97749cd2008-01-01 14:27:24 -0500722 battery->update_time = 0;
Andrey Borzenkov508df922007-10-28 12:50:09 +0300723 return 0;
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300724 }
Lan Tianyu9e50bc12014-05-04 14:07:06 +0800725
726 if (resume)
727 return 0;
728
Alexey Starikovskiy50b17852008-12-23 02:44:54 +0300729 if (!battery->update_time ||
730 old_present != acpi_battery_present(battery)) {
Alexey Starikovskiy97749cd2008-01-01 14:27:24 -0500731 result = acpi_battery_get_info(battery);
732 if (result)
733 return result;
734 acpi_battery_init_alarm(battery);
735 }
Krzysztof Kozlowski297d7162015-03-12 08:44:11 +0100736 if (!battery->bat) {
Stefan Hajnoczieb03cb02011-07-12 09:03:29 +0100737 result = sysfs_add_battery(battery);
738 if (result)
739 return result;
740 }
Zhang Rui557d5862010-10-22 10:02:06 +0800741 result = acpi_battery_get_state(battery);
Zhang Ruie0d1f092014-05-28 15:23:38 +0800742 if (result)
743 return result;
Lan Tianyu7b786222011-06-30 11:33:27 +0800744 acpi_battery_quirks(battery);
Zhang Ruie0d1f092014-05-28 15:23:38 +0800745
746 /*
747 * Wakeup the system if battery is critical low
748 * or lower than the alarm level
749 */
750 if ((battery->state & ACPI_BATTERY_STATE_CRITICAL) ||
751 (test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags) &&
752 (battery->capacity_now <= battery->alarm)))
753 pm_wakeup_event(&battery->device->dev, 0);
754
Zhang Rui557d5862010-10-22 10:02:06 +0800755 return result;
Vladimir Lebedev4bd35cd2007-02-10 01:43:48 -0500756}
757
Rafael J. Wysockida8aeb92011-01-06 23:42:27 +0100758static void acpi_battery_refresh(struct acpi_battery *battery)
759{
Andy Whitcroftc5971452012-05-03 14:48:26 +0100760 int power_unit;
761
Krzysztof Kozlowski297d7162015-03-12 08:44:11 +0100762 if (!battery->bat)
Rafael J. Wysockida8aeb92011-01-06 23:42:27 +0100763 return;
764
Andy Whitcroftc5971452012-05-03 14:48:26 +0100765 power_unit = battery->power_unit;
766
Rafael J. Wysockida8aeb92011-01-06 23:42:27 +0100767 acpi_battery_get_info(battery);
Andy Whitcroftc5971452012-05-03 14:48:26 +0100768
769 if (power_unit == battery->power_unit)
770 return;
771
772 /* The battery has changed its reporting units. */
Rafael J. Wysockida8aeb92011-01-06 23:42:27 +0100773 sysfs_remove_battery(battery);
774 sysfs_add_battery(battery);
775}
776
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777/* --------------------------------------------------------------------------
Lan Tianyu3a670cc2014-05-04 11:07:25 +0800778 FS Interface (/proc)
779 -------------------------------------------------------------------------- */
780
781#ifdef CONFIG_ACPI_PROCFS_POWER
782static struct proc_dir_entry *acpi_battery_dir;
783
Mathias Krause27059b92015-06-13 14:26:54 +0200784static const char *acpi_battery_units(const struct acpi_battery *battery)
785{
786 return (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) ?
787 "mA" : "mW";
788}
789
Lan Tianyu3a670cc2014-05-04 11:07:25 +0800790static int acpi_battery_print_info(struct seq_file *seq, int result)
791{
792 struct acpi_battery *battery = seq->private;
793
794 if (result)
795 goto end;
796
797 seq_printf(seq, "present: %s\n",
798 acpi_battery_present(battery) ? "yes" : "no");
799 if (!acpi_battery_present(battery))
800 goto end;
801 if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
802 seq_printf(seq, "design capacity: unknown\n");
803 else
804 seq_printf(seq, "design capacity: %d %sh\n",
805 battery->design_capacity,
806 acpi_battery_units(battery));
807
808 if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
809 seq_printf(seq, "last full capacity: unknown\n");
810 else
811 seq_printf(seq, "last full capacity: %d %sh\n",
812 battery->full_charge_capacity,
813 acpi_battery_units(battery));
814
815 seq_printf(seq, "battery technology: %srechargeable\n",
816 (!battery->technology)?"non-":"");
817
818 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
819 seq_printf(seq, "design voltage: unknown\n");
820 else
821 seq_printf(seq, "design voltage: %d mV\n",
822 battery->design_voltage);
823 seq_printf(seq, "design capacity warning: %d %sh\n",
824 battery->design_capacity_warning,
825 acpi_battery_units(battery));
826 seq_printf(seq, "design capacity low: %d %sh\n",
827 battery->design_capacity_low,
828 acpi_battery_units(battery));
829 seq_printf(seq, "cycle count: %i\n", battery->cycle_count);
830 seq_printf(seq, "capacity granularity 1: %d %sh\n",
831 battery->capacity_granularity_1,
832 acpi_battery_units(battery));
833 seq_printf(seq, "capacity granularity 2: %d %sh\n",
834 battery->capacity_granularity_2,
835 acpi_battery_units(battery));
836 seq_printf(seq, "model number: %s\n", battery->model_number);
837 seq_printf(seq, "serial number: %s\n", battery->serial_number);
838 seq_printf(seq, "battery type: %s\n", battery->type);
839 seq_printf(seq, "OEM info: %s\n", battery->oem_info);
840 end:
841 if (result)
842 seq_printf(seq, "ERROR: Unable to read battery info\n");
843 return result;
844}
845
846static int acpi_battery_print_state(struct seq_file *seq, int result)
847{
848 struct acpi_battery *battery = seq->private;
849
850 if (result)
851 goto end;
852
853 seq_printf(seq, "present: %s\n",
854 acpi_battery_present(battery) ? "yes" : "no");
855 if (!acpi_battery_present(battery))
856 goto end;
857
858 seq_printf(seq, "capacity state: %s\n",
859 (battery->state & 0x04) ? "critical" : "ok");
860 if ((battery->state & 0x01) && (battery->state & 0x02))
861 seq_printf(seq,
862 "charging state: charging/discharging\n");
863 else if (battery->state & 0x01)
864 seq_printf(seq, "charging state: discharging\n");
865 else if (battery->state & 0x02)
866 seq_printf(seq, "charging state: charging\n");
867 else
868 seq_printf(seq, "charging state: charged\n");
869
870 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
871 seq_printf(seq, "present rate: unknown\n");
872 else
873 seq_printf(seq, "present rate: %d %s\n",
874 battery->rate_now, acpi_battery_units(battery));
875
876 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
877 seq_printf(seq, "remaining capacity: unknown\n");
878 else
879 seq_printf(seq, "remaining capacity: %d %sh\n",
880 battery->capacity_now, acpi_battery_units(battery));
881 if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
882 seq_printf(seq, "present voltage: unknown\n");
883 else
884 seq_printf(seq, "present voltage: %d mV\n",
885 battery->voltage_now);
886 end:
887 if (result)
888 seq_printf(seq, "ERROR: Unable to read battery state\n");
889
890 return result;
891}
892
893static int acpi_battery_print_alarm(struct seq_file *seq, int result)
894{
895 struct acpi_battery *battery = seq->private;
896
897 if (result)
898 goto end;
899
900 if (!acpi_battery_present(battery)) {
901 seq_printf(seq, "present: no\n");
902 goto end;
903 }
904 seq_printf(seq, "alarm: ");
905 if (!battery->alarm)
906 seq_printf(seq, "unsupported\n");
907 else
908 seq_printf(seq, "%u %sh\n", battery->alarm,
909 acpi_battery_units(battery));
910 end:
911 if (result)
912 seq_printf(seq, "ERROR: Unable to read battery alarm\n");
913 return result;
914}
915
916static ssize_t acpi_battery_write_alarm(struct file *file,
917 const char __user * buffer,
918 size_t count, loff_t * ppos)
919{
920 int result = 0;
921 char alarm_string[12] = { '\0' };
922 struct seq_file *m = file->private_data;
923 struct acpi_battery *battery = m->private;
924
925 if (!battery || (count > sizeof(alarm_string) - 1))
926 return -EINVAL;
927 if (!acpi_battery_present(battery)) {
928 result = -ENODEV;
929 goto end;
930 }
931 if (copy_from_user(alarm_string, buffer, count)) {
932 result = -EFAULT;
933 goto end;
934 }
935 alarm_string[count] = '\0';
Christoph Jaeger3d915892014-06-13 21:49:58 +0200936 if (kstrtoint(alarm_string, 0, &battery->alarm)) {
937 result = -EINVAL;
938 goto end;
939 }
Lan Tianyu3a670cc2014-05-04 11:07:25 +0800940 result = acpi_battery_set_alarm(battery);
941 end:
942 if (!result)
943 return count;
944 return result;
945}
946
947typedef int(*print_func)(struct seq_file *seq, int result);
948
949static print_func acpi_print_funcs[ACPI_BATTERY_NUMFILES] = {
950 acpi_battery_print_info,
951 acpi_battery_print_state,
952 acpi_battery_print_alarm,
953};
954
955static int acpi_battery_read(int fid, struct seq_file *seq)
956{
957 struct acpi_battery *battery = seq->private;
Lan Tianyu9e50bc12014-05-04 14:07:06 +0800958 int result = acpi_battery_update(battery, false);
Lan Tianyu3a670cc2014-05-04 11:07:25 +0800959 return acpi_print_funcs[fid](seq, result);
960}
961
962#define DECLARE_FILE_FUNCTIONS(_name) \
963static int acpi_battery_read_##_name(struct seq_file *seq, void *offset) \
964{ \
965 return acpi_battery_read(_name##_tag, seq); \
966} \
967static int acpi_battery_##_name##_open_fs(struct inode *inode, struct file *file) \
968{ \
969 return single_open(file, acpi_battery_read_##_name, PDE_DATA(inode)); \
970}
971
972DECLARE_FILE_FUNCTIONS(info);
973DECLARE_FILE_FUNCTIONS(state);
974DECLARE_FILE_FUNCTIONS(alarm);
975
976#undef DECLARE_FILE_FUNCTIONS
977
978#define FILE_DESCRIPTION_RO(_name) \
979 { \
980 .name = __stringify(_name), \
981 .mode = S_IRUGO, \
982 .ops = { \
983 .open = acpi_battery_##_name##_open_fs, \
984 .read = seq_read, \
985 .llseek = seq_lseek, \
986 .release = single_release, \
987 .owner = THIS_MODULE, \
988 }, \
989 }
990
991#define FILE_DESCRIPTION_RW(_name) \
992 { \
993 .name = __stringify(_name), \
994 .mode = S_IFREG | S_IRUGO | S_IWUSR, \
995 .ops = { \
996 .open = acpi_battery_##_name##_open_fs, \
997 .read = seq_read, \
998 .llseek = seq_lseek, \
999 .write = acpi_battery_write_##_name, \
1000 .release = single_release, \
1001 .owner = THIS_MODULE, \
1002 }, \
1003 }
1004
1005static const struct battery_file {
1006 struct file_operations ops;
1007 umode_t mode;
1008 const char *name;
1009} acpi_battery_file[] = {
1010 FILE_DESCRIPTION_RO(info),
1011 FILE_DESCRIPTION_RO(state),
1012 FILE_DESCRIPTION_RW(alarm),
1013};
1014
1015#undef FILE_DESCRIPTION_RO
1016#undef FILE_DESCRIPTION_RW
1017
1018static int acpi_battery_add_fs(struct acpi_device *device)
1019{
1020 struct proc_dir_entry *entry = NULL;
1021 int i;
1022
1023 printk(KERN_WARNING PREFIX "Deprecated procfs I/F for battery is loaded,"
1024 " please retry with CONFIG_ACPI_PROCFS_POWER cleared\n");
1025 if (!acpi_device_dir(device)) {
1026 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
1027 acpi_battery_dir);
1028 if (!acpi_device_dir(device))
1029 return -ENODEV;
1030 }
1031
1032 for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i) {
1033 entry = proc_create_data(acpi_battery_file[i].name,
1034 acpi_battery_file[i].mode,
1035 acpi_device_dir(device),
1036 &acpi_battery_file[i].ops,
1037 acpi_driver_data(device));
1038 if (!entry)
1039 return -ENODEV;
1040 }
1041 return 0;
1042}
1043
1044static void acpi_battery_remove_fs(struct acpi_device *device)
1045{
1046 int i;
1047 if (!acpi_device_dir(device))
1048 return;
1049 for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i)
1050 remove_proc_entry(acpi_battery_file[i].name,
1051 acpi_device_dir(device));
1052
1053 remove_proc_entry(acpi_device_bid(device), acpi_battery_dir);
1054 acpi_device_dir(device) = NULL;
1055}
1056
1057#endif
1058
1059/* --------------------------------------------------------------------------
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060 Driver Interface
1061 -------------------------------------------------------------------------- */
1062
Bjorn Helgaasd9406692009-04-30 09:35:47 -06001063static void acpi_battery_notify(struct acpi_device *device, u32 event)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064{
Bjorn Helgaasd9406692009-04-30 09:35:47 -06001065 struct acpi_battery *battery = acpi_driver_data(device);
Krzysztof Kozlowski297d7162015-03-12 08:44:11 +01001066 struct power_supply *old;
Bjorn Helgaasd9406692009-04-30 09:35:47 -06001067
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068 if (!battery)
Patrick Mocheld550d982006-06-27 00:41:40 -04001069 return;
Krzysztof Kozlowski297d7162015-03-12 08:44:11 +01001070 old = battery->bat;
Alexander Mezinf43691c2014-06-04 02:01:23 +07001071 /*
1072 * On Acer Aspire V5-573G notifications are sometimes triggered too
1073 * early. For example, when AC is unplugged and notification is
1074 * triggered, battery state is still reported as "Full", and changes to
1075 * "Discharging" only after short delay, without any notification.
1076 */
1077 if (battery_notification_delay_ms > 0)
1078 msleep(battery_notification_delay_ms);
Rafael J. Wysockida8aeb92011-01-06 23:42:27 +01001079 if (event == ACPI_BATTERY_NOTIFY_INFO)
1080 acpi_battery_refresh(battery);
Lan Tianyu9e50bc12014-05-04 14:07:06 +08001081 acpi_battery_update(battery, false);
Alexey Starikovskiyf1d46612007-09-26 19:42:52 +04001082 acpi_bus_generate_netlink_event(device->pnp.device_class,
Kay Sievers07944692008-10-30 01:18:59 +01001083 dev_name(&device->dev), event,
Vladimir Lebedev9ea7d572007-02-20 15:48:06 +03001084 acpi_battery_present(battery));
Alexander Mezin411e0f72014-03-12 00:58:47 +07001085 acpi_notifier_call_chain(device, event, acpi_battery_present(battery));
Justin P. Mattock2345baf2009-12-13 14:42:36 -08001086 /* acpi_battery_update could remove power_supply object */
Krzysztof Kozlowski297d7162015-03-12 08:44:11 +01001087 if (old && battery->bat)
1088 power_supply_changed(battery->bat);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089}
1090
Kyle McMartin25be5822011-03-22 16:19:50 -04001091static int battery_notify(struct notifier_block *nb,
1092 unsigned long mode, void *_unused)
1093{
1094 struct acpi_battery *battery = container_of(nb, struct acpi_battery,
1095 pm_nb);
Lan Tianyu9e50bc12014-05-04 14:07:06 +08001096 int result;
1097
Kyle McMartin25be5822011-03-22 16:19:50 -04001098 switch (mode) {
Lan Tianyud5a59112011-06-30 11:33:40 +08001099 case PM_POST_HIBERNATION:
Kyle McMartin25be5822011-03-22 16:19:50 -04001100 case PM_POST_SUSPEND:
Lan Tianyu9e50bc12014-05-04 14:07:06 +08001101 if (!acpi_battery_present(battery))
1102 return 0;
1103
Krzysztof Kozlowski31f7dc72015-04-14 22:24:13 +09001104 if (!battery->bat) {
Lan Tianyu9e50bc12014-05-04 14:07:06 +08001105 result = acpi_battery_get_info(battery);
1106 if (result)
1107 return result;
1108
1109 result = sysfs_add_battery(battery);
1110 if (result)
1111 return result;
1112 } else
1113 acpi_battery_refresh(battery);
1114
1115 acpi_battery_init_alarm(battery);
1116 acpi_battery_get_state(battery);
Kyle McMartin25be5822011-03-22 16:19:50 -04001117 break;
1118 }
1119
1120 return 0;
1121}
1122
Mathias Krause048d16d2015-06-13 14:26:55 +02001123static int __init
1124battery_bix_broken_package_quirk(const struct dmi_system_id *d)
Alexander Mezin3f5dc082014-06-04 02:01:22 +07001125{
1126 battery_bix_broken_package = 1;
1127 return 0;
1128}
1129
Mathias Krause048d16d2015-06-13 14:26:55 +02001130static int __init
1131battery_notification_delay_quirk(const struct dmi_system_id *d)
Alexander Mezinf43691c2014-06-04 02:01:23 +07001132{
1133 battery_notification_delay_ms = 1000;
1134 return 0;
1135}
1136
Mathias Krause048d16d2015-06-13 14:26:55 +02001137static const struct dmi_system_id bat_dmi_table[] __initconst = {
Lan Tianyua90b4032014-01-06 22:50:37 +08001138 {
Alexander Mezin3f5dc082014-06-04 02:01:22 +07001139 .callback = battery_bix_broken_package_quirk,
Lan Tianyua90b4032014-01-06 22:50:37 +08001140 .ident = "NEC LZ750/LS",
1141 .matches = {
1142 DMI_MATCH(DMI_SYS_VENDOR, "NEC"),
1143 DMI_MATCH(DMI_PRODUCT_NAME, "PC-LZ750LS"),
1144 },
1145 },
Alexander Mezinf43691c2014-06-04 02:01:23 +07001146 {
1147 .callback = battery_notification_delay_quirk,
1148 .ident = "Acer Aspire V5-573G",
1149 .matches = {
1150 DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
1151 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire V5-573G"),
1152 },
1153 },
Lan Tianyua90b4032014-01-06 22:50:37 +08001154 {},
1155};
1156
Lan Tianyu75646e72014-07-07 15:47:12 +08001157/*
1158 * Some machines'(E,G Lenovo Z480) ECs are not stable
1159 * during boot up and this causes battery driver fails to be
1160 * probed due to failure of getting battery information
1161 * from EC sometimes. After several retries, the operation
1162 * may work. So add retry code here and 20ms sleep between
1163 * every retries.
1164 */
1165static int acpi_battery_update_retry(struct acpi_battery *battery)
1166{
1167 int retry, ret;
1168
1169 for (retry = 5; retry; retry--) {
1170 ret = acpi_battery_update(battery, false);
1171 if (!ret)
1172 break;
1173
1174 msleep(20);
1175 }
1176 return ret;
1177}
1178
Len Brown4be44fc2005-08-05 00:44:28 -04001179static int acpi_battery_add(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180{
Len Brown4be44fc2005-08-05 00:44:28 -04001181 int result = 0;
Len Brown4be44fc2005-08-05 00:44:28 -04001182 struct acpi_battery *battery = NULL;
Jiang Liu952c63e2013-06-29 00:24:38 +08001183
Linus Torvalds1da177e2005-04-16 15:20:36 -07001184 if (!device)
Patrick Mocheld550d982006-06-27 00:41:40 -04001185 return -EINVAL;
Lan Tianyu40e7fcb2014-11-23 21:22:54 +08001186
1187 if (device->dep_unmet)
1188 return -EPROBE_DEFER;
1189
Burman Yan36bcbec2006-12-19 12:56:11 -08001190 battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001191 if (!battery)
Patrick Mocheld550d982006-06-27 00:41:40 -04001192 return -ENOMEM;
Patrick Mochel145def82006-05-19 16:54:39 -04001193 battery->device = device;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001194 strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME);
1195 strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS);
Pavel Machekdb89b4f2008-09-22 14:37:34 -07001196 device->driver_data = battery;
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +04001197 mutex_init(&battery->lock);
Sergey Senozhatsky69d94ec2011-08-06 01:34:08 +03001198 mutex_init(&battery->sysfs_lock);
Jiang Liu952c63e2013-06-29 00:24:38 +08001199 if (acpi_has_method(battery->device->handle, "_BIX"))
Alexey Starikovskiyc67fcd62009-10-15 14:31:44 +04001200 set_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags);
Lan Tianyu75646e72014-07-07 15:47:12 +08001201
1202 result = acpi_battery_update_retry(battery);
Stefan Hajnoczieb03cb02011-07-12 09:03:29 +01001203 if (result)
1204 goto fail;
Lan Tianyu75646e72014-07-07 15:47:12 +08001205
Lan Tianyu3a670cc2014-05-04 11:07:25 +08001206#ifdef CONFIG_ACPI_PROCFS_POWER
1207 result = acpi_battery_add_fs(device);
1208#endif
1209 if (result) {
1210#ifdef CONFIG_ACPI_PROCFS_POWER
1211 acpi_battery_remove_fs(device);
1212#endif
1213 goto fail;
1214 }
Kyle McMartin25be5822011-03-22 16:19:50 -04001215
Stefan Hajnoczie80bba42011-07-12 09:03:28 +01001216 printk(KERN_INFO PREFIX "%s Slot [%s] (battery %s)\n",
1217 ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device),
1218 device->status.battery_present ? "present" : "absent");
1219
Kyle McMartin25be5822011-03-22 16:19:50 -04001220 battery->pm_nb.notifier_call = battery_notify;
1221 register_pm_notifier(&battery->pm_nb);
1222
Zhang Ruie0d1f092014-05-28 15:23:38 +08001223 device_init_wakeup(&device->dev, 1);
1224
Patrick Mocheld550d982006-06-27 00:41:40 -04001225 return result;
Stefan Hajnoczie80bba42011-07-12 09:03:28 +01001226
1227fail:
1228 sysfs_remove_battery(battery);
1229 mutex_destroy(&battery->lock);
Sergey Senozhatsky69d94ec2011-08-06 01:34:08 +03001230 mutex_destroy(&battery->sysfs_lock);
Stefan Hajnoczie80bba42011-07-12 09:03:28 +01001231 kfree(battery);
1232 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233}
1234
Rafael J. Wysocki51fac832013-01-24 00:24:48 +01001235static int acpi_battery_remove(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001236{
Len Brown4be44fc2005-08-05 00:44:28 -04001237 struct acpi_battery *battery = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001238
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239 if (!device || !acpi_driver_data(device))
Patrick Mocheld550d982006-06-27 00:41:40 -04001240 return -EINVAL;
Zhang Ruie0d1f092014-05-28 15:23:38 +08001241 device_init_wakeup(&device->dev, 0);
Jan Engelhardt50dd0962006-10-01 00:28:50 +02001242 battery = acpi_driver_data(device);
Kyle McMartin25be5822011-03-22 16:19:50 -04001243 unregister_pm_notifier(&battery->pm_nb);
Lan Tianyu3a670cc2014-05-04 11:07:25 +08001244#ifdef CONFIG_ACPI_PROCFS_POWER
1245 acpi_battery_remove_fs(device);
1246#endif
Andrey Borzenkov508df922007-10-28 12:50:09 +03001247 sysfs_remove_battery(battery);
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +04001248 mutex_destroy(&battery->lock);
Sergey Senozhatsky69d94ec2011-08-06 01:34:08 +03001249 mutex_destroy(&battery->sysfs_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001250 kfree(battery);
Patrick Mocheld550d982006-06-27 00:41:40 -04001251 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001252}
1253
Rafael J. Wysocki90692402012-08-09 23:00:02 +02001254#ifdef CONFIG_PM_SLEEP
Jiri Kosina34c44152006-10-10 14:20:41 -07001255/* this is needed to learn about changes made in suspended state */
Rafael J. Wysockia6f50dc2012-06-27 23:26:43 +02001256static int acpi_battery_resume(struct device *dev)
Jiri Kosina34c44152006-10-10 14:20:41 -07001257{
1258 struct acpi_battery *battery;
Rafael J. Wysockia6f50dc2012-06-27 23:26:43 +02001259
1260 if (!dev)
Jiri Kosina34c44152006-10-10 14:20:41 -07001261 return -EINVAL;
Rafael J. Wysockia6f50dc2012-06-27 23:26:43 +02001262
1263 battery = acpi_driver_data(to_acpi_device(dev));
1264 if (!battery)
1265 return -EINVAL;
1266
Alexey Starikovskiyf1d46612007-09-26 19:42:52 +04001267 battery->update_time = 0;
Lan Tianyu9e50bc12014-05-04 14:07:06 +08001268 acpi_battery_update(battery, true);
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +03001269 return 0;
Jiri Kosina34c44152006-10-10 14:20:41 -07001270}
Shuah Khan7f6895c2014-02-12 20:19:06 -07001271#else
1272#define acpi_battery_resume NULL
Rafael J. Wysocki90692402012-08-09 23:00:02 +02001273#endif
Jiri Kosina34c44152006-10-10 14:20:41 -07001274
Rafael J. Wysockia6f50dc2012-06-27 23:26:43 +02001275static SIMPLE_DEV_PM_OPS(acpi_battery_pm, NULL, acpi_battery_resume);
1276
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +04001277static struct acpi_driver acpi_battery_driver = {
1278 .name = "battery",
1279 .class = ACPI_BATTERY_CLASS,
1280 .ids = battery_device_ids,
Bjorn Helgaasd9406692009-04-30 09:35:47 -06001281 .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +04001282 .ops = {
1283 .add = acpi_battery_add,
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +04001284 .remove = acpi_battery_remove,
Bjorn Helgaasd9406692009-04-30 09:35:47 -06001285 .notify = acpi_battery_notify,
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +04001286 },
Rafael J. Wysockia6f50dc2012-06-27 23:26:43 +02001287 .drv.pm = &acpi_battery_pm,
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +04001288};
1289
Linus Torvaldsb0cbc862009-04-11 12:45:20 -07001290static void __init acpi_battery_init_async(void *unused, async_cookie_t cookie)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001291{
Luis Henriques479faaf2015-05-11 22:48:46 +01001292 int result;
1293
Alexander Mezin3f5dc082014-06-04 02:01:22 +07001294 dmi_check_system(bat_dmi_table);
Luis Henriques479faaf2015-05-11 22:48:46 +01001295
Lan Tianyu3a670cc2014-05-04 11:07:25 +08001296#ifdef CONFIG_ACPI_PROCFS_POWER
1297 acpi_battery_dir = acpi_lock_battery_dir();
1298 if (!acpi_battery_dir)
1299 return;
1300#endif
Luis Henriques479faaf2015-05-11 22:48:46 +01001301 result = acpi_bus_register_driver(&acpi_battery_driver);
Lan Tianyu3a670cc2014-05-04 11:07:25 +08001302#ifdef CONFIG_ACPI_PROCFS_POWER
Luis Henriques479faaf2015-05-11 22:48:46 +01001303 if (result < 0)
Lan Tianyu3a670cc2014-05-04 11:07:25 +08001304 acpi_unlock_battery_dir(acpi_battery_dir);
1305#endif
Arjan van de Ven0f66af52009-01-10 14:19:05 -05001306}
1307
1308static int __init acpi_battery_init(void)
1309{
Luis Henriquese234b072015-05-11 22:48:38 +01001310 if (acpi_disabled)
1311 return -ENODEV;
1312
Luis Henriqueseca21d912015-05-11 22:49:05 +01001313 async_cookie = async_schedule(acpi_battery_init_async, NULL);
Patrick Mocheld550d982006-06-27 00:41:40 -04001314 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315}
1316
Len Brown4be44fc2005-08-05 00:44:28 -04001317static void __exit acpi_battery_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318{
Chris Wilson5dfa0c72016-05-19 09:11:52 +01001319 async_synchronize_cookie(async_cookie + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001320 acpi_bus_unregister_driver(&acpi_battery_driver);
Lan Tianyu3a670cc2014-05-04 11:07:25 +08001321#ifdef CONFIG_ACPI_PROCFS_POWER
1322 acpi_unlock_battery_dir(acpi_battery_dir);
1323#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324}
1325
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326module_init(acpi_battery_init);
1327module_exit(acpi_battery_exit);