diff options
author | Len Brown <len.brown@intel.com> | 2007-02-10 01:18:25 -0500 |
---|---|---|
committer | Len Brown <len.brown@intel.com> | 2007-02-16 21:45:57 -0500 |
commit | 5ee6edbcde4d3b14e4e03d4b331df1099a34aa8d (patch) | |
tree | 0255c41c950217eedd582c80aa060f49ff5682e6 /drivers | |
parent | eaefd5fb7d793c9c1bcef1b0c0d5ec3824a85b91 (diff) |
ACPI: hotkey: remove driver, per feature-removal-schedule.txt
Signed-off-by: Len Brown <len.brown@intel.com>
Diffstat (limited to 'drivers')
-rw-r--r-- | drivers/acpi/Kconfig | 9 | ||||
-rw-r--r-- | drivers/acpi/Makefile | 1 | ||||
-rw-r--r-- | drivers/acpi/asus_acpi.c | 4 | ||||
-rw-r--r-- | drivers/acpi/hotkey.c | 1042 | ||||
-rw-r--r-- | drivers/acpi/ibm_acpi.c | 5 | ||||
-rw-r--r-- | drivers/acpi/osl.c | 11 | ||||
-rw-r--r-- | drivers/acpi/toshiba_acpi.c | 4 | ||||
-rw-r--r-- | drivers/misc/asus-laptop.c | 5 |
8 files changed, 0 insertions, 1081 deletions
diff --git a/drivers/acpi/Kconfig b/drivers/acpi/Kconfig index 20eacc2c9e0e..4f5bfb1e629a 100644 --- a/drivers/acpi/Kconfig +++ b/drivers/acpi/Kconfig | |||
@@ -132,15 +132,6 @@ config ACPI_VIDEO | |||
132 | Note that this is an ref. implementation only. It may or may not work | 132 | Note that this is an ref. implementation only. It may or may not work |
133 | for your integrated video device. | 133 | for your integrated video device. |
134 | 134 | ||
135 | config ACPI_HOTKEY | ||
136 | tristate "Generic Hotkey (EXPERIMENTAL)" | ||
137 | depends on EXPERIMENTAL | ||
138 | depends on X86 | ||
139 | default n | ||
140 | help | ||
141 | Experimental consolidated hotkey driver. | ||
142 | If you are unsure, say N. | ||
143 | |||
144 | config ACPI_FAN | 135 | config ACPI_FAN |
145 | tristate "Fan" | 136 | tristate "Fan" |
146 | default y | 137 | default y |
diff --git a/drivers/acpi/Makefile b/drivers/acpi/Makefile index 856c32bccacb..5956e9f64a8b 100644 --- a/drivers/acpi/Makefile +++ b/drivers/acpi/Makefile | |||
@@ -46,7 +46,6 @@ obj-$(CONFIG_ACPI_FAN) += fan.o | |||
46 | obj-$(CONFIG_ACPI_DOCK) += dock.o | 46 | obj-$(CONFIG_ACPI_DOCK) += dock.o |
47 | obj-$(CONFIG_ACPI_BAY) += bay.o | 47 | obj-$(CONFIG_ACPI_BAY) += bay.o |
48 | obj-$(CONFIG_ACPI_VIDEO) += video.o | 48 | obj-$(CONFIG_ACPI_VIDEO) += video.o |
49 | obj-$(CONFIG_ACPI_HOTKEY) += hotkey.o | ||
50 | obj-y += pci_root.o pci_link.o pci_irq.o pci_bind.o | 49 | obj-y += pci_root.o pci_link.o pci_irq.o pci_bind.o |
51 | obj-$(CONFIG_ACPI_POWER) += power.o | 50 | obj-$(CONFIG_ACPI_POWER) += power.o |
52 | obj-$(CONFIG_ACPI_PROCESSOR) += processor.o | 51 | obj-$(CONFIG_ACPI_PROCESSOR) += processor.o |
diff --git a/drivers/acpi/asus_acpi.c b/drivers/acpi/asus_acpi.c index 31ad70a6e22e..ab8c5cb8384d 100644 --- a/drivers/acpi/asus_acpi.c +++ b/drivers/acpi/asus_acpi.c | |||
@@ -1365,10 +1365,6 @@ static int __init asus_acpi_init(void) | |||
1365 | if (acpi_disabled) | 1365 | if (acpi_disabled) |
1366 | return -ENODEV; | 1366 | return -ENODEV; |
1367 | 1367 | ||
1368 | if (!acpi_specific_hotkey_enabled) { | ||
1369 | printk(KERN_ERR "Using generic hotkey driver\n"); | ||
1370 | return -ENODEV; | ||
1371 | } | ||
1372 | asus_proc_dir = proc_mkdir(PROC_ASUS, acpi_root_dir); | 1368 | asus_proc_dir = proc_mkdir(PROC_ASUS, acpi_root_dir); |
1373 | if (!asus_proc_dir) { | 1369 | if (!asus_proc_dir) { |
1374 | printk(KERN_ERR "Asus ACPI: Unable to create /proc entry\n"); | 1370 | printk(KERN_ERR "Asus ACPI: Unable to create /proc entry\n"); |
diff --git a/drivers/acpi/hotkey.c b/drivers/acpi/hotkey.c deleted file mode 100644 index 8edfb92f7ede..000000000000 --- a/drivers/acpi/hotkey.c +++ /dev/null | |||
@@ -1,1042 +0,0 @@ | |||
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, ¶ms, 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); | ||
diff --git a/drivers/acpi/ibm_acpi.c b/drivers/acpi/ibm_acpi.c index c6144ca66638..4def52ca69e5 100644 --- a/drivers/acpi/ibm_acpi.c +++ b/drivers/acpi/ibm_acpi.c | |||
@@ -2696,11 +2696,6 @@ static int __init acpi_ibm_init(void) | |||
2696 | if (acpi_disabled) | 2696 | if (acpi_disabled) |
2697 | return -ENODEV; | 2697 | return -ENODEV; |
2698 | 2698 | ||
2699 | if (!acpi_specific_hotkey_enabled) { | ||
2700 | printk(IBM_ERR "using generic hotkey driver\n"); | ||
2701 | return -ENODEV; | ||
2702 | } | ||
2703 | |||
2704 | /* ec is required because many other handles are relative to it */ | 2699 | /* ec is required because many other handles are relative to it */ |
2705 | IBM_HANDLE_INIT(ec); | 2700 | IBM_HANDLE_INIT(ec); |
2706 | if (!ec_handle) { | 2701 | if (!ec_handle) { |
diff --git a/drivers/acpi/osl.c b/drivers/acpi/osl.c index 0f6f3bcbc8eb..368e111100bd 100644 --- a/drivers/acpi/osl.c +++ b/drivers/acpi/osl.c | |||
@@ -68,9 +68,6 @@ EXPORT_SYMBOL(acpi_in_debugger); | |||
68 | extern char line_buf[80]; | 68 | extern char line_buf[80]; |
69 | #endif /*ENABLE_DEBUGGER */ | 69 | #endif /*ENABLE_DEBUGGER */ |
70 | 70 | ||
71 | int acpi_specific_hotkey_enabled = TRUE; | ||
72 | EXPORT_SYMBOL(acpi_specific_hotkey_enabled); | ||
73 | |||
74 | static unsigned int acpi_irq_irq; | 71 | static unsigned int acpi_irq_irq; |
75 | static acpi_osd_handler acpi_irq_handler; | 72 | static acpi_osd_handler acpi_irq_handler; |
76 | static void *acpi_irq_context; | 73 | static void *acpi_irq_context; |
@@ -1012,14 +1009,6 @@ static int __init acpi_wake_gpes_always_on_setup(char *str) | |||
1012 | 1009 | ||
1013 | __setup("acpi_wake_gpes_always_on", acpi_wake_gpes_always_on_setup); | 1010 | __setup("acpi_wake_gpes_always_on", acpi_wake_gpes_always_on_setup); |
1014 | 1011 | ||
1015 | static int __init acpi_hotkey_setup(char *str) | ||
1016 | { | ||
1017 | acpi_specific_hotkey_enabled = FALSE; | ||
1018 | return 1; | ||
1019 | } | ||
1020 | |||
1021 | __setup("acpi_generic_hotkey", acpi_hotkey_setup); | ||
1022 | |||
1023 | /* | 1012 | /* |
1024 | * max_cstate is defined in the base kernel so modules can | 1013 | * max_cstate is defined in the base kernel so modules can |
1025 | * change it w/o depending on the state of the processor module. | 1014 | * change it w/o depending on the state of the processor module. |
diff --git a/drivers/acpi/toshiba_acpi.c b/drivers/acpi/toshiba_acpi.c index d9b651ffcdc0..56ec5503a124 100644 --- a/drivers/acpi/toshiba_acpi.c +++ b/drivers/acpi/toshiba_acpi.c | |||
@@ -561,10 +561,6 @@ static int __init toshiba_acpi_init(void) | |||
561 | if (acpi_disabled) | 561 | if (acpi_disabled) |
562 | return -ENODEV; | 562 | return -ENODEV; |
563 | 563 | ||
564 | if (!acpi_specific_hotkey_enabled) { | ||
565 | printk(MY_INFO "Using generic hotkey driver\n"); | ||
566 | return -ENODEV; | ||
567 | } | ||
568 | /* simple device detection: look for HCI method */ | 564 | /* simple device detection: look for HCI method */ |
569 | if (is_valid_acpi_path(METHOD_HCI_1)) | 565 | if (is_valid_acpi_path(METHOD_HCI_1)) |
570 | method_hci = METHOD_HCI_1; | 566 | method_hci = METHOD_HCI_1; |
diff --git a/drivers/misc/asus-laptop.c b/drivers/misc/asus-laptop.c index 861c39935f99..e4e2b707a353 100644 --- a/drivers/misc/asus-laptop.c +++ b/drivers/misc/asus-laptop.c | |||
@@ -1088,11 +1088,6 @@ static int __init asus_laptop_init(void) | |||
1088 | if (acpi_disabled) | 1088 | if (acpi_disabled) |
1089 | return -ENODEV; | 1089 | return -ENODEV; |
1090 | 1090 | ||
1091 | if (!acpi_specific_hotkey_enabled) { | ||
1092 | printk(ASUS_ERR "Using generic hotkey driver\n"); | ||
1093 | return -ENODEV; | ||
1094 | } | ||
1095 | |||
1096 | result = acpi_bus_register_driver(&asus_hotk_driver); | 1091 | result = acpi_bus_register_driver(&asus_hotk_driver); |
1097 | if (result < 0) | 1092 | if (result < 0) |
1098 | return result; | 1093 | return result; |