2 * hotkey.c - ACPI Hotkey Driver ($Revision: 0.2 $)
4 * Copyright (C) 2004 Luming Yu <luming.yu@intel.com>
6 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
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.
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.
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.
22 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
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>
36 #define HOTKEY_ACPI_VERSION "0.1"
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"
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
50 #define ACPI_HOTKEY_EVENT 0x1
51 #define ACPI_HOTKEY_POLLING 0x2
52 #define ACPI_UNDEFINED_EVENT 0xf
54 #define RESULT_STR_LEN 80
56 #define ACTION_METHOD 0
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")
65 MODULE_AUTHOR("luming.yu@intel.com");
66 MODULE_DESCRIPTION(ACPI_HOTK_NAME
);
67 MODULE_LICENSE("GPL");
69 /* standardized internal hotkey number/event */
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
,
85 HK_EVENT_VOLUME_INCLREASE
,
86 HK_EVENT_VOLUME_DECREASE
,
88 /* running state control */
89 HK_EVENT_ENTERRING_S3
,
90 HK_EVENT_ENTERRING_S4
,
91 HK_EVENT_ENTERRING_S5
,
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
;
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 */
108 /* event based hotkey */
109 struct acpi_event_hotkey
{
110 struct acpi_hotkey_link hotkey_link
;
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 */
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.
127 /* polling based hotkey */
128 struct acpi_polling_hotkey
{
129 struct acpi_hotkey_link hotkey_link
;
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
;
139 /* hotkey object union */
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
;
147 /* hotkey object list */
148 struct acpi_hotkey_list
{
149 struct list_head
*entries
;
153 static int auto_hotkey_add(struct acpi_device
*device
);
154 static int auto_hotkey_remove(struct acpi_device
*device
, int type
);
156 static struct acpi_driver hotkey_driver
= {
157 .name
= ACPI_HOTK_NAME
,
158 .class = ACPI_HOTK_CLASS
,
159 .ids
= ACPI_HOTK_HID
,
161 .add
= auto_hotkey_add
,
162 .remove
= auto_hotkey_remove
,
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
184 *hotkey_list
, int event
);
186 /* event based config */
187 static struct file_operations hotkey_config_fops
= {
188 .open
= hotkey_open_config
,
190 .write
= hotkey_write_config
,
192 .release
= single_release
,
195 /* polling based config */
196 static struct file_operations hotkey_poll_config_fops
= {
197 .open
= hotkey_poll_open_config
,
199 .write
= hotkey_write_config
,
201 .release
= single_release
,
204 /* hotkey driver info */
205 static struct file_operations hotkey_info_fops
= {
206 .open
= hotkey_info_open_fs
,
209 .release
= single_release
,
213 static struct file_operations hotkey_action_fops
= {
214 .open
= hotkey_action_open_fs
,
216 .write
= hotkey_execute_aml_method
,
218 .release
= single_release
,
221 /* polling results */
222 static struct file_operations hotkey_polling_fops
= {
223 .open
= hotkey_polling_open_fs
,
226 .release
= single_release
,
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 */
232 static int hotkey_info_seq_show(struct seq_file
*seq
, void *offset
)
234 ACPI_FUNCTION_TRACE("hotkey_info_seq_show");
236 seq_printf(seq
, "Hotkey generic driver ver: %s\n", HOTKEY_ACPI_VERSION
);
241 static int hotkey_info_open_fs(struct inode
*inode
, struct file
*file
)
243 return single_open(file
, hotkey_info_seq_show
, PDE(inode
)->data
);
246 static char *format_result(union acpi_object
*object
)
250 buf
= (char *)kmalloc(RESULT_STR_LEN
, GFP_KERNEL
);
252 memset(buf
, 0, RESULT_STR_LEN
);
256 /* Now, just support integer type */
257 if (object
->type
== ACPI_TYPE_INTEGER
)
258 sprintf(buf
, "%d\n", (u32
) object
->integer
.value
);
263 static int hotkey_polling_seq_show(struct seq_file
*seq
, void *offset
)
265 struct acpi_polling_hotkey
*poll_hotkey
=
266 (struct acpi_polling_hotkey
*)seq
->private;
269 ACPI_FUNCTION_TRACE("hotkey_polling_seq_show");
271 if (poll_hotkey
->poll_result
) {
272 buf
= format_result(poll_hotkey
->poll_result
);
274 seq_printf(seq
, "%s", buf
);
280 static int hotkey_polling_open_fs(struct inode
*inode
, struct file
*file
)
282 return single_open(file
, hotkey_polling_seq_show
, PDE(inode
)->data
);
285 static int hotkey_action_open_fs(struct inode
*inode
, struct file
*file
)
287 return single_open(file
, hotkey_info_seq_show
, PDE(inode
)->data
);
290 /* Mapping external hotkey number to standardized hotkey event num */
291 static int hotkey_get_internal_event(int event
, struct acpi_hotkey_list
*list
)
293 struct list_head
*entries
;
296 ACPI_FUNCTION_TRACE("hotkey_get_internal_event");
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
;
312 acpi_hotkey_notify_handler(acpi_handle handle
, u32 event
, void *data
)
314 struct acpi_device
*device
= NULL
;
317 ACPI_FUNCTION_TRACE("acpi_hotkey_notify_handler");
319 if (acpi_bus_get_device(handle
, &device
))
322 internal_event
= hotkey_get_internal_event(event
, &global_hotkey_list
);
323 acpi_bus_generate_event(device
, internal_event
, 0);
328 /* Need to invent automatically hotkey add method */
329 static int auto_hotkey_add(struct acpi_device
*device
)
335 /* Need to invent automatically hotkey remove method */
336 static int auto_hotkey_remove(struct acpi_device
*device
, int type
)
342 /* Create a proc file for each polling method */
343 static int create_polling_proc(union acpi_hotkey
*device
)
345 struct proc_dir_entry
*proc
;
349 ACPI_FUNCTION_TRACE("create_polling_proc");
350 mode
= S_IFREG
| S_IRUGO
| S_IWUGO
;
352 sprintf(proc_name
, "%d", device
->link
.hotkey_standard_num
);
354 strcat(proc_name, device->poll_hotkey.poll_method);
356 proc
= create_proc_entry(proc_name
, mode
, hotkey_proc_dir
);
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
);
364 proc
->proc_fops
= &hotkey_polling_fops
;
365 proc
->owner
= THIS_MODULE
;
369 device
->poll_hotkey
.proc
= proc
;
374 static int hotkey_add(union acpi_hotkey
*device
)
377 struct acpi_device
*dev
= NULL
;
379 ACPI_FUNCTION_TRACE("hotkey_add");
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
,
385 acpi_hotkey_notify_handler
,
387 } else /* Add polling hotkey */
388 create_polling_proc(device
);
390 global_hotkey_list
.count
++;
392 list_add_tail(&device
->link
.entries
, global_hotkey_list
.entries
);
394 return_VALUE(status
);
397 static int hotkey_remove(union acpi_hotkey
*device
)
399 struct list_head
*entries
, *next
;
401 ACPI_FUNCTION_TRACE("hotkey_remove");
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
--;
418 static int hotkey_update(union acpi_hotkey
*key
)
420 struct list_head
*entries
;
422 ACPI_FUNCTION_TRACE("hotkey_update");
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
;
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);
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
;
460 create_polling_proc(tmp);
469 return_VALUE(-ENODEV
);
472 static void free_hotkey_device(union acpi_hotkey
*key
)
474 struct acpi_device
*dev
;
476 ACPI_FUNCTION_TRACE("free_hotkey_device");
478 if (key
->link
.hotkey_type
== ACPI_HOTKEY_EVENT
) {
479 acpi_bus_get_device(key
->event_hotkey
.bus_handle
, &dev
);
481 acpi_remove_notify_handler(dev
->handle
,
483 acpi_hotkey_notify_handler
);
484 free_hotkey_buffer(key
);
488 sprintf(proc_name
, "%d", key
->link
.hotkey_standard_num
);
490 strcat(proc_name, key->poll_hotkey.poll_method);
492 remove_proc_entry(proc_name
, hotkey_proc_dir
);
493 free_poll_hotkey_buffer(key
);
499 static void free_hotkey_buffer(union acpi_hotkey
*key
)
501 kfree(key
->event_hotkey
.action_method
);
504 static void free_poll_hotkey_buffer(union acpi_hotkey
*key
)
506 kfree(key
->poll_hotkey
.action_method
);
507 kfree(key
->poll_hotkey
.poll_method
);
508 kfree(key
->poll_hotkey
.poll_result
);
511 init_hotkey_device(union acpi_hotkey
*key
, char *bus_str
, char *action_str
,
512 char *method
, int std_num
, int external_num
)
514 acpi_handle tmp_handle
;
515 acpi_status status
= AE_OK
;
517 ACPI_FUNCTION_TRACE("init_hotkey_device");
519 if (std_num
< 0 || IS_POLL(std_num
) || !key
)
522 if (!bus_str
|| !action_str
|| !method
)
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
;
531 acpi_get_handle(NULL
, bus_str
, &(key
->event_hotkey
.bus_handle
));
532 if (ACPI_FAILURE(status
))
534 key
->event_hotkey
.external_hotkey_num
= external_num
;
536 acpi_get_handle(NULL
, action_str
,
537 &(key
->event_hotkey
.action_handle
));
538 if (ACPI_FAILURE(status
))
540 status
= acpi_get_handle(key
->event_hotkey
.action_handle
,
541 method
, &tmp_handle
);
542 if (ACPI_FAILURE(status
))
546 return_VALUE(-ENODEV
);
550 init_poll_hotkey_device(union acpi_hotkey
*key
,
553 char *action_str
, char *action_method
, int std_num
)
555 acpi_status status
= AE_OK
;
556 acpi_handle tmp_handle
;
558 ACPI_FUNCTION_TRACE("init_poll_hotkey_device");
560 if (std_num
< 0 || IS_EVENT(std_num
) || !key
)
563 if (!poll_str
|| !poll_method
|| !action_str
|| !action_method
)
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
;
573 acpi_get_handle(NULL
, poll_str
, &(key
->poll_hotkey
.poll_handle
));
574 if (ACPI_FAILURE(status
))
576 status
= acpi_get_handle(key
->poll_hotkey
.poll_handle
,
577 poll_method
, &tmp_handle
);
578 if (ACPI_FAILURE(status
))
581 acpi_get_handle(NULL
, action_str
,
582 &(key
->poll_hotkey
.action_handle
));
583 if (ACPI_FAILURE(status
))
585 status
= acpi_get_handle(key
->poll_hotkey
.action_handle
,
586 action_method
, &tmp_handle
);
587 if (ACPI_FAILURE(status
))
589 key
->poll_hotkey
.poll_result
=
590 (union acpi_object
*)kmalloc(sizeof(union acpi_object
), GFP_KERNEL
);
591 if (!key
->poll_hotkey
.poll_result
)
595 return_VALUE(-ENODEV
);
598 static int hotkey_open_config(struct inode
*inode
, struct file
*file
)
600 ACPI_FUNCTION_TRACE("hotkey_open_config");
601 return_VALUE(single_open
602 (file
, hotkey_config_seq_show
, PDE(inode
)->data
));
605 static int hotkey_poll_open_config(struct inode
*inode
, struct file
*file
)
607 ACPI_FUNCTION_TRACE("hotkey_poll_open_config");
608 return_VALUE(single_open
609 (file
, hotkey_poll_config_seq_show
, PDE(inode
)->data
));
612 static int hotkey_config_seq_show(struct seq_file
*seq
, void *offset
)
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
};
621 ACPI_FUNCTION_TRACE(("hotkey_config_seq_show"));
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
,
633 key
->event_hotkey
.action_method
,
634 key
->link
.hotkey_standard_num
,
635 key
->event_hotkey
.external_hotkey_num
);
642 static int hotkey_poll_config_seq_show(struct seq_file
*seq
, void *offset
)
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
};
651 ACPI_FUNCTION_TRACE(("hotkey_config_seq_show"));
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
,
664 key
->poll_hotkey
.action_method
,
665 key
->link
.hotkey_standard_num
);
673 get_parms(char *config_record
,
677 char **action_handle
,
678 char **method
, int *internal_event_num
, int *external_event_num
)
680 char *tmp
, *tmp1
, count
;
681 ACPI_FUNCTION_TRACE(("get_parms"));
683 sscanf(config_record
, "%d", cmd
);
686 if (sscanf(config_record
, "%d:%d", cmd
, internal_event_num
) !=
692 tmp
= strchr(config_record
, ':');
696 tmp1
= strchr(tmp
, ':');
701 *bus_handle
= (char *)kmalloc(count
+ 1, GFP_KERNEL
);
704 strncpy(*bus_handle
, tmp
, count
);
705 *(*bus_handle
+ count
) = 0;
709 tmp1
= strchr(tmp
, ':');
713 *bus_method
= (char *)kmalloc(count
+ 1, GFP_KERNEL
);
716 strncpy(*bus_method
, tmp
, count
);
717 *(*bus_method
+ count
) = 0;
721 tmp1
= strchr(tmp
, ':');
725 *action_handle
= (char *)kmalloc(count
+ 1, GFP_KERNEL
);
728 strncpy(*action_handle
, tmp
, count
);
729 *(*action_handle
+ count
) = 0;
733 tmp1
= strchr(tmp
, ':');
737 *method
= (char *)kmalloc(count
+ 1, GFP_KERNEL
);
740 strncpy(*method
, tmp
, count
);
741 *(*method
+ count
) = 0;
743 if (sscanf(tmp1
+ 1, "%d:%d", internal_event_num
, external_event_num
) <=
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
)
757 char *config_record
= NULL
;
758 char *bus_handle
= NULL
;
759 char *bus_method
= NULL
;
760 char *action_handle
= NULL
;
762 int cmd
, internal_event_num
, external_event_num
;
764 union acpi_hotkey
*key
= NULL
;
766 ACPI_FUNCTION_TRACE(("hotkey_write_config"));
768 config_record
= (char *)kmalloc(count
+ 1, GFP_KERNEL
);
770 return_VALUE(-ENOMEM
);
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
);
777 config_record
[count
] = 0;
779 ret
= get_parms(config_record
,
784 &method
, &internal_event_num
, &external_event_num
);
786 kfree(config_record
);
787 if (IS_OTHERS(internal_event_num
))
793 kfree(action_handle
);
795 ACPI_DEBUG_PRINT((ACPI_DB_ERROR
,
796 "Invalid data format ret=%d\n", ret
));
797 return_VALUE(-EINVAL
);
800 key
= kmalloc(sizeof(union acpi_hotkey
), GFP_KERNEL
);
803 memset(key
, 0, sizeof(union acpi_hotkey
));
805 union acpi_hotkey
*tmp
= NULL
;
806 tmp
= get_hotkey_by_event(&global_hotkey_list
,
809 ACPI_DEBUG_PRINT((ACPI_DB_ERROR
, "Invalid key"));
811 memcpy(key
, tmp
, sizeof(union acpi_hotkey
));
814 if (IS_EVENT(internal_event_num
)) {
816 ret
= init_hotkey_device(key
, bus_handle
, action_handle
, method
,
820 ret
= init_poll_hotkey_device(key
, bus_handle
, bus_method
,
821 action_handle
, method
,
825 kfree(action_handle
);
826 if (IS_EVENT(internal_event_num
))
827 free_hotkey_buffer(key
);
829 free_poll_hotkey_buffer(key
);
831 ACPI_DEBUG_PRINT((ACPI_DB_ERROR
, "Invalid hotkey \n"));
832 return_VALUE(-EINVAL
);
837 kfree(action_handle
);
841 if (get_hotkey_by_event
842 (&global_hotkey_list
, key
->link
.hotkey_standard_num
))
851 if (hotkey_update(key
))
860 if (IS_EVENT(internal_event_num
))
861 free_hotkey_buffer(key
);
863 free_poll_hotkey_buffer(key
);
865 ACPI_DEBUG_PRINT((ACPI_DB_ERROR
, "invalid key\n"));
866 return_VALUE(-EINVAL
);
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
874 * returns 1 if write is successful, 0 else.
876 static int write_acpi_int(acpi_handle handle
, const char *method
, int val
,
877 struct acpi_buffer
*output
)
879 struct acpi_object_list params
; /* list of input parameters (an int here) */
880 union acpi_object in_obj
; /* the only param we use */
883 ACPI_FUNCTION_TRACE("write_acpi_int");
885 params
.pointer
= &in_obj
;
886 in_obj
.type
= ACPI_TYPE_INTEGER
;
887 in_obj
.integer
.value
= val
;
889 status
= acpi_evaluate_object(handle
, (char *)method
, ¶ms
, output
);
891 return_VALUE(status
== AE_OK
);
894 static int read_acpi_int(acpi_handle handle
, const char *method
,
895 union acpi_object
*val
)
897 struct acpi_buffer output
;
898 union acpi_object out_obj
;
901 ACPI_FUNCTION_TRACE("read_acpi_int");
902 output
.length
= sizeof(out_obj
);
903 output
.pointer
= &out_obj
;
905 status
= acpi_evaluate_object(handle
, (char *)method
, NULL
, &output
);
907 val
->integer
.value
= out_obj
.integer
.value
;
908 val
->type
= out_obj
.type
;
910 ACPI_DEBUG_PRINT((ACPI_DB_ERROR
, "null val pointer"));
911 return_VALUE((status
== AE_OK
)
912 && (out_obj
.type
== ACPI_TYPE_INTEGER
));
915 static union acpi_hotkey
*get_hotkey_by_event(struct
917 *hotkey_list
, int event
)
919 struct list_head
*entries
;
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
) {
932 * user call AML method interface:
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
939 static ssize_t
hotkey_execute_aml_method(struct file
*file
,
940 const char __user
* buffer
,
941 size_t count
, loff_t
* data
)
943 struct acpi_hotkey_list
*hotkey_list
= &global_hotkey_list
;
945 int event
, method_type
, type
, value
;
946 union acpi_hotkey
*key
;
948 ACPI_FUNCTION_TRACE("hotkey_execte_aml_method");
950 arg
= (char *)kmalloc(count
+ 1, GFP_KERNEL
);
952 return_VALUE(-ENOMEM
);
955 if (copy_from_user(arg
, buffer
, count
)) {
957 ACPI_DEBUG_PRINT((ACPI_DB_ERROR
, "Invalid argument 2"));
958 return_VALUE(-EINVAL
);
961 if (sscanf(arg
, "%d:%d:%d:%d", &event
, &method_type
, &type
, &value
) !=
964 ACPI_DEBUG_PRINT((ACPI_DB_ERROR
, "Invalid argument 3"));
965 return_VALUE(-EINVAL
);
968 if (type
== ACPI_TYPE_INTEGER
) {
969 key
= get_hotkey_by_event(hotkey_list
, event
);
973 write_acpi_int(key
->event_hotkey
.action_handle
,
974 key
->event_hotkey
.action_method
, value
,
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
,
990 ACPI_DEBUG_PRINT((ACPI_DB_ERROR
, "Not supported"));
991 return_VALUE(-EINVAL
);
995 return_VALUE(-EINVAL
);
999 static int __init
hotkey_init(void)
1002 mode_t mode
= S_IFREG
| S_IRUGO
| S_IWUGO
;
1004 ACPI_FUNCTION_TRACE("hotkey_init");
1009 if (acpi_specific_hotkey_enabled
) {
1010 printk("Using specific hotkey driver\n");
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",
1021 hotkey_proc_dir
->owner
= THIS_MODULE
;
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",
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;
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",
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;
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",
1061 hotkey_action
->proc_fops
= &hotkey_action_fops
;
1062 hotkey_action
->owner
= THIS_MODULE
;
1063 hotkey_action
->uid
= 0;
1064 hotkey_action
->gid
= 0;
1067 hotkey_info
= create_proc_entry(HOTKEY_INFO
, mode
, hotkey_proc_dir
);
1069 ACPI_DEBUG_PRINT((ACPI_DB_ERROR
,
1070 "Hotkey: Unable to create %s entry\n",
1074 hotkey_info
->proc_fops
= &hotkey_info_fops
;
1075 hotkey_info
->owner
= THIS_MODULE
;
1076 hotkey_info
->uid
= 0;
1077 hotkey_info
->gid
= 0;
1080 result
= acpi_bus_register_driver(&hotkey_driver
);
1083 global_hotkey_list
.count
= 0;
1084 global_hotkey_list
.entries
= &hotkey_entries
;
1086 INIT_LIST_HEAD(&hotkey_entries
);
1091 remove_proc_entry(HOTKEY_INFO
, hotkey_proc_dir
);
1093 remove_proc_entry(HOTKEY_ACTION
, hotkey_proc_dir
);
1095 remove_proc_entry(HOTKEY_PL_CONFIG
, hotkey_proc_dir
);
1097 remove_proc_entry(HOTKEY_EV_CONFIG
, hotkey_proc_dir
);
1099 remove_proc_entry(HOTKEY_PROC
, acpi_root_dir
);
1103 static void __exit
hotkey_exit(void)
1105 struct list_head
*entries
, *next
;
1107 ACPI_FUNCTION_TRACE("hotkey_exit");
1109 list_for_each_safe(entries
, next
, global_hotkey_list
.entries
) {
1110 union acpi_hotkey
*key
=
1111 container_of(entries
, union acpi_hotkey
, entries
);
1113 acpi_os_wait_events_complete(NULL
);
1114 list_del(&key
->link
.entries
);
1115 global_hotkey_list
.count
--;
1116 free_hotkey_device(key
);
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
);
1127 module_init(hotkey_init
);
1128 module_exit(hotkey_exit
);