blob: 8ec8a89a20ab9d734b6fca390d60f3501dc591a3 [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 *
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>
Alexey Starikovskiyf1d46612007-09-26 19:42:52 +040032#include <linux/jiffies.h>
Arjan van de Ven0f66af52009-01-10 14:19:05 -050033#include <linux/async.h>
Hector Martinbc76f902009-08-06 15:57:48 -070034#include <linux/dmi.h>
Alexander Mezinf43691c2014-06-04 02:01:23 +070035#include <linux/delay.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090036#include <linux/slab.h>
Kyle McMartin25be5822011-03-22 16:19:50 -040037#include <linux/suspend.h>
Kamil Iskra4000e6262012-11-16 22:28:58 +010038#include <asm/unaligned.h>
Alexey Starikovskiyd7380962007-09-26 19:43:04 +040039
Lan Tianyu3a670cc2014-05-04 11:07:25 +080040#ifdef CONFIG_ACPI_PROCFS_POWER
41#include <linux/proc_fs.h>
42#include <linux/seq_file.h>
43#include <asm/uaccess.h>
44#endif
45
Lv Zheng8b484632013-12-03 08:49:16 +080046#include <linux/acpi.h>
Alexey Starikovskiyd7380962007-09-26 19:43:04 +040047#include <linux/power_supply.h>
48
Alexander Mezinf03be352014-03-12 00:58:46 +070049#include "battery.h"
50
Len Browna192a952009-07-28 16:45:54 -040051#define PREFIX "ACPI: "
52
Linus Torvalds1da177e2005-04-16 15:20:36 -070053#define ACPI_BATTERY_VALUE_UNKNOWN 0xFFFFFFFF
54
Linus Torvalds1da177e2005-04-16 15:20:36 -070055#define ACPI_BATTERY_DEVICE_NAME "Battery"
Linus Torvalds1da177e2005-04-16 15:20:36 -070056
Lan Tianyuae6f6182011-06-30 11:32:40 +080057/* Battery power unit: 0 means mW, 1 means mA */
58#define ACPI_BATTERY_POWER_UNIT_MA 1
59
Zhang Rui1ac5aaa2014-05-28 15:23:36 +080060#define ACPI_BATTERY_STATE_DISCHARGING 0x1
61#define ACPI_BATTERY_STATE_CHARGING 0x2
62#define ACPI_BATTERY_STATE_CRITICAL 0x4
63
Linus Torvalds1da177e2005-04-16 15:20:36 -070064#define _COMPONENT ACPI_BATTERY_COMPONENT
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +030065
Len Brownf52fd662007-02-12 22:42:12 -050066ACPI_MODULE_NAME("battery");
Linus Torvalds1da177e2005-04-16 15:20:36 -070067
Len Brownf52fd662007-02-12 22:42:12 -050068MODULE_AUTHOR("Paul Diefenbaugh");
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +040069MODULE_AUTHOR("Alexey Starikovskiy <astarikovskiy@suse.de>");
Len Brown7cda93e2007-02-12 23:50:02 -050070MODULE_DESCRIPTION("ACPI Battery Driver");
Linus Torvalds1da177e2005-04-16 15:20:36 -070071MODULE_LICENSE("GPL");
72
Lan Tianyua90b4032014-01-06 22:50:37 +080073static int battery_bix_broken_package;
Alexander Mezinf43691c2014-06-04 02:01:23 +070074static int battery_notification_delay_ms;
Alexey Starikovskiyf1d46612007-09-26 19:42:52 +040075static unsigned int cache_time = 1000;
76module_param(cache_time, uint, 0644);
77MODULE_PARM_DESC(cache_time, "cache time in milliseconds");
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +030078
Lan Tianyu3a670cc2014-05-04 11:07:25 +080079#ifdef CONFIG_ACPI_PROCFS_POWER
80extern struct proc_dir_entry *acpi_lock_battery_dir(void);
81extern void *acpi_unlock_battery_dir(struct proc_dir_entry *acpi_battery_dir);
82
83enum acpi_battery_files {
84 info_tag = 0,
85 state_tag,
86 alarm_tag,
87 ACPI_BATTERY_NUMFILES,
88};
89
90#endif
91
Alexey Starikovskiyd7380962007-09-26 19:43:04 +040092static const struct acpi_device_id battery_device_ids[] = {
93 {"PNP0C0A", 0},
94 {"", 0},
95};
96
97MODULE_DEVICE_TABLE(acpi, battery_device_ids);
98
Alexey Starikovskiy7b3bcc42009-10-15 14:31:24 +040099enum {
100 ACPI_BATTERY_ALARM_PRESENT,
Alexey Starikovskiyc67fcd62009-10-15 14:31:44 +0400101 ACPI_BATTERY_XINFO_PRESENT,
Zhang Rui557d5862010-10-22 10:02:06 +0800102 ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY,
Kamil Iskra4000e6262012-11-16 22:28:58 +0100103 /* On Lenovo Thinkpad models from 2010 and 2011, the power unit
104 switches between mWh and mAh depending on whether the system
105 is running on battery or not. When mAh is the unit, most
106 reported values are incorrect and need to be adjusted by
107 10000/design_voltage. Verified on x201, t410, t410s, and x220.
108 Pre-2010 and 2012 models appear to always report in mWh and
109 are thus unaffected (tested with t42, t61, t500, x200, x300,
110 and x230). Also, in mid-2012 Lenovo issued a BIOS update for
111 the 2011 models that fixes the issue (tested on x220 with a
112 post-1.29 BIOS), but as of Nov. 2012, no such update is
113 available for the 2010 models. */
114 ACPI_BATTERY_QUIRK_THINKPAD_MAH,
Alexey Starikovskiy7b3bcc42009-10-15 14:31:24 +0400115};
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400116
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400117struct acpi_battery {
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400118 struct mutex lock;
Sergey Senozhatsky69d94ec2011-08-06 01:34:08 +0300119 struct mutex sysfs_lock;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400120 struct power_supply bat;
Alexey Starikovskiyf1d46612007-09-26 19:42:52 +0400121 struct acpi_device *device;
Kyle McMartin25be5822011-03-22 16:19:50 -0400122 struct notifier_block pm_nb;
Alexey Starikovskiyf1d46612007-09-26 19:42:52 +0400123 unsigned long update_time;
Lan Tianyu016d5ba2013-07-30 14:00:42 +0200124 int revision;
Alexey Starikovskiy7faa1442009-03-27 22:23:52 -0400125 int rate_now;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400126 int capacity_now;
127 int voltage_now;
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400128 int design_capacity;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400129 int full_charge_capacity;
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400130 int technology;
131 int design_voltage;
132 int design_capacity_warning;
133 int design_capacity_low;
Alexey Starikovskiyc67fcd62009-10-15 14:31:44 +0400134 int cycle_count;
135 int measurement_accuracy;
136 int max_sampling_time;
137 int min_sampling_time;
138 int max_averaging_interval;
139 int min_averaging_interval;
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400140 int capacity_granularity_1;
141 int capacity_granularity_2;
Alexey Starikovskiyf1d46612007-09-26 19:42:52 +0400142 int alarm;
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400143 char model_number[32];
144 char serial_number[32];
145 char type[32];
146 char oem_info[32];
Alexey Starikovskiyf1d46612007-09-26 19:42:52 +0400147 int state;
148 int power_unit;
Alexey Starikovskiy7b3bcc42009-10-15 14:31:24 +0400149 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150};
151
Phil Carmody497888c2011-07-14 15:07:13 +0300152#define to_acpi_battery(x) container_of(x, struct acpi_battery, bat)
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400153
Andy Shevchenkoefd941f2013-03-11 09:17:06 +0000154static inline int acpi_battery_present(struct acpi_battery *battery)
Alexey Starikovskiy78490d82007-05-11 13:18:55 -0400155{
156 return battery->device->status.battery_present;
157}
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400158
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400159static int acpi_battery_technology(struct acpi_battery *battery)
160{
161 if (!strcasecmp("NiCd", battery->type))
162 return POWER_SUPPLY_TECHNOLOGY_NiCd;
163 if (!strcasecmp("NiMH", battery->type))
164 return POWER_SUPPLY_TECHNOLOGY_NiMH;
165 if (!strcasecmp("LION", battery->type))
166 return POWER_SUPPLY_TECHNOLOGY_LION;
Andrey Borzenkovad40e682007-11-10 20:02:49 +0300167 if (!strncasecmp("LI-ION", battery->type, 6))
Alexey Starikovskiy0bde7ee2007-10-28 15:33:10 +0300168 return POWER_SUPPLY_TECHNOLOGY_LION;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400169 if (!strcasecmp("LiP", battery->type))
170 return POWER_SUPPLY_TECHNOLOGY_LIPO;
171 return POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
172}
173
Alexey Starikovskiy91044762007-11-13 12:23:06 +0300174static int acpi_battery_get_state(struct acpi_battery *battery);
Alexey Starikovskiyb19073a2007-10-25 17:10:47 -0400175
Richard Hughes56f382a2009-01-25 15:05:50 +0000176static int acpi_battery_is_charged(struct acpi_battery *battery)
177{
Zhang Rui1ac5aaa2014-05-28 15:23:36 +0800178 /* charging, discharging or critical low */
Richard Hughes56f382a2009-01-25 15:05:50 +0000179 if (battery->state != 0)
180 return 0;
181
182 /* battery not reporting charge */
183 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN ||
184 battery->capacity_now == 0)
185 return 0;
186
187 /* good batteries update full_charge as the batteries degrade */
188 if (battery->full_charge_capacity == battery->capacity_now)
189 return 1;
190
191 /* fallback to using design values for broken batteries */
192 if (battery->design_capacity == battery->capacity_now)
193 return 1;
194
195 /* we don't do any sort of metric based on percentages */
196 return 0;
197}
198
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400199static int acpi_battery_get_property(struct power_supply *psy,
200 enum power_supply_property psp,
201 union power_supply_propval *val)
202{
Rafael J. Wysockia1b4bd62010-10-23 19:35:15 +0200203 int ret = 0;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400204 struct acpi_battery *battery = to_acpi_battery(psy);
205
Alexey Starikovskiy91044762007-11-13 12:23:06 +0300206 if (acpi_battery_present(battery)) {
207 /* run battery update only if it is present */
208 acpi_battery_get_state(battery);
209 } else if (psp != POWER_SUPPLY_PROP_PRESENT)
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400210 return -ENODEV;
211 switch (psp) {
212 case POWER_SUPPLY_PROP_STATUS:
Zhang Rui1ac5aaa2014-05-28 15:23:36 +0800213 if (battery->state & ACPI_BATTERY_STATE_DISCHARGING)
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400214 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
Zhang Rui1ac5aaa2014-05-28 15:23:36 +0800215 else if (battery->state & ACPI_BATTERY_STATE_CHARGING)
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400216 val->intval = POWER_SUPPLY_STATUS_CHARGING;
Richard Hughes56f382a2009-01-25 15:05:50 +0000217 else if (acpi_battery_is_charged(battery))
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400218 val->intval = POWER_SUPPLY_STATUS_FULL;
Roland Dreier4c41d3a2007-11-07 15:09:09 -0800219 else
220 val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400221 break;
222 case POWER_SUPPLY_PROP_PRESENT:
223 val->intval = acpi_battery_present(battery);
224 break;
225 case POWER_SUPPLY_PROP_TECHNOLOGY:
226 val->intval = acpi_battery_technology(battery);
227 break;
Alexey Starikovskiyc67fcd62009-10-15 14:31:44 +0400228 case POWER_SUPPLY_PROP_CYCLE_COUNT:
229 val->intval = battery->cycle_count;
230 break;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400231 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
Rafael J. Wysockia1b4bd62010-10-23 19:35:15 +0200232 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
233 ret = -ENODEV;
234 else
235 val->intval = battery->design_voltage * 1000;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400236 break;
237 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
Rafael J. Wysockia1b4bd62010-10-23 19:35:15 +0200238 if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
239 ret = -ENODEV;
240 else
241 val->intval = battery->voltage_now * 1000;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400242 break;
243 case POWER_SUPPLY_PROP_CURRENT_NOW:
Alexey Starikovskiy7faa1442009-03-27 22:23:52 -0400244 case POWER_SUPPLY_PROP_POWER_NOW:
Rafael J. Wysockia1b4bd62010-10-23 19:35:15 +0200245 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
246 ret = -ENODEV;
247 else
248 val->intval = battery->rate_now * 1000;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400249 break;
250 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
251 case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
Rafael J. Wysockia1b4bd62010-10-23 19:35:15 +0200252 if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
253 ret = -ENODEV;
254 else
255 val->intval = battery->design_capacity * 1000;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400256 break;
257 case POWER_SUPPLY_PROP_CHARGE_FULL:
258 case POWER_SUPPLY_PROP_ENERGY_FULL:
Rafael J. Wysockia1b4bd62010-10-23 19:35:15 +0200259 if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
260 ret = -ENODEV;
261 else
262 val->intval = battery->full_charge_capacity * 1000;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400263 break;
264 case POWER_SUPPLY_PROP_CHARGE_NOW:
265 case POWER_SUPPLY_PROP_ENERGY_NOW:
Rafael J. Wysockia1b4bd62010-10-23 19:35:15 +0200266 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
267 ret = -ENODEV;
268 else
269 val->intval = battery->capacity_now * 1000;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400270 break;
srinivas pandruvadaa58e1152012-04-05 17:38:54 -0700271 case POWER_SUPPLY_PROP_CAPACITY:
272 if (battery->capacity_now && battery->full_charge_capacity)
273 val->intval = battery->capacity_now * 100/
274 battery->full_charge_capacity;
275 else
276 val->intval = 0;
277 break;
Zhang Rui1ac5aaa2014-05-28 15:23:36 +0800278 case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
279 if (battery->state & ACPI_BATTERY_STATE_CRITICAL)
280 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
281 else if (test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags) &&
282 (battery->capacity_now <= battery->alarm))
283 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_LOW;
284 else if (acpi_battery_is_charged(battery))
285 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
286 else
287 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
288 break;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400289 case POWER_SUPPLY_PROP_MODEL_NAME:
290 val->strval = battery->model_number;
291 break;
292 case POWER_SUPPLY_PROP_MANUFACTURER:
293 val->strval = battery->oem_info;
294 break;
maximilian attems7c2670b2008-01-22 18:46:50 +0100295 case POWER_SUPPLY_PROP_SERIAL_NUMBER:
296 val->strval = battery->serial_number;
297 break;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400298 default:
Rafael J. Wysockia1b4bd62010-10-23 19:35:15 +0200299 ret = -EINVAL;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400300 }
Rafael J. Wysockia1b4bd62010-10-23 19:35:15 +0200301 return ret;
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400302}
303
304static enum power_supply_property charge_battery_props[] = {
305 POWER_SUPPLY_PROP_STATUS,
306 POWER_SUPPLY_PROP_PRESENT,
307 POWER_SUPPLY_PROP_TECHNOLOGY,
Alexey Starikovskiyc67fcd62009-10-15 14:31:44 +0400308 POWER_SUPPLY_PROP_CYCLE_COUNT,
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400309 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
310 POWER_SUPPLY_PROP_VOLTAGE_NOW,
311 POWER_SUPPLY_PROP_CURRENT_NOW,
312 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
313 POWER_SUPPLY_PROP_CHARGE_FULL,
314 POWER_SUPPLY_PROP_CHARGE_NOW,
srinivas pandruvadaa58e1152012-04-05 17:38:54 -0700315 POWER_SUPPLY_PROP_CAPACITY,
Zhang Rui1ac5aaa2014-05-28 15:23:36 +0800316 POWER_SUPPLY_PROP_CAPACITY_LEVEL,
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400317 POWER_SUPPLY_PROP_MODEL_NAME,
318 POWER_SUPPLY_PROP_MANUFACTURER,
maximilian attems7c2670b2008-01-22 18:46:50 +0100319 POWER_SUPPLY_PROP_SERIAL_NUMBER,
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400320};
321
322static enum power_supply_property energy_battery_props[] = {
323 POWER_SUPPLY_PROP_STATUS,
324 POWER_SUPPLY_PROP_PRESENT,
325 POWER_SUPPLY_PROP_TECHNOLOGY,
Alexey Starikovskiyc67fcd62009-10-15 14:31:44 +0400326 POWER_SUPPLY_PROP_CYCLE_COUNT,
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400327 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
328 POWER_SUPPLY_PROP_VOLTAGE_NOW,
Alexey Starikovskiy7faa1442009-03-27 22:23:52 -0400329 POWER_SUPPLY_PROP_POWER_NOW,
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400330 POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
331 POWER_SUPPLY_PROP_ENERGY_FULL,
332 POWER_SUPPLY_PROP_ENERGY_NOW,
srinivas pandruvadaa58e1152012-04-05 17:38:54 -0700333 POWER_SUPPLY_PROP_CAPACITY,
Zhang Rui1ac5aaa2014-05-28 15:23:36 +0800334 POWER_SUPPLY_PROP_CAPACITY_LEVEL,
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400335 POWER_SUPPLY_PROP_MODEL_NAME,
336 POWER_SUPPLY_PROP_MANUFACTURER,
maximilian attems7c2670b2008-01-22 18:46:50 +0100337 POWER_SUPPLY_PROP_SERIAL_NUMBER,
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400338};
339
Lan Tianyu3a670cc2014-05-04 11:07:25 +0800340#ifdef CONFIG_ACPI_PROCFS_POWER
341inline char *acpi_battery_units(struct acpi_battery *battery)
342{
343 return (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) ?
344 "mA" : "mW";
345}
346#endif
347
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348/* --------------------------------------------------------------------------
349 Battery Management
350 -------------------------------------------------------------------------- */
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400351struct acpi_offsets {
352 size_t offset; /* offset inside struct acpi_sbs_battery */
353 u8 mode; /* int or string? */
354};
355
356static struct acpi_offsets state_offsets[] = {
357 {offsetof(struct acpi_battery, state), 0},
Alexey Starikovskiy7faa1442009-03-27 22:23:52 -0400358 {offsetof(struct acpi_battery, rate_now), 0},
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400359 {offsetof(struct acpi_battery, capacity_now), 0},
360 {offsetof(struct acpi_battery, voltage_now), 0},
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400361};
362
363static struct acpi_offsets info_offsets[] = {
364 {offsetof(struct acpi_battery, power_unit), 0},
365 {offsetof(struct acpi_battery, design_capacity), 0},
Alexey Starikovskiyd7380962007-09-26 19:43:04 +0400366 {offsetof(struct acpi_battery, full_charge_capacity), 0},
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400367 {offsetof(struct acpi_battery, technology), 0},
368 {offsetof(struct acpi_battery, design_voltage), 0},
369 {offsetof(struct acpi_battery, design_capacity_warning), 0},
370 {offsetof(struct acpi_battery, design_capacity_low), 0},
371 {offsetof(struct acpi_battery, capacity_granularity_1), 0},
372 {offsetof(struct acpi_battery, capacity_granularity_2), 0},
373 {offsetof(struct acpi_battery, model_number), 1},
374 {offsetof(struct acpi_battery, serial_number), 1},
375 {offsetof(struct acpi_battery, type), 1},
376 {offsetof(struct acpi_battery, oem_info), 1},
377};
378
Alexey Starikovskiyc67fcd62009-10-15 14:31:44 +0400379static struct acpi_offsets extended_info_offsets[] = {
Lan Tianyu016d5ba2013-07-30 14:00:42 +0200380 {offsetof(struct acpi_battery, revision), 0},
Alexey Starikovskiyc67fcd62009-10-15 14:31:44 +0400381 {offsetof(struct acpi_battery, power_unit), 0},
382 {offsetof(struct acpi_battery, design_capacity), 0},
383 {offsetof(struct acpi_battery, full_charge_capacity), 0},
384 {offsetof(struct acpi_battery, technology), 0},
385 {offsetof(struct acpi_battery, design_voltage), 0},
386 {offsetof(struct acpi_battery, design_capacity_warning), 0},
387 {offsetof(struct acpi_battery, design_capacity_low), 0},
388 {offsetof(struct acpi_battery, cycle_count), 0},
389 {offsetof(struct acpi_battery, measurement_accuracy), 0},
390 {offsetof(struct acpi_battery, max_sampling_time), 0},
391 {offsetof(struct acpi_battery, min_sampling_time), 0},
392 {offsetof(struct acpi_battery, max_averaging_interval), 0},
393 {offsetof(struct acpi_battery, min_averaging_interval), 0},
394 {offsetof(struct acpi_battery, capacity_granularity_1), 0},
395 {offsetof(struct acpi_battery, capacity_granularity_2), 0},
396 {offsetof(struct acpi_battery, model_number), 1},
397 {offsetof(struct acpi_battery, serial_number), 1},
398 {offsetof(struct acpi_battery, type), 1},
399 {offsetof(struct acpi_battery, oem_info), 1},
400};
401
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400402static int extract_package(struct acpi_battery *battery,
403 union acpi_object *package,
404 struct acpi_offsets *offsets, int num)
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300405{
Alexey Starikovskiy106449e2007-10-29 23:29:40 +0300406 int i;
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400407 union acpi_object *element;
408 if (package->type != ACPI_TYPE_PACKAGE)
409 return -EFAULT;
410 for (i = 0; i < num; ++i) {
411 if (package->package.count <= i)
412 return -EFAULT;
413 element = &package->package.elements[i];
414 if (offsets[i].mode) {
Alexey Starikovskiy106449e2007-10-29 23:29:40 +0300415 u8 *ptr = (u8 *)battery + offsets[i].offset;
416 if (element->type == ACPI_TYPE_STRING ||
417 element->type == ACPI_TYPE_BUFFER)
418 strncpy(ptr, element->string.pointer, 32);
419 else if (element->type == ACPI_TYPE_INTEGER) {
420 strncpy(ptr, (u8 *)&element->integer.value,
Lin Ming439913f2010-01-28 10:53:19 +0800421 sizeof(u64));
422 ptr[sizeof(u64)] = 0;
Alexey Starikovskiyb8a1bdb2008-03-17 22:37:42 -0400423 } else
424 *ptr = 0; /* don't have value */
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400425 } else {
Alexey Starikovskiyb8a1bdb2008-03-17 22:37:42 -0400426 int *x = (int *)((u8 *)battery + offsets[i].offset);
427 *x = (element->type == ACPI_TYPE_INTEGER) ?
428 element->integer.value : -1;
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300429 }
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300430 }
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300431 return 0;
432}
433
434static int acpi_battery_get_status(struct acpi_battery *battery)
435{
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400436 if (acpi_bus_get_status(battery->device)) {
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300437 ACPI_EXCEPTION((AE_INFO, AE_ERROR, "Evaluating _STA"));
438 return -ENODEV;
439 }
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400440 return 0;
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300441}
442
443static int acpi_battery_get_info(struct acpi_battery *battery)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444{
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400445 int result = -EFAULT;
Len Brown4be44fc2005-08-05 00:44:28 -0400446 acpi_status status = 0;
Nicholas Mazzuca0f4c6542013-05-08 23:11:15 +0000447 char *name = test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags) ?
Alexey Starikovskiyc67fcd62009-10-15 14:31:44 +0400448 "_BIX" : "_BIF";
449
Len Brown4be44fc2005-08-05 00:44:28 -0400450 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300452 if (!acpi_battery_present(battery))
453 return 0;
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400454 mutex_lock(&battery->lock);
Alexey Starikovskiyc67fcd62009-10-15 14:31:44 +0400455 status = acpi_evaluate_object(battery->device->handle, name,
456 NULL, &buffer);
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400457 mutex_unlock(&battery->lock);
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400458
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 if (ACPI_FAILURE(status)) {
Alexey Starikovskiyc67fcd62009-10-15 14:31:44 +0400460 ACPI_EXCEPTION((AE_INFO, status, "Evaluating %s", name));
Patrick Mocheld550d982006-06-27 00:41:40 -0400461 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 }
Lan Tianyua90b4032014-01-06 22:50:37 +0800463
464 if (battery_bix_broken_package)
465 result = extract_package(battery, buffer.pointer,
466 extended_info_offsets + 1,
467 ARRAY_SIZE(extended_info_offsets) - 1);
468 else if (test_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags))
Alexey Starikovskiyc67fcd62009-10-15 14:31:44 +0400469 result = extract_package(battery, buffer.pointer,
470 extended_info_offsets,
471 ARRAY_SIZE(extended_info_offsets));
472 else
473 result = extract_package(battery, buffer.pointer,
474 info_offsets, ARRAY_SIZE(info_offsets));
Alexey Starikovskiy78490d82007-05-11 13:18:55 -0400475 kfree(buffer.pointer);
Zhang Rui557d5862010-10-22 10:02:06 +0800476 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
477 battery->full_charge_capacity = battery->design_capacity;
Kamil Iskra4000e6262012-11-16 22:28:58 +0100478 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
479 battery->power_unit && battery->design_voltage) {
480 battery->design_capacity = battery->design_capacity *
481 10000 / battery->design_voltage;
482 battery->full_charge_capacity = battery->full_charge_capacity *
483 10000 / battery->design_voltage;
484 battery->design_capacity_warning =
485 battery->design_capacity_warning *
486 10000 / battery->design_voltage;
487 /* Curiously, design_capacity_low, unlike the rest of them,
488 is correct. */
489 /* capacity_granularity_* equal 1 on the systems tested, so
490 it's impossible to tell if they would need an adjustment
491 or not if their values were higher. */
492 }
Patrick Mocheld550d982006-06-27 00:41:40 -0400493 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494}
495
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300496static int acpi_battery_get_state(struct acpi_battery *battery)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497{
Len Brown4be44fc2005-08-05 00:44:28 -0400498 int result = 0;
499 acpi_status status = 0;
500 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300502 if (!acpi_battery_present(battery))
503 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504
Alexey Starikovskiyf1d46612007-09-26 19:42:52 +0400505 if (battery->update_time &&
506 time_before(jiffies, battery->update_time +
507 msecs_to_jiffies(cache_time)))
508 return 0;
509
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400510 mutex_lock(&battery->lock);
Alexey Starikovskiyf1d46612007-09-26 19:42:52 +0400511 status = acpi_evaluate_object(battery->device->handle, "_BST",
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400512 NULL, &buffer);
513 mutex_unlock(&battery->lock);
Len Brown5b31d892007-08-15 00:19:26 -0400514
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515 if (ACPI_FAILURE(status)) {
Thomas Renningera6fc6722006-06-26 23:58:43 -0400516 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BST"));
Patrick Mocheld550d982006-06-27 00:41:40 -0400517 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518 }
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400519
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400520 result = extract_package(battery, buffer.pointer,
521 state_offsets, ARRAY_SIZE(state_offsets));
Alexey Starikovskiyf1d46612007-09-26 19:42:52 +0400522 battery->update_time = jiffies;
Alexey Starikovskiy78490d82007-05-11 13:18:55 -0400523 kfree(buffer.pointer);
Hector Martinbc76f902009-08-06 15:57:48 -0700524
Lan Tianyu55003b22011-06-30 11:33:12 +0800525 /* For buggy DSDTs that report negative 16-bit values for either
526 * charging or discharging current and/or report 0 as 65536
527 * due to bad math.
528 */
529 if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA &&
530 battery->rate_now != ACPI_BATTERY_VALUE_UNKNOWN &&
531 (s16)(battery->rate_now) < 0) {
Hector Martinbc76f902009-08-06 15:57:48 -0700532 battery->rate_now = abs((s16)battery->rate_now);
Lan Tianyu55003b22011-06-30 11:33:12 +0800533 printk_once(KERN_WARNING FW_BUG "battery: (dis)charge rate"
534 " invalid.\n");
535 }
Hector Martinbc76f902009-08-06 15:57:48 -0700536
Zhang Rui557d5862010-10-22 10:02:06 +0800537 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags)
538 && battery->capacity_now >= 0 && battery->capacity_now <= 100)
539 battery->capacity_now = (battery->capacity_now *
540 battery->full_charge_capacity) / 100;
Kamil Iskra4000e6262012-11-16 22:28:58 +0100541 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags) &&
542 battery->power_unit && battery->design_voltage) {
543 battery->capacity_now = battery->capacity_now *
544 10000 / battery->design_voltage;
545 }
Patrick Mocheld550d982006-06-27 00:41:40 -0400546 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547}
548
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400549static int acpi_battery_set_alarm(struct acpi_battery *battery)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550{
Len Brown4be44fc2005-08-05 00:44:28 -0400551 acpi_status status = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552
Alexey Starikovskiyc67fcd62009-10-15 14:31:44 +0400553 if (!acpi_battery_present(battery) ||
Alexey Starikovskiy7b3bcc42009-10-15 14:31:24 +0400554 !test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags))
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300555 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400557 mutex_lock(&battery->lock);
Jiang Liu0db98202013-06-29 00:24:39 +0800558 status = acpi_execute_simple_method(battery->device->handle, "_BTP",
559 battery->alarm);
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +0400560 mutex_unlock(&battery->lock);
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400561
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 if (ACPI_FAILURE(status))
Patrick Mocheld550d982006-06-27 00:41:40 -0400563 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400565 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Alarm set to %d\n", battery->alarm));
Patrick Mocheld550d982006-06-27 00:41:40 -0400566 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567}
568
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300569static int acpi_battery_init_alarm(struct acpi_battery *battery)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570{
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300571 /* See if alarms are supported, and if so, set default */
Jiang Liu952c63e2013-06-29 00:24:38 +0800572 if (!acpi_has_method(battery->device->handle, "_BTP")) {
Alexey Starikovskiy7b3bcc42009-10-15 14:31:24 +0400573 clear_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
Alexey Starikovskiyf1d46612007-09-26 19:42:52 +0400574 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 }
Alexey Starikovskiy7b3bcc42009-10-15 14:31:24 +0400576 set_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
Alexey Starikovskiyf1d46612007-09-26 19:42:52 +0400577 if (!battery->alarm)
578 battery->alarm = battery->design_capacity_warning;
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +0400579 return acpi_battery_set_alarm(battery);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580}
581
Andrey Borzenkov508df922007-10-28 12:50:09 +0300582static ssize_t acpi_battery_alarm_show(struct device *dev,
583 struct device_attribute *attr,
584 char *buf)
585{
586 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
587 return sprintf(buf, "%d\n", battery->alarm * 1000);
588}
589
590static ssize_t acpi_battery_alarm_store(struct device *dev,
591 struct device_attribute *attr,
592 const char *buf, size_t count)
593{
594 unsigned long x;
595 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
Luis G.F47a08c82014-01-21 15:40:43 +0100596 if (sscanf(buf, "%lu\n", &x) == 1)
Andrey Borzenkov508df922007-10-28 12:50:09 +0300597 battery->alarm = x/1000;
598 if (acpi_battery_present(battery))
599 acpi_battery_set_alarm(battery);
600 return count;
601}
602
603static struct device_attribute alarm_attr = {
Parag Warudkar01e8ef12008-10-18 20:28:50 -0700604 .attr = {.name = "alarm", .mode = 0644},
Andrey Borzenkov508df922007-10-28 12:50:09 +0300605 .show = acpi_battery_alarm_show,
606 .store = acpi_battery_alarm_store,
607};
608
609static int sysfs_add_battery(struct acpi_battery *battery)
610{
611 int result;
612
Lan Tianyuae6f6182011-06-30 11:32:40 +0800613 if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) {
Andrey Borzenkov508df922007-10-28 12:50:09 +0300614 battery->bat.properties = charge_battery_props;
615 battery->bat.num_properties =
616 ARRAY_SIZE(charge_battery_props);
617 } else {
618 battery->bat.properties = energy_battery_props;
619 battery->bat.num_properties =
620 ARRAY_SIZE(energy_battery_props);
621 }
622
623 battery->bat.name = acpi_device_bid(battery->device);
624 battery->bat.type = POWER_SUPPLY_TYPE_BATTERY;
625 battery->bat.get_property = acpi_battery_get_property;
626
Zhang Ruie0d1f092014-05-28 15:23:38 +0800627 result = power_supply_register_no_ws(&battery->device->dev, &battery->bat);
628
Andrey Borzenkov508df922007-10-28 12:50:09 +0300629 if (result)
630 return result;
631 return device_create_file(battery->bat.dev, &alarm_attr);
632}
633
634static void sysfs_remove_battery(struct acpi_battery *battery)
635{
Sergey Senozhatsky69d94ec2011-08-06 01:34:08 +0300636 mutex_lock(&battery->sysfs_lock);
Lan Tianyu9c921c222011-06-30 11:34:12 +0800637 if (!battery->bat.dev) {
Sergey Senozhatsky69d94ec2011-08-06 01:34:08 +0300638 mutex_unlock(&battery->sysfs_lock);
Andrey Borzenkov508df922007-10-28 12:50:09 +0300639 return;
Lan Tianyu9c921c222011-06-30 11:34:12 +0800640 }
641
Andrey Borzenkov508df922007-10-28 12:50:09 +0300642 device_remove_file(battery->bat.dev, &alarm_attr);
643 power_supply_unregister(&battery->bat);
Alexey Starikovskiy91044762007-11-13 12:23:06 +0300644 battery->bat.dev = NULL;
Sergey Senozhatsky69d94ec2011-08-06 01:34:08 +0300645 mutex_unlock(&battery->sysfs_lock);
Hector Martinbc76f902009-08-06 15:57:48 -0700646}
647
Kamil Iskra4000e6262012-11-16 22:28:58 +0100648static void find_battery(const struct dmi_header *dm, void *private)
649{
650 struct acpi_battery *battery = (struct acpi_battery *)private;
651 /* Note: the hardcoded offsets below have been extracted from
652 the source code of dmidecode. */
653 if (dm->type == DMI_ENTRY_PORTABLE_BATTERY && dm->length >= 8) {
654 const u8 *dmi_data = (const u8 *)(dm + 1);
655 int dmi_capacity = get_unaligned((const u16 *)(dmi_data + 6));
656 if (dm->length >= 18)
657 dmi_capacity *= dmi_data[17];
658 if (battery->design_capacity * battery->design_voltage / 1000
659 != dmi_capacity &&
660 battery->design_capacity * 10 == dmi_capacity)
661 set_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
662 &battery->flags);
663 }
664}
665
Zhang Rui557d5862010-10-22 10:02:06 +0800666/*
667 * According to the ACPI spec, some kinds of primary batteries can
668 * report percentage battery remaining capacity directly to OS.
669 * In this case, it reports the Last Full Charged Capacity == 100
670 * and BatteryPresentRate == 0xFFFFFFFF.
671 *
672 * Now we found some battery reports percentage remaining capacity
673 * even if it's rechargeable.
674 * https://bugzilla.kernel.org/show_bug.cgi?id=15979
675 *
676 * Handle this correctly so that they won't break userspace.
677 */
Lan Tianyu7b786222011-06-30 11:33:27 +0800678static void acpi_battery_quirks(struct acpi_battery *battery)
Zhang Rui557d5862010-10-22 10:02:06 +0800679{
680 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
Nicholas Mazzuca0f4c6542013-05-08 23:11:15 +0000681 return;
Zhang Rui557d5862010-10-22 10:02:06 +0800682
Nicholas Mazzuca0f4c6542013-05-08 23:11:15 +0000683 if (battery->full_charge_capacity == 100 &&
684 battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN &&
685 battery->capacity_now >= 0 && battery->capacity_now <= 100) {
Zhang Rui557d5862010-10-22 10:02:06 +0800686 set_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags);
687 battery->full_charge_capacity = battery->design_capacity;
688 battery->capacity_now = (battery->capacity_now *
689 battery->full_charge_capacity) / 100;
690 }
Kamil Iskra4000e6262012-11-16 22:28:58 +0100691
692 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH, &battery->flags))
Nicholas Mazzuca0f4c6542013-05-08 23:11:15 +0000693 return;
Kamil Iskra4000e6262012-11-16 22:28:58 +0100694
695 if (battery->power_unit && dmi_name_in_vendors("LENOVO")) {
696 const char *s;
697 s = dmi_get_system_info(DMI_PRODUCT_VERSION);
Rasmus Villemoesffd8a732014-09-16 22:51:24 +0200698 if (s && !strncasecmp(s, "ThinkPad", 8)) {
Kamil Iskra4000e6262012-11-16 22:28:58 +0100699 dmi_walk(find_battery, battery);
700 if (test_bit(ACPI_BATTERY_QUIRK_THINKPAD_MAH,
701 &battery->flags) &&
702 battery->design_voltage) {
703 battery->design_capacity =
704 battery->design_capacity *
705 10000 / battery->design_voltage;
706 battery->full_charge_capacity =
707 battery->full_charge_capacity *
708 10000 / battery->design_voltage;
709 battery->design_capacity_warning =
710 battery->design_capacity_warning *
711 10000 / battery->design_voltage;
712 battery->capacity_now = battery->capacity_now *
713 10000 / battery->design_voltage;
714 }
715 }
716 }
Zhang Rui557d5862010-10-22 10:02:06 +0800717}
718
Lan Tianyu9e50bc12014-05-04 14:07:06 +0800719static int acpi_battery_update(struct acpi_battery *battery, bool resume)
Vladimir Lebedev4bd35cd2007-02-10 01:43:48 -0500720{
Alexey Starikovskiy50b17852008-12-23 02:44:54 +0300721 int result, old_present = acpi_battery_present(battery);
Alexey Starikovskiy97749cd2008-01-01 14:27:24 -0500722 result = acpi_battery_get_status(battery);
Andrey Borzenkov508df922007-10-28 12:50:09 +0300723 if (result)
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300724 return result;
Andrey Borzenkov508df922007-10-28 12:50:09 +0300725 if (!acpi_battery_present(battery)) {
726 sysfs_remove_battery(battery);
Alexey Starikovskiy97749cd2008-01-01 14:27:24 -0500727 battery->update_time = 0;
Andrey Borzenkov508df922007-10-28 12:50:09 +0300728 return 0;
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +0300729 }
Lan Tianyu9e50bc12014-05-04 14:07:06 +0800730
731 if (resume)
732 return 0;
733
Alexey Starikovskiy50b17852008-12-23 02:44:54 +0300734 if (!battery->update_time ||
735 old_present != acpi_battery_present(battery)) {
Alexey Starikovskiy97749cd2008-01-01 14:27:24 -0500736 result = acpi_battery_get_info(battery);
737 if (result)
738 return result;
739 acpi_battery_init_alarm(battery);
740 }
Stefan Hajnoczieb03cb02011-07-12 09:03:29 +0100741 if (!battery->bat.dev) {
742 result = sysfs_add_battery(battery);
743 if (result)
744 return result;
745 }
Zhang Rui557d5862010-10-22 10:02:06 +0800746 result = acpi_battery_get_state(battery);
Zhang Ruie0d1f092014-05-28 15:23:38 +0800747 if (result)
748 return result;
Lan Tianyu7b786222011-06-30 11:33:27 +0800749 acpi_battery_quirks(battery);
Zhang Ruie0d1f092014-05-28 15:23:38 +0800750
751 /*
752 * Wakeup the system if battery is critical low
753 * or lower than the alarm level
754 */
755 if ((battery->state & ACPI_BATTERY_STATE_CRITICAL) ||
756 (test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags) &&
757 (battery->capacity_now <= battery->alarm)))
758 pm_wakeup_event(&battery->device->dev, 0);
759
Zhang Rui557d5862010-10-22 10:02:06 +0800760 return result;
Vladimir Lebedev4bd35cd2007-02-10 01:43:48 -0500761}
762
Rafael J. Wysockida8aeb92011-01-06 23:42:27 +0100763static void acpi_battery_refresh(struct acpi_battery *battery)
764{
Andy Whitcroftc5971452012-05-03 14:48:26 +0100765 int power_unit;
766
Rafael J. Wysockida8aeb92011-01-06 23:42:27 +0100767 if (!battery->bat.dev)
768 return;
769
Andy Whitcroftc5971452012-05-03 14:48:26 +0100770 power_unit = battery->power_unit;
771
Rafael J. Wysockida8aeb92011-01-06 23:42:27 +0100772 acpi_battery_get_info(battery);
Andy Whitcroftc5971452012-05-03 14:48:26 +0100773
774 if (power_unit == battery->power_unit)
775 return;
776
777 /* The battery has changed its reporting units. */
Rafael J. Wysockida8aeb92011-01-06 23:42:27 +0100778 sysfs_remove_battery(battery);
779 sysfs_add_battery(battery);
780}
781
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782/* --------------------------------------------------------------------------
Lan Tianyu3a670cc2014-05-04 11:07:25 +0800783 FS Interface (/proc)
784 -------------------------------------------------------------------------- */
785
786#ifdef CONFIG_ACPI_PROCFS_POWER
787static struct proc_dir_entry *acpi_battery_dir;
788
789static int acpi_battery_print_info(struct seq_file *seq, int result)
790{
791 struct acpi_battery *battery = seq->private;
792
793 if (result)
794 goto end;
795
796 seq_printf(seq, "present: %s\n",
797 acpi_battery_present(battery) ? "yes" : "no");
798 if (!acpi_battery_present(battery))
799 goto end;
800 if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
801 seq_printf(seq, "design capacity: unknown\n");
802 else
803 seq_printf(seq, "design capacity: %d %sh\n",
804 battery->design_capacity,
805 acpi_battery_units(battery));
806
807 if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
808 seq_printf(seq, "last full capacity: unknown\n");
809 else
810 seq_printf(seq, "last full capacity: %d %sh\n",
811 battery->full_charge_capacity,
812 acpi_battery_units(battery));
813
814 seq_printf(seq, "battery technology: %srechargeable\n",
815 (!battery->technology)?"non-":"");
816
817 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
818 seq_printf(seq, "design voltage: unknown\n");
819 else
820 seq_printf(seq, "design voltage: %d mV\n",
821 battery->design_voltage);
822 seq_printf(seq, "design capacity warning: %d %sh\n",
823 battery->design_capacity_warning,
824 acpi_battery_units(battery));
825 seq_printf(seq, "design capacity low: %d %sh\n",
826 battery->design_capacity_low,
827 acpi_battery_units(battery));
828 seq_printf(seq, "cycle count: %i\n", battery->cycle_count);
829 seq_printf(seq, "capacity granularity 1: %d %sh\n",
830 battery->capacity_granularity_1,
831 acpi_battery_units(battery));
832 seq_printf(seq, "capacity granularity 2: %d %sh\n",
833 battery->capacity_granularity_2,
834 acpi_battery_units(battery));
835 seq_printf(seq, "model number: %s\n", battery->model_number);
836 seq_printf(seq, "serial number: %s\n", battery->serial_number);
837 seq_printf(seq, "battery type: %s\n", battery->type);
838 seq_printf(seq, "OEM info: %s\n", battery->oem_info);
839 end:
840 if (result)
841 seq_printf(seq, "ERROR: Unable to read battery info\n");
842 return result;
843}
844
845static int acpi_battery_print_state(struct seq_file *seq, int result)
846{
847 struct acpi_battery *battery = seq->private;
848
849 if (result)
850 goto end;
851
852 seq_printf(seq, "present: %s\n",
853 acpi_battery_present(battery) ? "yes" : "no");
854 if (!acpi_battery_present(battery))
855 goto end;
856
857 seq_printf(seq, "capacity state: %s\n",
858 (battery->state & 0x04) ? "critical" : "ok");
859 if ((battery->state & 0x01) && (battery->state & 0x02))
860 seq_printf(seq,
861 "charging state: charging/discharging\n");
862 else if (battery->state & 0x01)
863 seq_printf(seq, "charging state: discharging\n");
864 else if (battery->state & 0x02)
865 seq_printf(seq, "charging state: charging\n");
866 else
867 seq_printf(seq, "charging state: charged\n");
868
869 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
870 seq_printf(seq, "present rate: unknown\n");
871 else
872 seq_printf(seq, "present rate: %d %s\n",
873 battery->rate_now, acpi_battery_units(battery));
874
875 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
876 seq_printf(seq, "remaining capacity: unknown\n");
877 else
878 seq_printf(seq, "remaining capacity: %d %sh\n",
879 battery->capacity_now, acpi_battery_units(battery));
880 if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
881 seq_printf(seq, "present voltage: unknown\n");
882 else
883 seq_printf(seq, "present voltage: %d mV\n",
884 battery->voltage_now);
885 end:
886 if (result)
887 seq_printf(seq, "ERROR: Unable to read battery state\n");
888
889 return result;
890}
891
892static int acpi_battery_print_alarm(struct seq_file *seq, int result)
893{
894 struct acpi_battery *battery = seq->private;
895
896 if (result)
897 goto end;
898
899 if (!acpi_battery_present(battery)) {
900 seq_printf(seq, "present: no\n");
901 goto end;
902 }
903 seq_printf(seq, "alarm: ");
904 if (!battery->alarm)
905 seq_printf(seq, "unsupported\n");
906 else
907 seq_printf(seq, "%u %sh\n", battery->alarm,
908 acpi_battery_units(battery));
909 end:
910 if (result)
911 seq_printf(seq, "ERROR: Unable to read battery alarm\n");
912 return result;
913}
914
915static ssize_t acpi_battery_write_alarm(struct file *file,
916 const char __user * buffer,
917 size_t count, loff_t * ppos)
918{
919 int result = 0;
920 char alarm_string[12] = { '\0' };
921 struct seq_file *m = file->private_data;
922 struct acpi_battery *battery = m->private;
923
924 if (!battery || (count > sizeof(alarm_string) - 1))
925 return -EINVAL;
926 if (!acpi_battery_present(battery)) {
927 result = -ENODEV;
928 goto end;
929 }
930 if (copy_from_user(alarm_string, buffer, count)) {
931 result = -EFAULT;
932 goto end;
933 }
934 alarm_string[count] = '\0';
Christoph Jaeger3d915892014-06-13 21:49:58 +0200935 if (kstrtoint(alarm_string, 0, &battery->alarm)) {
936 result = -EINVAL;
937 goto end;
938 }
Lan Tianyu3a670cc2014-05-04 11:07:25 +0800939 result = acpi_battery_set_alarm(battery);
940 end:
941 if (!result)
942 return count;
943 return result;
944}
945
946typedef int(*print_func)(struct seq_file *seq, int result);
947
948static print_func acpi_print_funcs[ACPI_BATTERY_NUMFILES] = {
949 acpi_battery_print_info,
950 acpi_battery_print_state,
951 acpi_battery_print_alarm,
952};
953
954static int acpi_battery_read(int fid, struct seq_file *seq)
955{
956 struct acpi_battery *battery = seq->private;
Lan Tianyu9e50bc12014-05-04 14:07:06 +0800957 int result = acpi_battery_update(battery, false);
Lan Tianyu3a670cc2014-05-04 11:07:25 +0800958 return acpi_print_funcs[fid](seq, result);
959}
960
961#define DECLARE_FILE_FUNCTIONS(_name) \
962static int acpi_battery_read_##_name(struct seq_file *seq, void *offset) \
963{ \
964 return acpi_battery_read(_name##_tag, seq); \
965} \
966static int acpi_battery_##_name##_open_fs(struct inode *inode, struct file *file) \
967{ \
968 return single_open(file, acpi_battery_read_##_name, PDE_DATA(inode)); \
969}
970
971DECLARE_FILE_FUNCTIONS(info);
972DECLARE_FILE_FUNCTIONS(state);
973DECLARE_FILE_FUNCTIONS(alarm);
974
975#undef DECLARE_FILE_FUNCTIONS
976
977#define FILE_DESCRIPTION_RO(_name) \
978 { \
979 .name = __stringify(_name), \
980 .mode = S_IRUGO, \
981 .ops = { \
982 .open = acpi_battery_##_name##_open_fs, \
983 .read = seq_read, \
984 .llseek = seq_lseek, \
985 .release = single_release, \
986 .owner = THIS_MODULE, \
987 }, \
988 }
989
990#define FILE_DESCRIPTION_RW(_name) \
991 { \
992 .name = __stringify(_name), \
993 .mode = S_IFREG | S_IRUGO | S_IWUSR, \
994 .ops = { \
995 .open = acpi_battery_##_name##_open_fs, \
996 .read = seq_read, \
997 .llseek = seq_lseek, \
998 .write = acpi_battery_write_##_name, \
999 .release = single_release, \
1000 .owner = THIS_MODULE, \
1001 }, \
1002 }
1003
1004static const struct battery_file {
1005 struct file_operations ops;
1006 umode_t mode;
1007 const char *name;
1008} acpi_battery_file[] = {
1009 FILE_DESCRIPTION_RO(info),
1010 FILE_DESCRIPTION_RO(state),
1011 FILE_DESCRIPTION_RW(alarm),
1012};
1013
1014#undef FILE_DESCRIPTION_RO
1015#undef FILE_DESCRIPTION_RW
1016
1017static int acpi_battery_add_fs(struct acpi_device *device)
1018{
1019 struct proc_dir_entry *entry = NULL;
1020 int i;
1021
1022 printk(KERN_WARNING PREFIX "Deprecated procfs I/F for battery is loaded,"
1023 " please retry with CONFIG_ACPI_PROCFS_POWER cleared\n");
1024 if (!acpi_device_dir(device)) {
1025 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
1026 acpi_battery_dir);
1027 if (!acpi_device_dir(device))
1028 return -ENODEV;
1029 }
1030
1031 for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i) {
1032 entry = proc_create_data(acpi_battery_file[i].name,
1033 acpi_battery_file[i].mode,
1034 acpi_device_dir(device),
1035 &acpi_battery_file[i].ops,
1036 acpi_driver_data(device));
1037 if (!entry)
1038 return -ENODEV;
1039 }
1040 return 0;
1041}
1042
1043static void acpi_battery_remove_fs(struct acpi_device *device)
1044{
1045 int i;
1046 if (!acpi_device_dir(device))
1047 return;
1048 for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i)
1049 remove_proc_entry(acpi_battery_file[i].name,
1050 acpi_device_dir(device));
1051
1052 remove_proc_entry(acpi_device_bid(device), acpi_battery_dir);
1053 acpi_device_dir(device) = NULL;
1054}
1055
1056#endif
1057
1058/* --------------------------------------------------------------------------
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059 Driver Interface
1060 -------------------------------------------------------------------------- */
1061
Bjorn Helgaasd9406692009-04-30 09:35:47 -06001062static void acpi_battery_notify(struct acpi_device *device, u32 event)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063{
Bjorn Helgaasd9406692009-04-30 09:35:47 -06001064 struct acpi_battery *battery = acpi_driver_data(device);
Zhang Rui153e5002010-07-07 09:11:57 +08001065 struct device *old;
Bjorn Helgaasd9406692009-04-30 09:35:47 -06001066
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067 if (!battery)
Patrick Mocheld550d982006-06-27 00:41:40 -04001068 return;
Zhang Rui153e5002010-07-07 09:11:57 +08001069 old = battery->bat.dev;
Alexander Mezinf43691c2014-06-04 02:01:23 +07001070 /*
1071 * On Acer Aspire V5-573G notifications are sometimes triggered too
1072 * early. For example, when AC is unplugged and notification is
1073 * triggered, battery state is still reported as "Full", and changes to
1074 * "Discharging" only after short delay, without any notification.
1075 */
1076 if (battery_notification_delay_ms > 0)
1077 msleep(battery_notification_delay_ms);
Rafael J. Wysockida8aeb92011-01-06 23:42:27 +01001078 if (event == ACPI_BATTERY_NOTIFY_INFO)
1079 acpi_battery_refresh(battery);
Lan Tianyu9e50bc12014-05-04 14:07:06 +08001080 acpi_battery_update(battery, false);
Alexey Starikovskiyf1d46612007-09-26 19:42:52 +04001081 acpi_bus_generate_netlink_event(device->pnp.device_class,
Kay Sievers07944692008-10-30 01:18:59 +01001082 dev_name(&device->dev), event,
Vladimir Lebedev9ea7d572007-02-20 15:48:06 +03001083 acpi_battery_present(battery));
Alexander Mezin411e0f72014-03-12 00:58:47 +07001084 acpi_notifier_call_chain(device, event, acpi_battery_present(battery));
Justin P. Mattock2345baf2009-12-13 14:42:36 -08001085 /* acpi_battery_update could remove power_supply object */
Zhang Rui153e5002010-07-07 09:11:57 +08001086 if (old && battery->bat.dev)
Alan Jenkinsf79e1ce2009-06-30 14:36:16 +00001087 power_supply_changed(&battery->bat);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001088}
1089
Kyle McMartin25be5822011-03-22 16:19:50 -04001090static int battery_notify(struct notifier_block *nb,
1091 unsigned long mode, void *_unused)
1092{
1093 struct acpi_battery *battery = container_of(nb, struct acpi_battery,
1094 pm_nb);
Lan Tianyu9e50bc12014-05-04 14:07:06 +08001095 int result;
1096
Kyle McMartin25be5822011-03-22 16:19:50 -04001097 switch (mode) {
Lan Tianyud5a59112011-06-30 11:33:40 +08001098 case PM_POST_HIBERNATION:
Kyle McMartin25be5822011-03-22 16:19:50 -04001099 case PM_POST_SUSPEND:
Lan Tianyu9e50bc12014-05-04 14:07:06 +08001100 if (!acpi_battery_present(battery))
1101 return 0;
1102
1103 if (!battery->bat.dev) {
1104 result = acpi_battery_get_info(battery);
1105 if (result)
1106 return result;
1107
1108 result = sysfs_add_battery(battery);
1109 if (result)
1110 return result;
1111 } else
1112 acpi_battery_refresh(battery);
1113
1114 acpi_battery_init_alarm(battery);
1115 acpi_battery_get_state(battery);
Kyle McMartin25be5822011-03-22 16:19:50 -04001116 break;
1117 }
1118
1119 return 0;
1120}
1121
Alexander Mezin3f5dc082014-06-04 02:01:22 +07001122static int battery_bix_broken_package_quirk(const struct dmi_system_id *d)
1123{
1124 battery_bix_broken_package = 1;
1125 return 0;
1126}
1127
Alexander Mezinf43691c2014-06-04 02:01:23 +07001128static int battery_notification_delay_quirk(const struct dmi_system_id *d)
1129{
1130 battery_notification_delay_ms = 1000;
1131 return 0;
1132}
1133
Lan Tianyua90b4032014-01-06 22:50:37 +08001134static struct dmi_system_id bat_dmi_table[] = {
1135 {
Alexander Mezin3f5dc082014-06-04 02:01:22 +07001136 .callback = battery_bix_broken_package_quirk,
Lan Tianyua90b4032014-01-06 22:50:37 +08001137 .ident = "NEC LZ750/LS",
1138 .matches = {
1139 DMI_MATCH(DMI_SYS_VENDOR, "NEC"),
1140 DMI_MATCH(DMI_PRODUCT_NAME, "PC-LZ750LS"),
1141 },
1142 },
Alexander Mezinf43691c2014-06-04 02:01:23 +07001143 {
1144 .callback = battery_notification_delay_quirk,
1145 .ident = "Acer Aspire V5-573G",
1146 .matches = {
1147 DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
1148 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire V5-573G"),
1149 },
1150 },
Lan Tianyua90b4032014-01-06 22:50:37 +08001151 {},
1152};
1153
Lan Tianyu75646e72014-07-07 15:47:12 +08001154/*
1155 * Some machines'(E,G Lenovo Z480) ECs are not stable
1156 * during boot up and this causes battery driver fails to be
1157 * probed due to failure of getting battery information
1158 * from EC sometimes. After several retries, the operation
1159 * may work. So add retry code here and 20ms sleep between
1160 * every retries.
1161 */
1162static int acpi_battery_update_retry(struct acpi_battery *battery)
1163{
1164 int retry, ret;
1165
1166 for (retry = 5; retry; retry--) {
1167 ret = acpi_battery_update(battery, false);
1168 if (!ret)
1169 break;
1170
1171 msleep(20);
1172 }
1173 return ret;
1174}
1175
Len Brown4be44fc2005-08-05 00:44:28 -04001176static int acpi_battery_add(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001177{
Len Brown4be44fc2005-08-05 00:44:28 -04001178 int result = 0;
Len Brown4be44fc2005-08-05 00:44:28 -04001179 struct acpi_battery *battery = NULL;
Jiang Liu952c63e2013-06-29 00:24:38 +08001180
Linus Torvalds1da177e2005-04-16 15:20:36 -07001181 if (!device)
Patrick Mocheld550d982006-06-27 00:41:40 -04001182 return -EINVAL;
Burman Yan36bcbec2006-12-19 12:56:11 -08001183 battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001184 if (!battery)
Patrick Mocheld550d982006-06-27 00:41:40 -04001185 return -ENOMEM;
Patrick Mochel145def82006-05-19 16:54:39 -04001186 battery->device = device;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001187 strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME);
1188 strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS);
Pavel Machekdb89b4f2008-09-22 14:37:34 -07001189 device->driver_data = battery;
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +04001190 mutex_init(&battery->lock);
Sergey Senozhatsky69d94ec2011-08-06 01:34:08 +03001191 mutex_init(&battery->sysfs_lock);
Jiang Liu952c63e2013-06-29 00:24:38 +08001192 if (acpi_has_method(battery->device->handle, "_BIX"))
Alexey Starikovskiyc67fcd62009-10-15 14:31:44 +04001193 set_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags);
Lan Tianyu75646e72014-07-07 15:47:12 +08001194
1195 result = acpi_battery_update_retry(battery);
Stefan Hajnoczieb03cb02011-07-12 09:03:29 +01001196 if (result)
1197 goto fail;
Lan Tianyu75646e72014-07-07 15:47:12 +08001198
Lan Tianyu3a670cc2014-05-04 11:07:25 +08001199#ifdef CONFIG_ACPI_PROCFS_POWER
1200 result = acpi_battery_add_fs(device);
1201#endif
1202 if (result) {
1203#ifdef CONFIG_ACPI_PROCFS_POWER
1204 acpi_battery_remove_fs(device);
1205#endif
1206 goto fail;
1207 }
Kyle McMartin25be5822011-03-22 16:19:50 -04001208
Stefan Hajnoczie80bba42011-07-12 09:03:28 +01001209 printk(KERN_INFO PREFIX "%s Slot [%s] (battery %s)\n",
1210 ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device),
1211 device->status.battery_present ? "present" : "absent");
1212
Kyle McMartin25be5822011-03-22 16:19:50 -04001213 battery->pm_nb.notifier_call = battery_notify;
1214 register_pm_notifier(&battery->pm_nb);
1215
Zhang Ruie0d1f092014-05-28 15:23:38 +08001216 device_init_wakeup(&device->dev, 1);
1217
Patrick Mocheld550d982006-06-27 00:41:40 -04001218 return result;
Stefan Hajnoczie80bba42011-07-12 09:03:28 +01001219
1220fail:
1221 sysfs_remove_battery(battery);
1222 mutex_destroy(&battery->lock);
Sergey Senozhatsky69d94ec2011-08-06 01:34:08 +03001223 mutex_destroy(&battery->sysfs_lock);
Stefan Hajnoczie80bba42011-07-12 09:03:28 +01001224 kfree(battery);
1225 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001226}
1227
Rafael J. Wysocki51fac832013-01-24 00:24:48 +01001228static int acpi_battery_remove(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229{
Len Brown4be44fc2005-08-05 00:44:28 -04001230 struct acpi_battery *battery = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001231
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232 if (!device || !acpi_driver_data(device))
Patrick Mocheld550d982006-06-27 00:41:40 -04001233 return -EINVAL;
Zhang Ruie0d1f092014-05-28 15:23:38 +08001234 device_init_wakeup(&device->dev, 0);
Jan Engelhardt50dd0962006-10-01 00:28:50 +02001235 battery = acpi_driver_data(device);
Kyle McMartin25be5822011-03-22 16:19:50 -04001236 unregister_pm_notifier(&battery->pm_nb);
Lan Tianyu3a670cc2014-05-04 11:07:25 +08001237#ifdef CONFIG_ACPI_PROCFS_POWER
1238 acpi_battery_remove_fs(device);
1239#endif
Andrey Borzenkov508df922007-10-28 12:50:09 +03001240 sysfs_remove_battery(battery);
Alexey Starikovskiy038fdea2007-09-26 19:42:46 +04001241 mutex_destroy(&battery->lock);
Sergey Senozhatsky69d94ec2011-08-06 01:34:08 +03001242 mutex_destroy(&battery->sysfs_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001243 kfree(battery);
Patrick Mocheld550d982006-06-27 00:41:40 -04001244 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245}
1246
Rafael J. Wysocki90692402012-08-09 23:00:02 +02001247#ifdef CONFIG_PM_SLEEP
Jiri Kosina34c44152006-10-10 14:20:41 -07001248/* this is needed to learn about changes made in suspended state */
Rafael J. Wysockia6f50dc2012-06-27 23:26:43 +02001249static int acpi_battery_resume(struct device *dev)
Jiri Kosina34c44152006-10-10 14:20:41 -07001250{
1251 struct acpi_battery *battery;
Rafael J. Wysockia6f50dc2012-06-27 23:26:43 +02001252
1253 if (!dev)
Jiri Kosina34c44152006-10-10 14:20:41 -07001254 return -EINVAL;
Rafael J. Wysockia6f50dc2012-06-27 23:26:43 +02001255
1256 battery = acpi_driver_data(to_acpi_device(dev));
1257 if (!battery)
1258 return -EINVAL;
1259
Alexey Starikovskiyf1d46612007-09-26 19:42:52 +04001260 battery->update_time = 0;
Lan Tianyu9e50bc12014-05-04 14:07:06 +08001261 acpi_battery_update(battery, true);
Vladimir Lebedevb6ce4082007-02-20 15:48:06 +03001262 return 0;
Jiri Kosina34c44152006-10-10 14:20:41 -07001263}
Shuah Khan7f6895c2014-02-12 20:19:06 -07001264#else
1265#define acpi_battery_resume NULL
Rafael J. Wysocki90692402012-08-09 23:00:02 +02001266#endif
Jiri Kosina34c44152006-10-10 14:20:41 -07001267
Rafael J. Wysockia6f50dc2012-06-27 23:26:43 +02001268static SIMPLE_DEV_PM_OPS(acpi_battery_pm, NULL, acpi_battery_resume);
1269
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +04001270static struct acpi_driver acpi_battery_driver = {
1271 .name = "battery",
1272 .class = ACPI_BATTERY_CLASS,
1273 .ids = battery_device_ids,
Bjorn Helgaasd9406692009-04-30 09:35:47 -06001274 .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +04001275 .ops = {
1276 .add = acpi_battery_add,
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +04001277 .remove = acpi_battery_remove,
Bjorn Helgaasd9406692009-04-30 09:35:47 -06001278 .notify = acpi_battery_notify,
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +04001279 },
Rafael J. Wysockia6f50dc2012-06-27 23:26:43 +02001280 .drv.pm = &acpi_battery_pm,
Alexey Starikovskiyaa650bb2007-09-26 19:42:58 +04001281};
1282
Linus Torvaldsb0cbc862009-04-11 12:45:20 -07001283static void __init acpi_battery_init_async(void *unused, async_cookie_t cookie)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284{
Pavel Machek4d8316d2006-08-14 22:37:22 -07001285 if (acpi_disabled)
Arjan van de Ven0f66af52009-01-10 14:19:05 -05001286 return;
Lan Tianyua90b4032014-01-06 22:50:37 +08001287
Alexander Mezin3f5dc082014-06-04 02:01:22 +07001288 dmi_check_system(bat_dmi_table);
Lan Tianyu3a670cc2014-05-04 11:07:25 +08001289
1290#ifdef CONFIG_ACPI_PROCFS_POWER
1291 acpi_battery_dir = acpi_lock_battery_dir();
1292 if (!acpi_battery_dir)
1293 return;
1294#endif
1295 if (acpi_bus_register_driver(&acpi_battery_driver) < 0) {
1296#ifdef CONFIG_ACPI_PROCFS_POWER
1297 acpi_unlock_battery_dir(acpi_battery_dir);
1298#endif
1299 return;
1300 }
1301 return;
Arjan van de Ven0f66af52009-01-10 14:19:05 -05001302}
1303
1304static int __init acpi_battery_init(void)
1305{
1306 async_schedule(acpi_battery_init_async, NULL);
Patrick Mocheld550d982006-06-27 00:41:40 -04001307 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308}
1309
Len Brown4be44fc2005-08-05 00:44:28 -04001310static void __exit acpi_battery_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001311{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312 acpi_bus_unregister_driver(&acpi_battery_driver);
Lan Tianyu3a670cc2014-05-04 11:07:25 +08001313#ifdef CONFIG_ACPI_PROCFS_POWER
1314 acpi_unlock_battery_dir(acpi_battery_dir);
1315#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316}
1317
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318module_init(acpi_battery_init);
1319module_exit(acpi_battery_exit);