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