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