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