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