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