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>
35 #include <linux/slab.h>
36 #include <linux/suspend.h>
38 #ifdef CONFIG_ACPI_PROCFS_POWER
39 #include <linux/proc_fs.h>
40 #include <linux/seq_file.h>
41 #include <asm/uaccess.h>
44 #include <acpi/acpi_bus.h>
45 #include <acpi/acpi_drivers.h>
46 #include <linux/power_supply.h>
48 #define PREFIX "ACPI: "
50 #define ACPI_BATTERY_VALUE_UNKNOWN 0xFFFFFFFF
52 #define ACPI_BATTERY_CLASS "battery"
53 #define ACPI_BATTERY_DEVICE_NAME "Battery"
54 #define ACPI_BATTERY_NOTIFY_STATUS 0x80
55 #define ACPI_BATTERY_NOTIFY_INFO 0x81
56 #define ACPI_BATTERY_NOTIFY_THRESHOLD 0x82
58 /* Battery power unit: 0 means mW, 1 means mA */
59 #define ACPI_BATTERY_POWER_UNIT_MA 1
61 #define _COMPONENT ACPI_BATTERY_COMPONENT
63 ACPI_MODULE_NAME("battery");
65 MODULE_AUTHOR("Paul Diefenbaugh");
66 MODULE_AUTHOR("Alexey Starikovskiy <astarikovskiy@suse.de>");
67 MODULE_DESCRIPTION("ACPI Battery Driver");
68 MODULE_LICENSE("GPL");
70 static unsigned int cache_time
= 1000;
71 module_param(cache_time
, uint
, 0644);
72 MODULE_PARM_DESC(cache_time
, "cache time in milliseconds");
74 #ifdef CONFIG_ACPI_PROCFS_POWER
75 extern struct proc_dir_entry
*acpi_lock_battery_dir(void);
76 extern void *acpi_unlock_battery_dir(struct proc_dir_entry
*acpi_battery_dir
);
78 enum acpi_battery_files
{
82 ACPI_BATTERY_NUMFILES
,
87 static const struct acpi_device_id battery_device_ids
[] = {
92 MODULE_DEVICE_TABLE(acpi
, battery_device_ids
);
95 ACPI_BATTERY_ALARM_PRESENT
,
96 ACPI_BATTERY_XINFO_PRESENT
,
97 /* For buggy DSDTs that report negative 16-bit values for either
98 * charging or discharging current and/or report 0 as 65536
101 ACPI_BATTERY_QUIRK_SIGNED16_CURRENT
,
102 ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY
,
105 struct acpi_battery
{
107 struct power_supply bat
;
108 struct acpi_device
*device
;
109 struct notifier_block pm_nb
;
110 unsigned long update_time
;
115 int full_charge_capacity
;
118 int design_capacity_warning
;
119 int design_capacity_low
;
121 int measurement_accuracy
;
122 int max_sampling_time
;
123 int min_sampling_time
;
124 int max_averaging_interval
;
125 int min_averaging_interval
;
126 int capacity_granularity_1
;
127 int capacity_granularity_2
;
129 char model_number
[32];
130 char serial_number
[32];
138 #define to_acpi_battery(x) container_of(x, struct acpi_battery, bat);
140 inline int acpi_battery_present(struct acpi_battery
*battery
)
142 return battery
->device
->status
.battery_present
;
145 static int acpi_battery_technology(struct acpi_battery
*battery
)
147 if (!strcasecmp("NiCd", battery
->type
))
148 return POWER_SUPPLY_TECHNOLOGY_NiCd
;
149 if (!strcasecmp("NiMH", battery
->type
))
150 return POWER_SUPPLY_TECHNOLOGY_NiMH
;
151 if (!strcasecmp("LION", battery
->type
))
152 return POWER_SUPPLY_TECHNOLOGY_LION
;
153 if (!strncasecmp("LI-ION", battery
->type
, 6))
154 return POWER_SUPPLY_TECHNOLOGY_LION
;
155 if (!strcasecmp("LiP", battery
->type
))
156 return POWER_SUPPLY_TECHNOLOGY_LIPO
;
157 return POWER_SUPPLY_TECHNOLOGY_UNKNOWN
;
160 static int acpi_battery_get_state(struct acpi_battery
*battery
);
162 static int acpi_battery_is_charged(struct acpi_battery
*battery
)
164 /* either charging or discharging */
165 if (battery
->state
!= 0)
168 /* battery not reporting charge */
169 if (battery
->capacity_now
== ACPI_BATTERY_VALUE_UNKNOWN
||
170 battery
->capacity_now
== 0)
173 /* good batteries update full_charge as the batteries degrade */
174 if (battery
->full_charge_capacity
== battery
->capacity_now
)
177 /* fallback to using design values for broken batteries */
178 if (battery
->design_capacity
== battery
->capacity_now
)
181 /* we don't do any sort of metric based on percentages */
185 static int acpi_battery_get_property(struct power_supply
*psy
,
186 enum power_supply_property psp
,
187 union power_supply_propval
*val
)
190 struct acpi_battery
*battery
= to_acpi_battery(psy
);
192 if (acpi_battery_present(battery
)) {
193 /* run battery update only if it is present */
194 acpi_battery_get_state(battery
);
195 } else if (psp
!= POWER_SUPPLY_PROP_PRESENT
)
198 case POWER_SUPPLY_PROP_STATUS
:
199 if (battery
->state
& 0x01)
200 val
->intval
= POWER_SUPPLY_STATUS_DISCHARGING
;
201 else if (battery
->state
& 0x02)
202 val
->intval
= POWER_SUPPLY_STATUS_CHARGING
;
203 else if (acpi_battery_is_charged(battery
))
204 val
->intval
= POWER_SUPPLY_STATUS_FULL
;
206 val
->intval
= POWER_SUPPLY_STATUS_UNKNOWN
;
208 case POWER_SUPPLY_PROP_PRESENT
:
209 val
->intval
= acpi_battery_present(battery
);
211 case POWER_SUPPLY_PROP_TECHNOLOGY
:
212 val
->intval
= acpi_battery_technology(battery
);
214 case POWER_SUPPLY_PROP_CYCLE_COUNT
:
215 val
->intval
= battery
->cycle_count
;
217 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN
:
218 if (battery
->design_voltage
== ACPI_BATTERY_VALUE_UNKNOWN
)
221 val
->intval
= battery
->design_voltage
* 1000;
223 case POWER_SUPPLY_PROP_VOLTAGE_NOW
:
224 if (battery
->voltage_now
== ACPI_BATTERY_VALUE_UNKNOWN
)
227 val
->intval
= battery
->voltage_now
* 1000;
229 case POWER_SUPPLY_PROP_CURRENT_NOW
:
230 case POWER_SUPPLY_PROP_POWER_NOW
:
231 if (battery
->rate_now
== ACPI_BATTERY_VALUE_UNKNOWN
)
234 val
->intval
= battery
->rate_now
* 1000;
236 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN
:
237 case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN
:
238 if (battery
->design_capacity
== ACPI_BATTERY_VALUE_UNKNOWN
)
241 val
->intval
= battery
->design_capacity
* 1000;
243 case POWER_SUPPLY_PROP_CHARGE_FULL
:
244 case POWER_SUPPLY_PROP_ENERGY_FULL
:
245 if (battery
->full_charge_capacity
== ACPI_BATTERY_VALUE_UNKNOWN
)
248 val
->intval
= battery
->full_charge_capacity
* 1000;
250 case POWER_SUPPLY_PROP_CHARGE_NOW
:
251 case POWER_SUPPLY_PROP_ENERGY_NOW
:
252 if (battery
->capacity_now
== ACPI_BATTERY_VALUE_UNKNOWN
)
255 val
->intval
= battery
->capacity_now
* 1000;
257 case POWER_SUPPLY_PROP_MODEL_NAME
:
258 val
->strval
= battery
->model_number
;
260 case POWER_SUPPLY_PROP_MANUFACTURER
:
261 val
->strval
= battery
->oem_info
;
263 case POWER_SUPPLY_PROP_SERIAL_NUMBER
:
264 val
->strval
= battery
->serial_number
;
272 static enum power_supply_property charge_battery_props
[] = {
273 POWER_SUPPLY_PROP_STATUS
,
274 POWER_SUPPLY_PROP_PRESENT
,
275 POWER_SUPPLY_PROP_TECHNOLOGY
,
276 POWER_SUPPLY_PROP_CYCLE_COUNT
,
277 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN
,
278 POWER_SUPPLY_PROP_VOLTAGE_NOW
,
279 POWER_SUPPLY_PROP_CURRENT_NOW
,
280 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN
,
281 POWER_SUPPLY_PROP_CHARGE_FULL
,
282 POWER_SUPPLY_PROP_CHARGE_NOW
,
283 POWER_SUPPLY_PROP_MODEL_NAME
,
284 POWER_SUPPLY_PROP_MANUFACTURER
,
285 POWER_SUPPLY_PROP_SERIAL_NUMBER
,
288 static enum power_supply_property energy_battery_props
[] = {
289 POWER_SUPPLY_PROP_STATUS
,
290 POWER_SUPPLY_PROP_PRESENT
,
291 POWER_SUPPLY_PROP_TECHNOLOGY
,
292 POWER_SUPPLY_PROP_CYCLE_COUNT
,
293 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN
,
294 POWER_SUPPLY_PROP_VOLTAGE_NOW
,
295 POWER_SUPPLY_PROP_POWER_NOW
,
296 POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN
,
297 POWER_SUPPLY_PROP_ENERGY_FULL
,
298 POWER_SUPPLY_PROP_ENERGY_NOW
,
299 POWER_SUPPLY_PROP_MODEL_NAME
,
300 POWER_SUPPLY_PROP_MANUFACTURER
,
301 POWER_SUPPLY_PROP_SERIAL_NUMBER
,
304 #ifdef CONFIG_ACPI_PROCFS_POWER
305 inline char *acpi_battery_units(struct acpi_battery
*battery
)
307 return (battery
->power_unit
== ACPI_BATTERY_POWER_UNIT_MA
) ?
312 /* --------------------------------------------------------------------------
314 -------------------------------------------------------------------------- */
315 struct acpi_offsets
{
316 size_t offset
; /* offset inside struct acpi_sbs_battery */
317 u8 mode
; /* int or string? */
320 static struct acpi_offsets state_offsets
[] = {
321 {offsetof(struct acpi_battery
, state
), 0},
322 {offsetof(struct acpi_battery
, rate_now
), 0},
323 {offsetof(struct acpi_battery
, capacity_now
), 0},
324 {offsetof(struct acpi_battery
, voltage_now
), 0},
327 static struct acpi_offsets info_offsets
[] = {
328 {offsetof(struct acpi_battery
, power_unit
), 0},
329 {offsetof(struct acpi_battery
, design_capacity
), 0},
330 {offsetof(struct acpi_battery
, full_charge_capacity
), 0},
331 {offsetof(struct acpi_battery
, technology
), 0},
332 {offsetof(struct acpi_battery
, design_voltage
), 0},
333 {offsetof(struct acpi_battery
, design_capacity_warning
), 0},
334 {offsetof(struct acpi_battery
, design_capacity_low
), 0},
335 {offsetof(struct acpi_battery
, capacity_granularity_1
), 0},
336 {offsetof(struct acpi_battery
, capacity_granularity_2
), 0},
337 {offsetof(struct acpi_battery
, model_number
), 1},
338 {offsetof(struct acpi_battery
, serial_number
), 1},
339 {offsetof(struct acpi_battery
, type
), 1},
340 {offsetof(struct acpi_battery
, oem_info
), 1},
343 static struct acpi_offsets extended_info_offsets
[] = {
344 {offsetof(struct acpi_battery
, power_unit
), 0},
345 {offsetof(struct acpi_battery
, design_capacity
), 0},
346 {offsetof(struct acpi_battery
, full_charge_capacity
), 0},
347 {offsetof(struct acpi_battery
, technology
), 0},
348 {offsetof(struct acpi_battery
, design_voltage
), 0},
349 {offsetof(struct acpi_battery
, design_capacity_warning
), 0},
350 {offsetof(struct acpi_battery
, design_capacity_low
), 0},
351 {offsetof(struct acpi_battery
, cycle_count
), 0},
352 {offsetof(struct acpi_battery
, measurement_accuracy
), 0},
353 {offsetof(struct acpi_battery
, max_sampling_time
), 0},
354 {offsetof(struct acpi_battery
, min_sampling_time
), 0},
355 {offsetof(struct acpi_battery
, max_averaging_interval
), 0},
356 {offsetof(struct acpi_battery
, min_averaging_interval
), 0},
357 {offsetof(struct acpi_battery
, capacity_granularity_1
), 0},
358 {offsetof(struct acpi_battery
, capacity_granularity_2
), 0},
359 {offsetof(struct acpi_battery
, model_number
), 1},
360 {offsetof(struct acpi_battery
, serial_number
), 1},
361 {offsetof(struct acpi_battery
, type
), 1},
362 {offsetof(struct acpi_battery
, oem_info
), 1},
365 static int extract_package(struct acpi_battery
*battery
,
366 union acpi_object
*package
,
367 struct acpi_offsets
*offsets
, int num
)
370 union acpi_object
*element
;
371 if (package
->type
!= ACPI_TYPE_PACKAGE
)
373 for (i
= 0; i
< num
; ++i
) {
374 if (package
->package
.count
<= i
)
376 element
= &package
->package
.elements
[i
];
377 if (offsets
[i
].mode
) {
378 u8
*ptr
= (u8
*)battery
+ offsets
[i
].offset
;
379 if (element
->type
== ACPI_TYPE_STRING
||
380 element
->type
== ACPI_TYPE_BUFFER
)
381 strncpy(ptr
, element
->string
.pointer
, 32);
382 else if (element
->type
== ACPI_TYPE_INTEGER
) {
383 strncpy(ptr
, (u8
*)&element
->integer
.value
,
385 ptr
[sizeof(u64
)] = 0;
387 *ptr
= 0; /* don't have value */
389 int *x
= (int *)((u8
*)battery
+ offsets
[i
].offset
);
390 *x
= (element
->type
== ACPI_TYPE_INTEGER
) ?
391 element
->integer
.value
: -1;
397 static int acpi_battery_get_status(struct acpi_battery
*battery
)
399 if (acpi_bus_get_status(battery
->device
)) {
400 ACPI_EXCEPTION((AE_INFO
, AE_ERROR
, "Evaluating _STA"));
406 static int acpi_battery_get_info(struct acpi_battery
*battery
)
408 int result
= -EFAULT
;
409 acpi_status status
= 0;
410 char *name
= test_bit(ACPI_BATTERY_XINFO_PRESENT
, &battery
->flags
)?
413 struct acpi_buffer buffer
= { ACPI_ALLOCATE_BUFFER
, NULL
};
415 if (!acpi_battery_present(battery
))
417 mutex_lock(&battery
->lock
);
418 status
= acpi_evaluate_object(battery
->device
->handle
, name
,
420 mutex_unlock(&battery
->lock
);
422 if (ACPI_FAILURE(status
)) {
423 ACPI_EXCEPTION((AE_INFO
, status
, "Evaluating %s", name
));
426 if (test_bit(ACPI_BATTERY_XINFO_PRESENT
, &battery
->flags
))
427 result
= extract_package(battery
, buffer
.pointer
,
428 extended_info_offsets
,
429 ARRAY_SIZE(extended_info_offsets
));
431 result
= extract_package(battery
, buffer
.pointer
,
432 info_offsets
, ARRAY_SIZE(info_offsets
));
433 kfree(buffer
.pointer
);
434 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY
, &battery
->flags
))
435 battery
->full_charge_capacity
= battery
->design_capacity
;
439 static int acpi_battery_get_state(struct acpi_battery
*battery
)
442 acpi_status status
= 0;
443 struct acpi_buffer buffer
= { ACPI_ALLOCATE_BUFFER
, NULL
};
445 if (!acpi_battery_present(battery
))
448 if (battery
->update_time
&&
449 time_before(jiffies
, battery
->update_time
+
450 msecs_to_jiffies(cache_time
)))
453 mutex_lock(&battery
->lock
);
454 status
= acpi_evaluate_object(battery
->device
->handle
, "_BST",
456 mutex_unlock(&battery
->lock
);
458 if (ACPI_FAILURE(status
)) {
459 ACPI_EXCEPTION((AE_INFO
, status
, "Evaluating _BST"));
463 result
= extract_package(battery
, buffer
.pointer
,
464 state_offsets
, ARRAY_SIZE(state_offsets
));
465 battery
->update_time
= jiffies
;
466 kfree(buffer
.pointer
);
468 if (test_bit(ACPI_BATTERY_QUIRK_SIGNED16_CURRENT
, &battery
->flags
) &&
469 battery
->rate_now
!= -1)
470 battery
->rate_now
= abs((s16
)battery
->rate_now
);
472 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY
, &battery
->flags
)
473 && battery
->capacity_now
>= 0 && battery
->capacity_now
<= 100)
474 battery
->capacity_now
= (battery
->capacity_now
*
475 battery
->full_charge_capacity
) / 100;
479 static int acpi_battery_set_alarm(struct acpi_battery
*battery
)
481 acpi_status status
= 0;
482 union acpi_object arg0
= { .type
= ACPI_TYPE_INTEGER
};
483 struct acpi_object_list arg_list
= { 1, &arg0
};
485 if (!acpi_battery_present(battery
) ||
486 !test_bit(ACPI_BATTERY_ALARM_PRESENT
, &battery
->flags
))
489 arg0
.integer
.value
= battery
->alarm
;
491 mutex_lock(&battery
->lock
);
492 status
= acpi_evaluate_object(battery
->device
->handle
, "_BTP",
494 mutex_unlock(&battery
->lock
);
496 if (ACPI_FAILURE(status
))
499 ACPI_DEBUG_PRINT((ACPI_DB_INFO
, "Alarm set to %d\n", battery
->alarm
));
503 static int acpi_battery_init_alarm(struct acpi_battery
*battery
)
505 acpi_status status
= AE_OK
;
506 acpi_handle handle
= NULL
;
508 /* See if alarms are supported, and if so, set default */
509 status
= acpi_get_handle(battery
->device
->handle
, "_BTP", &handle
);
510 if (ACPI_FAILURE(status
)) {
511 clear_bit(ACPI_BATTERY_ALARM_PRESENT
, &battery
->flags
);
514 set_bit(ACPI_BATTERY_ALARM_PRESENT
, &battery
->flags
);
516 battery
->alarm
= battery
->design_capacity_warning
;
517 return acpi_battery_set_alarm(battery
);
520 static ssize_t
acpi_battery_alarm_show(struct device
*dev
,
521 struct device_attribute
*attr
,
524 struct acpi_battery
*battery
= to_acpi_battery(dev_get_drvdata(dev
));
525 return sprintf(buf
, "%d\n", battery
->alarm
* 1000);
528 static ssize_t
acpi_battery_alarm_store(struct device
*dev
,
529 struct device_attribute
*attr
,
530 const char *buf
, size_t count
)
533 struct acpi_battery
*battery
= to_acpi_battery(dev_get_drvdata(dev
));
534 if (sscanf(buf
, "%ld\n", &x
) == 1)
535 battery
->alarm
= x
/1000;
536 if (acpi_battery_present(battery
))
537 acpi_battery_set_alarm(battery
);
541 static struct device_attribute alarm_attr
= {
542 .attr
= {.name
= "alarm", .mode
= 0644},
543 .show
= acpi_battery_alarm_show
,
544 .store
= acpi_battery_alarm_store
,
547 static int sysfs_add_battery(struct acpi_battery
*battery
)
551 if (battery
->power_unit
== ACPI_BATTERY_POWER_UNIT_MA
) {
552 battery
->bat
.properties
= charge_battery_props
;
553 battery
->bat
.num_properties
=
554 ARRAY_SIZE(charge_battery_props
);
556 battery
->bat
.properties
= energy_battery_props
;
557 battery
->bat
.num_properties
=
558 ARRAY_SIZE(energy_battery_props
);
561 battery
->bat
.name
= acpi_device_bid(battery
->device
);
562 battery
->bat
.type
= POWER_SUPPLY_TYPE_BATTERY
;
563 battery
->bat
.get_property
= acpi_battery_get_property
;
565 result
= power_supply_register(&battery
->device
->dev
, &battery
->bat
);
568 return device_create_file(battery
->bat
.dev
, &alarm_attr
);
571 static void sysfs_remove_battery(struct acpi_battery
*battery
)
573 if (!battery
->bat
.dev
)
575 device_remove_file(battery
->bat
.dev
, &alarm_attr
);
576 power_supply_unregister(&battery
->bat
);
577 battery
->bat
.dev
= NULL
;
580 static void acpi_battery_quirks(struct acpi_battery
*battery
)
582 if (dmi_name_in_vendors("Acer") &&
583 battery
->power_unit
== ACPI_BATTERY_POWER_UNIT_MA
) {
584 set_bit(ACPI_BATTERY_QUIRK_SIGNED16_CURRENT
, &battery
->flags
);
589 * According to the ACPI spec, some kinds of primary batteries can
590 * report percentage battery remaining capacity directly to OS.
591 * In this case, it reports the Last Full Charged Capacity == 100
592 * and BatteryPresentRate == 0xFFFFFFFF.
594 * Now we found some battery reports percentage remaining capacity
595 * even if it's rechargeable.
596 * https://bugzilla.kernel.org/show_bug.cgi?id=15979
598 * Handle this correctly so that they won't break userspace.
600 static void acpi_battery_quirks2(struct acpi_battery
*battery
)
602 if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY
, &battery
->flags
))
605 if (battery
->full_charge_capacity
== 100 &&
606 battery
->rate_now
== ACPI_BATTERY_VALUE_UNKNOWN
&&
607 battery
->capacity_now
>=0 && battery
->capacity_now
<= 100) {
608 set_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY
, &battery
->flags
);
609 battery
->full_charge_capacity
= battery
->design_capacity
;
610 battery
->capacity_now
= (battery
->capacity_now
*
611 battery
->full_charge_capacity
) / 100;
615 static int acpi_battery_update(struct acpi_battery
*battery
)
617 int result
, old_present
= acpi_battery_present(battery
);
618 result
= acpi_battery_get_status(battery
);
621 if (!acpi_battery_present(battery
)) {
622 sysfs_remove_battery(battery
);
623 battery
->update_time
= 0;
626 if (!battery
->update_time
||
627 old_present
!= acpi_battery_present(battery
)) {
628 result
= acpi_battery_get_info(battery
);
631 acpi_battery_quirks(battery
);
632 acpi_battery_init_alarm(battery
);
634 if (!battery
->bat
.dev
)
635 sysfs_add_battery(battery
);
636 result
= acpi_battery_get_state(battery
);
637 acpi_battery_quirks2(battery
);
641 static void acpi_battery_refresh(struct acpi_battery
*battery
)
643 if (!battery
->bat
.dev
)
646 acpi_battery_get_info(battery
);
647 /* The battery may have changed its reporting units. */
648 sysfs_remove_battery(battery
);
649 sysfs_add_battery(battery
);
652 /* --------------------------------------------------------------------------
654 -------------------------------------------------------------------------- */
656 #ifdef CONFIG_ACPI_PROCFS_POWER
657 static struct proc_dir_entry
*acpi_battery_dir
;
659 static int acpi_battery_print_info(struct seq_file
*seq
, int result
)
661 struct acpi_battery
*battery
= seq
->private;
666 seq_printf(seq
, "present: %s\n",
667 acpi_battery_present(battery
)?"yes":"no");
668 if (!acpi_battery_present(battery
))
670 if (battery
->design_capacity
== ACPI_BATTERY_VALUE_UNKNOWN
)
671 seq_printf(seq
, "design capacity: unknown\n");
673 seq_printf(seq
, "design capacity: %d %sh\n",
674 battery
->design_capacity
,
675 acpi_battery_units(battery
));
677 if (battery
->full_charge_capacity
== ACPI_BATTERY_VALUE_UNKNOWN
)
678 seq_printf(seq
, "last full capacity: unknown\n");
680 seq_printf(seq
, "last full capacity: %d %sh\n",
681 battery
->full_charge_capacity
,
682 acpi_battery_units(battery
));
684 seq_printf(seq
, "battery technology: %srechargeable\n",
685 (!battery
->technology
)?"non-":"");
687 if (battery
->design_voltage
== ACPI_BATTERY_VALUE_UNKNOWN
)
688 seq_printf(seq
, "design voltage: unknown\n");
690 seq_printf(seq
, "design voltage: %d mV\n",
691 battery
->design_voltage
);
692 seq_printf(seq
, "design capacity warning: %d %sh\n",
693 battery
->design_capacity_warning
,
694 acpi_battery_units(battery
));
695 seq_printf(seq
, "design capacity low: %d %sh\n",
696 battery
->design_capacity_low
,
697 acpi_battery_units(battery
));
698 seq_printf(seq
, "cycle count: %i\n", battery
->cycle_count
);
699 seq_printf(seq
, "capacity granularity 1: %d %sh\n",
700 battery
->capacity_granularity_1
,
701 acpi_battery_units(battery
));
702 seq_printf(seq
, "capacity granularity 2: %d %sh\n",
703 battery
->capacity_granularity_2
,
704 acpi_battery_units(battery
));
705 seq_printf(seq
, "model number: %s\n", battery
->model_number
);
706 seq_printf(seq
, "serial number: %s\n", battery
->serial_number
);
707 seq_printf(seq
, "battery type: %s\n", battery
->type
);
708 seq_printf(seq
, "OEM info: %s\n", battery
->oem_info
);
711 seq_printf(seq
, "ERROR: Unable to read battery info\n");
715 static int acpi_battery_print_state(struct seq_file
*seq
, int result
)
717 struct acpi_battery
*battery
= seq
->private;
722 seq_printf(seq
, "present: %s\n",
723 acpi_battery_present(battery
)?"yes":"no");
724 if (!acpi_battery_present(battery
))
727 seq_printf(seq
, "capacity state: %s\n",
728 (battery
->state
& 0x04)?"critical":"ok");
729 if ((battery
->state
& 0x01) && (battery
->state
& 0x02))
731 "charging state: charging/discharging\n");
732 else if (battery
->state
& 0x01)
733 seq_printf(seq
, "charging state: discharging\n");
734 else if (battery
->state
& 0x02)
735 seq_printf(seq
, "charging state: charging\n");
737 seq_printf(seq
, "charging state: charged\n");
739 if (battery
->rate_now
== ACPI_BATTERY_VALUE_UNKNOWN
)
740 seq_printf(seq
, "present rate: unknown\n");
742 seq_printf(seq
, "present rate: %d %s\n",
743 battery
->rate_now
, acpi_battery_units(battery
));
745 if (battery
->capacity_now
== ACPI_BATTERY_VALUE_UNKNOWN
)
746 seq_printf(seq
, "remaining capacity: unknown\n");
748 seq_printf(seq
, "remaining capacity: %d %sh\n",
749 battery
->capacity_now
, acpi_battery_units(battery
));
750 if (battery
->voltage_now
== ACPI_BATTERY_VALUE_UNKNOWN
)
751 seq_printf(seq
, "present voltage: unknown\n");
753 seq_printf(seq
, "present voltage: %d mV\n",
754 battery
->voltage_now
);
757 seq_printf(seq
, "ERROR: Unable to read battery state\n");
762 static int acpi_battery_print_alarm(struct seq_file
*seq
, int result
)
764 struct acpi_battery
*battery
= seq
->private;
769 if (!acpi_battery_present(battery
)) {
770 seq_printf(seq
, "present: no\n");
773 seq_printf(seq
, "alarm: ");
775 seq_printf(seq
, "unsupported\n");
777 seq_printf(seq
, "%u %sh\n", battery
->alarm
,
778 acpi_battery_units(battery
));
781 seq_printf(seq
, "ERROR: Unable to read battery alarm\n");
785 static ssize_t
acpi_battery_write_alarm(struct file
*file
,
786 const char __user
* buffer
,
787 size_t count
, loff_t
* ppos
)
790 char alarm_string
[12] = { '\0' };
791 struct seq_file
*m
= file
->private_data
;
792 struct acpi_battery
*battery
= m
->private;
794 if (!battery
|| (count
> sizeof(alarm_string
) - 1))
796 if (!acpi_battery_present(battery
)) {
800 if (copy_from_user(alarm_string
, buffer
, count
)) {
804 alarm_string
[count
] = '\0';
805 battery
->alarm
= simple_strtol(alarm_string
, NULL
, 0);
806 result
= acpi_battery_set_alarm(battery
);
813 typedef int(*print_func
)(struct seq_file
*seq
, int result
);
815 static print_func acpi_print_funcs
[ACPI_BATTERY_NUMFILES
] = {
816 acpi_battery_print_info
,
817 acpi_battery_print_state
,
818 acpi_battery_print_alarm
,
821 static int acpi_battery_read(int fid
, struct seq_file
*seq
)
823 struct acpi_battery
*battery
= seq
->private;
824 int result
= acpi_battery_update(battery
);
825 return acpi_print_funcs
[fid
](seq
, result
);
828 #define DECLARE_FILE_FUNCTIONS(_name) \
829 static int acpi_battery_read_##_name(struct seq_file *seq, void *offset) \
831 return acpi_battery_read(_name##_tag, seq); \
833 static int acpi_battery_##_name##_open_fs(struct inode *inode, struct file *file) \
835 return single_open(file, acpi_battery_read_##_name, PDE(inode)->data); \
838 DECLARE_FILE_FUNCTIONS(info
);
839 DECLARE_FILE_FUNCTIONS(state
);
840 DECLARE_FILE_FUNCTIONS(alarm
);
842 #undef DECLARE_FILE_FUNCTIONS
844 #define FILE_DESCRIPTION_RO(_name) \
846 .name = __stringify(_name), \
849 .open = acpi_battery_##_name##_open_fs, \
851 .llseek = seq_lseek, \
852 .release = single_release, \
853 .owner = THIS_MODULE, \
857 #define FILE_DESCRIPTION_RW(_name) \
859 .name = __stringify(_name), \
860 .mode = S_IFREG | S_IRUGO | S_IWUSR, \
862 .open = acpi_battery_##_name##_open_fs, \
864 .llseek = seq_lseek, \
865 .write = acpi_battery_write_##_name, \
866 .release = single_release, \
867 .owner = THIS_MODULE, \
871 static struct battery_file
{
872 struct file_operations ops
;
875 } acpi_battery_file
[] = {
876 FILE_DESCRIPTION_RO(info
),
877 FILE_DESCRIPTION_RO(state
),
878 FILE_DESCRIPTION_RW(alarm
),
881 #undef FILE_DESCRIPTION_RO
882 #undef FILE_DESCRIPTION_RW
884 static int acpi_battery_add_fs(struct acpi_device
*device
)
886 struct proc_dir_entry
*entry
= NULL
;
889 printk(KERN_WARNING PREFIX
"Deprecated procfs I/F for battery is loaded,"
890 " please retry with CONFIG_ACPI_PROCFS_POWER cleared\n");
891 if (!acpi_device_dir(device
)) {
892 acpi_device_dir(device
) = proc_mkdir(acpi_device_bid(device
),
894 if (!acpi_device_dir(device
))
898 for (i
= 0; i
< ACPI_BATTERY_NUMFILES
; ++i
) {
899 entry
= proc_create_data(acpi_battery_file
[i
].name
,
900 acpi_battery_file
[i
].mode
,
901 acpi_device_dir(device
),
902 &acpi_battery_file
[i
].ops
,
903 acpi_driver_data(device
));
910 static void acpi_battery_remove_fs(struct acpi_device
*device
)
913 if (!acpi_device_dir(device
))
915 for (i
= 0; i
< ACPI_BATTERY_NUMFILES
; ++i
)
916 remove_proc_entry(acpi_battery_file
[i
].name
,
917 acpi_device_dir(device
));
919 remove_proc_entry(acpi_device_bid(device
), acpi_battery_dir
);
920 acpi_device_dir(device
) = NULL
;
925 /* --------------------------------------------------------------------------
927 -------------------------------------------------------------------------- */
929 static void acpi_battery_notify(struct acpi_device
*device
, u32 event
)
931 struct acpi_battery
*battery
= acpi_driver_data(device
);
936 old
= battery
->bat
.dev
;
937 if (event
== ACPI_BATTERY_NOTIFY_INFO
)
938 acpi_battery_refresh(battery
);
939 acpi_battery_update(battery
);
940 acpi_bus_generate_proc_event(device
, event
,
941 acpi_battery_present(battery
));
942 acpi_bus_generate_netlink_event(device
->pnp
.device_class
,
943 dev_name(&device
->dev
), event
,
944 acpi_battery_present(battery
));
945 /* acpi_battery_update could remove power_supply object */
946 if (old
&& battery
->bat
.dev
)
947 power_supply_changed(&battery
->bat
);
950 static int battery_notify(struct notifier_block
*nb
,
951 unsigned long mode
, void *_unused
)
953 struct acpi_battery
*battery
= container_of(nb
, struct acpi_battery
,
956 case PM_POST_SUSPEND
:
957 sysfs_remove_battery(battery
);
958 sysfs_add_battery(battery
);
965 static int acpi_battery_add(struct acpi_device
*device
)
968 struct acpi_battery
*battery
= NULL
;
972 battery
= kzalloc(sizeof(struct acpi_battery
), GFP_KERNEL
);
975 battery
->device
= device
;
976 strcpy(acpi_device_name(device
), ACPI_BATTERY_DEVICE_NAME
);
977 strcpy(acpi_device_class(device
), ACPI_BATTERY_CLASS
);
978 device
->driver_data
= battery
;
979 mutex_init(&battery
->lock
);
980 if (ACPI_SUCCESS(acpi_get_handle(battery
->device
->handle
,
982 set_bit(ACPI_BATTERY_XINFO_PRESENT
, &battery
->flags
);
983 acpi_battery_update(battery
);
984 #ifdef CONFIG_ACPI_PROCFS_POWER
985 result
= acpi_battery_add_fs(device
);
988 printk(KERN_INFO PREFIX
"%s Slot [%s] (battery %s)\n",
989 ACPI_BATTERY_DEVICE_NAME
, acpi_device_bid(device
),
990 device
->status
.battery_present
? "present" : "absent");
992 #ifdef CONFIG_ACPI_PROCFS_POWER
993 acpi_battery_remove_fs(device
);
998 battery
->pm_nb
.notifier_call
= battery_notify
;
999 register_pm_notifier(&battery
->pm_nb
);
1004 static int acpi_battery_remove(struct acpi_device
*device
, int type
)
1006 struct acpi_battery
*battery
= NULL
;
1008 if (!device
|| !acpi_driver_data(device
))
1010 battery
= acpi_driver_data(device
);
1011 unregister_pm_notifier(&battery
->pm_nb
);
1012 #ifdef CONFIG_ACPI_PROCFS_POWER
1013 acpi_battery_remove_fs(device
);
1015 sysfs_remove_battery(battery
);
1016 mutex_destroy(&battery
->lock
);
1021 /* this is needed to learn about changes made in suspended state */
1022 static int acpi_battery_resume(struct acpi_device
*device
)
1024 struct acpi_battery
*battery
;
1027 battery
= acpi_driver_data(device
);
1028 battery
->update_time
= 0;
1029 acpi_battery_update(battery
);
1033 static struct acpi_driver acpi_battery_driver
= {
1035 .class = ACPI_BATTERY_CLASS
,
1036 .ids
= battery_device_ids
,
1037 .flags
= ACPI_DRIVER_ALL_NOTIFY_EVENTS
,
1039 .add
= acpi_battery_add
,
1040 .resume
= acpi_battery_resume
,
1041 .remove
= acpi_battery_remove
,
1042 .notify
= acpi_battery_notify
,
1046 static void __init
acpi_battery_init_async(void *unused
, async_cookie_t cookie
)
1050 #ifdef CONFIG_ACPI_PROCFS_POWER
1051 acpi_battery_dir
= acpi_lock_battery_dir();
1052 if (!acpi_battery_dir
)
1055 if (acpi_bus_register_driver(&acpi_battery_driver
) < 0) {
1056 #ifdef CONFIG_ACPI_PROCFS_POWER
1057 acpi_unlock_battery_dir(acpi_battery_dir
);
1064 static int __init
acpi_battery_init(void)
1066 async_schedule(acpi_battery_init_async
, NULL
);
1070 static void __exit
acpi_battery_exit(void)
1072 acpi_bus_unregister_driver(&acpi_battery_driver
);
1073 #ifdef CONFIG_ACPI_PROCFS_POWER
1074 acpi_unlock_battery_dir(acpi_battery_dir
);
1078 module_init(acpi_battery_init
);
1079 module_exit(acpi_battery_exit
);