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