ACPI: battery: make internal names consistent with battery "state"
[linux-3.10.git] / drivers / acpi / battery.c
1 /*
2  *  acpi_battery.c - ACPI Battery Driver ($Revision: 37 $)
3  *
4  *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
5  *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
6  *
7  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
8  *
9  *  This program is free software; you can redistribute it and/or modify
10  *  it under the terms of the GNU General Public License as published by
11  *  the Free Software Foundation; either version 2 of the License, or (at
12  *  your option) any later version.
13  *
14  *  This program is distributed in the hope that it will be useful, but
15  *  WITHOUT ANY WARRANTY; without even the implied warranty of
16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  *  General Public License for more details.
18  *
19  *  You should have received a copy of the GNU General Public License along
20  *  with this program; if not, write to the Free Software Foundation, Inc.,
21  *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
22  *
23  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
24  */
25
26 #include <linux/kernel.h>
27 #include <linux/module.h>
28 #include <linux/init.h>
29 #include <linux/types.h>
30 #include <linux/proc_fs.h>
31 #include <linux/seq_file.h>
32 #include <asm/uaccess.h>
33
34 #include <acpi/acpi_bus.h>
35 #include <acpi/acpi_drivers.h>
36
37 #define ACPI_BATTERY_VALUE_UNKNOWN 0xFFFFFFFF
38
39 #define ACPI_BATTERY_FORMAT_BIF "NNNNNNNNNSSSS"
40 #define ACPI_BATTERY_FORMAT_BST "NNNN"
41
42 #define ACPI_BATTERY_COMPONENT          0x00040000
43 #define ACPI_BATTERY_CLASS              "battery"
44 #define ACPI_BATTERY_HID                "PNP0C0A"
45 #define ACPI_BATTERY_DEVICE_NAME        "Battery"
46 #define ACPI_BATTERY_FILE_INFO          "info"
47 #define ACPI_BATTERY_FILE_STATE         "state"
48 #define ACPI_BATTERY_FILE_ALARM         "alarm"
49 #define ACPI_BATTERY_NOTIFY_STATUS      0x80
50 #define ACPI_BATTERY_NOTIFY_INFO        0x81
51 #define ACPI_BATTERY_UNITS_WATTS        "mW"
52 #define ACPI_BATTERY_UNITS_AMPS         "mA"
53
54 #define _COMPONENT              ACPI_BATTERY_COMPONENT
55 ACPI_MODULE_NAME("battery");
56
57 MODULE_AUTHOR("Paul Diefenbaugh");
58 MODULE_DESCRIPTION("ACPI Battery Driver");
59 MODULE_LICENSE("GPL");
60
61 extern struct proc_dir_entry *acpi_lock_battery_dir(void);
62 extern void *acpi_unlock_battery_dir(struct proc_dir_entry *acpi_battery_dir);
63
64 static int acpi_battery_add(struct acpi_device *device);
65 static int acpi_battery_remove(struct acpi_device *device, int type);
66 static int acpi_battery_resume(struct acpi_device *device);
67
68 static struct acpi_driver acpi_battery_driver = {
69         .name = "battery",
70         .class = ACPI_BATTERY_CLASS,
71         .ids = ACPI_BATTERY_HID,
72         .ops = {
73                 .add = acpi_battery_add,
74                 .resume = acpi_battery_resume,
75                 .remove = acpi_battery_remove,
76                 },
77 };
78
79 struct acpi_battery_state {
80         acpi_integer state;
81         acpi_integer present_rate;
82         acpi_integer remaining_capacity;
83         acpi_integer present_voltage;
84 };
85
86 struct acpi_battery_info {
87         acpi_integer power_unit;
88         acpi_integer design_capacity;
89         acpi_integer last_full_capacity;
90         acpi_integer battery_technology;
91         acpi_integer design_voltage;
92         acpi_integer design_capacity_warning;
93         acpi_integer design_capacity_low;
94         acpi_integer battery_capacity_granularity_1;
95         acpi_integer battery_capacity_granularity_2;
96         acpi_string model_number;
97         acpi_string serial_number;
98         acpi_string battery_type;
99         acpi_string oem_info;
100 };
101
102 struct acpi_battery_flags {
103         u8 present:1;           /* Bay occupied? */
104         u8 power_unit:1;        /* 0=watts, 1=apms */
105         u8 alarm:1;             /* _BTP present? */
106         u8 reserved:5;
107 };
108
109 struct acpi_battery_trips {
110         unsigned long warning;
111         unsigned long low;
112 };
113
114 struct acpi_battery {
115         struct acpi_device * device;
116         struct acpi_battery_flags flags;
117         struct acpi_battery_trips trips;
118         unsigned long alarm;
119         struct acpi_battery_info *info;
120 };
121
122 /* --------------------------------------------------------------------------
123                                Battery Management
124    -------------------------------------------------------------------------- */
125
126 static int
127 acpi_battery_get_info(struct acpi_battery *battery,
128                       struct acpi_battery_info **bif)
129 {
130         int result = 0;
131         acpi_status status = 0;
132         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
133         struct acpi_buffer format = { sizeof(ACPI_BATTERY_FORMAT_BIF),
134                 ACPI_BATTERY_FORMAT_BIF
135         };
136         struct acpi_buffer data = { 0, NULL };
137         union acpi_object *package = NULL;
138
139
140         if (!battery || !bif)
141                 return -EINVAL;
142
143         /* Evalute _BIF */
144
145         status = acpi_evaluate_object(battery->device->handle, "_BIF", NULL, &buffer);
146         if (ACPI_FAILURE(status)) {
147                 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BIF"));
148                 return -ENODEV;
149         }
150
151         package = buffer.pointer;
152
153         /* Extract Package Data */
154
155         status = acpi_extract_package(package, &format, &data);
156         if (status != AE_BUFFER_OVERFLOW) {
157                 ACPI_EXCEPTION((AE_INFO, status, "Extracting _BIF"));
158                 result = -ENODEV;
159                 goto end;
160         }
161
162         data.pointer = kzalloc(data.length, GFP_KERNEL);
163         if (!data.pointer) {
164                 result = -ENOMEM;
165                 goto end;
166         }
167
168         status = acpi_extract_package(package, &format, &data);
169         if (ACPI_FAILURE(status)) {
170                 ACPI_EXCEPTION((AE_INFO, status, "Extracting _BIF"));
171                 kfree(data.pointer);
172                 result = -ENODEV;
173                 goto end;
174         }
175
176       end:
177         kfree(buffer.pointer);
178
179         if (!result)
180                 (*bif) = data.pointer;
181
182         return result;
183 }
184
185 static int
186 acpi_battery_get_state(struct acpi_battery *battery,
187                         struct acpi_battery_state **bst)
188 {
189         int result = 0;
190         acpi_status status = 0;
191         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
192         struct acpi_buffer format = { sizeof(ACPI_BATTERY_FORMAT_BST),
193                 ACPI_BATTERY_FORMAT_BST
194         };
195         struct acpi_buffer data = { 0, NULL };
196         union acpi_object *package = NULL;
197
198
199         if (!battery || !bst)
200                 return -EINVAL;
201
202         /* Evalute _BST */
203
204         status = acpi_evaluate_object(battery->device->handle, "_BST", NULL, &buffer);
205         if (ACPI_FAILURE(status)) {
206                 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BST"));
207                 return -ENODEV;
208         }
209
210         package = buffer.pointer;
211
212         /* Extract Package Data */
213
214         status = acpi_extract_package(package, &format, &data);
215         if (status != AE_BUFFER_OVERFLOW) {
216                 ACPI_EXCEPTION((AE_INFO, status, "Extracting _BST"));
217                 result = -ENODEV;
218                 goto end;
219         }
220
221         data.pointer = kzalloc(data.length, GFP_KERNEL);
222         if (!data.pointer) {
223                 result = -ENOMEM;
224                 goto end;
225         }
226
227         status = acpi_extract_package(package, &format, &data);
228         if (ACPI_FAILURE(status)) {
229                 ACPI_EXCEPTION((AE_INFO, status, "Extracting _BST"));
230                 kfree(data.pointer);
231                 result = -ENODEV;
232                 goto end;
233         }
234
235       end:
236         kfree(buffer.pointer);
237
238         if (!result)
239                 (*bst) = data.pointer;
240
241         return result;
242 }
243
244 static int
245 acpi_battery_set_alarm(struct acpi_battery *battery, unsigned long alarm)
246 {
247         acpi_status status = 0;
248         union acpi_object arg0 = { ACPI_TYPE_INTEGER };
249         struct acpi_object_list arg_list = { 1, &arg0 };
250
251
252         if (!battery)
253                 return -EINVAL;
254
255         if (!battery->flags.alarm)
256                 return -ENODEV;
257
258         arg0.integer.value = alarm;
259
260         status = acpi_evaluate_object(battery->device->handle, "_BTP", &arg_list, NULL);
261         if (ACPI_FAILURE(status))
262                 return -ENODEV;
263
264         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Alarm set to %d\n", (u32) alarm));
265
266         battery->alarm = alarm;
267
268         return 0;
269 }
270
271 static int acpi_battery_check(struct acpi_battery *battery)
272 {
273         int result = 0;
274         acpi_status status = AE_OK;
275         acpi_handle handle = NULL;
276         struct acpi_device *device = NULL;
277         struct acpi_battery_info *bif = NULL;
278
279
280         if (!battery)
281                 return -EINVAL;
282
283         device = battery->device;
284
285         result = acpi_bus_get_status(device);
286         if (result)
287                 return result;
288
289         /* Insertion? */
290
291         if (!battery->flags.present && device->status.battery_present) {
292
293                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Battery inserted\n"));
294
295                 /* Evalute _BIF to get certain static information */
296
297                 result = acpi_battery_get_info(battery, &bif);
298                 if (result)
299                         return result;
300
301                 battery->flags.power_unit = bif->power_unit;
302                 battery->trips.warning = bif->design_capacity_warning;
303                 battery->trips.low = bif->design_capacity_low;
304                 kfree(bif);
305
306                 /* See if alarms are supported, and if so, set default */
307
308                 status = acpi_get_handle(battery->device->handle, "_BTP", &handle);
309                 if (ACPI_SUCCESS(status)) {
310                         battery->flags.alarm = 1;
311                         acpi_battery_set_alarm(battery, battery->trips.warning);
312                 }
313         }
314
315         /* Removal? */
316
317         else if (battery->flags.present && !device->status.battery_present) {
318                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Battery removed\n"));
319         }
320
321         battery->flags.present = device->status.battery_present;
322
323         return result;
324 }
325
326 static void acpi_battery_check_present(struct acpi_battery *battery)
327 {
328         if (!battery->flags.present) {
329                 acpi_battery_check(battery);
330         }
331 }
332
333 /* --------------------------------------------------------------------------
334                               FS Interface (/proc)
335    -------------------------------------------------------------------------- */
336
337 static struct proc_dir_entry *acpi_battery_dir;
338 static int acpi_battery_read_info(struct seq_file *seq, void *offset)
339 {
340         int result = 0;
341         struct acpi_battery *battery = seq->private;
342         struct acpi_battery_info *bif = NULL;
343         char *units = "?";
344
345
346         if (!battery)
347                 goto end;
348
349         acpi_battery_check_present(battery);
350
351         if (battery->flags.present)
352                 seq_printf(seq, "present:                 yes\n");
353         else {
354                 seq_printf(seq, "present:                 no\n");
355                 goto end;
356         }
357
358         /* Battery Info (_BIF) */
359
360         result = acpi_battery_get_info(battery, &bif);
361         if (result || !bif) {
362                 seq_printf(seq, "ERROR: Unable to read battery information\n");
363                 goto end;
364         }
365
366         units =
367             bif->
368             power_unit ? ACPI_BATTERY_UNITS_AMPS : ACPI_BATTERY_UNITS_WATTS;
369
370         if (bif->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
371                 seq_printf(seq, "design capacity:         unknown\n");
372         else
373                 seq_printf(seq, "design capacity:         %d %sh\n",
374                            (u32) bif->design_capacity, units);
375
376         if (bif->last_full_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
377                 seq_printf(seq, "last full capacity:      unknown\n");
378         else
379                 seq_printf(seq, "last full capacity:      %d %sh\n",
380                            (u32) bif->last_full_capacity, units);
381
382         switch ((u32) bif->battery_technology) {
383         case 0:
384                 seq_printf(seq, "battery technology:      non-rechargeable\n");
385                 break;
386         case 1:
387                 seq_printf(seq, "battery technology:      rechargeable\n");
388                 break;
389         default:
390                 seq_printf(seq, "battery technology:      unknown\n");
391                 break;
392         }
393
394         if (bif->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
395                 seq_printf(seq, "design voltage:          unknown\n");
396         else
397                 seq_printf(seq, "design voltage:          %d mV\n",
398                            (u32) bif->design_voltage);
399
400         seq_printf(seq, "design capacity warning: %d %sh\n",
401                    (u32) bif->design_capacity_warning, units);
402         seq_printf(seq, "design capacity low:     %d %sh\n",
403                    (u32) bif->design_capacity_low, units);
404         seq_printf(seq, "capacity granularity 1:  %d %sh\n",
405                    (u32) bif->battery_capacity_granularity_1, units);
406         seq_printf(seq, "capacity granularity 2:  %d %sh\n",
407                    (u32) bif->battery_capacity_granularity_2, units);
408         seq_printf(seq, "model number:            %s\n", bif->model_number);
409         seq_printf(seq, "serial number:           %s\n", bif->serial_number);
410         seq_printf(seq, "battery type:            %s\n", bif->battery_type);
411         seq_printf(seq, "OEM info:                %s\n", bif->oem_info);
412
413       end:
414         kfree(bif);
415
416         return 0;
417 }
418
419 static int acpi_battery_info_open_fs(struct inode *inode, struct file *file)
420 {
421         return single_open(file, acpi_battery_read_info, PDE(inode)->data);
422 }
423
424 static int acpi_battery_read_state(struct seq_file *seq, void *offset)
425 {
426         int result = 0;
427         struct acpi_battery *battery = seq->private;
428         struct acpi_battery_state *bst = NULL;
429         char *units = "?";
430
431
432         if (!battery)
433                 goto end;
434
435         acpi_battery_check_present(battery);
436
437         if (battery->flags.present)
438                 seq_printf(seq, "present:                 yes\n");
439         else {
440                 seq_printf(seq, "present:                 no\n");
441                 goto end;
442         }
443
444         /* Battery Units */
445
446         units =
447             battery->flags.
448             power_unit ? ACPI_BATTERY_UNITS_AMPS : ACPI_BATTERY_UNITS_WATTS;
449
450         /* Battery Status (_BST) */
451
452         result = acpi_battery_get_state(battery, &bst);
453         if (result || !bst) {
454                 seq_printf(seq, "ERROR: Unable to read battery state\n");
455                 goto end;
456         }
457
458         if (!(bst->state & 0x04))
459                 seq_printf(seq, "capacity state:          ok\n");
460         else
461                 seq_printf(seq, "capacity state:          critical\n");
462
463         if ((bst->state & 0x01) && (bst->state & 0x02)) {
464                 seq_printf(seq,
465                            "charging state:          charging/discharging\n");
466         } else if (bst->state & 0x01)
467                 seq_printf(seq, "charging state:          discharging\n");
468         else if (bst->state & 0x02)
469                 seq_printf(seq, "charging state:          charging\n");
470         else {
471                 seq_printf(seq, "charging state:          charged\n");
472         }
473
474         if (bst->present_rate == ACPI_BATTERY_VALUE_UNKNOWN)
475                 seq_printf(seq, "present rate:            unknown\n");
476         else
477                 seq_printf(seq, "present rate:            %d %s\n",
478                            (u32) bst->present_rate, units);
479
480         if (bst->remaining_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
481                 seq_printf(seq, "remaining capacity:      unknown\n");
482         else
483                 seq_printf(seq, "remaining capacity:      %d %sh\n",
484                            (u32) bst->remaining_capacity, units);
485
486         if (bst->present_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
487                 seq_printf(seq, "present voltage:         unknown\n");
488         else
489                 seq_printf(seq, "present voltage:         %d mV\n",
490                            (u32) bst->present_voltage);
491
492       end:
493         kfree(bst);
494
495         return 0;
496 }
497
498 static int acpi_battery_state_open_fs(struct inode *inode, struct file *file)
499 {
500         return single_open(file, acpi_battery_read_state, PDE(inode)->data);
501 }
502
503 static int acpi_battery_read_alarm(struct seq_file *seq, void *offset)
504 {
505         struct acpi_battery *battery = seq->private;
506         char *units = "?";
507
508
509         if (!battery)
510                 goto end;
511
512         acpi_battery_check_present(battery);
513
514         if (!battery->flags.present) {
515                 seq_printf(seq, "present:                 no\n");
516                 goto end;
517         }
518
519         /* Battery Units */
520
521         units =
522             battery->flags.
523             power_unit ? ACPI_BATTERY_UNITS_AMPS : ACPI_BATTERY_UNITS_WATTS;
524
525         /* Battery Alarm */
526
527         seq_printf(seq, "alarm:                   ");
528         if (!battery->alarm)
529                 seq_printf(seq, "unsupported\n");
530         else
531                 seq_printf(seq, "%d %sh\n", (u32) battery->alarm, units);
532
533       end:
534         return 0;
535 }
536
537 static ssize_t
538 acpi_battery_write_alarm(struct file *file,
539                          const char __user * buffer,
540                          size_t count, loff_t * ppos)
541 {
542         int result = 0;
543         char alarm_string[12] = { '\0' };
544         struct seq_file *m = file->private_data;
545         struct acpi_battery *battery = m->private;
546
547
548         if (!battery || (count > sizeof(alarm_string) - 1))
549                 return -EINVAL;
550
551         acpi_battery_check_present(battery);
552
553         if (!battery->flags.present)
554                 return -ENODEV;
555
556         if (copy_from_user(alarm_string, buffer, count))
557                 return -EFAULT;
558
559         alarm_string[count] = '\0';
560
561         result = acpi_battery_set_alarm(battery,
562                                         simple_strtoul(alarm_string, NULL, 0));
563         if (result)
564                 return result;
565
566         return count;
567 }
568
569 static int acpi_battery_alarm_open_fs(struct inode *inode, struct file *file)
570 {
571         return single_open(file, acpi_battery_read_alarm, PDE(inode)->data);
572 }
573
574 static const struct file_operations acpi_battery_info_ops = {
575         .open = acpi_battery_info_open_fs,
576         .read = seq_read,
577         .llseek = seq_lseek,
578         .release = single_release,
579         .owner = THIS_MODULE,
580 };
581
582 static const struct file_operations acpi_battery_state_ops = {
583         .open = acpi_battery_state_open_fs,
584         .read = seq_read,
585         .llseek = seq_lseek,
586         .release = single_release,
587         .owner = THIS_MODULE,
588 };
589
590 static const struct file_operations acpi_battery_alarm_ops = {
591         .open = acpi_battery_alarm_open_fs,
592         .read = seq_read,
593         .write = acpi_battery_write_alarm,
594         .llseek = seq_lseek,
595         .release = single_release,
596         .owner = THIS_MODULE,
597 };
598
599 static int acpi_battery_add_fs(struct acpi_device *device)
600 {
601         struct proc_dir_entry *entry = NULL;
602
603
604         if (!acpi_device_dir(device)) {
605                 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
606                                                      acpi_battery_dir);
607                 if (!acpi_device_dir(device))
608                         return -ENODEV;
609                 acpi_device_dir(device)->owner = THIS_MODULE;
610         }
611
612         /* 'info' [R] */
613         entry = create_proc_entry(ACPI_BATTERY_FILE_INFO,
614                                   S_IRUGO, acpi_device_dir(device));
615         if (!entry)
616                 return -ENODEV;
617         else {
618                 entry->proc_fops = &acpi_battery_info_ops;
619                 entry->data = acpi_driver_data(device);
620                 entry->owner = THIS_MODULE;
621         }
622
623         /* 'status' [R] */
624         entry = create_proc_entry(ACPI_BATTERY_FILE_STATE,
625                                   S_IRUGO, acpi_device_dir(device));
626         if (!entry)
627                 return -ENODEV;
628         else {
629                 entry->proc_fops = &acpi_battery_state_ops;
630                 entry->data = acpi_driver_data(device);
631                 entry->owner = THIS_MODULE;
632         }
633
634         /* 'alarm' [R/W] */
635         entry = create_proc_entry(ACPI_BATTERY_FILE_ALARM,
636                                   S_IFREG | S_IRUGO | S_IWUSR,
637                                   acpi_device_dir(device));
638         if (!entry)
639                 return -ENODEV;
640         else {
641                 entry->proc_fops = &acpi_battery_alarm_ops;
642                 entry->data = acpi_driver_data(device);
643                 entry->owner = THIS_MODULE;
644         }
645
646         return 0;
647 }
648
649 static int acpi_battery_remove_fs(struct acpi_device *device)
650 {
651
652         if (acpi_device_dir(device)) {
653                 remove_proc_entry(ACPI_BATTERY_FILE_ALARM,
654                                   acpi_device_dir(device));
655                 remove_proc_entry(ACPI_BATTERY_FILE_STATE,
656                                   acpi_device_dir(device));
657                 remove_proc_entry(ACPI_BATTERY_FILE_INFO,
658                                   acpi_device_dir(device));
659
660                 remove_proc_entry(acpi_device_bid(device), acpi_battery_dir);
661                 acpi_device_dir(device) = NULL;
662         }
663
664         return 0;
665 }
666
667 /* --------------------------------------------------------------------------
668                                  Driver Interface
669    -------------------------------------------------------------------------- */
670
671 static void acpi_battery_notify(acpi_handle handle, u32 event, void *data)
672 {
673         struct acpi_battery *battery = data;
674         struct acpi_device *device = NULL;
675
676
677         if (!battery)
678                 return;
679
680         device = battery->device;
681
682         switch (event) {
683         case ACPI_BATTERY_NOTIFY_STATUS:
684         case ACPI_BATTERY_NOTIFY_INFO:
685         case ACPI_NOTIFY_BUS_CHECK:
686         case ACPI_NOTIFY_DEVICE_CHECK:
687                 acpi_battery_check(battery);
688                 acpi_bus_generate_event(device, event, battery->flags.present);
689                 break;
690         default:
691                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
692                                   "Unsupported event [0x%x]\n", event));
693                 break;
694         }
695
696         return;
697 }
698
699 static int acpi_battery_add(struct acpi_device *device)
700 {
701         int result = 0;
702         acpi_status status = 0;
703         struct acpi_battery *battery = NULL;
704
705
706         if (!device)
707                 return -EINVAL;
708
709         battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL);
710         if (!battery)
711                 return -ENOMEM;
712
713         battery->device = device;
714         strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME);
715         strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS);
716         acpi_driver_data(device) = battery;
717
718         result = acpi_battery_check(battery);
719         if (result)
720                 goto end;
721
722         result = acpi_battery_add_fs(device);
723         if (result)
724                 goto end;
725
726         status = acpi_install_notify_handler(device->handle,
727                                              ACPI_ALL_NOTIFY,
728                                              acpi_battery_notify, battery);
729         if (ACPI_FAILURE(status)) {
730                 result = -ENODEV;
731                 goto end;
732         }
733
734         printk(KERN_INFO PREFIX "%s Slot [%s] (battery %s)\n",
735                ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device),
736                device->status.battery_present ? "present" : "absent");
737
738       end:
739         if (result) {
740                 acpi_battery_remove_fs(device);
741                 kfree(battery);
742         }
743
744         return result;
745 }
746
747 static int acpi_battery_remove(struct acpi_device *device, int type)
748 {
749         acpi_status status = 0;
750         struct acpi_battery *battery = NULL;
751
752
753         if (!device || !acpi_driver_data(device))
754                 return -EINVAL;
755
756         battery = acpi_driver_data(device);
757
758         status = acpi_remove_notify_handler(device->handle,
759                                             ACPI_ALL_NOTIFY,
760                                             acpi_battery_notify);
761
762         acpi_battery_remove_fs(device);
763
764         kfree(battery);
765
766         return 0;
767 }
768
769 /* this is needed to learn about changes made in suspended state */
770 static int acpi_battery_resume(struct acpi_device *device)
771 {
772         struct acpi_battery *battery;
773
774         if (!device)
775                 return -EINVAL;
776
777         battery = device->driver_data;
778         return acpi_battery_check(battery);
779 }
780
781 static int __init acpi_battery_init(void)
782 {
783         int result;
784
785         if (acpi_disabled)
786                 return -ENODEV;
787
788         acpi_battery_dir = acpi_lock_battery_dir();
789         if (!acpi_battery_dir)
790                 return -ENODEV;
791
792         result = acpi_bus_register_driver(&acpi_battery_driver);
793         if (result < 0) {
794                 acpi_unlock_battery_dir(acpi_battery_dir);
795                 return -ENODEV;
796         }
797
798         return 0;
799 }
800
801 static void __exit acpi_battery_exit(void)
802 {
803
804         acpi_bus_unregister_driver(&acpi_battery_driver);
805
806         acpi_unlock_battery_dir(acpi_battery_dir);
807
808         return;
809 }
810
811 module_init(acpi_battery_init);
812 module_exit(acpi_battery_exit);