ACPI: battery: register power_supply subdevice only when battery is present
[linux-3.10.git] / drivers / acpi / battery.c
1 /*
2  *  battery.c - ACPI Battery Driver (Revision: 2.0)
3  *
4  *  Copyright (C) 2007 Alexey Starikovskiy <astarikovskiy@suse.de>
5  *  Copyright (C) 2004-2007 Vladimir Lebedev <vladimir.p.lebedev@intel.com>
6  *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
7  *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
8  *
9  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
10  *
11  *  This program is free software; you can redistribute it and/or modify
12  *  it under the terms of the GNU General Public License as published by
13  *  the Free Software Foundation; either version 2 of the License, or (at
14  *  your option) any later version.
15  *
16  *  This program is distributed in the hope that it will be useful, but
17  *  WITHOUT ANY WARRANTY; without even the implied warranty of
18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19  *  General Public License for more details.
20  *
21  *  You should have received a copy of the GNU General Public License along
22  *  with this program; if not, write to the Free Software Foundation, Inc.,
23  *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
24  *
25  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
26  */
27
28 #include <linux/kernel.h>
29 #include <linux/module.h>
30 #include <linux/init.h>
31 #include <linux/types.h>
32 #include <linux/jiffies.h>
33
34 #ifdef CONFIG_ACPI_PROCFS
35 #include <linux/proc_fs.h>
36 #include <linux/seq_file.h>
37 #include <asm/uaccess.h>
38 #endif
39
40 #include <acpi/acpi_bus.h>
41 #include <acpi/acpi_drivers.h>
42
43 #include <linux/power_supply.h>
44
45 #define ACPI_BATTERY_VALUE_UNKNOWN 0xFFFFFFFF
46
47 #define ACPI_BATTERY_COMPONENT          0x00040000
48 #define ACPI_BATTERY_CLASS              "battery"
49 #define ACPI_BATTERY_DEVICE_NAME        "Battery"
50 #define ACPI_BATTERY_NOTIFY_STATUS      0x80
51 #define ACPI_BATTERY_NOTIFY_INFO        0x81
52
53 #define _COMPONENT              ACPI_BATTERY_COMPONENT
54
55 ACPI_MODULE_NAME("battery");
56
57 MODULE_AUTHOR("Paul Diefenbaugh");
58 MODULE_AUTHOR("Alexey Starikovskiy <astarikovskiy@suse.de>");
59 MODULE_DESCRIPTION("ACPI Battery Driver");
60 MODULE_LICENSE("GPL");
61
62 static unsigned int cache_time = 1000;
63 module_param(cache_time, uint, 0644);
64 MODULE_PARM_DESC(cache_time, "cache time in milliseconds");
65
66 #ifdef CONFIG_ACPI_PROCFS
67 extern struct proc_dir_entry *acpi_lock_battery_dir(void);
68 extern void *acpi_unlock_battery_dir(struct proc_dir_entry *acpi_battery_dir);
69
70 enum acpi_battery_files {
71         info_tag = 0,
72         state_tag,
73         alarm_tag,
74         ACPI_BATTERY_NUMFILES,
75 };
76
77 #endif
78
79 static const struct acpi_device_id battery_device_ids[] = {
80         {"PNP0C0A", 0},
81         {"", 0},
82 };
83
84 MODULE_DEVICE_TABLE(acpi, battery_device_ids);
85
86
87 struct acpi_battery {
88         struct mutex lock;
89         struct power_supply bat;
90         struct acpi_device *device;
91         unsigned long update_time;
92         int current_now;
93         int capacity_now;
94         int voltage_now;
95         int design_capacity;
96         int full_charge_capacity;
97         int technology;
98         int design_voltage;
99         int design_capacity_warning;
100         int design_capacity_low;
101         int capacity_granularity_1;
102         int capacity_granularity_2;
103         int alarm;
104         char model_number[32];
105         char serial_number[32];
106         char type[32];
107         char oem_info[32];
108         int state;
109         int power_unit;
110         u8 alarm_present;
111 };
112
113 #define to_acpi_battery(x) container_of(x, struct acpi_battery, bat);
114
115 inline int acpi_battery_present(struct acpi_battery *battery)
116 {
117         return battery->device->status.battery_present;
118 }
119
120 static int acpi_battery_technology(struct acpi_battery *battery)
121 {
122         if (!strcasecmp("NiCd", battery->type))
123                 return POWER_SUPPLY_TECHNOLOGY_NiCd;
124         if (!strcasecmp("NiMH", battery->type))
125                 return POWER_SUPPLY_TECHNOLOGY_NiMH;
126         if (!strcasecmp("LION", battery->type))
127                 return POWER_SUPPLY_TECHNOLOGY_LION;
128         if (!strcasecmp("LiP", battery->type))
129                 return POWER_SUPPLY_TECHNOLOGY_LIPO;
130         return POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
131 }
132
133 static int acpi_battery_update(struct acpi_battery *battery);
134
135 static int acpi_battery_get_property(struct power_supply *psy,
136                                      enum power_supply_property psp,
137                                      union power_supply_propval *val)
138 {
139         struct acpi_battery *battery = to_acpi_battery(psy);
140
141         if ((!acpi_battery_present(battery)) &&
142              psp != POWER_SUPPLY_PROP_PRESENT)
143                 return -ENODEV;
144         acpi_battery_update(battery);
145         switch (psp) {
146         case POWER_SUPPLY_PROP_STATUS:
147                 if (battery->state & 0x01)
148                         val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
149                 else if (battery->state & 0x02)
150                         val->intval = POWER_SUPPLY_STATUS_CHARGING;
151                 else if (battery->state == 0)
152                         val->intval = POWER_SUPPLY_STATUS_FULL;
153                 break;
154         case POWER_SUPPLY_PROP_PRESENT:
155                 val->intval = acpi_battery_present(battery);
156                 break;
157         case POWER_SUPPLY_PROP_TECHNOLOGY:
158                 val->intval = acpi_battery_technology(battery);
159                 break;
160         case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
161                 val->intval = battery->design_voltage * 1000;
162                 break;
163         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
164                 val->intval = battery->voltage_now * 1000;
165                 break;
166         case POWER_SUPPLY_PROP_CURRENT_NOW:
167                 val->intval = battery->current_now * 1000;
168                 break;
169         case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
170         case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
171                 val->intval = battery->design_capacity * 1000;
172                 break;
173         case POWER_SUPPLY_PROP_CHARGE_FULL:
174         case POWER_SUPPLY_PROP_ENERGY_FULL:
175                 val->intval = battery->full_charge_capacity * 1000;
176                 break;
177         case POWER_SUPPLY_PROP_CHARGE_NOW:
178         case POWER_SUPPLY_PROP_ENERGY_NOW:
179                 val->intval = battery->capacity_now * 1000;
180                 break;
181         case POWER_SUPPLY_PROP_MODEL_NAME:
182                 val->strval = battery->model_number;
183                 break;
184         case POWER_SUPPLY_PROP_MANUFACTURER:
185                 val->strval = battery->oem_info;
186                 break;
187         default:
188                 return -EINVAL;
189         }
190         return 0;
191 }
192
193 static enum power_supply_property charge_battery_props[] = {
194         POWER_SUPPLY_PROP_STATUS,
195         POWER_SUPPLY_PROP_PRESENT,
196         POWER_SUPPLY_PROP_TECHNOLOGY,
197         POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
198         POWER_SUPPLY_PROP_VOLTAGE_NOW,
199         POWER_SUPPLY_PROP_CURRENT_NOW,
200         POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
201         POWER_SUPPLY_PROP_CHARGE_FULL,
202         POWER_SUPPLY_PROP_CHARGE_NOW,
203         POWER_SUPPLY_PROP_MODEL_NAME,
204         POWER_SUPPLY_PROP_MANUFACTURER,
205 };
206
207 static enum power_supply_property energy_battery_props[] = {
208         POWER_SUPPLY_PROP_STATUS,
209         POWER_SUPPLY_PROP_PRESENT,
210         POWER_SUPPLY_PROP_TECHNOLOGY,
211         POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
212         POWER_SUPPLY_PROP_VOLTAGE_NOW,
213         POWER_SUPPLY_PROP_CURRENT_NOW,
214         POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
215         POWER_SUPPLY_PROP_ENERGY_FULL,
216         POWER_SUPPLY_PROP_ENERGY_NOW,
217         POWER_SUPPLY_PROP_MODEL_NAME,
218         POWER_SUPPLY_PROP_MANUFACTURER,
219 };
220
221 #ifdef CONFIG_ACPI_PROCFS
222 inline char *acpi_battery_units(struct acpi_battery *battery)
223 {
224         return (battery->power_unit)?"mA":"mW";
225 }
226 #endif
227
228 /* --------------------------------------------------------------------------
229                                Battery Management
230    -------------------------------------------------------------------------- */
231 struct acpi_offsets {
232         size_t offset;          /* offset inside struct acpi_sbs_battery */
233         u8 mode;                /* int or string? */
234 };
235
236 static struct acpi_offsets state_offsets[] = {
237         {offsetof(struct acpi_battery, state), 0},
238         {offsetof(struct acpi_battery, current_now), 0},
239         {offsetof(struct acpi_battery, capacity_now), 0},
240         {offsetof(struct acpi_battery, voltage_now), 0},
241 };
242
243 static struct acpi_offsets info_offsets[] = {
244         {offsetof(struct acpi_battery, power_unit), 0},
245         {offsetof(struct acpi_battery, design_capacity), 0},
246         {offsetof(struct acpi_battery, full_charge_capacity), 0},
247         {offsetof(struct acpi_battery, technology), 0},
248         {offsetof(struct acpi_battery, design_voltage), 0},
249         {offsetof(struct acpi_battery, design_capacity_warning), 0},
250         {offsetof(struct acpi_battery, design_capacity_low), 0},
251         {offsetof(struct acpi_battery, capacity_granularity_1), 0},
252         {offsetof(struct acpi_battery, capacity_granularity_2), 0},
253         {offsetof(struct acpi_battery, model_number), 1},
254         {offsetof(struct acpi_battery, serial_number), 1},
255         {offsetof(struct acpi_battery, type), 1},
256         {offsetof(struct acpi_battery, oem_info), 1},
257 };
258
259 static int extract_package(struct acpi_battery *battery,
260                            union acpi_object *package,
261                            struct acpi_offsets *offsets, int num)
262 {
263         int i, *x;
264         union acpi_object *element;
265         if (package->type != ACPI_TYPE_PACKAGE)
266                 return -EFAULT;
267         for (i = 0; i < num; ++i) {
268                 if (package->package.count <= i)
269                         return -EFAULT;
270                 element = &package->package.elements[i];
271                 if (offsets[i].mode) {
272                         if (element->type != ACPI_TYPE_STRING &&
273                             element->type != ACPI_TYPE_BUFFER)
274                                 return -EFAULT;
275                         strncpy((u8 *)battery + offsets[i].offset,
276                                 element->string.pointer, 32);
277                 } else {
278                         if (element->type != ACPI_TYPE_INTEGER)
279                                 return -EFAULT;
280                         x = (int *)((u8 *)battery + offsets[i].offset);
281                         *x = element->integer.value;
282                 }
283         }
284         return 0;
285 }
286
287 static int acpi_battery_get_status(struct acpi_battery *battery)
288 {
289         if (acpi_bus_get_status(battery->device)) {
290                 ACPI_EXCEPTION((AE_INFO, AE_ERROR, "Evaluating _STA"));
291                 return -ENODEV;
292         }
293         return 0;
294 }
295
296 static int acpi_battery_get_info(struct acpi_battery *battery)
297 {
298         int result = -EFAULT;
299         acpi_status status = 0;
300         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
301
302         if (!acpi_battery_present(battery))
303                 return 0;
304         mutex_lock(&battery->lock);
305         status = acpi_evaluate_object(battery->device->handle, "_BIF",
306                                       NULL, &buffer);
307         mutex_unlock(&battery->lock);
308
309         if (ACPI_FAILURE(status)) {
310                 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BIF"));
311                 return -ENODEV;
312         }
313
314         result = extract_package(battery, buffer.pointer,
315                                  info_offsets, ARRAY_SIZE(info_offsets));
316         kfree(buffer.pointer);
317         return result;
318 }
319
320 static int acpi_battery_get_state(struct acpi_battery *battery)
321 {
322         int result = 0;
323         acpi_status status = 0;
324         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
325
326         if (!acpi_battery_present(battery))
327                 return 0;
328
329         if (battery->update_time &&
330             time_before(jiffies, battery->update_time +
331                         msecs_to_jiffies(cache_time)))
332                 return 0;
333
334         mutex_lock(&battery->lock);
335         status = acpi_evaluate_object(battery->device->handle, "_BST",
336                                       NULL, &buffer);
337         mutex_unlock(&battery->lock);
338
339         if (ACPI_FAILURE(status)) {
340                 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BST"));
341                 return -ENODEV;
342         }
343
344         result = extract_package(battery, buffer.pointer,
345                                  state_offsets, ARRAY_SIZE(state_offsets));
346         battery->update_time = jiffies;
347         kfree(buffer.pointer);
348         return result;
349 }
350
351 static int acpi_battery_set_alarm(struct acpi_battery *battery)
352 {
353         acpi_status status = 0;
354         union acpi_object arg0 = { .type = ACPI_TYPE_INTEGER };
355         struct acpi_object_list arg_list = { 1, &arg0 };
356
357         if (!acpi_battery_present(battery)|| !battery->alarm_present)
358                 return -ENODEV;
359
360         arg0.integer.value = battery->alarm;
361
362         mutex_lock(&battery->lock);
363         status = acpi_evaluate_object(battery->device->handle, "_BTP",
364                                  &arg_list, NULL);
365         mutex_unlock(&battery->lock);
366
367         if (ACPI_FAILURE(status))
368                 return -ENODEV;
369
370         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Alarm set to %d\n", battery->alarm));
371         return 0;
372 }
373
374 static int acpi_battery_init_alarm(struct acpi_battery *battery)
375 {
376         acpi_status status = AE_OK;
377         acpi_handle handle = NULL;
378
379         /* See if alarms are supported, and if so, set default */
380         status = acpi_get_handle(battery->device->handle, "_BTP", &handle);
381         if (ACPI_FAILURE(status)) {
382                 battery->alarm_present = 0;
383                 return 0;
384         }
385         battery->alarm_present = 1;
386         if (!battery->alarm)
387                 battery->alarm = battery->design_capacity_warning;
388         return acpi_battery_set_alarm(battery);
389 }
390
391 static ssize_t acpi_battery_alarm_show(struct device *dev,
392                                         struct device_attribute *attr,
393                                         char *buf)
394 {
395         struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
396         return sprintf(buf, "%d\n", battery->alarm * 1000);
397 }
398
399 static ssize_t acpi_battery_alarm_store(struct device *dev,
400                                         struct device_attribute *attr,
401                                         const char *buf, size_t count)
402 {
403         unsigned long x;
404         struct acpi_battery *battery = to_acpi_battery(dev_get_drvdata(dev));
405         if (sscanf(buf, "%ld\n", &x) == 1)
406                 battery->alarm = x/1000;
407         if (acpi_battery_present(battery))
408                 acpi_battery_set_alarm(battery);
409         return count;
410 }
411
412 static struct device_attribute alarm_attr = {
413         .attr = {.name = "alarm", .mode = 0644, .owner = THIS_MODULE},
414         .show = acpi_battery_alarm_show,
415         .store = acpi_battery_alarm_store,
416 };
417
418 static int sysfs_add_battery(struct acpi_battery *battery)
419 {
420         int result;
421
422         battery->update_time = 0;
423         result = acpi_battery_get_info(battery);
424         acpi_battery_init_alarm(battery);
425         if (result)
426                 return result;
427         if (battery->power_unit) {
428                 battery->bat.properties = charge_battery_props;
429                 battery->bat.num_properties =
430                         ARRAY_SIZE(charge_battery_props);
431         } else {
432                 battery->bat.properties = energy_battery_props;
433                 battery->bat.num_properties =
434                         ARRAY_SIZE(energy_battery_props);
435         }
436
437         battery->bat.name = acpi_device_bid(battery->device);
438         battery->bat.type = POWER_SUPPLY_TYPE_BATTERY;
439         battery->bat.get_property = acpi_battery_get_property;
440
441         result = power_supply_register(&battery->device->dev, &battery->bat);
442         if (result)
443                 return result;
444         return device_create_file(battery->bat.dev, &alarm_attr);
445 }
446
447 static void sysfs_remove_battery(struct acpi_battery *battery)
448 {
449         if (!battery->bat.dev)
450                 return;
451         device_remove_file(battery->bat.dev, &alarm_attr);
452         power_supply_unregister(&battery->bat);
453 }
454
455 static int acpi_battery_update(struct acpi_battery *battery)
456 {
457         int result = acpi_battery_get_status(battery);
458         if (result)
459                 return result;
460         if (!acpi_battery_present(battery)) {
461                 sysfs_remove_battery(battery);
462                 return 0;
463         }
464         if (!battery->bat.dev)
465                 sysfs_add_battery(battery);
466         return acpi_battery_get_state(battery);
467 }
468
469 /* --------------------------------------------------------------------------
470                               FS Interface (/proc)
471    -------------------------------------------------------------------------- */
472
473 #ifdef CONFIG_ACPI_PROCFS
474 static struct proc_dir_entry *acpi_battery_dir;
475
476 static int acpi_battery_print_info(struct seq_file *seq, int result)
477 {
478         struct acpi_battery *battery = seq->private;
479
480         if (result)
481                 goto end;
482
483         seq_printf(seq, "present:                 %s\n",
484                    acpi_battery_present(battery)?"yes":"no");
485         if (!acpi_battery_present(battery))
486                 goto end;
487         if (battery->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
488                 seq_printf(seq, "design capacity:         unknown\n");
489         else
490                 seq_printf(seq, "design capacity:         %d %sh\n",
491                            battery->design_capacity,
492                            acpi_battery_units(battery));
493
494         if (battery->full_charge_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
495                 seq_printf(seq, "last full capacity:      unknown\n");
496         else
497                 seq_printf(seq, "last full capacity:      %d %sh\n",
498                            battery->full_charge_capacity,
499                            acpi_battery_units(battery));
500
501         seq_printf(seq, "battery technology:      %srechargeable\n",
502                    (!battery->technology)?"non-":"");
503
504         if (battery->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
505                 seq_printf(seq, "design voltage:          unknown\n");
506         else
507                 seq_printf(seq, "design voltage:          %d mV\n",
508                            battery->design_voltage);
509         seq_printf(seq, "design capacity warning: %d %sh\n",
510                    battery->design_capacity_warning,
511                    acpi_battery_units(battery));
512         seq_printf(seq, "design capacity low:     %d %sh\n",
513                    battery->design_capacity_low,
514                    acpi_battery_units(battery));
515         seq_printf(seq, "capacity granularity 1:  %d %sh\n",
516                    battery->capacity_granularity_1,
517                    acpi_battery_units(battery));
518         seq_printf(seq, "capacity granularity 2:  %d %sh\n",
519                    battery->capacity_granularity_2,
520                    acpi_battery_units(battery));
521         seq_printf(seq, "model number:            %s\n", battery->model_number);
522         seq_printf(seq, "serial number:           %s\n", battery->serial_number);
523         seq_printf(seq, "battery type:            %s\n", battery->type);
524         seq_printf(seq, "OEM info:                %s\n", battery->oem_info);
525       end:
526         if (result)
527                 seq_printf(seq, "ERROR: Unable to read battery info\n");
528         return result;
529 }
530
531 static int acpi_battery_print_state(struct seq_file *seq, int result)
532 {
533         struct acpi_battery *battery = seq->private;
534
535         if (result)
536                 goto end;
537
538         seq_printf(seq, "present:                 %s\n",
539                    acpi_battery_present(battery)?"yes":"no");
540         if (!acpi_battery_present(battery))
541                 goto end;
542
543         seq_printf(seq, "capacity state:          %s\n",
544                         (battery->state & 0x04)?"critical":"ok");
545         if ((battery->state & 0x01) && (battery->state & 0x02))
546                 seq_printf(seq,
547                            "charging state:          charging/discharging\n");
548         else if (battery->state & 0x01)
549                 seq_printf(seq, "charging state:          discharging\n");
550         else if (battery->state & 0x02)
551                 seq_printf(seq, "charging state:          charging\n");
552         else
553                 seq_printf(seq, "charging state:          charged\n");
554
555         if (battery->current_now == ACPI_BATTERY_VALUE_UNKNOWN)
556                 seq_printf(seq, "present rate:            unknown\n");
557         else
558                 seq_printf(seq, "present rate:            %d %s\n",
559                            battery->current_now, acpi_battery_units(battery));
560
561         if (battery->capacity_now == ACPI_BATTERY_VALUE_UNKNOWN)
562                 seq_printf(seq, "remaining capacity:      unknown\n");
563         else
564                 seq_printf(seq, "remaining capacity:      %d %sh\n",
565                            battery->capacity_now, acpi_battery_units(battery));
566         if (battery->voltage_now == ACPI_BATTERY_VALUE_UNKNOWN)
567                 seq_printf(seq, "present voltage:         unknown\n");
568         else
569                 seq_printf(seq, "present voltage:         %d mV\n",
570                            battery->voltage_now);
571       end:
572         if (result)
573                 seq_printf(seq, "ERROR: Unable to read battery state\n");
574
575         return result;
576 }
577
578 static int acpi_battery_print_alarm(struct seq_file *seq, int result)
579 {
580         struct acpi_battery *battery = seq->private;
581
582         if (result)
583                 goto end;
584
585         if (!acpi_battery_present(battery)) {
586                 seq_printf(seq, "present:                 no\n");
587                 goto end;
588         }
589         seq_printf(seq, "alarm:                   ");
590         if (!battery->alarm)
591                 seq_printf(seq, "unsupported\n");
592         else
593                 seq_printf(seq, "%u %sh\n", battery->alarm,
594                                 acpi_battery_units(battery));
595       end:
596         if (result)
597                 seq_printf(seq, "ERROR: Unable to read battery alarm\n");
598         return result;
599 }
600
601 static ssize_t acpi_battery_write_alarm(struct file *file,
602                                         const char __user * buffer,
603                                         size_t count, loff_t * ppos)
604 {
605         int result = 0;
606         char alarm_string[12] = { '\0' };
607         struct seq_file *m = file->private_data;
608         struct acpi_battery *battery = m->private;
609
610         if (!battery || (count > sizeof(alarm_string) - 1))
611                 return -EINVAL;
612         if (!acpi_battery_present(battery)) {
613                 result = -ENODEV;
614                 goto end;
615         }
616         if (copy_from_user(alarm_string, buffer, count)) {
617                 result = -EFAULT;
618                 goto end;
619         }
620         alarm_string[count] = '\0';
621         battery->alarm = simple_strtol(alarm_string, NULL, 0);
622         result = acpi_battery_set_alarm(battery);
623       end:
624         if (!result)
625                 return count;
626         return result;
627 }
628
629 typedef int(*print_func)(struct seq_file *seq, int result);
630
631 static print_func acpi_print_funcs[ACPI_BATTERY_NUMFILES] = {
632         acpi_battery_print_info,
633         acpi_battery_print_state,
634         acpi_battery_print_alarm,
635 };
636
637 static int acpi_battery_read(int fid, struct seq_file *seq)
638 {
639         struct acpi_battery *battery = seq->private;
640         int result = acpi_battery_update(battery);
641         return acpi_print_funcs[fid](seq, result);
642 }
643
644 #define DECLARE_FILE_FUNCTIONS(_name) \
645 static int acpi_battery_read_##_name(struct seq_file *seq, void *offset) \
646 { \
647         return acpi_battery_read(_name##_tag, seq); \
648 } \
649 static int acpi_battery_##_name##_open_fs(struct inode *inode, struct file *file) \
650 { \
651         return single_open(file, acpi_battery_read_##_name, PDE(inode)->data); \
652 }
653
654 DECLARE_FILE_FUNCTIONS(info);
655 DECLARE_FILE_FUNCTIONS(state);
656 DECLARE_FILE_FUNCTIONS(alarm);
657
658 #undef DECLARE_FILE_FUNCTIONS
659
660 #define FILE_DESCRIPTION_RO(_name) \
661         { \
662         .name = __stringify(_name), \
663         .mode = S_IRUGO, \
664         .ops = { \
665                 .open = acpi_battery_##_name##_open_fs, \
666                 .read = seq_read, \
667                 .llseek = seq_lseek, \
668                 .release = single_release, \
669                 .owner = THIS_MODULE, \
670                 }, \
671         }
672
673 #define FILE_DESCRIPTION_RW(_name) \
674         { \
675         .name = __stringify(_name), \
676         .mode = S_IFREG | S_IRUGO | S_IWUSR, \
677         .ops = { \
678                 .open = acpi_battery_##_name##_open_fs, \
679                 .read = seq_read, \
680                 .llseek = seq_lseek, \
681                 .write = acpi_battery_write_##_name, \
682                 .release = single_release, \
683                 .owner = THIS_MODULE, \
684                 }, \
685         }
686
687 static struct battery_file {
688         struct file_operations ops;
689         mode_t mode;
690         char *name;
691 } acpi_battery_file[] = {
692         FILE_DESCRIPTION_RO(info),
693         FILE_DESCRIPTION_RO(state),
694         FILE_DESCRIPTION_RW(alarm),
695 };
696
697 #undef FILE_DESCRIPTION_RO
698 #undef FILE_DESCRIPTION_RW
699
700 static int acpi_battery_add_fs(struct acpi_device *device)
701 {
702         struct proc_dir_entry *entry = NULL;
703         int i;
704
705         if (!acpi_device_dir(device)) {
706                 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
707                                                      acpi_battery_dir);
708                 if (!acpi_device_dir(device))
709                         return -ENODEV;
710                 acpi_device_dir(device)->owner = THIS_MODULE;
711         }
712
713         for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i) {
714                 entry = create_proc_entry(acpi_battery_file[i].name,
715                                   acpi_battery_file[i].mode, acpi_device_dir(device));
716                 if (!entry)
717                         return -ENODEV;
718                 else {
719                         entry->proc_fops = &acpi_battery_file[i].ops;
720                         entry->data = acpi_driver_data(device);
721                         entry->owner = THIS_MODULE;
722                 }
723         }
724         return 0;
725 }
726
727 static void acpi_battery_remove_fs(struct acpi_device *device)
728 {
729         int i;
730         if (!acpi_device_dir(device))
731                 return;
732         for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i)
733                 remove_proc_entry(acpi_battery_file[i].name,
734                                   acpi_device_dir(device));
735
736         remove_proc_entry(acpi_device_bid(device), acpi_battery_dir);
737         acpi_device_dir(device) = NULL;
738 }
739
740 #endif
741
742 /* --------------------------------------------------------------------------
743                                  Driver Interface
744    -------------------------------------------------------------------------- */
745
746 static void acpi_battery_notify(acpi_handle handle, u32 event, void *data)
747 {
748         struct acpi_battery *battery = data;
749         struct acpi_device *device;
750         if (!battery)
751                 return;
752         device = battery->device;
753         acpi_battery_update(battery);
754         acpi_bus_generate_proc_event(device, event,
755                                      acpi_battery_present(battery));
756         acpi_bus_generate_netlink_event(device->pnp.device_class,
757                                         device->dev.bus_id, event,
758                                         acpi_battery_present(battery));
759         /* acpi_batter_update could remove power_supply object */
760         if (battery->bat.dev)
761                 kobject_uevent(&battery->bat.dev->kobj, KOBJ_CHANGE);
762 }
763
764 static int acpi_battery_add(struct acpi_device *device)
765 {
766         int result = 0;
767         acpi_status status = 0;
768         struct acpi_battery *battery = NULL;
769         if (!device)
770                 return -EINVAL;
771         battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL);
772         if (!battery)
773                 return -ENOMEM;
774         battery->device = device;
775         strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME);
776         strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS);
777         acpi_driver_data(device) = battery;
778         mutex_init(&battery->lock);
779         acpi_battery_update(battery);
780 #ifdef CONFIG_ACPI_PROCFS
781         result = acpi_battery_add_fs(device);
782         if (result)
783                 goto end;
784 #endif
785         status = acpi_install_notify_handler(device->handle,
786                                              ACPI_ALL_NOTIFY,
787                                              acpi_battery_notify, battery);
788         if (ACPI_FAILURE(status)) {
789                 ACPI_EXCEPTION((AE_INFO, status, "Installing notify handler"));
790                 result = -ENODEV;
791                 goto end;
792         }
793         printk(KERN_INFO PREFIX "%s Slot [%s] (battery %s)\n",
794                ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device),
795                device->status.battery_present ? "present" : "absent");
796       end:
797         if (result) {
798 #ifdef CONFIG_ACPI_PROCFS
799                 acpi_battery_remove_fs(device);
800 #endif
801                 kfree(battery);
802         }
803         return result;
804 }
805
806 static int acpi_battery_remove(struct acpi_device *device, int type)
807 {
808         acpi_status status = 0;
809         struct acpi_battery *battery = NULL;
810
811         if (!device || !acpi_driver_data(device))
812                 return -EINVAL;
813         battery = acpi_driver_data(device);
814         status = acpi_remove_notify_handler(device->handle,
815                                             ACPI_ALL_NOTIFY,
816                                             acpi_battery_notify);
817 #ifdef CONFIG_ACPI_PROCFS
818         acpi_battery_remove_fs(device);
819 #endif
820         sysfs_remove_battery(battery);
821         mutex_destroy(&battery->lock);
822         kfree(battery);
823         return 0;
824 }
825
826 /* this is needed to learn about changes made in suspended state */
827 static int acpi_battery_resume(struct acpi_device *device)
828 {
829         struct acpi_battery *battery;
830         if (!device)
831                 return -EINVAL;
832         battery = acpi_driver_data(device);
833         battery->update_time = 0;
834         acpi_battery_update(battery);
835         return 0;
836 }
837
838 static struct acpi_driver acpi_battery_driver = {
839         .name = "battery",
840         .class = ACPI_BATTERY_CLASS,
841         .ids = battery_device_ids,
842         .ops = {
843                 .add = acpi_battery_add,
844                 .resume = acpi_battery_resume,
845                 .remove = acpi_battery_remove,
846                 },
847 };
848
849 static int __init acpi_battery_init(void)
850 {
851         if (acpi_disabled)
852                 return -ENODEV;
853 #ifdef CONFIG_ACPI_PROCFS
854         acpi_battery_dir = acpi_lock_battery_dir();
855         if (!acpi_battery_dir)
856                 return -ENODEV;
857 #endif
858         if (acpi_bus_register_driver(&acpi_battery_driver) < 0) {
859 #ifdef CONFIG_ACPI_PROCFS
860                 acpi_unlock_battery_dir(acpi_battery_dir);
861 #endif
862                 return -ENODEV;
863         }
864         return 0;
865 }
866
867 static void __exit acpi_battery_exit(void)
868 {
869         acpi_bus_unregister_driver(&acpi_battery_driver);
870 #ifdef CONFIG_ACPI_PROCFS
871         acpi_unlock_battery_dir(acpi_battery_dir);
872 #endif
873 }
874
875 module_init(acpi_battery_init);
876 module_exit(acpi_battery_exit);