?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] new toplevel target: headers_check_all
[wrt350n-kernel.git] / drivers / acpi / hotkey.c
blob8edfb92f7ede258ef665aa7dabfc1aeea73b87ab
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);
WRT350N Kernel Patches