2 * battery.c - ACPI Battery Driver (Revision: 2.0)
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>
9 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
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.
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.
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.
25 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
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>
36 #ifdef CONFIG_ACPI_PROCFS_POWER
37 #include <linux/proc_fs.h>
38 #include <linux/seq_file.h>
39 #include <asm/uaccess.h>
42 #include <acpi/acpi_bus.h>
43 #include <acpi/acpi_drivers.h>
45 #ifdef CONFIG_ACPI_SYSFS_POWER
46 #include <linux/power_supply.h>
49 #define PREFIX "ACPI: "
51 #define ACPI_BATTERY_VALUE_UNKNOWN 0xFFFFFFFF
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
59 #define _COMPONENT ACPI_BATTERY_COMPONENT
61 ACPI_MODULE_NAME("battery");
63 MODULE_AUTHOR("Paul Diefenbaugh");
64 MODULE_AUTHOR("Alexey Starikovskiy <astarikovskiy@suse.de>");
65 MODULE_DESCRIPTION("ACPI Battery Driver");
66 MODULE_LICENSE("GPL");
68 static unsigned int cache_time
= 1000;
69 module_param(cache_time
, uint
, 0644);
70 MODULE_PARM_DESC(cache_time
, "cache time in milliseconds");
72 #ifdef CONFIG_ACPI_PROCFS_POWER
73 extern struct proc_dir_entry
*acpi_lock_battery_dir(void);
74 extern void *acpi_unlock_battery_dir(struct proc_dir_entry
*acpi_battery_dir
);
76 enum acpi_battery_files
{
80 ACPI_BATTERY_NUMFILES
,
85 static const struct acpi_device_id battery_device_ids
[] = {
90 MODULE_DEVICE_TABLE(acpi
, battery_device_ids
);
93 ACPI_BATTERY_ALARM_PRESENT
,
94 ACPI_BATTERY_XINFO_PRESENT
,
95 /* For buggy DSDTs that report negative 16-bit values for either
96 * charging or discharging current and/or report 0 as 65536
99 ACPI_BATTERY_QUIRK_SIGNED16_CURRENT
,
102 struct acpi_battery
{
104 #ifdef CONFIG_ACPI_SYSFS_POWER
105 struct power_supply bat
;
107 struct acpi_device
*device
;
108 unsigned long update_time
;
113 int full_charge_capacity
;
116 int design_capacity_warning
;
117 int design_capacity_low
;
119 int measurement_accuracy
;
120 int max_sampling_time
;
121 int min_sampling_time
;
122 int max_averaging_interval
;
123 int min_averaging_interval
;
124 int capacity_granularity_1
;
125 int capacity_granularity_2
;
127 char model_number
[32];
128 char serial_number
[32];
136 #define to_acpi_battery(x) container_of(x, struct acpi_battery, bat);
138 inline int acpi_battery_present(struct acpi_battery
*battery
)
140 return battery
->device
->status
.battery_present
;
143 #ifdef CONFIG_ACPI_SYSFS_POWER
144 static int acpi_battery_technology(struct acpi_battery
*battery
)
146 if (!strcasecmp("NiCd", battery
->type
))
147 return POWER_SUPPLY_TECHNOLOGY_NiCd
;
148 if (!strcasecmp("NiMH", battery
->type
))
149 return POWER_SUPPLY_TECHNOLOGY_NiMH
;
150 if (!strcasecmp("LION", battery
->type
))
151 return POWER_SUPPLY_TECHNOLOGY_LION
;
152 if (!strncasecmp("LI-ION", battery
->type
, 6))
153 return POWER_SUPPLY_TECHNOLOGY_LION
;
154 if (!strcasecmp("LiP", battery
->type
))
155 return POWER_SUPPLY_TECHNOLOGY_LIPO
;
156 return POWER_SUPPLY_TECHNOLOGY_UNKNOWN
;
159 static int acpi_battery_get_state(struct acpi_battery
*battery
);
161 static int acpi_battery_is_charged(struct acpi_battery
*battery
)
163 /* either charging or discharging */
164 if (battery
->state
!= 0)
167 /* battery not reporting charge */
168 if (battery
->capacity_now
== ACPI_BATTERY_VALUE_UNKNOWN
||
169 battery
->capacity_now
== 0)
172 /* good batteries update full_charge as the batteries degrade */
173 if (battery
->full_charge_capacity
== battery
->capacity_now
)
176 /* fallback to using design values for broken batteries */
177 if (battery
->design_capacity
== battery
->capacity_now
)
180 /* we don't do any sort of metric based on percentages */
184 static int acpi_battery_get_property(struct power_supply
*psy
,
185 enum power_supply_property psp
,
186 union power_supply_propval
*val
)
188 struct acpi_battery
*battery
= to_acpi_battery(psy
);
190 if (acpi_battery_present(battery
)) {
191 /* run battery update only if it is present */
192 acpi_battery_get_state(battery
);
193 } else if (psp
!= POWER_SUPPLY_PROP_PRESENT
)
196 case POWER_SUPPLY_PROP_STATUS
:
197 if (battery
->state
& 0x01)
198 val
->intval
= POWER_SUPPLY_STATUS_DISCHARGING
;
199 else if (battery
->state
& 0x02)
200 val
->intval
= POWER_SUPPLY_STATUS_CHARGING
;
201 else if (acpi_battery_is_charged(battery
))
202 val
->intval
= POWER_SUPPLY_STATUS_FULL
;
204 val
->intval
= POWER_SUPPLY_STATUS_UNKNOWN
;
206 case POWER_SUPPLY_PROP_PRESENT
:
207 val
->intval
= acpi_battery_present(battery
);
209 case POWER_SUPPLY_PROP_TECHNOLOGY
:
210 val
->intval
= acpi_battery_technology(battery
);
212 case POWER_SUPPLY_PROP_CYCLE_COUNT
:
213 val
->intval
= battery
->cycle_count
;
215 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN
:
216 val
->intval
= battery
->design_voltage
* 1000;
218 case POWER_SUPPLY_PROP_VOLTAGE_NOW
:
219 val
->intval
= battery
->voltage_now
* 1000;
221 case POWER_SUPPLY_PROP_CURRENT_NOW
:
222 case POWER_SUPPLY_PROP_POWER_NOW
:
223 val
->intval
= battery
->rate_now
* 1000;
225 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN
:
226 case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN
:
227 val
->intval
= battery
->design_capacity
* 1000;
229 case POWER_SUPPLY_PROP_CHARGE_FULL
:
230 case POWER_SUPPLY_PROP_ENERGY_FULL
:
231 val
->intval
= battery
->full_charge_capacity
* 1000;
233 case POWER_SUPPLY_PROP_CHARGE_NOW
:
234 case POWER_SUPPLY_PROP_ENERGY_NOW
:
235 val
->intval
= battery
->capacity_now
* 1000;
237 case POWER_SUPPLY_PROP_MODEL_NAME
:
238 val
->strval
= battery
->model_number
;
240 case POWER_SUPPLY_PROP_MANUFACTURER
:
241 val
->strval
= battery
->oem_info
;
243 case POWER_SUPPLY_PROP_SERIAL_NUMBER
:
244 val
->strval
= battery
->serial_number
;
252 static enum power_supply_property charge_battery_props
[] = {
253 POWER_SUPPLY_PROP_STATUS
,
254 POWER_SUPPLY_PROP_PRESENT
,
255 POWER_SUPPLY_PROP_TECHNOLOGY
,
256 POWER_SUPPLY_PROP_CYCLE_COUNT
,
257 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN
,
258 POWER_SUPPLY_PROP_VOLTAGE_NOW
,
259 POWER_SUPPLY_PROP_CURRENT_NOW
,
260 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN
,
261 POWER_SUPPLY_PROP_CHARGE_FULL
,
262 POWER_SUPPLY_PROP_CHARGE_NOW
,
263 POWER_SUPPLY_PROP_MODEL_NAME
,
264 POWER_SUPPLY_PROP_MANUFACTURER
,
265 POWER_SUPPLY_PROP_SERIAL_NUMBER
,
268 static enum power_supply_property energy_battery_props
[] = {
269 POWER_SUPPLY_PROP_STATUS
,
270 POWER_SUPPLY_PROP_PRESENT
,
271 POWER_SUPPLY_PROP_TECHNOLOGY
,
272 POWER_SUPPLY_PROP_CYCLE_COUNT
,
273 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN
,
274 POWER_SUPPLY_PROP_VOLTAGE_NOW
,
275 POWER_SUPPLY_PROP_CURRENT_NOW
,
276 POWER_SUPPLY_PROP_POWER_NOW
,
277 POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN
,
278 POWER_SUPPLY_PROP_ENERGY_FULL
,
279 POWER_SUPPLY_PROP_ENERGY_NOW
,
280 POWER_SUPPLY_PROP_MODEL_NAME
,
281 POWER_SUPPLY_PROP_MANUFACTURER
,
282 POWER_SUPPLY_PROP_SERIAL_NUMBER
,
286 #ifdef CONFIG_ACPI_PROCFS_POWER
287 inline char *acpi_battery_units(struct acpi_battery
*battery
)
289 return (battery
->power_unit
)?"mA":"mW";
293 /* --------------------------------------------------------------------------
295 -------------------------------------------------------------------------- */
296 struct acpi_offsets
{
297 size_t offset
; /* offset inside struct acpi_sbs_battery */
298 u8 mode
; /* int or string? */
301 static struct acpi_offsets state_offsets
[] = {
302 {offsetof(struct acpi_battery
, state
), 0},
303 {offsetof(struct acpi_battery
, rate_now
), 0},
304 {offsetof(struct acpi_battery
, capacity_now
), 0},
305 {offsetof(struct acpi_battery
, voltage_now
), 0},
308 static struct acpi_offsets info_offsets
[] = {
309 {offsetof(struct acpi_battery
, power_unit
), 0},
310 {offsetof(struct acpi_battery
, design_capacity
), 0},
311 {offsetof(struct acpi_battery
, full_charge_capacity
), 0},
312 {offsetof(struct acpi_battery
, technology
), 0},
313 {offsetof(struct acpi_battery
, design_voltage
), 0},
314 {offsetof(struct acpi_battery
, design_capacity_warning
), 0},
315 {offsetof(struct acpi_battery
, design_capacity_low
), 0},
316 {offsetof(struct acpi_battery
, capacity_granularity_1
), 0},
317 {offsetof(struct acpi_battery
, capacity_granularity_2
), 0},
318 {offsetof(struct acpi_battery
, model_number
), 1},
319 {offsetof(struct acpi_battery
, serial_number
), 1},
320 {offsetof(struct acpi_battery
, type
), 1},
321 {offsetof(struct acpi_battery
, oem_info
), 1},
324 static struct acpi_offsets extended_info_offsets
[] = {
325 {offsetof(struct acpi_battery
, power_unit
), 0},
326 {offsetof(struct acpi_battery
, design_capacity
), 0},
327 {offsetof(struct acpi_battery
, full_charge_capacity
), 0},
328 {offsetof(struct acpi_battery
, technology
), 0},
329 {offsetof(struct acpi_battery
, design_voltage
), 0},
330 {offsetof(struct acpi_battery
, design_capacity_warning
), 0},
331 {offsetof(struct acpi_battery
, design_capacity_low
), 0},
332 {offsetof(struct acpi_battery
, cycle_count
), 0},
333 {offsetof(struct acpi_battery
, measurement_accuracy
), 0},
334 {offsetof(struct acpi_battery
, max_sampling_time
), 0},
335 {offsetof(struct acpi_battery
, min_sampling_time
), 0},
336 {offsetof(struct acpi_battery
, max_averaging_interval
), 0},
337 {offsetof(struct acpi_battery
, min_averaging_interval
), 0},
338 {offsetof(struct acpi_battery
, capacity_granularity_1
), 0},
339 {offsetof(struct acpi_battery
, capacity_granularity_2
), 0},
340 {offsetof(struct acpi_battery
, model_number
), 1},
341 {offsetof(struct acpi_battery
, serial_number
), 1},
342 {offsetof(struct acpi_battery
, type
), 1},
343 {offsetof(struct acpi_battery
, oem_info
), 1},
346 static int extract_package(struct acpi_battery
*battery
,
347 union acpi_object
*package
,
348 struct acpi_offsets
*offsets
, int num
)
351 union acpi_object
*element
;
352 if (package
->type
!= ACPI_TYPE_PACKAGE
)
354 for (i
= 0; i
< num
; ++i
) {
355 if (package
->package
.count
<= i
)
357 element
= &package
->package
.elements
[i
];
358 if (offsets
[i
].mode
) {
359 u8
*ptr
= (u8
*)battery
+ offsets
[i
].offset
;
360 if (element
->type
== ACPI_TYPE_STRING
||
361 element
->type
== ACPI_TYPE_BUFFER
)
362 strncpy(ptr
, element
->string
.pointer
, 32);
363 else if (element
->type
== ACPI_TYPE_INTEGER
) {
364 strncpy(ptr
, (u8
*)&element
->integer
.value
,
366 ptr
[sizeof(u64
)] = 0;
368 *ptr
= 0; /* don't have value */
370 int *x
= (int *)((u8
*)battery
+ offsets
[i
].offset
);
371 *x
= (element
->type
== ACPI_TYPE_INTEGER
) ?
372 element
->integer
.value
: -1;
378 static int acpi_battery_get_status(struct acpi_battery
*battery
)
380 if (acpi_bus_get_status(battery
->device
)) {
381 ACPI_EXCEPTION((AE_INFO
, AE_ERROR
, "Evaluating _STA"));
387 static int acpi_battery_get_info(struct acpi_battery
*battery
)
389 int result
= -EFAULT
;
390 acpi_status status
= 0;
391 char *name
= test_bit(ACPI_BATTERY_XINFO_PRESENT
, &battery
->flags
)?
394 struct acpi_buffer buffer
= { ACPI_ALLOCATE_BUFFER
, NULL
};
396 if (!acpi_battery_present(battery
))
398 mutex_lock(&battery
->lock
);
399 status
= acpi_evaluate_object(battery
->device
->handle
, name
,
401 mutex_unlock(&battery
->lock
);
403 if (ACPI_FAILURE(status
)) {
404 ACPI_EXCEPTION((AE_INFO
, status
, "Evaluating %s", name
));
407 if (test_bit(ACPI_BATTERY_XINFO_PRESENT
, &battery
->flags
))
408 result
= extract_package(battery
, buffer
.pointer
,
409 extended_info_offsets
,
410 ARRAY_SIZE(extended_info_offsets
));
412 result
= extract_package(battery
, buffer
.pointer
,
413 info_offsets
, ARRAY_SIZE(info_offsets
));
414 kfree(buffer
.pointer
);
418 static int acpi_battery_get_state(struct acpi_battery
*battery
)
421 acpi_status status
= 0;
422 struct acpi_buffer buffer
= { ACPI_ALLOCATE_BUFFER
, NULL
};
424 if (!acpi_battery_present(battery
))
427 if (battery
->update_time
&&
428 time_before(jiffies
, battery
->update_time
+
429 msecs_to_jiffies(cache_time
)))
432 mutex_lock(&battery
->lock
);
433 status
= acpi_evaluate_object(battery
->device
->handle
, "_BST",
435 mutex_unlock(&battery
->lock
);
437 if (ACPI_FAILURE(status
)) {
438 ACPI_EXCEPTION((AE_INFO
, status
, "Evaluating _BST"));
442 result
= extract_package(battery
, buffer
.pointer
,
443 state_offsets
, ARRAY_SIZE(state_offsets
));
444 battery
->update_time
= jiffies
;
445 kfree(buffer
.pointer
);
447 if (test_bit(ACPI_BATTERY_QUIRK_SIGNED16_CURRENT
, &battery
->flags
) &&
448 battery
->rate_now
!= -1)
449 battery
->rate_now
= abs((s16
)battery
->rate_now
);
454 static int acpi_battery_set_alarm(struct acpi_battery
*battery
)
456 acpi_status status
= 0;
457 union acpi_object arg0
= { .type
= ACPI_TYPE_INTEGER
};
458 struct acpi_object_list arg_list
= { 1, &arg0
};
460 if (!acpi_battery_present(battery
) ||
461 !test_bit(ACPI_BATTERY_ALARM_PRESENT
, &battery
->flags
))
464 arg0
.integer
.value
= battery
->alarm
;
466 mutex_lock(&battery
->lock
);
467 status
= acpi_evaluate_object(battery
->device
->handle
, "_BTP",
469 mutex_unlock(&battery
->lock
);
471 if (ACPI_FAILURE(status
))
474 ACPI_DEBUG_PRINT((ACPI_DB_INFO
, "Alarm set to %d\n", battery
->alarm
));
478 static int acpi_battery_init_alarm(struct acpi_battery
*battery
)
480 acpi_status status
= AE_OK
;
481 acpi_handle handle
= NULL
;
483 /* See if alarms are supported, and if so, set default */
484 status
= acpi_get_handle(battery
->device
->handle
, "_BTP", &handle
);
485 if (ACPI_FAILURE(status
)) {
486 clear_bit(ACPI_BATTERY_ALARM_PRESENT
, &battery
->flags
);
489 set_bit(ACPI_BATTERY_ALARM_PRESENT
, &battery
->flags
);
491 battery
->alarm
= battery
->design_capacity_warning
;
492 return acpi_battery_set_alarm(battery
);
495 #ifdef CONFIG_ACPI_SYSFS_POWER
496 static ssize_t
acpi_battery_alarm_show(struct device
*dev
,
497 struct device_attribute
*attr
,
500 struct acpi_battery
*battery
= to_acpi_battery(dev_get_drvdata(dev
));
501 return sprintf(buf
, "%d\n", battery
->alarm
* 1000);
504 static ssize_t
acpi_battery_alarm_store(struct device
*dev
,
505 struct device_attribute
*attr
,
506 const char *buf
, size_t count
)
509 struct acpi_battery
*battery
= to_acpi_battery(dev_get_drvdata(dev
));
510 if (sscanf(buf
, "%ld\n", &x
) == 1)
511 battery
->alarm
= x
/1000;
512 if (acpi_battery_present(battery
))
513 acpi_battery_set_alarm(battery
);
517 static struct device_attribute alarm_attr
= {
518 .attr
= {.name
= "alarm", .mode
= 0644},
519 .show
= acpi_battery_alarm_show
,
520 .store
= acpi_battery_alarm_store
,
523 static int sysfs_add_battery(struct acpi_battery
*battery
)
527 if (battery
->power_unit
) {
528 battery
->bat
.properties
= charge_battery_props
;
529 battery
->bat
.num_properties
=
530 ARRAY_SIZE(charge_battery_props
);
532 battery
->bat
.properties
= energy_battery_props
;
533 battery
->bat
.num_properties
=
534 ARRAY_SIZE(energy_battery_props
);
537 battery
->bat
.name
= acpi_device_bid(battery
->device
);
538 battery
->bat
.type
= POWER_SUPPLY_TYPE_BATTERY
;
539 battery
->bat
.get_property
= acpi_battery_get_property
;
541 result
= power_supply_register(&battery
->device
->dev
, &battery
->bat
);
544 return device_create_file(battery
->bat
.dev
, &alarm_attr
);
547 static void sysfs_remove_battery(struct acpi_battery
*battery
)
549 if (!battery
->bat
.dev
)
551 device_remove_file(battery
->bat
.dev
, &alarm_attr
);
552 power_supply_unregister(&battery
->bat
);
553 battery
->bat
.dev
= NULL
;
557 static void acpi_battery_quirks(struct acpi_battery
*battery
)
559 if (dmi_name_in_vendors("Acer") && battery
->power_unit
) {
560 set_bit(ACPI_BATTERY_QUIRK_SIGNED16_CURRENT
, &battery
->flags
);
564 static int acpi_battery_update(struct acpi_battery
*battery
)
566 int result
, old_present
= acpi_battery_present(battery
);
567 result
= acpi_battery_get_status(battery
);
570 if (!acpi_battery_present(battery
)) {
571 #ifdef CONFIG_ACPI_SYSFS_POWER
572 sysfs_remove_battery(battery
);
574 battery
->update_time
= 0;
577 if (!battery
->update_time
||
578 old_present
!= acpi_battery_present(battery
)) {
579 result
= acpi_battery_get_info(battery
);
582 acpi_battery_quirks(battery
);
583 acpi_battery_init_alarm(battery
);
585 #ifdef CONFIG_ACPI_SYSFS_POWER
586 if (!battery
->bat
.dev
)
587 sysfs_add_battery(battery
);
589 return acpi_battery_get_state(battery
);
592 /* --------------------------------------------------------------------------
594 -------------------------------------------------------------------------- */
596 #ifdef CONFIG_ACPI_PROCFS_POWER
597 static struct proc_dir_entry
*acpi_battery_dir
;
599 static int acpi_battery_print_info(struct seq_file
*seq
, int result
)
601 struct acpi_battery
*battery
= seq
->private;
606 seq_printf(seq
, "present: %s\n",
607 acpi_battery_present(battery
)?"yes":"no");
608 if (!acpi_battery_present(battery
))
610 if (battery
->design_capacity
== ACPI_BATTERY_VALUE_UNKNOWN
)
611 seq_printf(seq
, "design capacity: unknown\n");
613 seq_printf(seq
, "design capacity: %d %sh\n",
614 battery
->design_capacity
,
615 acpi_battery_units(battery
));
617 if (battery
->full_charge_capacity
== ACPI_BATTERY_VALUE_UNKNOWN
)
618 seq_printf(seq
, "last full capacity: unknown\n");
620 seq_printf(seq
, "last full capacity: %d %sh\n",
621 battery
->full_charge_capacity
,
622 acpi_battery_units(battery
));
624 seq_printf(seq
, "battery technology: %srechargeable\n",
625 (!battery
->technology
)?"non-":"");
627 if (battery
->design_voltage
== ACPI_BATTERY_VALUE_UNKNOWN
)
628 seq_printf(seq
, "design voltage: unknown\n");
630 seq_printf(seq
, "design voltage: %d mV\n",
631 battery
->design_voltage
);
632 seq_printf(seq
, "design capacity warning: %d %sh\n",
633 battery
->design_capacity_warning
,
634 acpi_battery_units(battery
));
635 seq_printf(seq
, "design capacity low: %d %sh\n",
636 battery
->design_capacity_low
,
637 acpi_battery_units(battery
));
638 seq_printf(seq
, "cycle count: %i\n", battery
->cycle_count
);
639 seq_printf(seq
, "capacity granularity 1: %d %sh\n",
640 battery
->capacity_granularity_1
,
641 acpi_battery_units(battery
));
642 seq_printf(seq
, "capacity granularity 2: %d %sh\n",
643 battery
->capacity_granularity_2
,
644 acpi_battery_units(battery
));
645 seq_printf(seq
, "model number: %s\n", battery
->model_number
);
646 seq_printf(seq
, "serial number: %s\n", battery
->serial_number
);
647 seq_printf(seq
, "battery type: %s\n", battery
->type
);
648 seq_printf(seq
, "OEM info: %s\n", battery
->oem_info
);
651 seq_printf(seq
, "ERROR: Unable to read battery info\n");
655 static int acpi_battery_print_state(struct seq_file
*seq
, int result
)
657 struct acpi_battery
*battery
= seq
->private;
662 seq_printf(seq
, "present: %s\n",
663 acpi_battery_present(battery
)?"yes":"no");
664 if (!acpi_battery_present(battery
))
667 seq_printf(seq
, "capacity state: %s\n",
668 (battery
->state
& 0x04)?"critical":"ok");
669 if ((battery
->state
& 0x01) && (battery
->state
& 0x02))
671 "charging state: charging/discharging\n");
672 else if (battery
->state
& 0x01)
673 seq_printf(seq
, "charging state: discharging\n");
674 else if (battery
->state
& 0x02)
675 seq_printf(seq
, "charging state: charging\n");
677 seq_printf(seq
, "charging state: charged\n");
679 if (battery
->rate_now
== ACPI_BATTERY_VALUE_UNKNOWN
)
680 seq_printf(seq
, "present rate: unknown\n");
682 seq_printf(seq
, "present rate: %d %s\n",
683 battery
->rate_now
, acpi_battery_units(battery
));
685 if (battery
->capacity_now
== ACPI_BATTERY_VALUE_UNKNOWN
)
686 seq_printf(seq
, "remaining capacity: unknown\n");
688 seq_printf(seq
, "remaining capacity: %d %sh\n",
689 battery
->capacity_now
, acpi_battery_units(battery
));
690 if (battery
->voltage_now
== ACPI_BATTERY_VALUE_UNKNOWN
)
691 seq_printf(seq
, "present voltage: unknown\n");
693 seq_printf(seq
, "present voltage: %d mV\n",
694 battery
->voltage_now
);
697 seq_printf(seq
, "ERROR: Unable to read battery state\n");
702 static int acpi_battery_print_alarm(struct seq_file
*seq
, int result
)
704 struct acpi_battery
*battery
= seq
->private;
709 if (!acpi_battery_present(battery
)) {
710 seq_printf(seq
, "present: no\n");
713 seq_printf(seq
, "alarm: ");
715 seq_printf(seq
, "unsupported\n");
717 seq_printf(seq
, "%u %sh\n", battery
->alarm
,
718 acpi_battery_units(battery
));
721 seq_printf(seq
, "ERROR: Unable to read battery alarm\n");
725 static ssize_t
acpi_battery_write_alarm(struct file
*file
,
726 const char __user
* buffer
,
727 size_t count
, loff_t
* ppos
)
730 char alarm_string
[12] = { '\0' };
731 struct seq_file
*m
= file
->private_data
;
732 struct acpi_battery
*battery
= m
->private;
734 if (!battery
|| (count
> sizeof(alarm_string
) - 1))
736 if (!acpi_battery_present(battery
)) {
740 if (copy_from_user(alarm_string
, buffer
, count
)) {
744 alarm_string
[count
] = '\0';
745 battery
->alarm
= simple_strtol(alarm_string
, NULL
, 0);
746 result
= acpi_battery_set_alarm(battery
);
753 typedef int(*print_func
)(struct seq_file
*seq
, int result
);
755 static print_func acpi_print_funcs
[ACPI_BATTERY_NUMFILES
] = {
756 acpi_battery_print_info
,
757 acpi_battery_print_state
,
758 acpi_battery_print_alarm
,
761 static int acpi_battery_read(int fid
, struct seq_file
*seq
)
763 struct acpi_battery
*battery
= seq
->private;
764 int result
= acpi_battery_update(battery
);
765 return acpi_print_funcs
[fid
](seq
, result
);
768 #define DECLARE_FILE_FUNCTIONS(_name) \
769 static int acpi_battery_read_##_name(struct seq_file *seq, void *offset) \
771 return acpi_battery_read(_name##_tag, seq); \
773 static int acpi_battery_##_name##_open_fs(struct inode *inode, struct file *file) \
775 return single_open(file, acpi_battery_read_##_name, PDE(inode)->data); \
778 DECLARE_FILE_FUNCTIONS(info
);
779 DECLARE_FILE_FUNCTIONS(state
);
780 DECLARE_FILE_FUNCTIONS(alarm
);
782 #undef DECLARE_FILE_FUNCTIONS
784 #define FILE_DESCRIPTION_RO(_name) \
786 .name = __stringify(_name), \
789 .open = acpi_battery_##_name##_open_fs, \
791 .llseek = seq_lseek, \
792 .release = single_release, \
793 .owner = THIS_MODULE, \
797 #define FILE_DESCRIPTION_RW(_name) \
799 .name = __stringify(_name), \
800 .mode = S_IFREG | S_IRUGO | S_IWUSR, \
802 .open = acpi_battery_##_name##_open_fs, \
804 .llseek = seq_lseek, \
805 .write = acpi_battery_write_##_name, \
806 .release = single_release, \
807 .owner = THIS_MODULE, \
811 static struct battery_file
{
812 struct file_operations ops
;
815 } acpi_battery_file
[] = {
816 FILE_DESCRIPTION_RO(info
),
817 FILE_DESCRIPTION_RO(state
),
818 FILE_DESCRIPTION_RW(alarm
),
821 #undef FILE_DESCRIPTION_RO
822 #undef FILE_DESCRIPTION_RW
824 static int acpi_battery_add_fs(struct acpi_device
*device
)
826 struct proc_dir_entry
*entry
= NULL
;
829 if (!acpi_device_dir(device
)) {
830 acpi_device_dir(device
) = proc_mkdir(acpi_device_bid(device
),
832 if (!acpi_device_dir(device
))
836 for (i
= 0; i
< ACPI_BATTERY_NUMFILES
; ++i
) {
837 entry
= proc_create_data(acpi_battery_file
[i
].name
,
838 acpi_battery_file
[i
].mode
,
839 acpi_device_dir(device
),
840 &acpi_battery_file
[i
].ops
,
841 acpi_driver_data(device
));
848 static void acpi_battery_remove_fs(struct acpi_device
*device
)
851 if (!acpi_device_dir(device
))
853 for (i
= 0; i
< ACPI_BATTERY_NUMFILES
; ++i
)
854 remove_proc_entry(acpi_battery_file
[i
].name
,
855 acpi_device_dir(device
));
857 remove_proc_entry(acpi_device_bid(device
), acpi_battery_dir
);
858 acpi_device_dir(device
) = NULL
;
863 /* --------------------------------------------------------------------------
865 -------------------------------------------------------------------------- */
867 static void acpi_battery_notify(struct acpi_device
*device
, u32 event
)
869 struct acpi_battery
*battery
= acpi_driver_data(device
);
873 acpi_battery_update(battery
);
874 acpi_bus_generate_proc_event(device
, event
,
875 acpi_battery_present(battery
));
876 acpi_bus_generate_netlink_event(device
->pnp
.device_class
,
877 dev_name(&device
->dev
), event
,
878 acpi_battery_present(battery
));
879 #ifdef CONFIG_ACPI_SYSFS_POWER
880 /* acpi_battery_update could remove power_supply object */
881 if (battery
->bat
.dev
)
882 power_supply_changed(&battery
->bat
);
886 static int acpi_battery_add(struct acpi_device
*device
)
889 struct acpi_battery
*battery
= NULL
;
893 battery
= kzalloc(sizeof(struct acpi_battery
), GFP_KERNEL
);
896 battery
->device
= device
;
897 strcpy(acpi_device_name(device
), ACPI_BATTERY_DEVICE_NAME
);
898 strcpy(acpi_device_class(device
), ACPI_BATTERY_CLASS
);
899 device
->driver_data
= battery
;
900 mutex_init(&battery
->lock
);
901 if (ACPI_SUCCESS(acpi_get_handle(battery
->device
->handle
,
903 set_bit(ACPI_BATTERY_XINFO_PRESENT
, &battery
->flags
);
904 acpi_battery_update(battery
);
905 #ifdef CONFIG_ACPI_PROCFS_POWER
906 result
= acpi_battery_add_fs(device
);
909 printk(KERN_INFO PREFIX
"%s Slot [%s] (battery %s)\n",
910 ACPI_BATTERY_DEVICE_NAME
, acpi_device_bid(device
),
911 device
->status
.battery_present
? "present" : "absent");
913 #ifdef CONFIG_ACPI_PROCFS_POWER
914 acpi_battery_remove_fs(device
);
921 static int acpi_battery_remove(struct acpi_device
*device
, int type
)
923 struct acpi_battery
*battery
= NULL
;
925 if (!device
|| !acpi_driver_data(device
))
927 battery
= acpi_driver_data(device
);
928 #ifdef CONFIG_ACPI_PROCFS_POWER
929 acpi_battery_remove_fs(device
);
931 #ifdef CONFIG_ACPI_SYSFS_POWER
932 sysfs_remove_battery(battery
);
934 mutex_destroy(&battery
->lock
);
939 /* this is needed to learn about changes made in suspended state */
940 static int acpi_battery_resume(struct acpi_device
*device
)
942 struct acpi_battery
*battery
;
945 battery
= acpi_driver_data(device
);
946 battery
->update_time
= 0;
947 acpi_battery_update(battery
);
951 static struct acpi_driver acpi_battery_driver
= {
953 .class = ACPI_BATTERY_CLASS
,
954 .ids
= battery_device_ids
,
955 .flags
= ACPI_DRIVER_ALL_NOTIFY_EVENTS
,
957 .add
= acpi_battery_add
,
958 .resume
= acpi_battery_resume
,
959 .remove
= acpi_battery_remove
,
960 .notify
= acpi_battery_notify
,
964 static void __init
acpi_battery_init_async(void *unused
, async_cookie_t cookie
)
968 #ifdef CONFIG_ACPI_PROCFS_POWER
969 acpi_battery_dir
= acpi_lock_battery_dir();
970 if (!acpi_battery_dir
)
973 if (acpi_bus_register_driver(&acpi_battery_driver
) < 0) {
974 #ifdef CONFIG_ACPI_PROCFS_POWER
975 acpi_unlock_battery_dir(acpi_battery_dir
);
982 static int __init
acpi_battery_init(void)
984 async_schedule(acpi_battery_init_async
, NULL
);
988 static void __exit
acpi_battery_exit(void)
990 acpi_bus_unregister_driver(&acpi_battery_driver
);
991 #ifdef CONFIG_ACPI_PROCFS_POWER
992 acpi_unlock_battery_dir(acpi_battery_dir
);
996 module_init(acpi_battery_init
);
997 module_exit(acpi_battery_exit
);