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
58 #define _COMPONENT ACPI_BATTERY_COMPONENT
60 ACPI_MODULE_NAME("battery");
62 MODULE_AUTHOR("Paul Diefenbaugh");
63 MODULE_AUTHOR("Alexey Starikovskiy <astarikovskiy@suse.de>");
64 MODULE_DESCRIPTION("ACPI Battery Driver");
65 MODULE_LICENSE("GPL");
67 static unsigned int cache_time = 1000;
68 module_param(cache_time, uint, 0644);
69 MODULE_PARM_DESC(cache_time, "cache time in milliseconds");
71 #ifdef CONFIG_ACPI_PROCFS_POWER
72 extern struct proc_dir_entry *acpi_lock_battery_dir(void);
73 extern void *acpi_unlock_battery_dir(struct proc_dir_entry *acpi_battery_dir);
75 enum acpi_battery_files {
79 ACPI_BATTERY_NUMFILES,
84 static const struct acpi_device_id battery_device_ids[] = {
89 MODULE_DEVICE_TABLE(acpi, battery_device_ids);
92 ACPI_BATTERY_ALARM_PRESENT,
93 /* For buggy DSDTs that report negative 16-bit values for either charging
94 * or discharging current and/or report 0 as 65536 due to bad math.
96 ACPI_BATTERY_QUIRK_SIGNED16_CURRENT,
101 #ifdef CONFIG_ACPI_SYSFS_POWER
102 struct power_supply bat;
104 struct acpi_device *device;
105 unsigned long update_time;
110 int full_charge_capacity;
113 int design_capacity_warning;
114 int design_capacity_low;
115 int capacity_granularity_1;
116 int capacity_granularity_2;
118 char model_number[32];
119 char serial_number[32];
127 #define to_acpi_battery(x) container_of(x, struct acpi_battery, bat);
129 inline int acpi_battery_present(struct acpi_battery *battery)
131 return battery->device->status.battery_present;
134 #ifdef CONFIG_ACPI_SYSFS_POWER
135 static int acpi_battery_technology(struct acpi_battery *battery)
137 if (!strcasecmp("NiCd", battery->type))
138 return POWER_SUPPLY_TECHNOLOGY_NiCd;
139 if (!strcasecmp("NiMH", battery->type))
140 return POWER_SUPPLY_TECHNOLOGY_NiMH;
141 if (!strcasecmp("LION", battery->type))
142 return POWER_SUPPLY_TECHNOLOGY_LION;
143 if (!strncasecmp("LI-ION", battery->type, 6))
144 return POWER_SUPPLY_TECHNOLOGY_LION;
145 if (!strcasecmp("LiP", battery->type))
146 return POWER_SUPPLY_TECHNOLOGY_LIPO;
147 return POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
150 static int acpi_battery_get_state(struct acpi_battery *battery);
152 static int acpi_battery_is_charged(struct acpi_battery *battery)
154 /* either charging or discharging */
155 if (battery->state != 0)
158 /* battery not reporting charge */
159 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN ||
160 battery->capacity_now == 0)
163 /* good batteries update full_charge as the batteries degrade */
164 if (battery->full_charge_capacity == battery->capacity_now)
167 /* fallback to using design values for broken batteries */
168 if (battery->design_capacity == battery->capacity_now)
171 /* we don't do any sort of metric based on percentages */
175 static int acpi_battery_get_property(struct power_supply *psy,
176 enum power_supply_property psp,
177 union power_supply_propval *val)
179 struct acpi_battery *battery = to_acpi_battery(psy);
181 if (acpi_battery_present(battery)) {
182 /* run battery update only if it is present */
183 acpi_battery_get_state(battery);
184 } else if (psp != POWER_SUPPLY_PROP_PRESENT)
187 case POWER_SUPPLY_PROP_STATUS:
188 if (battery->state & 0x01)
189 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
190 else if (battery->state & 0x02)
191 val->intval = POWER_SUPPLY_STATUS_CHARGING;
192 else if (acpi_battery_is_charged(battery))
193 val->intval = POWER_SUPPLY_STATUS_FULL;
195 val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
197 case POWER_SUPPLY_PROP_PRESENT:
198 val->intval = acpi_battery_present(battery);
200 case POWER_SUPPLY_PROP_TECHNOLOGY:
201 val->intval = acpi_battery_technology(battery);
203 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
204 val->intval = battery->design_voltage * 1000;
206 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
207 val->intval = battery->voltage_now * 1000;
209 case POWER_SUPPLY_PROP_CURRENT_NOW:
210 case POWER_SUPPLY_PROP_POWER_NOW:
211 val->intval = battery->rate_now * 1000;
213 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
214 case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
215 val->intval = battery->design_capacity * 1000;
217 case POWER_SUPPLY_PROP_CHARGE_FULL:
218 case POWER_SUPPLY_PROP_ENERGY_FULL:
219 val->intval = battery->full_charge_capacity * 1000;
221 case POWER_SUPPLY_PROP_CHARGE_NOW:
222 case POWER_SUPPLY_PROP_ENERGY_NOW:
223 val->intval = battery->capacity_now * 1000;
225 case POWER_SUPPLY_PROP_MODEL_NAME:
226 val->strval = battery->model_number;
228 case POWER_SUPPLY_PROP_MANUFACTURER:
229 val->strval = battery->oem_info;
231 case POWER_SUPPLY_PROP_SERIAL_NUMBER:
232 val->strval = battery->serial_number;
240 static enum power_supply_property charge_battery_props[] = {
241 POWER_SUPPLY_PROP_STATUS,
242 POWER_SUPPLY_PROP_PRESENT,
243 POWER_SUPPLY_PROP_TECHNOLOGY,
244 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
245 POWER_SUPPLY_PROP_VOLTAGE_NOW,
246 POWER_SUPPLY_PROP_CURRENT_NOW,
247 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
248 POWER_SUPPLY_PROP_CHARGE_FULL,
249 POWER_SUPPLY_PROP_CHARGE_NOW,
250 POWER_SUPPLY_PROP_MODEL_NAME,
251 POWER_SUPPLY_PROP_MANUFACTURER,
252 POWER_SUPPLY_PROP_SERIAL_NUMBER,
255 static enum power_supply_property energy_battery_props[] = {
256 POWER_SUPPLY_PROP_STATUS,
257 POWER_SUPPLY_PROP_PRESENT,
258 POWER_SUPPLY_PROP_TECHNOLOGY,
259 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
260 POWER_SUPPLY_PROP_VOLTAGE_NOW,
261 POWER_SUPPLY_PROP_CURRENT_NOW,
262 POWER_SUPPLY_PROP_POWER_NOW,
263 POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
264 POWER_SUPPLY_PROP_ENERGY_FULL,
265 POWER_SUPPLY_PROP_ENERGY_NOW,
266 POWER_SUPPLY_PROP_MODEL_NAME,
267 POWER_SUPPLY_PROP_MANUFACTURER,
268 POWER_SUPPLY_PROP_SERIAL_NUMBER,
272 #ifdef CONFIG_ACPI_PROCFS_POWER
273 inline char *acpi_battery_units(struct acpi_battery *battery)
275 return (battery->power_unit)?"mA":"mW";
279 /* --------------------------------------------------------------------------
281 -------------------------------------------------------------------------- */
282 struct acpi_offsets {
283 size_t offset; /* offset inside struct acpi_sbs_battery */
284 u8 mode; /* int or string? */
287 static struct acpi_offsets state_offsets[] = {
288 {offsetof(struct acpi_battery, state), 0},
289 {offsetof(struct acpi_battery, rate_now), 0},
290 {offsetof(struct acpi_battery, capacity_now), 0},
291 {offsetof(struct acpi_battery, voltage_now), 0},
294 static struct acpi_offsets info_offsets[] = {
295 {offsetof(struct acpi_battery, power_unit), 0},
296 {offsetof(struct acpi_battery, design_capacity), 0},
297 {offsetof(struct acpi_battery, full_charge_capacity), 0},
298 {offsetof(struct acpi_battery, technology), 0},
299 {offsetof(struct acpi_battery, design_voltage), 0},
300 {offsetof(struct acpi_battery, design_capacity_warning), 0},
301 {offsetof(struct acpi_battery, design_capacity_low), 0},
302 {offsetof(struct acpi_battery, capacity_granularity_1), 0},
303 {offsetof(struct acpi_battery, capacity_granularity_2), 0},
304 {offsetof(struct acpi_battery, model_number), 1},
305 {offsetof(struct acpi_battery, serial_number), 1},
306 {offsetof(struct acpi_battery, type), 1},
307 {offsetof(struct acpi_battery, oem_info), 1},
310 static int extract_package(struct acpi_battery *battery,
311 union acpi_object *package,
312 struct acpi_offsets *offsets, int num)
315 union acpi_object *element;
316 if (package->type != ACPI_TYPE_PACKAGE)
318 for (i = 0; i < num; ++i) {
319 if (package->package.count <= i)
321 element = &package->package.elements[i];
322 if (offsets[i].mode) {
323 u8 *ptr = (u8 *)battery + offsets[i].offset;
324 if (element->type == ACPI_TYPE_STRING ||
325 element->type == ACPI_TYPE_BUFFER)
326 strncpy(ptr, element->string.pointer, 32);
327 else if (element->type == ACPI_TYPE_INTEGER) {
328 strncpy(ptr, (u8 *)&element->integer.value,
329 sizeof(acpi_integer));
330 ptr[sizeof(acpi_integer)] = 0;
332 *ptr = 0; /* don't have value */
334 int *x = (int *)((u8 *)battery + offsets[i].offset);
335 *x = (element->type == ACPI_TYPE_INTEGER) ?
336 element->integer.value : -1;
342 static int acpi_battery_get_status(struct acpi_battery *battery)
344 if (acpi_bus_get_status(battery->device)) {
345 ACPI_EXCEPTION((AE_INFO, AE_ERROR, "Evaluating _STA"));
351 static int acpi_battery_get_info(struct acpi_battery *battery)
353 int result = -EFAULT;
354 acpi_status status = 0;
355 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
357 if (!acpi_battery_present(battery))
359 mutex_lock(&battery->lock);
360 status = acpi_evaluate_object(battery->device->handle, "_BIF",
362 mutex_unlock(&battery->lock);
364 if (ACPI_FAILURE(status)) {
365 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BIF"));
369 result = extract_package(battery, buffer.pointer,
370 info_offsets, ARRAY_SIZE(info_offsets));
371 kfree(buffer.pointer);
375 static int acpi_battery_get_state(struct acpi_battery *battery)
378 acpi_status status = 0;
379 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
381 if (!acpi_battery_present(battery))
384 if (battery->update_time &&
385 time_before(jiffies, battery->update_time +
386 msecs_to_jiffies(cache_time)))
389 mutex_lock(&battery->lock);
390 status = acpi_evaluate_object(battery->device->handle, "_BST",
392 mutex_unlock(&battery->lock);
394 if (ACPI_FAILURE(status)) {
395 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BST"));
399 result = extract_package(battery, buffer.pointer,
400 state_offsets, ARRAY_SIZE(state_offsets));
401 battery->update_time = jiffies;
402 kfree(buffer.pointer);
404 if (test_bit(ACPI_BATTERY_QUIRK_SIGNED16_CURRENT, &battery->flags) &&
405 battery->rate_now != -1)
406 battery->rate_now = abs((s16)battery->rate_now);
411 static int acpi_battery_set_alarm(struct acpi_battery *battery)
413 acpi_status status = 0;
414 union acpi_object arg0 = { .type = ACPI_TYPE_INTEGER };
415 struct acpi_object_list arg_list = { 1, &arg0 };
417 if (!acpi_battery_present(battery)||
418 !test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags))
421 arg0.integer.value = battery->alarm;
423 mutex_lock(&battery->lock);
424 status = acpi_evaluate_object(battery->device->handle, "_BTP",
426 mutex_unlock(&battery->lock);
428 if (ACPI_FAILURE(status))
431 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Alarm set to %d\n", battery->alarm));
435 static int acpi_battery_init_alarm(struct acpi_battery *battery)
437 acpi_status status = AE_OK;
438 acpi_handle handle = NULL;
440 /* See if alarms are supported, and if so, set default */
441 status = acpi_get_handle(battery->device->handle, "_BTP", &handle);
442 if (ACPI_FAILURE(status)) {
443 clear_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
446 set_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags);
448 battery->alarm = battery->design_capacity_warning;
449 return acpi_battery_set_alarm(battery);
452 #ifdef CONFIG_ACPI_SYSFS_POWER
453 static ssize_t acpi_battery_alarm_show(struct device *dev,
454 struct device_attribute *attr,
457 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
458 return sprintf(buf, "%d\n", battery->alarm * 1000);
461 static ssize_t acpi_battery_alarm_store(struct device *dev,
462 struct device_attribute *attr,
463 const char *buf, size_t count)
466 struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
467 if (sscanf(buf, "%ld\n", &x) == 1)
468 battery->alarm = x/1000;
469 if (acpi_battery_present(battery))
470 acpi_battery_set_alarm(battery);
474 static struct device_attribute alarm_attr = {
475 .attr = {.name = "alarm", .mode = 0644},
476 .show = acpi_battery_alarm_show,
477 .store = acpi_battery_alarm_store,
480 static int sysfs_add_battery(struct acpi_battery *battery)
484 if (battery->power_unit) {
485 battery->bat.properties = charge_battery_props;
486 battery->bat.num_properties =
487 ARRAY_SIZE(charge_battery_props);
489 battery->bat.properties = energy_battery_props;
490 battery->bat.num_properties =
491 ARRAY_SIZE(energy_battery_props);
494 battery->bat.name = acpi_device_bid(battery->device);
495 battery->bat.type = POWER_SUPPLY_TYPE_BATTERY;
496 battery->bat.get_property = acpi_battery_get_property;
498 result = power_supply_register(&battery->device->dev, &battery->bat);
501 return device_create_file(battery->bat.dev, &alarm_attr);
504 static void sysfs_remove_battery(struct acpi_battery *battery)
506 if (!battery->bat.dev)
508 device_remove_file(battery->bat.dev, &alarm_attr);
509 power_supply_unregister(&battery->bat);
510 battery->bat.dev = NULL;
514 static void acpi_battery_quirks(struct acpi_battery *battery)
516 if (dmi_name_in_vendors("Acer") && battery->power_unit) {
517 set_bit(ACPI_BATTERY_QUIRK_SIGNED16_CURRENT, &battery->flags);
521 static int acpi_battery_update(struct acpi_battery *battery)
523 int result, old_present = acpi_battery_present(battery);
524 result = acpi_battery_get_status(battery);
527 #ifdef CONFIG_ACPI_SYSFS_POWER
528 if (!acpi_battery_present(battery)) {
529 sysfs_remove_battery(battery);
530 battery->update_time = 0;
534 if (!battery->update_time ||
535 old_present != acpi_battery_present(battery)) {
536 result = acpi_battery_get_info(battery);
539 acpi_battery_quirks(battery);
540 acpi_battery_init_alarm(battery);
542 #ifdef CONFIG_ACPI_SYSFS_POWER
543 if (!battery->bat.dev)
544 sysfs_add_battery(battery);
546 return acpi_battery_get_state(battery);
549 /* --------------------------------------------------------------------------
551 -------------------------------------------------------------------------- */
553 #ifdef CONFIG_ACPI_PROCFS_POWER
554 static struct proc_dir_entry *acpi_battery_dir;
556 static int acpi_battery_print_info(struct seq_file *seq, int result)
558 struct acpi_battery *battery = seq->private;
563 seq_printf(seq, "present: %s\n",
564 acpi_battery_present(battery)?"yes":"no");
565 if (!acpi_battery_present(battery))
567 if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
568 seq_printf(seq, "design capacity: unknown\n");
570 seq_printf(seq, "design capacity: %d %sh\n",
571 battery->design_capacity,
572 acpi_battery_units(battery));
574 if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
575 seq_printf(seq, "last full capacity: unknown\n");
577 seq_printf(seq, "last full capacity: %d %sh\n",
578 battery->full_charge_capacity,
579 acpi_battery_units(battery));
581 seq_printf(seq, "battery technology: %srechargeable\n",
582 (!battery->technology)?"non-":"");
584 if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
585 seq_printf(seq, "design voltage: unknown\n");
587 seq_printf(seq, "design voltage: %d mV\n",
588 battery->design_voltage);
589 seq_printf(seq, "design capacity warning: %d %sh\n",
590 battery->design_capacity_warning,
591 acpi_battery_units(battery));
592 seq_printf(seq, "design capacity low: %d %sh\n",
593 battery->design_capacity_low,
594 acpi_battery_units(battery));
595 seq_printf(seq, "capacity granularity 1: %d %sh\n",
596 battery->capacity_granularity_1,
597 acpi_battery_units(battery));
598 seq_printf(seq, "capacity granularity 2: %d %sh\n",
599 battery->capacity_granularity_2,
600 acpi_battery_units(battery));
601 seq_printf(seq, "model number: %s\n", battery->model_number);
602 seq_printf(seq, "serial number: %s\n", battery->serial_number);
603 seq_printf(seq, "battery type: %s\n", battery->type);
604 seq_printf(seq, "OEM info: %s\n", battery->oem_info);
607 seq_printf(seq, "ERROR: Unable to read battery info\n");
611 static int acpi_battery_print_state(struct seq_file *seq, int result)
613 struct acpi_battery *battery = seq->private;
618 seq_printf(seq, "present: %s\n",
619 acpi_battery_present(battery)?"yes":"no");
620 if (!acpi_battery_present(battery))
623 seq_printf(seq, "capacity state: %s\n",
624 (battery->state & 0x04)?"critical":"ok");
625 if ((battery->state & 0x01) && (battery->state & 0x02))
627 "charging state: charging/discharging\n");
628 else if (battery->state & 0x01)
629 seq_printf(seq, "charging state: discharging\n");
630 else if (battery->state & 0x02)
631 seq_printf(seq, "charging state: charging\n");
633 seq_printf(seq, "charging state: charged\n");
635 if (battery->rate_now == ACPI_BATTERY_VALUE_UNKNOWN)
636 seq_printf(seq, "present rate: unknown\n");
638 seq_printf(seq, "present rate: %d %s\n",
639 battery->rate_now, acpi_battery_units(battery));
641 if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
642 seq_printf(seq, "remaining capacity: unknown\n");
644 seq_printf(seq, "remaining capacity: %d %sh\n",
645 battery->capacity_now, acpi_battery_units(battery));
646 if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
647 seq_printf(seq, "present voltage: unknown\n");
649 seq_printf(seq, "present voltage: %d mV\n",
650 battery->voltage_now);
653 seq_printf(seq, "ERROR: Unable to read battery state\n");
658 static int acpi_battery_print_alarm(struct seq_file *seq, int result)
660 struct acpi_battery *battery = seq->private;
665 if (!acpi_battery_present(battery)) {
666 seq_printf(seq, "present: no\n");
669 seq_printf(seq, "alarm: ");
671 seq_printf(seq, "unsupported\n");
673 seq_printf(seq, "%u %sh\n", battery->alarm,
674 acpi_battery_units(battery));
677 seq_printf(seq, "ERROR: Unable to read battery alarm\n");
681 static ssize_t acpi_battery_write_alarm(struct file *file,
682 const char __user * buffer,
683 size_t count, loff_t * ppos)
686 char alarm_string[12] = { '\0' };
687 struct seq_file *m = file->private_data;
688 struct acpi_battery *battery = m->private;
690 if (!battery || (count > sizeof(alarm_string) - 1))
692 if (!acpi_battery_present(battery)) {
696 if (copy_from_user(alarm_string, buffer, count)) {
700 alarm_string[count] = '\0';
701 battery->alarm = simple_strtol(alarm_string, NULL, 0);
702 result = acpi_battery_set_alarm(battery);
709 typedef int(*print_func)(struct seq_file *seq, int result);
711 static print_func acpi_print_funcs[ACPI_BATTERY_NUMFILES] = {
712 acpi_battery_print_info,
713 acpi_battery_print_state,
714 acpi_battery_print_alarm,
717 static int acpi_battery_read(int fid, struct seq_file *seq)
719 struct acpi_battery *battery = seq->private;
720 int result = acpi_battery_update(battery);
721 return acpi_print_funcs[fid](seq, result);
724 #define DECLARE_FILE_FUNCTIONS(_name) \
725 static int acpi_battery_read_##_name(struct seq_file *seq, void *offset) \
727 return acpi_battery_read(_name##_tag, seq); \
729 static int acpi_battery_##_name##_open_fs(struct inode *inode, struct file *file) \
731 return single_open(file, acpi_battery_read_##_name, PDE(inode)->data); \
734 DECLARE_FILE_FUNCTIONS(info);
735 DECLARE_FILE_FUNCTIONS(state);
736 DECLARE_FILE_FUNCTIONS(alarm);
738 #undef DECLARE_FILE_FUNCTIONS
740 #define FILE_DESCRIPTION_RO(_name) \
742 .name = __stringify(_name), \
745 .open = acpi_battery_##_name##_open_fs, \
747 .llseek = seq_lseek, \
748 .release = single_release, \
749 .owner = THIS_MODULE, \
753 #define FILE_DESCRIPTION_RW(_name) \
755 .name = __stringify(_name), \
756 .mode = S_IFREG | S_IRUGO | S_IWUSR, \
758 .open = acpi_battery_##_name##_open_fs, \
760 .llseek = seq_lseek, \
761 .write = acpi_battery_write_##_name, \
762 .release = single_release, \
763 .owner = THIS_MODULE, \
767 static struct battery_file {
768 struct file_operations ops;
771 } acpi_battery_file[] = {
772 FILE_DESCRIPTION_RO(info),
773 FILE_DESCRIPTION_RO(state),
774 FILE_DESCRIPTION_RW(alarm),
777 #undef FILE_DESCRIPTION_RO
778 #undef FILE_DESCRIPTION_RW
780 static int acpi_battery_add_fs(struct acpi_device *device)
782 struct proc_dir_entry *entry = NULL;
785 if (!acpi_device_dir(device)) {
786 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
788 if (!acpi_device_dir(device))
792 for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i) {
793 entry = proc_create_data(acpi_battery_file[i].name,
794 acpi_battery_file[i].mode,
795 acpi_device_dir(device),
796 &acpi_battery_file[i].ops,
797 acpi_driver_data(device));
804 static void acpi_battery_remove_fs(struct acpi_device *device)
807 if (!acpi_device_dir(device))
809 for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i)
810 remove_proc_entry(acpi_battery_file[i].name,
811 acpi_device_dir(device));
813 remove_proc_entry(acpi_device_bid(device), acpi_battery_dir);
814 acpi_device_dir(device) = NULL;
819 /* --------------------------------------------------------------------------
821 -------------------------------------------------------------------------- */
823 static void acpi_battery_notify(struct acpi_device *device, u32 event)
825 struct acpi_battery *battery = acpi_driver_data(device);
829 acpi_battery_update(battery);
830 acpi_bus_generate_proc_event(device, event,
831 acpi_battery_present(battery));
832 acpi_bus_generate_netlink_event(device->pnp.device_class,
833 dev_name(&device->dev), event,
834 acpi_battery_present(battery));
835 #ifdef CONFIG_ACPI_SYSFS_POWER
836 /* acpi_battery_update could remove power_supply object */
837 if (battery->bat.dev)
838 kobject_uevent(&battery->bat.dev->kobj, KOBJ_CHANGE);
842 static int acpi_battery_add(struct acpi_device *device)
845 struct acpi_battery *battery = NULL;
848 battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL);
851 battery->device = device;
852 strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME);
853 strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS);
854 device->driver_data = battery;
855 mutex_init(&battery->lock);
856 acpi_battery_update(battery);
857 #ifdef CONFIG_ACPI_PROCFS_POWER
858 result = acpi_battery_add_fs(device);
861 printk(KERN_INFO PREFIX "%s Slot [%s] (battery %s)\n",
862 ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device),
863 device->status.battery_present ? "present" : "absent");
865 #ifdef CONFIG_ACPI_PROCFS_POWER
866 acpi_battery_remove_fs(device);
873 static int acpi_battery_remove(struct acpi_device *device, int type)
875 struct acpi_battery *battery = NULL;
877 if (!device || !acpi_driver_data(device))
879 battery = acpi_driver_data(device);
880 #ifdef CONFIG_ACPI_PROCFS_POWER
881 acpi_battery_remove_fs(device);
883 #ifdef CONFIG_ACPI_SYSFS_POWER
884 sysfs_remove_battery(battery);
886 mutex_destroy(&battery->lock);
891 /* this is needed to learn about changes made in suspended state */
892 static int acpi_battery_resume(struct acpi_device *device)
894 struct acpi_battery *battery;
897 battery = acpi_driver_data(device);
898 battery->update_time = 0;
899 acpi_battery_update(battery);
903 static struct acpi_driver acpi_battery_driver = {
905 .class = ACPI_BATTERY_CLASS,
906 .ids = battery_device_ids,
907 .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
909 .add = acpi_battery_add,
910 .resume = acpi_battery_resume,
911 .remove = acpi_battery_remove,
912 .notify = acpi_battery_notify,
916 static void __init acpi_battery_init_async(void *unused, async_cookie_t cookie)
920 #ifdef CONFIG_ACPI_PROCFS_POWER
921 acpi_battery_dir = acpi_lock_battery_dir();
922 if (!acpi_battery_dir)
925 if (acpi_bus_register_driver(&acpi_battery_driver) < 0) {
926 #ifdef CONFIG_ACPI_PROCFS_POWER
927 acpi_unlock_battery_dir(acpi_battery_dir);
934 static int __init acpi_battery_init(void)
936 async_schedule(acpi_battery_init_async, NULL);
940 static void __exit acpi_battery_exit(void)
942 acpi_bus_unregister_driver(&acpi_battery_driver);
943 #ifdef CONFIG_ACPI_PROCFS_POWER
944 acpi_unlock_battery_dir(acpi_battery_dir);
948 module_init(acpi_battery_init);
949 module_exit(acpi_battery_exit);