ACPI: delete tracing macros from drivers/acpi/*.c
[linux-2.6.git] / drivers / acpi / hotkey.c
1 /*
2  *  hotkey.c - ACPI Hotkey Driver ($Revision: 0.2 $)
3  *
4  *  Copyright (C) 2004 Luming Yu <luming.yu@intel.com>
5  *
6  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7  *
8  *  This program is free software; you can redistribute it and/or modify
9  *  it under the terms of the GNU General Public License as published by
10  *  the Free Software Foundation; either version 2 of the License, or (at
11  *  your option) any later version.
12  *
13  *  This program is distributed in the hope that it will be useful, but
14  *  WITHOUT ANY WARRANTY; without even the implied warranty of
15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  *  General Public License for more details.
17  *
18  *  You should have received a copy of the GNU General Public License along
19  *  with this program; if not, write to the Free Software Foundation, Inc.,
20  *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
21  *
22  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
23  */
24 #include <linux/kernel.h>
25 #include <linux/module.h>
26 #include <linux/init.h>
27 #include <linux/types.h>
28 #include <linux/proc_fs.h>
29 #include <linux/sched.h>
30 #include <linux/kmod.h>
31 #include <linux/seq_file.h>
32 #include <acpi/acpi_drivers.h>
33 #include <acpi/acpi_bus.h>
34 #include <asm/uaccess.h>
35
36 #define HOTKEY_ACPI_VERSION "0.1"
37
38 #define HOTKEY_PROC "hotkey"
39 #define HOTKEY_EV_CONFIG    "event_config"
40 #define HOTKEY_PL_CONFIG    "poll_config"
41 #define HOTKEY_ACTION   "action"
42 #define HOTKEY_INFO "info"
43
44 #define ACPI_HOTK_NAME          "Generic Hotkey Driver"
45 #define ACPI_HOTK_CLASS         "Hotkey"
46 #define ACPI_HOTK_DEVICE_NAME   "Hotkey"
47 #define ACPI_HOTK_HID           "Unknown?"
48 #define ACPI_HOTKEY_COMPONENT   0x20000000
49
50 #define ACPI_HOTKEY_EVENT   0x1
51 #define ACPI_HOTKEY_POLLING 0x2
52 #define ACPI_UNDEFINED_EVENT    0xf
53
54 #define RESULT_STR_LEN      80
55
56 #define ACTION_METHOD   0
57 #define POLL_METHOD     1
58
59 #define IS_EVENT(e)             ((e) <= 10000 && (e) >0)
60 #define IS_POLL(e)              ((e) > 10000)
61 #define IS_OTHERS(e)            ((e)<=0 || (e)>=20000)
62 #define _COMPONENT              ACPI_HOTKEY_COMPONENT
63 ACPI_MODULE_NAME("acpi_hotkey")
64
65     MODULE_AUTHOR("luming.yu@intel.com");
66 MODULE_DESCRIPTION(ACPI_HOTK_NAME);
67 MODULE_LICENSE("GPL");
68
69 /*  standardized internal hotkey number/event  */
70 enum {
71         /* Video Extension event */
72         HK_EVENT_CYCLE_OUTPUT_DEVICE = 0x80,
73         HK_EVENT_OUTPUT_DEVICE_STATUS_CHANGE,
74         HK_EVENT_CYCLE_DISPLAY_OUTPUT,
75         HK_EVENT_NEXT_DISPLAY_OUTPUT,
76         HK_EVENT_PREVIOUS_DISPLAY_OUTPUT,
77         HK_EVENT_CYCLE_BRIGHTNESS,
78         HK_EVENT_INCREASE_BRIGHTNESS,
79         HK_EVENT_DECREASE_BRIGHTNESS,
80         HK_EVENT_ZERO_BRIGHTNESS,
81         HK_EVENT_DISPLAY_DEVICE_OFF,
82
83         /* Snd Card event */
84         HK_EVENT_VOLUME_MUTE,
85         HK_EVENT_VOLUME_INCLREASE,
86         HK_EVENT_VOLUME_DECREASE,
87
88         /* running state control */
89         HK_EVENT_ENTERRING_S3,
90         HK_EVENT_ENTERRING_S4,
91         HK_EVENT_ENTERRING_S5,
92 };
93
94 /*  procdir we use */
95 static struct proc_dir_entry *hotkey_proc_dir;
96 static struct proc_dir_entry *hotkey_config;
97 static struct proc_dir_entry *hotkey_poll_config;
98 static struct proc_dir_entry *hotkey_action;
99 static struct proc_dir_entry *hotkey_info;
100
101 /* linkage for all type of hotkey */
102 struct acpi_hotkey_link {
103         struct list_head entries;
104         int hotkey_type;        /* event or polling based hotkey  */
105         int hotkey_standard_num;        /* standardized hotkey(event) number */
106 };
107
108 /* event based hotkey */
109 struct acpi_event_hotkey {
110         struct acpi_hotkey_link hotkey_link;
111         int flag;
112         acpi_handle bus_handle; /* bus to install notify handler */
113         int external_hotkey_num;        /* external hotkey/event number */
114         acpi_handle action_handle;      /* acpi handle attached aml action method */
115         char *action_method;    /* action method */
116 };
117
118 /*
119  * There are two ways to poll status
120  * 1. directy call read_xxx method, without any arguments passed in
121  * 2. call write_xxx method, with arguments passed in, you need
122  * the result is saved in acpi_polling_hotkey.poll_result.
123  * anthoer read command through polling interface.
124  *
125  */
126
127 /* polling based hotkey */
128 struct acpi_polling_hotkey {
129         struct acpi_hotkey_link hotkey_link;
130         int flag;
131         acpi_handle poll_handle;        /* acpi handle attached polling method */
132         char *poll_method;      /* poll method */
133         acpi_handle action_handle;      /* acpi handle attached action method */
134         char *action_method;    /* action method */
135         union acpi_object *poll_result; /* polling_result */
136         struct proc_dir_entry *proc;
137 };
138
139 /* hotkey object union */
140 union acpi_hotkey {
141         struct list_head entries;
142         struct acpi_hotkey_link link;
143         struct acpi_event_hotkey event_hotkey;
144         struct acpi_polling_hotkey poll_hotkey;
145 };
146
147 /* hotkey object list */
148 struct acpi_hotkey_list {
149         struct list_head *entries;
150         int count;
151 };
152
153 static int auto_hotkey_add(struct acpi_device *device);
154 static int auto_hotkey_remove(struct acpi_device *device, int type);
155
156 static struct acpi_driver hotkey_driver = {
157         .name = ACPI_HOTK_NAME,
158         .class = ACPI_HOTK_CLASS,
159         .ids = ACPI_HOTK_HID,
160         .ops = {
161                 .add = auto_hotkey_add,
162                 .remove = auto_hotkey_remove,
163                 },
164 };
165
166 static void free_hotkey_device(union acpi_hotkey *key);
167 static void free_hotkey_buffer(union acpi_hotkey *key);
168 static void free_poll_hotkey_buffer(union acpi_hotkey *key);
169 static int hotkey_open_config(struct inode *inode, struct file *file);
170 static int hotkey_poll_open_config(struct inode *inode, struct file *file);
171 static ssize_t hotkey_write_config(struct file *file,
172                                    const char __user * buffer,
173                                    size_t count, loff_t * data);
174 static int hotkey_info_open_fs(struct inode *inode, struct file *file);
175 static int hotkey_action_open_fs(struct inode *inode, struct file *file);
176 static ssize_t hotkey_execute_aml_method(struct file *file,
177                                          const char __user * buffer,
178                                          size_t count, loff_t * data);
179 static int hotkey_config_seq_show(struct seq_file *seq, void *offset);
180 static int hotkey_poll_config_seq_show(struct seq_file *seq, void *offset);
181 static int hotkey_polling_open_fs(struct inode *inode, struct file *file);
182 static union acpi_hotkey *get_hotkey_by_event(struct
183                                               acpi_hotkey_list
184                                               *hotkey_list, int event);
185
186 /* event based config */
187 static struct file_operations hotkey_config_fops = {
188         .open = hotkey_open_config,
189         .read = seq_read,
190         .write = hotkey_write_config,
191         .llseek = seq_lseek,
192         .release = single_release,
193 };
194
195 /* polling based config */
196 static struct file_operations hotkey_poll_config_fops = {
197         .open = hotkey_poll_open_config,
198         .read = seq_read,
199         .write = hotkey_write_config,
200         .llseek = seq_lseek,
201         .release = single_release,
202 };
203
204 /* hotkey driver info */
205 static struct file_operations hotkey_info_fops = {
206         .open = hotkey_info_open_fs,
207         .read = seq_read,
208         .llseek = seq_lseek,
209         .release = single_release,
210 };
211
212 /* action */
213 static struct file_operations hotkey_action_fops = {
214         .open = hotkey_action_open_fs,
215         .read = seq_read,
216         .write = hotkey_execute_aml_method,
217         .llseek = seq_lseek,
218         .release = single_release,
219 };
220
221 /* polling results */
222 static struct file_operations hotkey_polling_fops = {
223         .open = hotkey_polling_open_fs,
224         .read = seq_read,
225         .llseek = seq_lseek,
226         .release = single_release,
227 };
228
229 struct acpi_hotkey_list global_hotkey_list;     /* link all ev or pl hotkey  */
230 struct list_head hotkey_entries;        /* head of the list of hotkey_list */
231
232 static int hotkey_info_seq_show(struct seq_file *seq, void *offset)
233 {
234
235         seq_printf(seq, "Hotkey generic driver ver: %s\n", HOTKEY_ACPI_VERSION);
236
237         return 0;
238 }
239
240 static int hotkey_info_open_fs(struct inode *inode, struct file *file)
241 {
242         return single_open(file, hotkey_info_seq_show, PDE(inode)->data);
243 }
244
245 static char *format_result(union acpi_object *object)
246 {
247         char *buf = NULL;
248
249         buf = (char *)kmalloc(RESULT_STR_LEN, GFP_KERNEL);
250         if (buf)
251                 memset(buf, 0, RESULT_STR_LEN);
252         else
253                 goto do_fail;
254
255         /* Now, just support integer type */
256         if (object->type == ACPI_TYPE_INTEGER)
257                 sprintf(buf, "%d\n", (u32) object->integer.value);
258       do_fail:
259         return (buf);
260 }
261
262 static int hotkey_polling_seq_show(struct seq_file *seq, void *offset)
263 {
264         struct acpi_polling_hotkey *poll_hotkey =
265             (struct acpi_polling_hotkey *)seq->private;
266         char *buf;
267
268
269         if (poll_hotkey->poll_result) {
270                 buf = format_result(poll_hotkey->poll_result);
271                 if (buf)
272                         seq_printf(seq, "%s", buf);
273                 kfree(buf);
274         }
275         return 0;
276 }
277
278 static int hotkey_polling_open_fs(struct inode *inode, struct file *file)
279 {
280         return single_open(file, hotkey_polling_seq_show, PDE(inode)->data);
281 }
282
283 static int hotkey_action_open_fs(struct inode *inode, struct file *file)
284 {
285         return single_open(file, hotkey_info_seq_show, PDE(inode)->data);
286 }
287
288 /* Mapping external hotkey number to standardized hotkey event num */
289 static int hotkey_get_internal_event(int event, struct acpi_hotkey_list *list)
290 {
291         struct list_head *entries;
292         int val = -1;
293
294
295         list_for_each(entries, list->entries) {
296                 union acpi_hotkey *key =
297                     container_of(entries, union acpi_hotkey, entries);
298                 if (key->link.hotkey_type == ACPI_HOTKEY_EVENT
299                     && key->event_hotkey.external_hotkey_num == event) {
300                         val = key->link.hotkey_standard_num;
301                         break;
302                 }
303         }
304
305         return val;
306 }
307
308 static void
309 acpi_hotkey_notify_handler(acpi_handle handle, u32 event, void *data)
310 {
311         struct acpi_device *device = NULL;
312         u32 internal_event;
313
314
315         if (acpi_bus_get_device(handle, &device))
316                 return;
317
318         internal_event = hotkey_get_internal_event(event, &global_hotkey_list);
319         acpi_bus_generate_event(device, internal_event, 0);
320
321         return;
322 }
323
324 /* Need to invent automatically hotkey add method */
325 static int auto_hotkey_add(struct acpi_device *device)
326 {
327         /* Implement me */
328         return 0;
329 }
330
331 /* Need to invent automatically hotkey remove method */
332 static int auto_hotkey_remove(struct acpi_device *device, int type)
333 {
334         /* Implement me */
335         return 0;
336 }
337
338 /* Create a proc file for each polling method */
339 static int create_polling_proc(union acpi_hotkey *device)
340 {
341         struct proc_dir_entry *proc;
342         char proc_name[80];
343         mode_t mode;
344
345         mode = S_IFREG | S_IRUGO | S_IWUGO;
346
347         sprintf(proc_name, "%d", device->link.hotkey_standard_num);
348         /*
349            strcat(proc_name, device->poll_hotkey.poll_method);
350          */
351         proc = create_proc_entry(proc_name, mode, hotkey_proc_dir);
352
353         if (!proc) {
354                 return -ENODEV;
355         } else {
356                 proc->proc_fops = &hotkey_polling_fops;
357                 proc->owner = THIS_MODULE;
358                 proc->data = device;
359                 proc->uid = 0;
360                 proc->gid = 0;
361                 device->poll_hotkey.proc = proc;
362         }
363         return 0;
364 }
365
366 static int hotkey_add(union acpi_hotkey *device)
367 {
368         int status = 0;
369         struct acpi_device *dev = NULL;
370
371
372         if (device->link.hotkey_type == ACPI_HOTKEY_EVENT) {
373                 acpi_bus_get_device(device->event_hotkey.bus_handle, &dev);
374                 status = acpi_install_notify_handler(dev->handle,
375                                                      ACPI_DEVICE_NOTIFY,
376                                                      acpi_hotkey_notify_handler,
377                                                      dev);
378         } else                  /* Add polling hotkey */
379                 create_polling_proc(device);
380
381         global_hotkey_list.count++;
382
383         list_add_tail(&device->link.entries, global_hotkey_list.entries);
384
385         return status;
386 }
387
388 static int hotkey_remove(union acpi_hotkey *device)
389 {
390         struct list_head *entries, *next;
391
392
393         list_for_each_safe(entries, next, global_hotkey_list.entries) {
394                 union acpi_hotkey *key =
395                     container_of(entries, union acpi_hotkey, entries);
396                 if (key->link.hotkey_standard_num ==
397                     device->link.hotkey_standard_num) {
398                         list_del(&key->link.entries);
399                         free_hotkey_device(key);
400                         global_hotkey_list.count--;
401                         break;
402                 }
403         }
404         kfree(device);
405         return 0;
406 }
407
408 static int hotkey_update(union acpi_hotkey *key)
409 {
410         struct list_head *entries;
411
412
413         list_for_each(entries, global_hotkey_list.entries) {
414                 union acpi_hotkey *tmp =
415                     container_of(entries, union acpi_hotkey, entries);
416                 if (tmp->link.hotkey_standard_num ==
417                     key->link.hotkey_standard_num) {
418                         if (key->link.hotkey_type == ACPI_HOTKEY_EVENT) {
419                                 free_hotkey_buffer(tmp);
420                                 tmp->event_hotkey.bus_handle =
421                                     key->event_hotkey.bus_handle;
422                                 tmp->event_hotkey.external_hotkey_num =
423                                     key->event_hotkey.external_hotkey_num;
424                                 tmp->event_hotkey.action_handle =
425                                     key->event_hotkey.action_handle;
426                                 tmp->event_hotkey.action_method =
427                                     key->event_hotkey.action_method;
428                                 kfree(key);
429                         } else {
430                                 /*
431                                    char  proc_name[80];
432
433                                    sprintf(proc_name, "%d", tmp->link.hotkey_standard_num);
434                                    strcat(proc_name, tmp->poll_hotkey.poll_method);
435                                    remove_proc_entry(proc_name,hotkey_proc_dir);
436                                  */
437                                 free_poll_hotkey_buffer(tmp);
438                                 tmp->poll_hotkey.poll_handle =
439                                     key->poll_hotkey.poll_handle;
440                                 tmp->poll_hotkey.poll_method =
441                                     key->poll_hotkey.poll_method;
442                                 tmp->poll_hotkey.action_handle =
443                                     key->poll_hotkey.action_handle;
444                                 tmp->poll_hotkey.action_method =
445                                     key->poll_hotkey.action_method;
446                                 tmp->poll_hotkey.poll_result =
447                                     key->poll_hotkey.poll_result;
448                                 /*
449                                    create_polling_proc(tmp);
450                                  */
451                                 kfree(key);
452                         }
453                         return 0;
454                         break;
455                 }
456         }
457
458         return -ENODEV;
459 }
460
461 static void free_hotkey_device(union acpi_hotkey *key)
462 {
463         struct acpi_device *dev;
464
465
466         if (key->link.hotkey_type == ACPI_HOTKEY_EVENT) {
467                 acpi_bus_get_device(key->event_hotkey.bus_handle, &dev);
468                 if (dev->handle)
469                         acpi_remove_notify_handler(dev->handle,
470                                                    ACPI_DEVICE_NOTIFY,
471                                                    acpi_hotkey_notify_handler);
472                 free_hotkey_buffer(key);
473         } else {
474                 char proc_name[80];
475
476                 sprintf(proc_name, "%d", key->link.hotkey_standard_num);
477                 /*
478                    strcat(proc_name, key->poll_hotkey.poll_method);
479                  */
480                 remove_proc_entry(proc_name, hotkey_proc_dir);
481                 free_poll_hotkey_buffer(key);
482         }
483         kfree(key);
484         return;
485 }
486
487 static void free_hotkey_buffer(union acpi_hotkey *key)
488 {
489         kfree(key->event_hotkey.action_method);
490 }
491
492 static void free_poll_hotkey_buffer(union acpi_hotkey *key)
493 {
494         kfree(key->poll_hotkey.action_method);
495         kfree(key->poll_hotkey.poll_method);
496         kfree(key->poll_hotkey.poll_result);
497 }
498 static int
499 init_hotkey_device(union acpi_hotkey *key, char *bus_str, char *action_str,
500                    char *method, int std_num, int external_num)
501 {
502         acpi_handle tmp_handle;
503         acpi_status status = AE_OK;
504
505
506         if (std_num < 0 || IS_POLL(std_num) || !key)
507                 goto do_fail;
508
509         if (!bus_str || !action_str || !method)
510                 goto do_fail;
511
512         key->link.hotkey_type = ACPI_HOTKEY_EVENT;
513         key->link.hotkey_standard_num = std_num;
514         key->event_hotkey.flag = 0;
515         key->event_hotkey.action_method = method;
516
517         status =
518             acpi_get_handle(NULL, bus_str, &(key->event_hotkey.bus_handle));
519         if (ACPI_FAILURE(status))
520                 goto do_fail;
521         key->event_hotkey.external_hotkey_num = external_num;
522         status =
523             acpi_get_handle(NULL, action_str,
524                             &(key->event_hotkey.action_handle));
525         if (ACPI_FAILURE(status))
526                 goto do_fail;
527         status = acpi_get_handle(key->event_hotkey.action_handle,
528                                  method, &tmp_handle);
529         if (ACPI_FAILURE(status))
530                 goto do_fail;
531         return AE_OK;
532       do_fail:
533         return -ENODEV;
534 }
535
536 static int
537 init_poll_hotkey_device(union acpi_hotkey *key,
538                         char *poll_str,
539                         char *poll_method,
540                         char *action_str, char *action_method, int std_num)
541 {
542         acpi_status status = AE_OK;
543         acpi_handle tmp_handle;
544
545
546         if (std_num < 0 || IS_EVENT(std_num) || !key)
547                 goto do_fail;
548
549         if (!poll_str || !poll_method || !action_str || !action_method)
550                 goto do_fail;
551
552         key->link.hotkey_type = ACPI_HOTKEY_POLLING;
553         key->link.hotkey_standard_num = std_num;
554         key->poll_hotkey.flag = 0;
555         key->poll_hotkey.poll_method = poll_method;
556         key->poll_hotkey.action_method = action_method;
557
558         status =
559             acpi_get_handle(NULL, poll_str, &(key->poll_hotkey.poll_handle));
560         if (ACPI_FAILURE(status))
561                 goto do_fail;
562         status = acpi_get_handle(key->poll_hotkey.poll_handle,
563                                  poll_method, &tmp_handle);
564         if (ACPI_FAILURE(status))
565                 goto do_fail;
566         status =
567             acpi_get_handle(NULL, action_str,
568                             &(key->poll_hotkey.action_handle));
569         if (ACPI_FAILURE(status))
570                 goto do_fail;
571         status = acpi_get_handle(key->poll_hotkey.action_handle,
572                                  action_method, &tmp_handle);
573         if (ACPI_FAILURE(status))
574                 goto do_fail;
575         key->poll_hotkey.poll_result =
576             (union acpi_object *)kmalloc(sizeof(union acpi_object), GFP_KERNEL);
577         if (!key->poll_hotkey.poll_result)
578                 goto do_fail;
579         return AE_OK;
580       do_fail:
581         return -ENODEV;
582 }
583
584 static int hotkey_open_config(struct inode *inode, struct file *file)
585 {
586         return (single_open
587                      (file, hotkey_config_seq_show, PDE(inode)->data));
588 }
589
590 static int hotkey_poll_open_config(struct inode *inode, struct file *file)
591 {
592         return (single_open
593                      (file, hotkey_poll_config_seq_show, PDE(inode)->data));
594 }
595
596 static int hotkey_config_seq_show(struct seq_file *seq, void *offset)
597 {
598         struct acpi_hotkey_list *hotkey_list = &global_hotkey_list;
599         struct list_head *entries;
600         char bus_name[ACPI_PATHNAME_MAX] = { 0 };
601         char action_name[ACPI_PATHNAME_MAX] = { 0 };
602         struct acpi_buffer bus = { ACPI_PATHNAME_MAX, bus_name };
603         struct acpi_buffer act = { ACPI_PATHNAME_MAX, action_name };
604
605
606         list_for_each(entries, hotkey_list->entries) {
607                 union acpi_hotkey *key =
608                     container_of(entries, union acpi_hotkey, entries);
609                 if (key->link.hotkey_type == ACPI_HOTKEY_EVENT) {
610                         acpi_get_name(key->event_hotkey.bus_handle,
611                                       ACPI_NAME_TYPE_MAX, &bus);
612                         acpi_get_name(key->event_hotkey.action_handle,
613                                       ACPI_NAME_TYPE_MAX, &act);
614                         seq_printf(seq, "%s:%s:%s:%d:%d\n", bus_name,
615                                    action_name,
616                                    key->event_hotkey.action_method,
617                                    key->link.hotkey_standard_num,
618                                    key->event_hotkey.external_hotkey_num);
619                 }
620         }
621         seq_puts(seq, "\n");
622         return 0;
623 }
624
625 static int hotkey_poll_config_seq_show(struct seq_file *seq, void *offset)
626 {
627         struct acpi_hotkey_list *hotkey_list = &global_hotkey_list;
628         struct list_head *entries;
629         char bus_name[ACPI_PATHNAME_MAX] = { 0 };
630         char action_name[ACPI_PATHNAME_MAX] = { 0 };
631         struct acpi_buffer bus = { ACPI_PATHNAME_MAX, bus_name };
632         struct acpi_buffer act = { ACPI_PATHNAME_MAX, action_name };
633
634
635         list_for_each(entries, hotkey_list->entries) {
636                 union acpi_hotkey *key =
637                     container_of(entries, union acpi_hotkey, entries);
638                 if (key->link.hotkey_type == ACPI_HOTKEY_POLLING) {
639                         acpi_get_name(key->poll_hotkey.poll_handle,
640                                       ACPI_NAME_TYPE_MAX, &bus);
641                         acpi_get_name(key->poll_hotkey.action_handle,
642                                       ACPI_NAME_TYPE_MAX, &act);
643                         seq_printf(seq, "%s:%s:%s:%s:%d\n", bus_name,
644                                    key->poll_hotkey.poll_method,
645                                    action_name,
646                                    key->poll_hotkey.action_method,
647                                    key->link.hotkey_standard_num);
648                 }
649         }
650         seq_puts(seq, "\n");
651         return 0;
652 }
653
654 static int
655 get_parms(char *config_record,
656           int *cmd,
657           char **bus_handle,
658           char **bus_method,
659           char **action_handle,
660           char **method, int *internal_event_num, int *external_event_num)
661 {
662         char *tmp, *tmp1, count;
663
664         sscanf(config_record, "%d", cmd);
665
666         if (*cmd == 1) {
667                 if (sscanf(config_record, "%d:%d", cmd, internal_event_num) !=
668                     2)
669                         goto do_fail;
670                 else
671                         return (6);
672         }
673         tmp = strchr(config_record, ':');
674         if (!tmp)
675                 goto do_fail;
676         tmp++;
677         tmp1 = strchr(tmp, ':');
678         if (!tmp1)
679                 goto do_fail;
680
681         count = tmp1 - tmp;
682         *bus_handle = (char *)kmalloc(count + 1, GFP_KERNEL);
683         if (!*bus_handle)
684                 goto do_fail;
685         strncpy(*bus_handle, tmp, count);
686         *(*bus_handle + count) = 0;
687
688         tmp = tmp1;
689         tmp++;
690         tmp1 = strchr(tmp, ':');
691         if (!tmp1)
692                 goto do_fail;
693         count = tmp1 - tmp;
694         *bus_method = (char *)kmalloc(count + 1, GFP_KERNEL);
695         if (!*bus_method)
696                 goto do_fail;
697         strncpy(*bus_method, tmp, count);
698         *(*bus_method + count) = 0;
699
700         tmp = tmp1;
701         tmp++;
702         tmp1 = strchr(tmp, ':');
703         if (!tmp1)
704                 goto do_fail;
705         count = tmp1 - tmp;
706         *action_handle = (char *)kmalloc(count + 1, GFP_KERNEL);
707         if (!*action_handle)
708                 goto do_fail;
709         strncpy(*action_handle, tmp, count);
710         *(*action_handle + count) = 0;
711
712         tmp = tmp1;
713         tmp++;
714         tmp1 = strchr(tmp, ':');
715         if (!tmp1)
716                 goto do_fail;
717         count = tmp1 - tmp;
718         *method = (char *)kmalloc(count + 1, GFP_KERNEL);
719         if (!*method)
720                 goto do_fail;
721         strncpy(*method, tmp, count);
722         *(*method + count) = 0;
723
724         if (sscanf(tmp1 + 1, "%d:%d", internal_event_num, external_event_num) <=
725             0)
726                 goto do_fail;
727
728         return 6;
729       do_fail:
730         return -1;
731 }
732
733 /*  count is length for one input record */
734 static ssize_t hotkey_write_config(struct file *file,
735                                    const char __user * buffer,
736                                    size_t count, loff_t * data)
737 {
738         char *config_record = NULL;
739         char *bus_handle = NULL;
740         char *bus_method = NULL;
741         char *action_handle = NULL;
742         char *method = NULL;
743         int cmd, internal_event_num, external_event_num;
744         int ret = 0;
745         union acpi_hotkey *key = NULL;
746
747
748         config_record = (char *)kmalloc(count + 1, GFP_KERNEL);
749         if (!config_record)
750                 return -ENOMEM;
751
752         if (copy_from_user(config_record, buffer, count)) {
753                 kfree(config_record);
754                 printk(KERN_ERR PREFIX "Invalid data\n");
755                 return -EINVAL;
756         }
757         config_record[count] = 0;
758
759         ret = get_parms(config_record,
760                         &cmd,
761                         &bus_handle,
762                         &bus_method,
763                         &action_handle,
764                         &method, &internal_event_num, &external_event_num);
765
766         kfree(config_record);
767         if (IS_OTHERS(internal_event_num))
768                 goto do_fail;
769         if (ret != 6) {
770               do_fail:
771                 kfree(bus_handle);
772                 kfree(bus_method);
773                 kfree(action_handle);
774                 kfree(method);
775                 printk(KERN_ERR PREFIX "Invalid data format ret=%d\n", ret);
776                 return -EINVAL;
777         }
778
779         key = kmalloc(sizeof(union acpi_hotkey), GFP_KERNEL);
780         if (!key)
781                 goto do_fail;
782         memset(key, 0, sizeof(union acpi_hotkey));
783         if (cmd == 1) {
784                 union acpi_hotkey *tmp = NULL;
785                 tmp = get_hotkey_by_event(&global_hotkey_list,
786                                           internal_event_num);
787                 if (!tmp)
788                         printk(KERN_ERR PREFIX "Invalid key\n");
789                 else
790                         memcpy(key, tmp, sizeof(union acpi_hotkey));
791                 goto cont_cmd;
792         }
793         if (IS_EVENT(internal_event_num)) {
794                 kfree(bus_method);
795                 ret = init_hotkey_device(key, bus_handle, action_handle, method,
796                                          internal_event_num,
797                                          external_event_num);
798         } else
799                 ret = init_poll_hotkey_device(key, bus_handle, bus_method,
800                                               action_handle, method,
801                                               internal_event_num);
802         if (ret) {
803                 kfree(bus_handle);
804                 kfree(action_handle);
805                 if (IS_EVENT(internal_event_num))
806                         free_hotkey_buffer(key);
807                 else
808                         free_poll_hotkey_buffer(key);
809                 kfree(key);
810                 printk(KERN_ERR PREFIX "Invalid hotkey\n");
811                 return -EINVAL;
812         }
813
814       cont_cmd:
815         kfree(bus_handle);
816         kfree(action_handle);
817
818         switch (cmd) {
819         case 0:
820                 if (get_hotkey_by_event
821                     (&global_hotkey_list, key->link.hotkey_standard_num))
822                         goto fail_out;
823                 else
824                         hotkey_add(key);
825                 break;
826         case 1:
827                 hotkey_remove(key);
828                 break;
829         case 2:
830                 if (hotkey_update(key))
831                         goto fail_out;
832                 break;
833         default:
834                 goto fail_out;
835                 break;
836         }
837         return count;
838       fail_out:
839         if (IS_EVENT(internal_event_num))
840                 free_hotkey_buffer(key);
841         else
842                 free_poll_hotkey_buffer(key);
843         kfree(key);
844         printk(KERN_ERR PREFIX "invalid key\n");
845         return -EINVAL;
846 }
847
848 /*
849  * This function evaluates an ACPI method, given an int as parameter, the
850  * method is searched within the scope of the handle, can be NULL. The output
851  * of the method is written is output, which can also be NULL
852  *
853  * returns 1 if write is successful, 0 else.
854  */
855 static int write_acpi_int(acpi_handle handle, const char *method, int val,
856                           struct acpi_buffer *output)
857 {
858         struct acpi_object_list params; /* list of input parameters (an int here) */
859         union acpi_object in_obj;       /* the only param we use */
860         acpi_status status;
861
862         params.count = 1;
863         params.pointer = &in_obj;
864         in_obj.type = ACPI_TYPE_INTEGER;
865         in_obj.integer.value = val;
866
867         status = acpi_evaluate_object(handle, (char *)method, &params, output);
868
869         return (status == AE_OK);
870 }
871
872 static int read_acpi_int(acpi_handle handle, const char *method,
873                          union acpi_object *val)
874 {
875         struct acpi_buffer output;
876         union acpi_object out_obj;
877         acpi_status status;
878
879         output.length = sizeof(out_obj);
880         output.pointer = &out_obj;
881
882         status = acpi_evaluate_object(handle, (char *)method, NULL, &output);
883         if (val) {
884                 val->integer.value = out_obj.integer.value;
885                 val->type = out_obj.type;
886         } else
887                 printk(KERN_ERR PREFIX "null val pointer\n");
888         return ((status == AE_OK)
889                      && (out_obj.type == ACPI_TYPE_INTEGER));
890 }
891
892 static union acpi_hotkey *get_hotkey_by_event(struct
893                                               acpi_hotkey_list
894                                               *hotkey_list, int event)
895 {
896         struct list_head *entries;
897
898         list_for_each(entries, hotkey_list->entries) {
899                 union acpi_hotkey *key =
900                     container_of(entries, union acpi_hotkey, entries);
901                 if (key->link.hotkey_standard_num == event) {
902                         return (key);
903                 }
904         }
905         return (NULL);
906 }
907
908 /*
909  * user call AML method interface:
910  * Call convention:
911  * echo "event_num: arg type : value"
912  * example: echo "1:1:30" > /proc/acpi/action
913  * Just support 1 integer arg passing to AML method
914  */
915
916 static ssize_t hotkey_execute_aml_method(struct file *file,
917                                          const char __user * buffer,
918                                          size_t count, loff_t * data)
919 {
920         struct acpi_hotkey_list *hotkey_list = &global_hotkey_list;
921         char *arg;
922         int event, method_type, type, value;
923         union acpi_hotkey *key;
924
925
926         arg = (char *)kmalloc(count + 1, GFP_KERNEL);
927         if (!arg)
928                 return -ENOMEM;
929         arg[count] = 0;
930
931         if (copy_from_user(arg, buffer, count)) {
932                 kfree(arg);
933                 printk(KERN_ERR PREFIX "Invalid argument 2\n");
934                 return -EINVAL;
935         }
936
937         if (sscanf(arg, "%d:%d:%d:%d", &event, &method_type, &type, &value) !=
938             4) {
939                 kfree(arg);
940                 printk(KERN_ERR PREFIX "Invalid argument 3\n");
941                 return -EINVAL;
942         }
943         kfree(arg);
944         if (type == ACPI_TYPE_INTEGER) {
945                 key = get_hotkey_by_event(hotkey_list, event);
946                 if (!key)
947                         goto do_fail;
948                 if (IS_EVENT(event))
949                         write_acpi_int(key->event_hotkey.action_handle,
950                                        key->event_hotkey.action_method, value,
951                                        NULL);
952                 else if (IS_POLL(event)) {
953                         if (method_type == POLL_METHOD)
954                                 read_acpi_int(key->poll_hotkey.poll_handle,
955                                               key->poll_hotkey.poll_method,
956                                               key->poll_hotkey.poll_result);
957                         else if (method_type == ACTION_METHOD)
958                                 write_acpi_int(key->poll_hotkey.action_handle,
959                                                key->poll_hotkey.action_method,
960                                                value, NULL);
961                         else
962                                 goto do_fail;
963
964                 }
965         } else {
966                 printk(KERN_WARNING "Not supported\n");
967                 return -EINVAL;
968         }
969         return count;
970       do_fail:
971         return -EINVAL;
972
973 }
974
975 static int __init hotkey_init(void)
976 {
977         int result;
978         mode_t mode = S_IFREG | S_IRUGO | S_IWUGO;
979
980
981         if (acpi_disabled)
982                 return -ENODEV;
983
984         if (acpi_specific_hotkey_enabled) {
985                 printk("Using specific hotkey driver\n");
986                 return -ENODEV;
987         }
988
989         hotkey_proc_dir = proc_mkdir(HOTKEY_PROC, acpi_root_dir);
990         if (!hotkey_proc_dir) {
991                 return (-ENODEV);
992         }
993         hotkey_proc_dir->owner = THIS_MODULE;
994
995         hotkey_config =
996             create_proc_entry(HOTKEY_EV_CONFIG, mode, hotkey_proc_dir);
997         if (!hotkey_config) {
998                 goto do_fail1;
999         } else {
1000                 hotkey_config->proc_fops = &hotkey_config_fops;
1001                 hotkey_config->data = &global_hotkey_list;
1002                 hotkey_config->owner = THIS_MODULE;
1003                 hotkey_config->uid = 0;
1004                 hotkey_config->gid = 0;
1005         }
1006
1007         hotkey_poll_config =
1008             create_proc_entry(HOTKEY_PL_CONFIG, mode, hotkey_proc_dir);
1009         if (!hotkey_poll_config) {
1010                 goto do_fail2;
1011         } else {
1012                 hotkey_poll_config->proc_fops = &hotkey_poll_config_fops;
1013                 hotkey_poll_config->data = &global_hotkey_list;
1014                 hotkey_poll_config->owner = THIS_MODULE;
1015                 hotkey_poll_config->uid = 0;
1016                 hotkey_poll_config->gid = 0;
1017         }
1018
1019         hotkey_action = create_proc_entry(HOTKEY_ACTION, mode, hotkey_proc_dir);
1020         if (!hotkey_action) {
1021                 goto do_fail3;
1022         } else {
1023                 hotkey_action->proc_fops = &hotkey_action_fops;
1024                 hotkey_action->owner = THIS_MODULE;
1025                 hotkey_action->uid = 0;
1026                 hotkey_action->gid = 0;
1027         }
1028
1029         hotkey_info = create_proc_entry(HOTKEY_INFO, mode, hotkey_proc_dir);
1030         if (!hotkey_info) {
1031                 goto do_fail4;
1032         } else {
1033                 hotkey_info->proc_fops = &hotkey_info_fops;
1034                 hotkey_info->owner = THIS_MODULE;
1035                 hotkey_info->uid = 0;
1036                 hotkey_info->gid = 0;
1037         }
1038
1039         result = acpi_bus_register_driver(&hotkey_driver);
1040         if (result < 0)
1041                 goto do_fail5;
1042         global_hotkey_list.count = 0;
1043         global_hotkey_list.entries = &hotkey_entries;
1044
1045         INIT_LIST_HEAD(&hotkey_entries);
1046
1047         return (0);
1048
1049       do_fail5:
1050         remove_proc_entry(HOTKEY_INFO, hotkey_proc_dir);
1051       do_fail4:
1052         remove_proc_entry(HOTKEY_ACTION, hotkey_proc_dir);
1053       do_fail3:
1054         remove_proc_entry(HOTKEY_PL_CONFIG, hotkey_proc_dir);
1055       do_fail2:
1056         remove_proc_entry(HOTKEY_EV_CONFIG, hotkey_proc_dir);
1057       do_fail1:
1058         remove_proc_entry(HOTKEY_PROC, acpi_root_dir);
1059         return (-ENODEV);
1060 }
1061
1062 static void __exit hotkey_exit(void)
1063 {
1064         struct list_head *entries, *next;
1065
1066
1067         list_for_each_safe(entries, next, global_hotkey_list.entries) {
1068                 union acpi_hotkey *key =
1069                     container_of(entries, union acpi_hotkey, entries);
1070
1071                 acpi_os_wait_events_complete(NULL);
1072                 list_del(&key->link.entries);
1073                 global_hotkey_list.count--;
1074                 free_hotkey_device(key);
1075         }
1076         acpi_bus_unregister_driver(&hotkey_driver);
1077         remove_proc_entry(HOTKEY_EV_CONFIG, hotkey_proc_dir);
1078         remove_proc_entry(HOTKEY_PL_CONFIG, hotkey_proc_dir);
1079         remove_proc_entry(HOTKEY_ACTION, hotkey_proc_dir);
1080         remove_proc_entry(HOTKEY_INFO, hotkey_proc_dir);
1081         remove_proc_entry(HOTKEY_PROC, acpi_root_dir);
1082         return;
1083 }
1084
1085 module_init(hotkey_init);
1086 module_exit(hotkey_exit);