Pull bugzilla-5737 into release branch
[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 /*  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         ACPI_FUNCTION_TRACE("hotkey_info_seq_show");
235
236         seq_printf(seq, "Hotkey generic driver ver: %s\n", HOTKEY_ACPI_VERSION);
237
238         return_VALUE(0);
239 }
240
241 static int hotkey_info_open_fs(struct inode *inode, struct file *file)
242 {
243         return single_open(file, hotkey_info_seq_show, PDE(inode)->data);
244 }
245
246 static char *format_result(union acpi_object *object)
247 {
248         char *buf = NULL;
249
250         buf = (char *)kmalloc(RESULT_STR_LEN, GFP_KERNEL);
251         if (buf)
252                 memset(buf, 0, RESULT_STR_LEN);
253         else
254                 goto do_fail;
255
256         /* Now, just support integer type */
257         if (object->type == ACPI_TYPE_INTEGER)
258                 sprintf(buf, "%d\n", (u32) object->integer.value);
259       do_fail:
260         return (buf);
261 }
262
263 static int hotkey_polling_seq_show(struct seq_file *seq, void *offset)
264 {
265         struct acpi_polling_hotkey *poll_hotkey =
266             (struct acpi_polling_hotkey *)seq->private;
267         char *buf;
268
269         ACPI_FUNCTION_TRACE("hotkey_polling_seq_show");
270
271         if (poll_hotkey->poll_result) {
272                 buf = format_result(poll_hotkey->poll_result);
273                 if (buf)
274                         seq_printf(seq, "%s", buf);
275                 kfree(buf);
276         }
277         return_VALUE(0);
278 }
279
280 static int hotkey_polling_open_fs(struct inode *inode, struct file *file)
281 {
282         return single_open(file, hotkey_polling_seq_show, PDE(inode)->data);
283 }
284
285 static int hotkey_action_open_fs(struct inode *inode, struct file *file)
286 {
287         return single_open(file, hotkey_info_seq_show, PDE(inode)->data);
288 }
289
290 /* Mapping external hotkey number to standardized hotkey event num */
291 static int hotkey_get_internal_event(int event, struct acpi_hotkey_list *list)
292 {
293         struct list_head *entries;
294         int val = -1;
295
296         ACPI_FUNCTION_TRACE("hotkey_get_internal_event");
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_VALUE(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         ACPI_FUNCTION_TRACE("acpi_hotkey_notify_handler");
318
319         if (acpi_bus_get_device(handle, &device))
320                 return_VOID;
321
322         internal_event = hotkey_get_internal_event(event, &global_hotkey_list);
323         acpi_bus_generate_event(device, internal_event, 0);
324
325         return_VOID;
326 }
327
328 /* Need to invent automatically hotkey add method */
329 static int auto_hotkey_add(struct acpi_device *device)
330 {
331         /* Implement me */
332         return 0;
333 }
334
335 /* Need to invent automatically hotkey remove method */
336 static int auto_hotkey_remove(struct acpi_device *device, int type)
337 {
338         /* Implement me */
339         return 0;
340 }
341
342 /* Create a proc file for each polling method */
343 static int create_polling_proc(union acpi_hotkey *device)
344 {
345         struct proc_dir_entry *proc;
346         char proc_name[80];
347         mode_t mode;
348
349         ACPI_FUNCTION_TRACE("create_polling_proc");
350         mode = S_IFREG | S_IRUGO | S_IWUGO;
351
352         sprintf(proc_name, "%d", device->link.hotkey_standard_num);
353         /*
354            strcat(proc_name, device->poll_hotkey.poll_method);
355          */
356         proc = create_proc_entry(proc_name, mode, hotkey_proc_dir);
357
358         if (!proc) {
359                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
360                                   "Hotkey: Unable to create %s entry\n",
361                                   device->poll_hotkey.poll_method));
362                 return_VALUE(-ENODEV);
363         } else {
364                 proc->proc_fops = &hotkey_polling_fops;
365                 proc->owner = THIS_MODULE;
366                 proc->data = device;
367                 proc->uid = 0;
368                 proc->gid = 0;
369                 device->poll_hotkey.proc = proc;
370         }
371         return_VALUE(0);
372 }
373
374 static int hotkey_add(union acpi_hotkey *device)
375 {
376         int status = 0;
377         struct acpi_device *dev = NULL;
378
379         ACPI_FUNCTION_TRACE("hotkey_add");
380
381         if (device->link.hotkey_type == ACPI_HOTKEY_EVENT) {
382                 acpi_bus_get_device(device->event_hotkey.bus_handle, &dev);
383                 status = acpi_install_notify_handler(dev->handle,
384                                                      ACPI_DEVICE_NOTIFY,
385                                                      acpi_hotkey_notify_handler,
386                                                      dev);
387         } else                  /* Add polling hotkey */
388                 create_polling_proc(device);
389
390         global_hotkey_list.count++;
391
392         list_add_tail(&device->link.entries, global_hotkey_list.entries);
393
394         return_VALUE(status);
395 }
396
397 static int hotkey_remove(union acpi_hotkey *device)
398 {
399         struct list_head *entries, *next;
400
401         ACPI_FUNCTION_TRACE("hotkey_remove");
402
403         list_for_each_safe(entries, next, global_hotkey_list.entries) {
404                 union acpi_hotkey *key =
405                     container_of(entries, union acpi_hotkey, entries);
406                 if (key->link.hotkey_standard_num ==
407                     device->link.hotkey_standard_num) {
408                         list_del(&key->link.entries);
409                         free_hotkey_device(key);
410                         global_hotkey_list.count--;
411                         break;
412                 }
413         }
414         kfree(device);
415         return_VALUE(0);
416 }
417
418 static int hotkey_update(union acpi_hotkey *key)
419 {
420         struct list_head *entries;
421
422         ACPI_FUNCTION_TRACE("hotkey_update");
423
424         list_for_each(entries, global_hotkey_list.entries) {
425                 union acpi_hotkey *tmp =
426                     container_of(entries, union acpi_hotkey, entries);
427                 if (tmp->link.hotkey_standard_num ==
428                     key->link.hotkey_standard_num) {
429                         if (key->link.hotkey_type == ACPI_HOTKEY_EVENT) {
430                                 free_hotkey_buffer(tmp);
431                                 tmp->event_hotkey.bus_handle =
432                                     key->event_hotkey.bus_handle;
433                                 tmp->event_hotkey.external_hotkey_num =
434                                     key->event_hotkey.external_hotkey_num;
435                                 tmp->event_hotkey.action_handle =
436                                     key->event_hotkey.action_handle;
437                                 tmp->event_hotkey.action_method =
438                                     key->event_hotkey.action_method;
439                                 kfree(key);
440                         } else {
441                                 /*
442                                    char  proc_name[80];
443
444                                    sprintf(proc_name, "%d", tmp->link.hotkey_standard_num);
445                                    strcat(proc_name, tmp->poll_hotkey.poll_method);
446                                    remove_proc_entry(proc_name,hotkey_proc_dir);
447                                  */
448                                 free_poll_hotkey_buffer(tmp);
449                                 tmp->poll_hotkey.poll_handle =
450                                     key->poll_hotkey.poll_handle;
451                                 tmp->poll_hotkey.poll_method =
452                                     key->poll_hotkey.poll_method;
453                                 tmp->poll_hotkey.action_handle =
454                                     key->poll_hotkey.action_handle;
455                                 tmp->poll_hotkey.action_method =
456                                     key->poll_hotkey.action_method;
457                                 tmp->poll_hotkey.poll_result =
458                                     key->poll_hotkey.poll_result;
459                                 /*
460                                    create_polling_proc(tmp);
461                                  */
462                                 kfree(key);
463                         }
464                         return_VALUE(0);
465                         break;
466                 }
467         }
468
469         return_VALUE(-ENODEV);
470 }
471
472 static void free_hotkey_device(union acpi_hotkey *key)
473 {
474         struct acpi_device *dev;
475
476         ACPI_FUNCTION_TRACE("free_hotkey_device");
477
478         if (key->link.hotkey_type == ACPI_HOTKEY_EVENT) {
479                 acpi_bus_get_device(key->event_hotkey.bus_handle, &dev);
480                 if (dev->handle)
481                         acpi_remove_notify_handler(dev->handle,
482                                                    ACPI_DEVICE_NOTIFY,
483                                                    acpi_hotkey_notify_handler);
484                 free_hotkey_buffer(key);
485         } else {
486                 char proc_name[80];
487
488                 sprintf(proc_name, "%d", key->link.hotkey_standard_num);
489                 /*
490                    strcat(proc_name, key->poll_hotkey.poll_method);
491                  */
492                 remove_proc_entry(proc_name, hotkey_proc_dir);
493                 free_poll_hotkey_buffer(key);
494         }
495         kfree(key);
496         return_VOID;
497 }
498
499 static void free_hotkey_buffer(union acpi_hotkey *key)
500 {
501         kfree(key->event_hotkey.action_method);
502 }
503
504 static void free_poll_hotkey_buffer(union acpi_hotkey *key)
505 {
506         kfree(key->poll_hotkey.action_method);
507         kfree(key->poll_hotkey.poll_method);
508         kfree(key->poll_hotkey.poll_result);
509 }
510 static int
511 init_hotkey_device(union acpi_hotkey *key, char *bus_str, char *action_str,
512                    char *method, int std_num, int external_num)
513 {
514         acpi_handle tmp_handle;
515         acpi_status status = AE_OK;
516
517         ACPI_FUNCTION_TRACE("init_hotkey_device");
518
519         if (std_num < 0 || IS_POLL(std_num) || !key)
520                 goto do_fail;
521
522         if (!bus_str || !action_str || !method)
523                 goto do_fail;
524
525         key->link.hotkey_type = ACPI_HOTKEY_EVENT;
526         key->link.hotkey_standard_num = std_num;
527         key->event_hotkey.flag = 0;
528         key->event_hotkey.action_method = method;
529
530         status =
531             acpi_get_handle(NULL, bus_str, &(key->event_hotkey.bus_handle));
532         if (ACPI_FAILURE(status))
533                 goto do_fail;
534         key->event_hotkey.external_hotkey_num = external_num;
535         status =
536             acpi_get_handle(NULL, action_str,
537                             &(key->event_hotkey.action_handle));
538         if (ACPI_FAILURE(status))
539                 goto do_fail;
540         status = acpi_get_handle(key->event_hotkey.action_handle,
541                                  method, &tmp_handle);
542         if (ACPI_FAILURE(status))
543                 goto do_fail;
544         return_VALUE(AE_OK);
545       do_fail:
546         return_VALUE(-ENODEV);
547 }
548
549 static int
550 init_poll_hotkey_device(union acpi_hotkey *key,
551                         char *poll_str,
552                         char *poll_method,
553                         char *action_str, char *action_method, int std_num)
554 {
555         acpi_status status = AE_OK;
556         acpi_handle tmp_handle;
557
558         ACPI_FUNCTION_TRACE("init_poll_hotkey_device");
559
560         if (std_num < 0 || IS_EVENT(std_num) || !key)
561                 goto do_fail;
562
563         if (!poll_str || !poll_method || !action_str || !action_method)
564                 goto do_fail;
565
566         key->link.hotkey_type = ACPI_HOTKEY_POLLING;
567         key->link.hotkey_standard_num = std_num;
568         key->poll_hotkey.flag = 0;
569         key->poll_hotkey.poll_method = poll_method;
570         key->poll_hotkey.action_method = action_method;
571
572         status =
573             acpi_get_handle(NULL, poll_str, &(key->poll_hotkey.poll_handle));
574         if (ACPI_FAILURE(status))
575                 goto do_fail;
576         status = acpi_get_handle(key->poll_hotkey.poll_handle,
577                                  poll_method, &tmp_handle);
578         if (ACPI_FAILURE(status))
579                 goto do_fail;
580         status =
581             acpi_get_handle(NULL, action_str,
582                             &(key->poll_hotkey.action_handle));
583         if (ACPI_FAILURE(status))
584                 goto do_fail;
585         status = acpi_get_handle(key->poll_hotkey.action_handle,
586                                  action_method, &tmp_handle);
587         if (ACPI_FAILURE(status))
588                 goto do_fail;
589         key->poll_hotkey.poll_result =
590             (union acpi_object *)kmalloc(sizeof(union acpi_object), GFP_KERNEL);
591         if (!key->poll_hotkey.poll_result)
592                 goto do_fail;
593         return_VALUE(AE_OK);
594       do_fail:
595         return_VALUE(-ENODEV);
596 }
597
598 static int hotkey_open_config(struct inode *inode, struct file *file)
599 {
600         ACPI_FUNCTION_TRACE("hotkey_open_config");
601         return_VALUE(single_open
602                      (file, hotkey_config_seq_show, PDE(inode)->data));
603 }
604
605 static int hotkey_poll_open_config(struct inode *inode, struct file *file)
606 {
607         ACPI_FUNCTION_TRACE("hotkey_poll_open_config");
608         return_VALUE(single_open
609                      (file, hotkey_poll_config_seq_show, PDE(inode)->data));
610 }
611
612 static int hotkey_config_seq_show(struct seq_file *seq, void *offset)
613 {
614         struct acpi_hotkey_list *hotkey_list = &global_hotkey_list;
615         struct list_head *entries;
616         char bus_name[ACPI_PATHNAME_MAX] = { 0 };
617         char action_name[ACPI_PATHNAME_MAX] = { 0 };
618         struct acpi_buffer bus = { ACPI_PATHNAME_MAX, bus_name };
619         struct acpi_buffer act = { ACPI_PATHNAME_MAX, action_name };
620
621         ACPI_FUNCTION_TRACE(("hotkey_config_seq_show"));
622
623         list_for_each(entries, hotkey_list->entries) {
624                 union acpi_hotkey *key =
625                     container_of(entries, union acpi_hotkey, entries);
626                 if (key->link.hotkey_type == ACPI_HOTKEY_EVENT) {
627                         acpi_get_name(key->event_hotkey.bus_handle,
628                                       ACPI_NAME_TYPE_MAX, &bus);
629                         acpi_get_name(key->event_hotkey.action_handle,
630                                       ACPI_NAME_TYPE_MAX, &act);
631                         seq_printf(seq, "%s:%s:%s:%d:%d\n", bus_name,
632                                    action_name,
633                                    key->event_hotkey.action_method,
634                                    key->link.hotkey_standard_num,
635                                    key->event_hotkey.external_hotkey_num);
636                 }
637         }
638         seq_puts(seq, "\n");
639         return_VALUE(0);
640 }
641
642 static int hotkey_poll_config_seq_show(struct seq_file *seq, void *offset)
643 {
644         struct acpi_hotkey_list *hotkey_list = &global_hotkey_list;
645         struct list_head *entries;
646         char bus_name[ACPI_PATHNAME_MAX] = { 0 };
647         char action_name[ACPI_PATHNAME_MAX] = { 0 };
648         struct acpi_buffer bus = { ACPI_PATHNAME_MAX, bus_name };
649         struct acpi_buffer act = { ACPI_PATHNAME_MAX, action_name };
650
651         ACPI_FUNCTION_TRACE(("hotkey_config_seq_show"));
652
653         list_for_each(entries, hotkey_list->entries) {
654                 union acpi_hotkey *key =
655                     container_of(entries, union acpi_hotkey, entries);
656                 if (key->link.hotkey_type == ACPI_HOTKEY_POLLING) {
657                         acpi_get_name(key->poll_hotkey.poll_handle,
658                                       ACPI_NAME_TYPE_MAX, &bus);
659                         acpi_get_name(key->poll_hotkey.action_handle,
660                                       ACPI_NAME_TYPE_MAX, &act);
661                         seq_printf(seq, "%s:%s:%s:%s:%d\n", bus_name,
662                                    key->poll_hotkey.poll_method,
663                                    action_name,
664                                    key->poll_hotkey.action_method,
665                                    key->link.hotkey_standard_num);
666                 }
667         }
668         seq_puts(seq, "\n");
669         return_VALUE(0);
670 }
671
672 static int
673 get_parms(char *config_record,
674           int *cmd,
675           char **bus_handle,
676           char **bus_method,
677           char **action_handle,
678           char **method, int *internal_event_num, int *external_event_num)
679 {
680         char *tmp, *tmp1, count;
681         ACPI_FUNCTION_TRACE(("get_parms"));
682
683         sscanf(config_record, "%d", cmd);
684
685         if (*cmd == 1) {
686                 if (sscanf(config_record, "%d:%d", cmd, internal_event_num) !=
687                     2)
688                         goto do_fail;
689                 else
690                         return (6);
691         }
692         tmp = strchr(config_record, ':');
693         if (!tmp)
694                 goto do_fail;
695         tmp++;
696         tmp1 = strchr(tmp, ':');
697         if (!tmp1)
698                 goto do_fail;
699
700         count = tmp1 - tmp;
701         *bus_handle = (char *)kmalloc(count + 1, GFP_KERNEL);
702         if (!*bus_handle)
703                 goto do_fail;
704         strncpy(*bus_handle, tmp, count);
705         *(*bus_handle + count) = 0;
706
707         tmp = tmp1;
708         tmp++;
709         tmp1 = strchr(tmp, ':');
710         if (!tmp1)
711                 goto do_fail;
712         count = tmp1 - tmp;
713         *bus_method = (char *)kmalloc(count + 1, GFP_KERNEL);
714         if (!*bus_method)
715                 goto do_fail;
716         strncpy(*bus_method, tmp, count);
717         *(*bus_method + count) = 0;
718
719         tmp = tmp1;
720         tmp++;
721         tmp1 = strchr(tmp, ':');
722         if (!tmp1)
723                 goto do_fail;
724         count = tmp1 - tmp;
725         *action_handle = (char *)kmalloc(count + 1, GFP_KERNEL);
726         if (!*action_handle)
727                 goto do_fail;
728         strncpy(*action_handle, tmp, count);
729         *(*action_handle + count) = 0;
730
731         tmp = tmp1;
732         tmp++;
733         tmp1 = strchr(tmp, ':');
734         if (!tmp1)
735                 goto do_fail;
736         count = tmp1 - tmp;
737         *method = (char *)kmalloc(count + 1, GFP_KERNEL);
738         if (!*method)
739                 goto do_fail;
740         strncpy(*method, tmp, count);
741         *(*method + count) = 0;
742
743         if (sscanf(tmp1 + 1, "%d:%d", internal_event_num, external_event_num) <=
744             0)
745                 goto do_fail;
746
747         return_VALUE(6);
748       do_fail:
749         return_VALUE(-1);
750 }
751
752 /*  count is length for one input record */
753 static ssize_t hotkey_write_config(struct file *file,
754                                    const char __user * buffer,
755                                    size_t count, loff_t * data)
756 {
757         char *config_record = NULL;
758         char *bus_handle = NULL;
759         char *bus_method = NULL;
760         char *action_handle = NULL;
761         char *method = NULL;
762         int cmd, internal_event_num, external_event_num;
763         int ret = 0;
764         union acpi_hotkey *key = NULL;
765
766         ACPI_FUNCTION_TRACE(("hotkey_write_config"));
767
768         config_record = (char *)kmalloc(count + 1, GFP_KERNEL);
769         if (!config_record)
770                 return_VALUE(-ENOMEM);
771
772         if (copy_from_user(config_record, buffer, count)) {
773                 kfree(config_record);
774                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid data \n"));
775                 return_VALUE(-EINVAL);
776         }
777         config_record[count] = 0;
778
779         ret = get_parms(config_record,
780                         &cmd,
781                         &bus_handle,
782                         &bus_method,
783                         &action_handle,
784                         &method, &internal_event_num, &external_event_num);
785
786         kfree(config_record);
787         if (IS_OTHERS(internal_event_num))
788                 goto do_fail;
789         if (ret != 6) {
790               do_fail:
791                 kfree(bus_handle);
792                 kfree(bus_method);
793                 kfree(action_handle);
794                 kfree(method);
795                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
796                                   "Invalid data format ret=%d\n", ret));
797                 return_VALUE(-EINVAL);
798         }
799
800         key = kmalloc(sizeof(union acpi_hotkey), GFP_KERNEL);
801         if (!key)
802                 goto do_fail;
803         memset(key, 0, sizeof(union acpi_hotkey));
804         if (cmd == 1) {
805                 union acpi_hotkey *tmp = NULL;
806                 tmp = get_hotkey_by_event(&global_hotkey_list,
807                                           internal_event_num);
808                 if (!tmp)
809                         ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid key"));
810                 else
811                         memcpy(key, tmp, sizeof(union acpi_hotkey));
812                 goto cont_cmd;
813         }
814         if (IS_EVENT(internal_event_num)) {
815                 kfree(bus_method);
816                 ret = init_hotkey_device(key, bus_handle, action_handle, method,
817                                          internal_event_num,
818                                          external_event_num);
819         } else
820                 ret = init_poll_hotkey_device(key, bus_handle, bus_method,
821                                               action_handle, method,
822                                               internal_event_num);
823         if (ret) {
824                 kfree(bus_handle);
825                 kfree(action_handle);
826                 if (IS_EVENT(internal_event_num))
827                         free_hotkey_buffer(key);
828                 else
829                         free_poll_hotkey_buffer(key);
830                 kfree(key);
831                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid hotkey \n"));
832                 return_VALUE(-EINVAL);
833         }
834
835       cont_cmd:
836         kfree(bus_handle);
837         kfree(action_handle);
838
839         switch (cmd) {
840         case 0:
841                 if (get_hotkey_by_event
842                     (&global_hotkey_list, key->link.hotkey_standard_num))
843                         goto fail_out;
844                 else
845                         hotkey_add(key);
846                 break;
847         case 1:
848                 hotkey_remove(key);
849                 break;
850         case 2:
851                 if (hotkey_update(key))
852                         goto fail_out;
853                 break;
854         default:
855                 goto fail_out;
856                 break;
857         }
858         return_VALUE(count);
859       fail_out:
860         if (IS_EVENT(internal_event_num))
861                 free_hotkey_buffer(key);
862         else
863                 free_poll_hotkey_buffer(key);
864         kfree(key);
865         ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "invalid key\n"));
866         return_VALUE(-EINVAL);
867 }
868
869 /*
870  * This function evaluates an ACPI method, given an int as parameter, the
871  * method is searched within the scope of the handle, can be NULL. The output
872  * of the method is written is output, which can also be NULL
873  *
874  * returns 1 if write is successful, 0 else.
875  */
876 static int write_acpi_int(acpi_handle handle, const char *method, int val,
877                           struct acpi_buffer *output)
878 {
879         struct acpi_object_list params; /* list of input parameters (an int here) */
880         union acpi_object in_obj;       /* the only param we use */
881         acpi_status status;
882
883         ACPI_FUNCTION_TRACE("write_acpi_int");
884         params.count = 1;
885         params.pointer = &in_obj;
886         in_obj.type = ACPI_TYPE_INTEGER;
887         in_obj.integer.value = val;
888
889         status = acpi_evaluate_object(handle, (char *)method, &params, output);
890
891         return_VALUE(status == AE_OK);
892 }
893
894 static int read_acpi_int(acpi_handle handle, const char *method,
895                          union acpi_object *val)
896 {
897         struct acpi_buffer output;
898         union acpi_object out_obj;
899         acpi_status status;
900
901         ACPI_FUNCTION_TRACE("read_acpi_int");
902         output.length = sizeof(out_obj);
903         output.pointer = &out_obj;
904
905         status = acpi_evaluate_object(handle, (char *)method, NULL, &output);
906         if (val) {
907                 val->integer.value = out_obj.integer.value;
908                 val->type = out_obj.type;
909         } else
910                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "null val pointer"));
911         return_VALUE((status == AE_OK)
912                      && (out_obj.type == ACPI_TYPE_INTEGER));
913 }
914
915 static union acpi_hotkey *get_hotkey_by_event(struct
916                                               acpi_hotkey_list
917                                               *hotkey_list, int event)
918 {
919         struct list_head *entries;
920
921         list_for_each(entries, hotkey_list->entries) {
922                 union acpi_hotkey *key =
923                     container_of(entries, union acpi_hotkey, entries);
924                 if (key->link.hotkey_standard_num == event) {
925                         return (key);
926                 }
927         }
928         return (NULL);
929 }
930
931 /*
932  * user call AML method interface:
933  * Call convention:
934  * echo "event_num: arg type : value"
935  * example: echo "1:1:30" > /proc/acpi/action
936  * Just support 1 integer arg passing to AML method
937  */
938
939 static ssize_t hotkey_execute_aml_method(struct file *file,
940                                          const char __user * buffer,
941                                          size_t count, loff_t * data)
942 {
943         struct acpi_hotkey_list *hotkey_list = &global_hotkey_list;
944         char *arg;
945         int event, method_type, type, value;
946         union acpi_hotkey *key;
947
948         ACPI_FUNCTION_TRACE("hotkey_execte_aml_method");
949
950         arg = (char *)kmalloc(count + 1, GFP_KERNEL);
951         if (!arg)
952                 return_VALUE(-ENOMEM);
953         arg[count] = 0;
954
955         if (copy_from_user(arg, buffer, count)) {
956                 kfree(arg);
957                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid argument 2"));
958                 return_VALUE(-EINVAL);
959         }
960
961         if (sscanf(arg, "%d:%d:%d:%d", &event, &method_type, &type, &value) !=
962             4) {
963                 kfree(arg);
964                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid argument 3"));
965                 return_VALUE(-EINVAL);
966         }
967         kfree(arg);
968         if (type == ACPI_TYPE_INTEGER) {
969                 key = get_hotkey_by_event(hotkey_list, event);
970                 if (!key)
971                         goto do_fail;
972                 if (IS_EVENT(event))
973                         write_acpi_int(key->event_hotkey.action_handle,
974                                        key->event_hotkey.action_method, value,
975                                        NULL);
976                 else if (IS_POLL(event)) {
977                         if (method_type == POLL_METHOD)
978                                 read_acpi_int(key->poll_hotkey.poll_handle,
979                                               key->poll_hotkey.poll_method,
980                                               key->poll_hotkey.poll_result);
981                         else if (method_type == ACTION_METHOD)
982                                 write_acpi_int(key->poll_hotkey.action_handle,
983                                                key->poll_hotkey.action_method,
984                                                value, NULL);
985                         else
986                                 goto do_fail;
987
988                 }
989         } else {
990                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Not supported"));
991                 return_VALUE(-EINVAL);
992         }
993         return_VALUE(count);
994       do_fail:
995         return_VALUE(-EINVAL);
996
997 }
998
999 static int __init hotkey_init(void)
1000 {
1001         int result;
1002         mode_t mode = S_IFREG | S_IRUGO | S_IWUGO;
1003
1004         ACPI_FUNCTION_TRACE("hotkey_init");
1005
1006         if (acpi_disabled)
1007                 return -ENODEV;
1008
1009         if (acpi_specific_hotkey_enabled) {
1010                 printk("Using specific hotkey driver\n");
1011                 return -ENODEV;
1012         }
1013
1014         hotkey_proc_dir = proc_mkdir(HOTKEY_PROC, acpi_root_dir);
1015         if (!hotkey_proc_dir) {
1016                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1017                                   "Hotkey: Unable to create %s entry\n",
1018                                   HOTKEY_PROC));
1019                 return (-ENODEV);
1020         }
1021         hotkey_proc_dir->owner = THIS_MODULE;
1022
1023         hotkey_config =
1024             create_proc_entry(HOTKEY_EV_CONFIG, mode, hotkey_proc_dir);
1025         if (!hotkey_config) {
1026                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1027                                   "Hotkey: Unable to create %s entry\n",
1028                                   HOTKEY_EV_CONFIG));
1029                 goto do_fail1;
1030         } else {
1031                 hotkey_config->proc_fops = &hotkey_config_fops;
1032                 hotkey_config->data = &global_hotkey_list;
1033                 hotkey_config->owner = THIS_MODULE;
1034                 hotkey_config->uid = 0;
1035                 hotkey_config->gid = 0;
1036         }
1037
1038         hotkey_poll_config =
1039             create_proc_entry(HOTKEY_PL_CONFIG, mode, hotkey_proc_dir);
1040         if (!hotkey_poll_config) {
1041                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1042                                   "Hotkey: Unable to create %s entry\n",
1043                                   HOTKEY_EV_CONFIG));
1044
1045                 goto do_fail2;
1046         } else {
1047                 hotkey_poll_config->proc_fops = &hotkey_poll_config_fops;
1048                 hotkey_poll_config->data = &global_hotkey_list;
1049                 hotkey_poll_config->owner = THIS_MODULE;
1050                 hotkey_poll_config->uid = 0;
1051                 hotkey_poll_config->gid = 0;
1052         }
1053
1054         hotkey_action = create_proc_entry(HOTKEY_ACTION, mode, hotkey_proc_dir);
1055         if (!hotkey_action) {
1056                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1057                                   "Hotkey: Unable to create %s entry\n",
1058                                   HOTKEY_ACTION));
1059                 goto do_fail3;
1060         } else {
1061                 hotkey_action->proc_fops = &hotkey_action_fops;
1062                 hotkey_action->owner = THIS_MODULE;
1063                 hotkey_action->uid = 0;
1064                 hotkey_action->gid = 0;
1065         }
1066
1067         hotkey_info = create_proc_entry(HOTKEY_INFO, mode, hotkey_proc_dir);
1068         if (!hotkey_info) {
1069                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1070                                   "Hotkey: Unable to create %s entry\n",
1071                                   HOTKEY_INFO));
1072                 goto do_fail4;
1073         } else {
1074                 hotkey_info->proc_fops = &hotkey_info_fops;
1075                 hotkey_info->owner = THIS_MODULE;
1076                 hotkey_info->uid = 0;
1077                 hotkey_info->gid = 0;
1078         }
1079
1080         result = acpi_bus_register_driver(&hotkey_driver);
1081         if (result < 0)
1082                 goto do_fail5;
1083         global_hotkey_list.count = 0;
1084         global_hotkey_list.entries = &hotkey_entries;
1085
1086         INIT_LIST_HEAD(&hotkey_entries);
1087
1088         return (0);
1089
1090       do_fail5:
1091         remove_proc_entry(HOTKEY_INFO, hotkey_proc_dir);
1092       do_fail4:
1093         remove_proc_entry(HOTKEY_ACTION, hotkey_proc_dir);
1094       do_fail3:
1095         remove_proc_entry(HOTKEY_PL_CONFIG, hotkey_proc_dir);
1096       do_fail2:
1097         remove_proc_entry(HOTKEY_EV_CONFIG, hotkey_proc_dir);
1098       do_fail1:
1099         remove_proc_entry(HOTKEY_PROC, acpi_root_dir);
1100         return (-ENODEV);
1101 }
1102
1103 static void __exit hotkey_exit(void)
1104 {
1105         struct list_head *entries, *next;
1106
1107         ACPI_FUNCTION_TRACE("hotkey_exit");
1108
1109         list_for_each_safe(entries, next, global_hotkey_list.entries) {
1110                 union acpi_hotkey *key =
1111                     container_of(entries, union acpi_hotkey, entries);
1112
1113                 acpi_os_wait_events_complete(NULL);
1114                 list_del(&key->link.entries);
1115                 global_hotkey_list.count--;
1116                 free_hotkey_device(key);
1117         }
1118         acpi_bus_unregister_driver(&hotkey_driver);
1119         remove_proc_entry(HOTKEY_EV_CONFIG, hotkey_proc_dir);
1120         remove_proc_entry(HOTKEY_PL_CONFIG, hotkey_proc_dir);
1121         remove_proc_entry(HOTKEY_ACTION, hotkey_proc_dir);
1122         remove_proc_entry(HOTKEY_INFO, hotkey_proc_dir);
1123         remove_proc_entry(HOTKEY_PROC, acpi_root_dir);
1124         return;
1125 }
1126
1127 module_init(hotkey_init);
1128 module_exit(hotkey_exit);