ACPI: delete extra #defines in /drivers/acpi/ drivers
[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_STATUS        "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_status {
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_status(struct acpi_battery *battery,
187                         struct acpi_battery_status **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 /* --------------------------------------------------------------------------
327                               FS Interface (/proc)
328    -------------------------------------------------------------------------- */
329
330 static struct proc_dir_entry *acpi_battery_dir;
331 static int acpi_battery_read_info(struct seq_file *seq, void *offset)
332 {
333         int result = 0;
334         struct acpi_battery *battery = seq->private;
335         struct acpi_battery_info *bif = NULL;
336         char *units = "?";
337
338
339         if (!battery)
340                 goto end;
341
342         if (battery->flags.present)
343                 seq_printf(seq, "present:                 yes\n");
344         else {
345                 seq_printf(seq, "present:                 no\n");
346                 goto end;
347         }
348
349         /* Battery Info (_BIF) */
350
351         result = acpi_battery_get_info(battery, &bif);
352         if (result || !bif) {
353                 seq_printf(seq, "ERROR: Unable to read battery information\n");
354                 goto end;
355         }
356
357         units =
358             bif->
359             power_unit ? ACPI_BATTERY_UNITS_AMPS : ACPI_BATTERY_UNITS_WATTS;
360
361         if (bif->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
362                 seq_printf(seq, "design capacity:         unknown\n");
363         else
364                 seq_printf(seq, "design capacity:         %d %sh\n",
365                            (u32) bif->design_capacity, units);
366
367         if (bif->last_full_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
368                 seq_printf(seq, "last full capacity:      unknown\n");
369         else
370                 seq_printf(seq, "last full capacity:      %d %sh\n",
371                            (u32) bif->last_full_capacity, units);
372
373         switch ((u32) bif->battery_technology) {
374         case 0:
375                 seq_printf(seq, "battery technology:      non-rechargeable\n");
376                 break;
377         case 1:
378                 seq_printf(seq, "battery technology:      rechargeable\n");
379                 break;
380         default:
381                 seq_printf(seq, "battery technology:      unknown\n");
382                 break;
383         }
384
385         if (bif->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
386                 seq_printf(seq, "design voltage:          unknown\n");
387         else
388                 seq_printf(seq, "design voltage:          %d mV\n",
389                            (u32) bif->design_voltage);
390
391         seq_printf(seq, "design capacity warning: %d %sh\n",
392                    (u32) bif->design_capacity_warning, units);
393         seq_printf(seq, "design capacity low:     %d %sh\n",
394                    (u32) bif->design_capacity_low, units);
395         seq_printf(seq, "capacity granularity 1:  %d %sh\n",
396                    (u32) bif->battery_capacity_granularity_1, units);
397         seq_printf(seq, "capacity granularity 2:  %d %sh\n",
398                    (u32) bif->battery_capacity_granularity_2, units);
399         seq_printf(seq, "model number:            %s\n", bif->model_number);
400         seq_printf(seq, "serial number:           %s\n", bif->serial_number);
401         seq_printf(seq, "battery type:            %s\n", bif->battery_type);
402         seq_printf(seq, "OEM info:                %s\n", bif->oem_info);
403
404       end:
405         kfree(bif);
406
407         return 0;
408 }
409
410 static int acpi_battery_info_open_fs(struct inode *inode, struct file *file)
411 {
412         return single_open(file, acpi_battery_read_info, PDE(inode)->data);
413 }
414
415 static int acpi_battery_read_state(struct seq_file *seq, void *offset)
416 {
417         int result = 0;
418         struct acpi_battery *battery = seq->private;
419         struct acpi_battery_status *bst = NULL;
420         char *units = "?";
421
422
423         if (!battery)
424                 goto end;
425
426         if (battery->flags.present)
427                 seq_printf(seq, "present:                 yes\n");
428         else {
429                 seq_printf(seq, "present:                 no\n");
430                 goto end;
431         }
432
433         /* Battery Units */
434
435         units =
436             battery->flags.
437             power_unit ? ACPI_BATTERY_UNITS_AMPS : ACPI_BATTERY_UNITS_WATTS;
438
439         /* Battery Status (_BST) */
440
441         result = acpi_battery_get_status(battery, &bst);
442         if (result || !bst) {
443                 seq_printf(seq, "ERROR: Unable to read battery status\n");
444                 goto end;
445         }
446
447         if (!(bst->state & 0x04))
448                 seq_printf(seq, "capacity state:          ok\n");
449         else
450                 seq_printf(seq, "capacity state:          critical\n");
451
452         if ((bst->state & 0x01) && (bst->state & 0x02)) {
453                 seq_printf(seq,
454                            "charging state:          charging/discharging\n");
455         } else if (bst->state & 0x01)
456                 seq_printf(seq, "charging state:          discharging\n");
457         else if (bst->state & 0x02)
458                 seq_printf(seq, "charging state:          charging\n");
459         else {
460                 seq_printf(seq, "charging state:          charged\n");
461         }
462
463         if (bst->present_rate == ACPI_BATTERY_VALUE_UNKNOWN)
464                 seq_printf(seq, "present rate:            unknown\n");
465         else
466                 seq_printf(seq, "present rate:            %d %s\n",
467                            (u32) bst->present_rate, units);
468
469         if (bst->remaining_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
470                 seq_printf(seq, "remaining capacity:      unknown\n");
471         else
472                 seq_printf(seq, "remaining capacity:      %d %sh\n",
473                            (u32) bst->remaining_capacity, units);
474
475         if (bst->present_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
476                 seq_printf(seq, "present voltage:         unknown\n");
477         else
478                 seq_printf(seq, "present voltage:         %d mV\n",
479                            (u32) bst->present_voltage);
480
481       end:
482         kfree(bst);
483
484         return 0;
485 }
486
487 static int acpi_battery_state_open_fs(struct inode *inode, struct file *file)
488 {
489         return single_open(file, acpi_battery_read_state, PDE(inode)->data);
490 }
491
492 static int acpi_battery_read_alarm(struct seq_file *seq, void *offset)
493 {
494         struct acpi_battery *battery = seq->private;
495         char *units = "?";
496
497
498         if (!battery)
499                 goto end;
500
501         if (!battery->flags.present) {
502                 seq_printf(seq, "present:                 no\n");
503                 goto end;
504         }
505
506         /* Battery Units */
507
508         units =
509             battery->flags.
510             power_unit ? ACPI_BATTERY_UNITS_AMPS : ACPI_BATTERY_UNITS_WATTS;
511
512         /* Battery Alarm */
513
514         seq_printf(seq, "alarm:                   ");
515         if (!battery->alarm)
516                 seq_printf(seq, "unsupported\n");
517         else
518                 seq_printf(seq, "%d %sh\n", (u32) battery->alarm, units);
519
520       end:
521         return 0;
522 }
523
524 static ssize_t
525 acpi_battery_write_alarm(struct file *file,
526                          const char __user * buffer,
527                          size_t count, loff_t * ppos)
528 {
529         int result = 0;
530         char alarm_string[12] = { '\0' };
531         struct seq_file *m = file->private_data;
532         struct acpi_battery *battery = m->private;
533
534
535         if (!battery || (count > sizeof(alarm_string) - 1))
536                 return -EINVAL;
537
538         if (!battery->flags.present)
539                 return -ENODEV;
540
541         if (copy_from_user(alarm_string, buffer, count))
542                 return -EFAULT;
543
544         alarm_string[count] = '\0';
545
546         result = acpi_battery_set_alarm(battery,
547                                         simple_strtoul(alarm_string, NULL, 0));
548         if (result)
549                 return result;
550
551         return count;
552 }
553
554 static int acpi_battery_alarm_open_fs(struct inode *inode, struct file *file)
555 {
556         return single_open(file, acpi_battery_read_alarm, PDE(inode)->data);
557 }
558
559 static const struct file_operations acpi_battery_info_ops = {
560         .open = acpi_battery_info_open_fs,
561         .read = seq_read,
562         .llseek = seq_lseek,
563         .release = single_release,
564         .owner = THIS_MODULE,
565 };
566
567 static const struct file_operations acpi_battery_state_ops = {
568         .open = acpi_battery_state_open_fs,
569         .read = seq_read,
570         .llseek = seq_lseek,
571         .release = single_release,
572         .owner = THIS_MODULE,
573 };
574
575 static const struct file_operations acpi_battery_alarm_ops = {
576         .open = acpi_battery_alarm_open_fs,
577         .read = seq_read,
578         .write = acpi_battery_write_alarm,
579         .llseek = seq_lseek,
580         .release = single_release,
581         .owner = THIS_MODULE,
582 };
583
584 static int acpi_battery_add_fs(struct acpi_device *device)
585 {
586         struct proc_dir_entry *entry = NULL;
587
588
589         if (!acpi_device_dir(device)) {
590                 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
591                                                      acpi_battery_dir);
592                 if (!acpi_device_dir(device))
593                         return -ENODEV;
594                 acpi_device_dir(device)->owner = THIS_MODULE;
595         }
596
597         /* 'info' [R] */
598         entry = create_proc_entry(ACPI_BATTERY_FILE_INFO,
599                                   S_IRUGO, acpi_device_dir(device));
600         if (!entry)
601                 return -ENODEV;
602         else {
603                 entry->proc_fops = &acpi_battery_info_ops;
604                 entry->data = acpi_driver_data(device);
605                 entry->owner = THIS_MODULE;
606         }
607
608         /* 'status' [R] */
609         entry = create_proc_entry(ACPI_BATTERY_FILE_STATUS,
610                                   S_IRUGO, acpi_device_dir(device));
611         if (!entry)
612                 return -ENODEV;
613         else {
614                 entry->proc_fops = &acpi_battery_state_ops;
615                 entry->data = acpi_driver_data(device);
616                 entry->owner = THIS_MODULE;
617         }
618
619         /* 'alarm' [R/W] */
620         entry = create_proc_entry(ACPI_BATTERY_FILE_ALARM,
621                                   S_IFREG | S_IRUGO | S_IWUSR,
622                                   acpi_device_dir(device));
623         if (!entry)
624                 return -ENODEV;
625         else {
626                 entry->proc_fops = &acpi_battery_alarm_ops;
627                 entry->data = acpi_driver_data(device);
628                 entry->owner = THIS_MODULE;
629         }
630
631         return 0;
632 }
633
634 static int acpi_battery_remove_fs(struct acpi_device *device)
635 {
636
637         if (acpi_device_dir(device)) {
638                 remove_proc_entry(ACPI_BATTERY_FILE_ALARM,
639                                   acpi_device_dir(device));
640                 remove_proc_entry(ACPI_BATTERY_FILE_STATUS,
641                                   acpi_device_dir(device));
642                 remove_proc_entry(ACPI_BATTERY_FILE_INFO,
643                                   acpi_device_dir(device));
644
645                 remove_proc_entry(acpi_device_bid(device), acpi_battery_dir);
646                 acpi_device_dir(device) = NULL;
647         }
648
649         return 0;
650 }
651
652 /* --------------------------------------------------------------------------
653                                  Driver Interface
654    -------------------------------------------------------------------------- */
655
656 static void acpi_battery_notify(acpi_handle handle, u32 event, void *data)
657 {
658         struct acpi_battery *battery = data;
659         struct acpi_device *device = NULL;
660
661
662         if (!battery)
663                 return;
664
665         device = battery->device;
666
667         switch (event) {
668         case ACPI_BATTERY_NOTIFY_STATUS:
669         case ACPI_BATTERY_NOTIFY_INFO:
670         case ACPI_NOTIFY_BUS_CHECK:
671         case ACPI_NOTIFY_DEVICE_CHECK:
672                 acpi_battery_check(battery);
673                 acpi_bus_generate_event(device, event, battery->flags.present);
674                 break;
675         default:
676                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
677                                   "Unsupported event [0x%x]\n", event));
678                 break;
679         }
680
681         return;
682 }
683
684 static int acpi_battery_add(struct acpi_device *device)
685 {
686         int result = 0;
687         acpi_status status = 0;
688         struct acpi_battery *battery = NULL;
689
690
691         if (!device)
692                 return -EINVAL;
693
694         battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL);
695         if (!battery)
696                 return -ENOMEM;
697
698         battery->device = device;
699         strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME);
700         strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS);
701         acpi_driver_data(device) = battery;
702
703         result = acpi_battery_check(battery);
704         if (result)
705                 goto end;
706
707         result = acpi_battery_add_fs(device);
708         if (result)
709                 goto end;
710
711         status = acpi_install_notify_handler(device->handle,
712                                              ACPI_ALL_NOTIFY,
713                                              acpi_battery_notify, battery);
714         if (ACPI_FAILURE(status)) {
715                 result = -ENODEV;
716                 goto end;
717         }
718
719         printk(KERN_INFO PREFIX "%s Slot [%s] (battery %s)\n",
720                ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device),
721                device->status.battery_present ? "present" : "absent");
722
723       end:
724         if (result) {
725                 acpi_battery_remove_fs(device);
726                 kfree(battery);
727         }
728
729         return result;
730 }
731
732 static int acpi_battery_remove(struct acpi_device *device, int type)
733 {
734         acpi_status status = 0;
735         struct acpi_battery *battery = NULL;
736
737
738         if (!device || !acpi_driver_data(device))
739                 return -EINVAL;
740
741         battery = acpi_driver_data(device);
742
743         status = acpi_remove_notify_handler(device->handle,
744                                             ACPI_ALL_NOTIFY,
745                                             acpi_battery_notify);
746
747         acpi_battery_remove_fs(device);
748
749         kfree(battery);
750
751         return 0;
752 }
753
754 /* this is needed to learn about changes made in suspended state */
755 static int acpi_battery_resume(struct acpi_device *device)
756 {
757         struct acpi_battery *battery;
758
759         if (!device)
760                 return -EINVAL;
761
762         battery = device->driver_data;
763         return acpi_battery_check(battery);
764 }
765
766 static int __init acpi_battery_init(void)
767 {
768         int result;
769
770         if (acpi_disabled)
771                 return -ENODEV;
772
773         acpi_battery_dir = acpi_lock_battery_dir();
774         if (!acpi_battery_dir)
775                 return -ENODEV;
776
777         result = acpi_bus_register_driver(&acpi_battery_driver);
778         if (result < 0) {
779                 acpi_unlock_battery_dir(acpi_battery_dir);
780                 return -ENODEV;
781         }
782
783         return 0;
784 }
785
786 static void __exit acpi_battery_exit(void)
787 {
788
789         acpi_bus_unregister_driver(&acpi_battery_driver);
790
791         acpi_unlock_battery_dir(acpi_battery_dir);
792
793         return;
794 }
795
796 module_init(acpi_battery_init);
797 module_exit(acpi_battery_exit);