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