diff options
Diffstat (limited to 'drivers')
-rw-r--r-- | drivers/acpi/Kconfig | 5 | ||||
-rw-r--r-- | drivers/acpi/hotkey.c | 690 |
2 files changed, 396 insertions, 299 deletions
diff --git a/drivers/acpi/Kconfig b/drivers/acpi/Kconfig index 84bbcb051cb7..281a64040f38 100644 --- a/drivers/acpi/Kconfig +++ b/drivers/acpi/Kconfig | |||
@@ -133,9 +133,10 @@ config ACPI_HOTKEY | |||
133 | depends on ACPI_INTERPRETER | 133 | depends on ACPI_INTERPRETER |
134 | depends on EXPERIMENTAL | 134 | depends on EXPERIMENTAL |
135 | depends on !IA64_SGI_SN | 135 | depends on !IA64_SGI_SN |
136 | default m | 136 | default n |
137 | help | 137 | help |
138 | ACPI generic hotkey | 138 | Experimental consolidated hotkey driver. |
139 | If you are unsure, say N. | ||
139 | 140 | ||
140 | config ACPI_FAN | 141 | config ACPI_FAN |
141 | tristate "Fan" | 142 | tristate "Fan" |
diff --git a/drivers/acpi/hotkey.c b/drivers/acpi/hotkey.c index babdf762eadb..1f76a40badec 100644 --- a/drivers/acpi/hotkey.c +++ b/drivers/acpi/hotkey.c | |||
@@ -1,5 +1,5 @@ | |||
1 | /* | 1 | /* |
2 | * hotkey.c - ACPI Hotkey Driver ($Revision:$) | 2 | * hotkey.c - ACPI Hotkey Driver ($Revision: 0.2 $) |
3 | * | 3 | * |
4 | * Copyright (C) 2004 Luming Yu <luming.yu@intel.com> | 4 | * Copyright (C) 2004 Luming Yu <luming.yu@intel.com> |
5 | * | 5 | * |
@@ -51,17 +51,18 @@ | |||
51 | #define ACPI_HOTKEY_POLLING 0x2 | 51 | #define ACPI_HOTKEY_POLLING 0x2 |
52 | #define ACPI_UNDEFINED_EVENT 0xf | 52 | #define ACPI_UNDEFINED_EVENT 0xf |
53 | 53 | ||
54 | #define MAX_CONFIG_RECORD_LEN 80 | 54 | #define RESULT_STR_LEN 80 |
55 | #define MAX_NAME_PATH_LEN 80 | ||
56 | #define MAX_CALL_PARM 80 | ||
57 | 55 | ||
58 | #define IS_EVENT(e) 0xff /* ((e) & 0x40000000) */ | 56 | #define ACTION_METHOD 0 |
59 | #define IS_POLL(e) 0xff /* (~((e) & 0x40000000)) */ | 57 | #define POLL_METHOD 1 |
60 | 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) | ||
61 | #define _COMPONENT ACPI_HOTKEY_COMPONENT | 62 | #define _COMPONENT ACPI_HOTKEY_COMPONENT |
62 | ACPI_MODULE_NAME("acpi_hotkey") | 63 | ACPI_MODULE_NAME("acpi_hotkey") |
63 | 64 | ||
64 | MODULE_AUTHOR("luming.yu@intel.com"); | 65 | MODULE_AUTHOR("luming.yu@intel.com"); |
65 | MODULE_DESCRIPTION(ACPI_HOTK_NAME); | 66 | MODULE_DESCRIPTION(ACPI_HOTK_NAME); |
66 | MODULE_LICENSE("GPL"); | 67 | MODULE_LICENSE("GPL"); |
67 | 68 | ||
@@ -114,7 +115,7 @@ struct acpi_event_hotkey { | |||
114 | char *action_method; /* action method */ | 115 | char *action_method; /* action method */ |
115 | }; | 116 | }; |
116 | 117 | ||
117 | /* | 118 | /* |
118 | * There are two ways to poll status | 119 | * There are two ways to poll status |
119 | * 1. directy call read_xxx method, without any arguments passed in | 120 | * 1. directy call read_xxx method, without any arguments passed in |
120 | * 2. call write_xxx method, with arguments passed in, you need | 121 | * 2. call write_xxx method, with arguments passed in, you need |
@@ -131,7 +132,7 @@ struct acpi_polling_hotkey { | |||
131 | char *poll_method; /* poll method */ | 132 | char *poll_method; /* poll method */ |
132 | acpi_handle action_handle; /* acpi handle attached action method */ | 133 | acpi_handle action_handle; /* acpi handle attached action method */ |
133 | char *action_method; /* action method */ | 134 | char *action_method; /* action method */ |
134 | void *poll_result; /* polling_result */ | 135 | union acpi_object *poll_result; /* polling_result */ |
135 | struct proc_dir_entry *proc; | 136 | struct proc_dir_entry *proc; |
136 | }; | 137 | }; |
137 | 138 | ||
@@ -162,20 +163,25 @@ static struct acpi_driver hotkey_driver = { | |||
162 | }, | 163 | }, |
163 | }; | 164 | }; |
164 | 165 | ||
166 | static void free_hotkey_device(union acpi_hotkey *key); | ||
167 | static void free_hotkey_buffer(union acpi_hotkey *key); | ||
168 | static void free_poll_hotkey_buffer(union acpi_hotkey *key); | ||
165 | static int hotkey_open_config(struct inode *inode, struct file *file); | 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); | ||
166 | static ssize_t hotkey_write_config(struct file *file, | 171 | static ssize_t hotkey_write_config(struct file *file, |
167 | const char __user * buffer, | 172 | const char __user * buffer, |
168 | size_t count, loff_t * data); | 173 | size_t count, loff_t * data); |
169 | static ssize_t hotkey_write_poll_config(struct file *file, | ||
170 | const char __user * buffer, | ||
171 | size_t count, loff_t * data); | ||
172 | static int hotkey_info_open_fs(struct inode *inode, struct file *file); | 174 | static int hotkey_info_open_fs(struct inode *inode, struct file *file); |
173 | static int hotkey_action_open_fs(struct inode *inode, struct file *file); | 175 | static int hotkey_action_open_fs(struct inode *inode, struct file *file); |
174 | static ssize_t hotkey_execute_aml_method(struct file *file, | 176 | static ssize_t hotkey_execute_aml_method(struct file *file, |
175 | const char __user * buffer, | 177 | const char __user * buffer, |
176 | size_t count, loff_t * data); | 178 | size_t count, loff_t * data); |
177 | static int hotkey_config_seq_show(struct seq_file *seq, void *offset); | 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); | ||
178 | static int hotkey_polling_open_fs(struct inode *inode, struct file *file); | 181 | static int hotkey_polling_open_fs(struct inode *inode, struct file *file); |
182 | static union acpi_hotkey *get_hotkey_by_event(struct | ||
183 | acpi_hotkey_list | ||
184 | *hotkey_list, int event); | ||
179 | 185 | ||
180 | /* event based config */ | 186 | /* event based config */ |
181 | static struct file_operations hotkey_config_fops = { | 187 | static struct file_operations hotkey_config_fops = { |
@@ -188,9 +194,9 @@ static struct file_operations hotkey_config_fops = { | |||
188 | 194 | ||
189 | /* polling based config */ | 195 | /* polling based config */ |
190 | static struct file_operations hotkey_poll_config_fops = { | 196 | static struct file_operations hotkey_poll_config_fops = { |
191 | .open = hotkey_open_config, | 197 | .open = hotkey_poll_open_config, |
192 | .read = seq_read, | 198 | .read = seq_read, |
193 | .write = hotkey_write_poll_config, | 199 | .write = hotkey_write_config, |
194 | .llseek = seq_lseek, | 200 | .llseek = seq_lseek, |
195 | .release = single_release, | 201 | .release = single_release, |
196 | }; | 202 | }; |
@@ -227,7 +233,7 @@ static int hotkey_info_seq_show(struct seq_file *seq, void *offset) | |||
227 | { | 233 | { |
228 | ACPI_FUNCTION_TRACE("hotkey_info_seq_show"); | 234 | ACPI_FUNCTION_TRACE("hotkey_info_seq_show"); |
229 | 235 | ||
230 | seq_printf(seq, "Hotkey generic driver ver: %s", HOTKEY_ACPI_VERSION); | 236 | seq_printf(seq, "Hotkey generic driver ver: %s\n", HOTKEY_ACPI_VERSION); |
231 | 237 | ||
232 | return_VALUE(0); | 238 | return_VALUE(0); |
233 | } | 239 | } |
@@ -239,27 +245,35 @@ static int hotkey_info_open_fs(struct inode *inode, struct file *file) | |||
239 | 245 | ||
240 | static char *format_result(union acpi_object *object) | 246 | static char *format_result(union acpi_object *object) |
241 | { | 247 | { |
242 | char *buf = (char *)kmalloc(sizeof(union acpi_object), GFP_KERNEL); | 248 | char *buf = NULL; |
243 | 249 | ||
244 | memset(buf, 0, sizeof(union acpi_object)); | 250 | buf = (char *)kmalloc(RESULT_STR_LEN, GFP_KERNEL); |
251 | if (buf) | ||
252 | memset(buf, 0, RESULT_STR_LEN); | ||
253 | else | ||
254 | goto do_fail; | ||
245 | 255 | ||
246 | /* Now, just support integer type */ | 256 | /* Now, just support integer type */ |
247 | if (object->type == ACPI_TYPE_INTEGER) | 257 | if (object->type == ACPI_TYPE_INTEGER) |
248 | sprintf(buf, "%d", (u32) object->integer.value); | 258 | sprintf(buf, "%d\n", (u32) object->integer.value); |
249 | 259 | do_fail: | |
250 | return buf; | 260 | return (buf); |
251 | } | 261 | } |
252 | 262 | ||
253 | static int hotkey_polling_seq_show(struct seq_file *seq, void *offset) | 263 | static int hotkey_polling_seq_show(struct seq_file *seq, void *offset) |
254 | { | 264 | { |
255 | struct acpi_polling_hotkey *poll_hotkey = | 265 | struct acpi_polling_hotkey *poll_hotkey = |
256 | (struct acpi_polling_hotkey *)seq->private; | 266 | (struct acpi_polling_hotkey *)seq->private; |
267 | char *buf; | ||
257 | 268 | ||
258 | ACPI_FUNCTION_TRACE("hotkey_polling_seq_show"); | 269 | ACPI_FUNCTION_TRACE("hotkey_polling_seq_show"); |
259 | 270 | ||
260 | if (poll_hotkey->poll_result) | 271 | if (poll_hotkey->poll_result){ |
261 | seq_printf(seq, "%s", format_result(poll_hotkey->poll_result)); | 272 | buf = format_result(poll_hotkey->poll_result); |
262 | 273 | if(buf) | |
274 | seq_printf(seq, "%s", buf); | ||
275 | kfree(buf); | ||
276 | } | ||
263 | return_VALUE(0); | 277 | return_VALUE(0); |
264 | } | 278 | } |
265 | 279 | ||
@@ -276,19 +290,19 @@ static int hotkey_action_open_fs(struct inode *inode, struct file *file) | |||
276 | /* Mapping external hotkey number to standardized hotkey event num */ | 290 | /* Mapping external hotkey number to standardized hotkey event num */ |
277 | static int hotkey_get_internal_event(int event, struct acpi_hotkey_list *list) | 291 | static int hotkey_get_internal_event(int event, struct acpi_hotkey_list *list) |
278 | { | 292 | { |
279 | struct list_head *entries, *next; | 293 | struct list_head *entries; |
280 | int val = 0; | 294 | int val = -1; |
281 | 295 | ||
282 | ACPI_FUNCTION_TRACE("hotkey_get_internal_event"); | 296 | ACPI_FUNCTION_TRACE("hotkey_get_internal_event"); |
283 | 297 | ||
284 | list_for_each_safe(entries, next, list->entries) { | 298 | list_for_each(entries, list->entries) { |
285 | union acpi_hotkey *key = | 299 | union acpi_hotkey *key = |
286 | container_of(entries, union acpi_hotkey, entries); | 300 | container_of(entries, union acpi_hotkey, entries); |
287 | if (key->link.hotkey_type == ACPI_HOTKEY_EVENT | 301 | if (key->link.hotkey_type == ACPI_HOTKEY_EVENT |
288 | && key->event_hotkey.external_hotkey_num == event) | 302 | && key->event_hotkey.external_hotkey_num == event){ |
289 | val = key->link.hotkey_standard_num; | 303 | val = key->link.hotkey_standard_num; |
290 | else | 304 | break; |
291 | val = -1; | 305 | } |
292 | } | 306 | } |
293 | 307 | ||
294 | return_VALUE(val); | 308 | return_VALUE(val); |
@@ -306,7 +320,7 @@ acpi_hotkey_notify_handler(acpi_handle handle, u32 event, void *data) | |||
306 | return_VOID; | 320 | return_VOID; |
307 | 321 | ||
308 | internal_event = hotkey_get_internal_event(event, &global_hotkey_list); | 322 | internal_event = hotkey_get_internal_event(event, &global_hotkey_list); |
309 | acpi_bus_generate_event(device, event, 0); | 323 | acpi_bus_generate_event(device, internal_event, 0); |
310 | 324 | ||
311 | return_VOID; | 325 | return_VOID; |
312 | } | 326 | } |
@@ -329,13 +343,17 @@ static int auto_hotkey_remove(struct acpi_device *device, int type) | |||
329 | static int create_polling_proc(union acpi_hotkey *device) | 343 | static int create_polling_proc(union acpi_hotkey *device) |
330 | { | 344 | { |
331 | struct proc_dir_entry *proc; | 345 | struct proc_dir_entry *proc; |
346 | char proc_name[80]; | ||
332 | mode_t mode; | 347 | mode_t mode; |
333 | 348 | ||
334 | ACPI_FUNCTION_TRACE("create_polling_proc"); | 349 | ACPI_FUNCTION_TRACE("create_polling_proc"); |
335 | mode = S_IFREG | S_IRUGO | S_IWUGO; | 350 | mode = S_IFREG | S_IRUGO | S_IWUGO; |
336 | 351 | ||
337 | proc = create_proc_entry(device->poll_hotkey.action_method, | 352 | sprintf(proc_name, "%d", device->link.hotkey_standard_num); |
338 | mode, hotkey_proc_dir); | 353 | /* |
354 | strcat(proc_name, device->poll_hotkey.poll_method); | ||
355 | */ | ||
356 | proc = create_proc_entry(proc_name, mode, hotkey_proc_dir); | ||
339 | 357 | ||
340 | if (!proc) { | 358 | if (!proc) { |
341 | ACPI_DEBUG_PRINT((ACPI_DB_ERROR, | 359 | ACPI_DEBUG_PRINT((ACPI_DB_ERROR, |
@@ -353,23 +371,6 @@ static int create_polling_proc(union acpi_hotkey *device) | |||
353 | return_VALUE(0); | 371 | return_VALUE(0); |
354 | } | 372 | } |
355 | 373 | ||
356 | static int is_valid_acpi_path(const char *pathname) | ||
357 | { | ||
358 | acpi_handle handle; | ||
359 | acpi_status status; | ||
360 | ACPI_FUNCTION_TRACE("is_valid_acpi_path"); | ||
361 | |||
362 | status = acpi_get_handle(NULL, (char *)pathname, &handle); | ||
363 | return_VALUE(!ACPI_FAILURE(status)); | ||
364 | } | ||
365 | |||
366 | static int is_valid_hotkey(union acpi_hotkey *device) | ||
367 | { | ||
368 | ACPI_FUNCTION_TRACE("is_valid_hotkey"); | ||
369 | /* Implement valid check */ | ||
370 | return_VALUE(1); | ||
371 | } | ||
372 | |||
373 | static int hotkey_add(union acpi_hotkey *device) | 374 | static int hotkey_add(union acpi_hotkey *device) |
374 | { | 375 | { |
375 | int status = 0; | 376 | int status = 0; |
@@ -378,15 +379,11 @@ static int hotkey_add(union acpi_hotkey *device) | |||
378 | ACPI_FUNCTION_TRACE("hotkey_add"); | 379 | ACPI_FUNCTION_TRACE("hotkey_add"); |
379 | 380 | ||
380 | if (device->link.hotkey_type == ACPI_HOTKEY_EVENT) { | 381 | if (device->link.hotkey_type == ACPI_HOTKEY_EVENT) { |
381 | status = | 382 | acpi_bus_get_device(device->event_hotkey.bus_handle, &dev); |
382 | acpi_bus_get_device(device->event_hotkey.bus_handle, &dev); | ||
383 | if (status) | ||
384 | return_VALUE(status); | ||
385 | |||
386 | status = acpi_install_notify_handler(dev->handle, | 383 | status = acpi_install_notify_handler(dev->handle, |
387 | ACPI_SYSTEM_NOTIFY, | 384 | ACPI_DEVICE_NOTIFY, |
388 | acpi_hotkey_notify_handler, | 385 | acpi_hotkey_notify_handler, |
389 | device); | 386 | dev); |
390 | } else /* Add polling hotkey */ | 387 | } else /* Add polling hotkey */ |
391 | create_polling_proc(device); | 388 | create_polling_proc(device); |
392 | 389 | ||
@@ -409,84 +406,143 @@ static int hotkey_remove(union acpi_hotkey *device) | |||
409 | if (key->link.hotkey_standard_num == | 406 | if (key->link.hotkey_standard_num == |
410 | device->link.hotkey_standard_num) { | 407 | device->link.hotkey_standard_num) { |
411 | list_del(&key->link.entries); | 408 | list_del(&key->link.entries); |
412 | remove_proc_entry(key->poll_hotkey.action_method, | 409 | free_hotkey_device(key); |
413 | hotkey_proc_dir); | ||
414 | global_hotkey_list.count--; | 410 | global_hotkey_list.count--; |
415 | break; | 411 | break; |
416 | } | 412 | } |
417 | } | 413 | } |
414 | kfree(device); | ||
418 | return_VALUE(0); | 415 | return_VALUE(0); |
419 | } | 416 | } |
420 | 417 | ||
421 | static void hotkey_update(union acpi_hotkey *key) | 418 | static int hotkey_update(union acpi_hotkey *key) |
422 | { | 419 | { |
423 | struct list_head *entries, *next; | 420 | struct list_head *entries; |
424 | 421 | ||
425 | ACPI_FUNCTION_TRACE("hotkey_update"); | 422 | ACPI_FUNCTION_TRACE("hotkey_update"); |
426 | 423 | ||
427 | list_for_each_safe(entries, next, global_hotkey_list.entries) { | 424 | list_for_each(entries, global_hotkey_list.entries) { |
428 | union acpi_hotkey *key = | 425 | union acpi_hotkey *tmp= |
429 | container_of(entries, union acpi_hotkey, entries); | 426 | container_of(entries, union acpi_hotkey, entries); |
430 | if (key->link.hotkey_standard_num == | 427 | if (tmp->link.hotkey_standard_num == |
431 | key->link.hotkey_standard_num) { | 428 | key->link.hotkey_standard_num) { |
432 | key->event_hotkey.bus_handle = | 429 | if (key->link.hotkey_type == ACPI_HOTKEY_EVENT) { |
433 | key->event_hotkey.bus_handle; | 430 | free_hotkey_buffer(tmp); |
434 | key->event_hotkey.external_hotkey_num = | 431 | tmp->event_hotkey.bus_handle = |
435 | key->event_hotkey.external_hotkey_num; | 432 | key->event_hotkey.bus_handle; |
436 | key->event_hotkey.action_handle = | 433 | tmp->event_hotkey.external_hotkey_num = |
437 | key->event_hotkey.action_handle; | 434 | key->event_hotkey.external_hotkey_num; |
438 | key->event_hotkey.action_method = | 435 | tmp->event_hotkey.action_handle = |
439 | key->event_hotkey.action_method; | 436 | key->event_hotkey.action_handle; |
437 | tmp->event_hotkey.action_method = | ||
438 | key->event_hotkey.action_method; | ||
439 | kfree(key); | ||
440 | } else { | ||
441 | /* | ||
442 | char proc_name[80]; | ||
443 | |||
444 | sprintf(proc_name, "%d", tmp->link.hotkey_standard_num); | ||
445 | strcat(proc_name, tmp->poll_hotkey.poll_method); | ||
446 | remove_proc_entry(proc_name,hotkey_proc_dir); | ||
447 | */ | ||
448 | free_poll_hotkey_buffer(tmp); | ||
449 | tmp->poll_hotkey.poll_handle = | ||
450 | key->poll_hotkey.poll_handle; | ||
451 | tmp->poll_hotkey.poll_method = | ||
452 | key->poll_hotkey.poll_method; | ||
453 | tmp->poll_hotkey.action_handle = | ||
454 | key->poll_hotkey.action_handle; | ||
455 | tmp->poll_hotkey.action_method = | ||
456 | key->poll_hotkey.action_method; | ||
457 | tmp->poll_hotkey.poll_result = | ||
458 | key->poll_hotkey.poll_result; | ||
459 | /* | ||
460 | create_polling_proc(tmp); | ||
461 | */ | ||
462 | kfree(key); | ||
463 | } | ||
464 | return_VALUE(0); | ||
440 | break; | 465 | break; |
441 | } | 466 | } |
442 | } | 467 | } |
443 | 468 | ||
444 | return_VOID; | 469 | return_VALUE(-ENODEV); |
445 | } | 470 | } |
446 | 471 | ||
447 | static void free_hotkey_device(union acpi_hotkey *key) | 472 | static void free_hotkey_device(union acpi_hotkey *key) |
448 | { | 473 | { |
449 | struct acpi_device *dev; | 474 | struct acpi_device *dev; |
450 | int status; | ||
451 | 475 | ||
452 | ACPI_FUNCTION_TRACE("free_hotkey_device"); | 476 | ACPI_FUNCTION_TRACE("free_hotkey_device"); |
453 | 477 | ||
454 | if (key->link.hotkey_type == ACPI_HOTKEY_EVENT) { | 478 | if (key->link.hotkey_type == ACPI_HOTKEY_EVENT) { |
455 | status = | 479 | acpi_bus_get_device(key->event_hotkey.bus_handle, &dev); |
456 | acpi_bus_get_device(key->event_hotkey.bus_handle, &dev); | ||
457 | if (dev->handle) | 480 | if (dev->handle) |
458 | acpi_remove_notify_handler(dev->handle, | 481 | acpi_remove_notify_handler(dev->handle, |
459 | ACPI_SYSTEM_NOTIFY, | 482 | ACPI_DEVICE_NOTIFY, |
460 | acpi_hotkey_notify_handler); | 483 | acpi_hotkey_notify_handler); |
461 | } else | 484 | free_hotkey_buffer(key); |
462 | remove_proc_entry(key->poll_hotkey.action_method, | 485 | } else { |
463 | hotkey_proc_dir); | 486 | char proc_name[80]; |
487 | |||
488 | sprintf(proc_name, "%d", key->link.hotkey_standard_num); | ||
489 | /* | ||
490 | strcat(proc_name, key->poll_hotkey.poll_method); | ||
491 | */ | ||
492 | remove_proc_entry(proc_name,hotkey_proc_dir); | ||
493 | free_poll_hotkey_buffer(key); | ||
494 | } | ||
464 | kfree(key); | 495 | kfree(key); |
465 | return_VOID; | 496 | return_VOID; |
466 | } | 497 | } |
467 | 498 | ||
499 | static void | ||
500 | free_hotkey_buffer(union acpi_hotkey *key) | ||
501 | { | ||
502 | kfree(key->event_hotkey.action_method); | ||
503 | } | ||
504 | |||
505 | static void | ||
506 | free_poll_hotkey_buffer(union acpi_hotkey *key) | ||
507 | { | ||
508 | kfree(key->poll_hotkey.action_method); | ||
509 | kfree(key->poll_hotkey.poll_method); | ||
510 | kfree(key->poll_hotkey.poll_result); | ||
511 | } | ||
468 | static int | 512 | static int |
469 | init_hotkey_device(union acpi_hotkey *key, char *bus_str, char *action_str, | 513 | init_hotkey_device(union acpi_hotkey *key, char *bus_str, char *action_str, |
470 | char *method, int std_num, int external_num) | 514 | char *method, int std_num, int external_num) |
471 | { | 515 | { |
516 | acpi_handle tmp_handle; | ||
517 | acpi_status status = AE_OK; | ||
518 | |||
472 | ACPI_FUNCTION_TRACE("init_hotkey_device"); | 519 | ACPI_FUNCTION_TRACE("init_hotkey_device"); |
473 | 520 | ||
521 | if(std_num < 0 || IS_POLL(std_num) || !key ) | ||
522 | goto do_fail; | ||
523 | |||
524 | if(!bus_str || !action_str || !method) | ||
525 | goto do_fail; | ||
526 | |||
474 | key->link.hotkey_type = ACPI_HOTKEY_EVENT; | 527 | key->link.hotkey_type = ACPI_HOTKEY_EVENT; |
475 | key->link.hotkey_standard_num = std_num; | 528 | key->link.hotkey_standard_num = std_num; |
476 | key->event_hotkey.flag = 0; | 529 | key->event_hotkey.flag = 0; |
477 | if (is_valid_acpi_path(bus_str)) | 530 | key->event_hotkey.action_method = method; |
478 | acpi_get_handle((acpi_handle) 0, | ||
479 | bus_str, &(key->event_hotkey.bus_handle)); | ||
480 | else | ||
481 | return_VALUE(-ENODEV); | ||
482 | key->event_hotkey.external_hotkey_num = external_num; | ||
483 | if (is_valid_acpi_path(action_str)) | ||
484 | acpi_get_handle((acpi_handle) 0, | ||
485 | action_str, &(key->event_hotkey.action_handle)); | ||
486 | key->event_hotkey.action_method = kmalloc(sizeof(method), GFP_KERNEL); | ||
487 | strcpy(key->event_hotkey.action_method, method); | ||
488 | 531 | ||
489 | return_VALUE(!is_valid_hotkey(key)); | 532 | status = acpi_get_handle(NULL,bus_str, &(key->event_hotkey.bus_handle)); |
533 | if(ACPI_FAILURE(status)) | ||
534 | goto do_fail; | ||
535 | key->event_hotkey.external_hotkey_num = external_num; | ||
536 | status = acpi_get_handle(NULL,action_str, &(key->event_hotkey.action_handle)); | ||
537 | if(ACPI_FAILURE(status)) | ||
538 | goto do_fail; | ||
539 | status = acpi_get_handle(key->event_hotkey.action_handle, | ||
540 | method, &tmp_handle); | ||
541 | if (ACPI_FAILURE(status)) | ||
542 | goto do_fail; | ||
543 | return_VALUE(AE_OK); | ||
544 | do_fail: | ||
545 | return_VALUE(-ENODEV); | ||
490 | } | 546 | } |
491 | 547 | ||
492 | static int | 548 | static int |
@@ -495,34 +551,46 @@ init_poll_hotkey_device(union acpi_hotkey *key, | |||
495 | char *poll_method, | 551 | char *poll_method, |
496 | char *action_str, char *action_method, int std_num) | 552 | char *action_str, char *action_method, int std_num) |
497 | { | 553 | { |
554 | acpi_status status = AE_OK; | ||
555 | acpi_handle tmp_handle; | ||
556 | |||
498 | ACPI_FUNCTION_TRACE("init_poll_hotkey_device"); | 557 | ACPI_FUNCTION_TRACE("init_poll_hotkey_device"); |
499 | 558 | ||
559 | if(std_num < 0 || IS_EVENT(std_num) || !key) | ||
560 | goto do_fail; | ||
561 | |||
562 | if(!poll_str || !poll_method || !action_str || !action_method) | ||
563 | goto do_fail; | ||
564 | |||
500 | key->link.hotkey_type = ACPI_HOTKEY_POLLING; | 565 | key->link.hotkey_type = ACPI_HOTKEY_POLLING; |
501 | key->link.hotkey_standard_num = std_num; | 566 | key->link.hotkey_standard_num = std_num; |
502 | key->poll_hotkey.flag = 0; | 567 | key->poll_hotkey.flag = 0; |
503 | if (is_valid_acpi_path(poll_str)) | ||
504 | acpi_get_handle((acpi_handle) 0, | ||
505 | poll_str, &(key->poll_hotkey.poll_handle)); | ||
506 | else | ||
507 | return_VALUE(-ENODEV); | ||
508 | key->poll_hotkey.poll_method = poll_method; | 568 | key->poll_hotkey.poll_method = poll_method; |
509 | if (is_valid_acpi_path(action_str)) | 569 | key->poll_hotkey.action_method = action_method; |
510 | acpi_get_handle((acpi_handle) 0, | 570 | |
511 | action_str, &(key->poll_hotkey.action_handle)); | 571 | status = acpi_get_handle(NULL,poll_str, &(key->poll_hotkey.poll_handle)); |
512 | key->poll_hotkey.action_method = | 572 | if(ACPI_FAILURE(status)) |
513 | kmalloc(sizeof(action_method), GFP_KERNEL); | 573 | goto do_fail; |
514 | strcpy(key->poll_hotkey.action_method, action_method); | 574 | status = acpi_get_handle(key->poll_hotkey.poll_handle, |
575 | poll_method, &tmp_handle); | ||
576 | if (ACPI_FAILURE(status)) | ||
577 | goto do_fail; | ||
578 | status = acpi_get_handle(NULL,action_str, &(key->poll_hotkey.action_handle)); | ||
579 | if (ACPI_FAILURE(status)) | ||
580 | goto do_fail; | ||
581 | status = acpi_get_handle(key->poll_hotkey.action_handle, | ||
582 | action_method, &tmp_handle); | ||
583 | if (ACPI_FAILURE(status)) | ||
584 | goto do_fail; | ||
515 | key->poll_hotkey.poll_result = | 585 | key->poll_hotkey.poll_result = |
516 | (union acpi_object *)kmalloc(sizeof(union acpi_object), GFP_KERNEL); | 586 | (union acpi_object *)kmalloc(sizeof(union acpi_object), GFP_KERNEL); |
517 | return_VALUE(is_valid_hotkey(key)); | 587 | if(!key->poll_hotkey.poll_result) |
588 | goto do_fail; | ||
589 | return_VALUE(AE_OK); | ||
590 | do_fail: | ||
591 | return_VALUE(-ENODEV); | ||
518 | } | 592 | } |
519 | 593 | ||
520 | static int check_hotkey_valid(union acpi_hotkey *key, | ||
521 | struct acpi_hotkey_list *list) | ||
522 | { | ||
523 | ACPI_FUNCTION_TRACE("check_hotkey_valid"); | ||
524 | return_VALUE(0); | ||
525 | } | ||
526 | 594 | ||
527 | static int hotkey_open_config(struct inode *inode, struct file *file) | 595 | static int hotkey_open_config(struct inode *inode, struct file *file) |
528 | { | 596 | { |
@@ -531,10 +599,17 @@ static int hotkey_open_config(struct inode *inode, struct file *file) | |||
531 | (file, hotkey_config_seq_show, PDE(inode)->data)); | 599 | (file, hotkey_config_seq_show, PDE(inode)->data)); |
532 | } | 600 | } |
533 | 601 | ||
602 | static int hotkey_poll_open_config(struct inode *inode, struct file *file) | ||
603 | { | ||
604 | ACPI_FUNCTION_TRACE("hotkey_poll_open_config"); | ||
605 | return_VALUE(single_open | ||
606 | (file, hotkey_poll_config_seq_show, PDE(inode)->data)); | ||
607 | } | ||
608 | |||
534 | static int hotkey_config_seq_show(struct seq_file *seq, void *offset) | 609 | static int hotkey_config_seq_show(struct seq_file *seq, void *offset) |
535 | { | 610 | { |
536 | struct acpi_hotkey_list *hotkey_list = &global_hotkey_list; | 611 | struct acpi_hotkey_list *hotkey_list = &global_hotkey_list; |
537 | struct list_head *entries, *next; | 612 | struct list_head *entries; |
538 | char bus_name[ACPI_PATHNAME_MAX] = { 0 }; | 613 | char bus_name[ACPI_PATHNAME_MAX] = { 0 }; |
539 | char action_name[ACPI_PATHNAME_MAX] = { 0 }; | 614 | char action_name[ACPI_PATHNAME_MAX] = { 0 }; |
540 | struct acpi_buffer bus = { ACPI_PATHNAME_MAX, bus_name }; | 615 | struct acpi_buffer bus = { ACPI_PATHNAME_MAX, bus_name }; |
@@ -542,10 +617,7 @@ static int hotkey_config_seq_show(struct seq_file *seq, void *offset) | |||
542 | 617 | ||
543 | ACPI_FUNCTION_TRACE(("hotkey_config_seq_show")); | 618 | ACPI_FUNCTION_TRACE(("hotkey_config_seq_show")); |
544 | 619 | ||
545 | if (!hotkey_list) | 620 | list_for_each(entries, hotkey_list->entries) { |
546 | goto end; | ||
547 | |||
548 | list_for_each_safe(entries, next, hotkey_list->entries) { | ||
549 | union acpi_hotkey *key = | 621 | union acpi_hotkey *key = |
550 | container_of(entries, union acpi_hotkey, entries); | 622 | container_of(entries, union acpi_hotkey, entries); |
551 | if (key->link.hotkey_type == ACPI_HOTKEY_EVENT) { | 623 | if (key->link.hotkey_type == ACPI_HOTKEY_EVENT) { |
@@ -553,18 +625,37 @@ static int hotkey_config_seq_show(struct seq_file *seq, void *offset) | |||
553 | ACPI_NAME_TYPE_MAX, &bus); | 625 | ACPI_NAME_TYPE_MAX, &bus); |
554 | acpi_get_name(key->event_hotkey.action_handle, | 626 | acpi_get_name(key->event_hotkey.action_handle, |
555 | ACPI_NAME_TYPE_MAX, &act); | 627 | ACPI_NAME_TYPE_MAX, &act); |
556 | seq_printf(seq, "%s:%s:%s:%d:%d", bus_name, | 628 | seq_printf(seq, "%s:%s:%s:%d:%d\n", bus_name, |
557 | action_name, | 629 | action_name, |
558 | key->event_hotkey.action_method, | 630 | key->event_hotkey.action_method, |
559 | key->link.hotkey_standard_num, | 631 | key->link.hotkey_standard_num, |
560 | key->event_hotkey.external_hotkey_num); | 632 | key->event_hotkey.external_hotkey_num); |
561 | } /* ACPI_HOTKEY_POLLING */ | 633 | } |
562 | else { | 634 | } |
635 | seq_puts(seq, "\n"); | ||
636 | return_VALUE(0); | ||
637 | } | ||
638 | |||
639 | static int hotkey_poll_config_seq_show(struct seq_file *seq, void *offset) | ||
640 | { | ||
641 | struct acpi_hotkey_list *hotkey_list = &global_hotkey_list; | ||
642 | struct list_head *entries; | ||
643 | char bus_name[ACPI_PATHNAME_MAX] = { 0 }; | ||
644 | char action_name[ACPI_PATHNAME_MAX] = { 0 }; | ||
645 | struct acpi_buffer bus = { ACPI_PATHNAME_MAX, bus_name }; | ||
646 | struct acpi_buffer act = { ACPI_PATHNAME_MAX, action_name }; | ||
647 | |||
648 | ACPI_FUNCTION_TRACE(("hotkey_config_seq_show")); | ||
649 | |||
650 | list_for_each(entries, hotkey_list->entries) { | ||
651 | union acpi_hotkey *key = | ||
652 | container_of(entries, union acpi_hotkey, entries); | ||
653 | if (key->link.hotkey_type == ACPI_HOTKEY_POLLING) { | ||
563 | acpi_get_name(key->poll_hotkey.poll_handle, | 654 | acpi_get_name(key->poll_hotkey.poll_handle, |
564 | ACPI_NAME_TYPE_MAX, &bus); | 655 | ACPI_NAME_TYPE_MAX, &bus); |
565 | acpi_get_name(key->poll_hotkey.action_handle, | 656 | acpi_get_name(key->poll_hotkey.action_handle, |
566 | ACPI_NAME_TYPE_MAX, &act); | 657 | ACPI_NAME_TYPE_MAX, &act); |
567 | seq_printf(seq, "%s:%s:%s:%s:%d", bus_name, | 658 | seq_printf(seq, "%s:%s:%s:%s:%d\n", bus_name, |
568 | key->poll_hotkey.poll_method, | 659 | key->poll_hotkey.poll_method, |
569 | action_name, | 660 | action_name, |
570 | key->poll_hotkey.action_method, | 661 | key->poll_hotkey.action_method, |
@@ -572,49 +663,83 @@ static int hotkey_config_seq_show(struct seq_file *seq, void *offset) | |||
572 | } | 663 | } |
573 | } | 664 | } |
574 | seq_puts(seq, "\n"); | 665 | seq_puts(seq, "\n"); |
575 | end: | ||
576 | return_VALUE(0); | 666 | return_VALUE(0); |
577 | } | 667 | } |
578 | 668 | ||
579 | static int | 669 | static int |
580 | get_parms(char *config_record, | 670 | get_parms(char *config_record, |
581 | int *cmd, | 671 | int *cmd, |
582 | char *bus_handle, | 672 | char **bus_handle, |
583 | char *bus_method, | 673 | char **bus_method, |
584 | char *action_handle, | 674 | char **action_handle, |
585 | char *method, int *internal_event_num, int *external_event_num) | 675 | char **method, int *internal_event_num, int *external_event_num) |
586 | { | 676 | { |
587 | char *tmp, *tmp1; | 677 | char *tmp, *tmp1, count; |
588 | ACPI_FUNCTION_TRACE(("get_parms")); | 678 | ACPI_FUNCTION_TRACE(("get_parms")); |
589 | 679 | ||
590 | sscanf(config_record, "%d", cmd); | 680 | sscanf(config_record, "%d", cmd); |
591 | 681 | ||
682 | if(*cmd == 1){ | ||
683 | if(sscanf(config_record, "%d:%d", cmd, internal_event_num)!=2) | ||
684 | goto do_fail; | ||
685 | else | ||
686 | return (6); | ||
687 | } | ||
592 | tmp = strchr(config_record, ':'); | 688 | tmp = strchr(config_record, ':'); |
689 | if (!tmp) | ||
690 | goto do_fail; | ||
593 | tmp++; | 691 | tmp++; |
594 | tmp1 = strchr(tmp, ':'); | 692 | tmp1 = strchr(tmp, ':'); |
595 | strncpy(bus_handle, tmp, tmp1 - tmp); | 693 | if (!tmp1) |
596 | bus_handle[tmp1 - tmp] = 0; | 694 | goto do_fail; |
695 | |||
696 | count = tmp1 - tmp; | ||
697 | *bus_handle = (char *) kmalloc(count+1, GFP_KERNEL); | ||
698 | if(!*bus_handle) | ||
699 | goto do_fail; | ||
700 | strncpy(*bus_handle, tmp, count); | ||
701 | *(*bus_handle + count) = 0; | ||
597 | 702 | ||
598 | tmp = tmp1; | 703 | tmp = tmp1; |
599 | tmp++; | 704 | tmp++; |
600 | tmp1 = strchr(tmp, ':'); | 705 | tmp1 = strchr(tmp, ':'); |
601 | strncpy(bus_method, tmp, tmp1 - tmp); | 706 | if (!tmp1) |
602 | bus_method[tmp1 - tmp] = 0; | 707 | goto do_fail; |
708 | count = tmp1 - tmp; | ||
709 | *bus_method = (char *) kmalloc(count+1, GFP_KERNEL); | ||
710 | if(!*bus_method) | ||
711 | goto do_fail; | ||
712 | strncpy(*bus_method, tmp, count); | ||
713 | *(*bus_method + count) = 0; | ||
603 | 714 | ||
604 | tmp = tmp1; | 715 | tmp = tmp1; |
605 | tmp++; | 716 | tmp++; |
606 | tmp1 = strchr(tmp, ':'); | 717 | tmp1 = strchr(tmp, ':'); |
607 | strncpy(action_handle, tmp, tmp1 - tmp); | 718 | if (!tmp1) |
608 | action_handle[tmp1 - tmp] = 0; | 719 | goto do_fail; |
720 | count = tmp1 - tmp; | ||
721 | *action_handle = (char *) kmalloc(count+1, GFP_KERNEL); | ||
722 | strncpy(*action_handle, tmp, count); | ||
723 | *(*action_handle + count) = 0; | ||
609 | 724 | ||
610 | tmp = tmp1; | 725 | tmp = tmp1; |
611 | tmp++; | 726 | tmp++; |
612 | tmp1 = strchr(tmp, ':'); | 727 | tmp1 = strchr(tmp, ':'); |
613 | strncpy(method, tmp, tmp1 - tmp); | 728 | if (!tmp1) |
614 | method[tmp1 - tmp] = 0; | 729 | goto do_fail; |
730 | count = tmp1 - tmp; | ||
731 | *method = (char *) kmalloc(count+1, GFP_KERNEL); | ||
732 | if(!*method) | ||
733 | goto do_fail; | ||
734 | strncpy(*method, tmp, count); | ||
735 | *(*method + count) = 0; | ||
736 | |||
737 | if(sscanf(tmp1 + 1, "%d:%d", internal_event_num, external_event_num)<=0) | ||
738 | goto do_fail; | ||
615 | 739 | ||
616 | sscanf(tmp1 + 1, "%d:%d", internal_event_num, external_event_num); | ||
617 | return_VALUE(6); | 740 | return_VALUE(6); |
741 | do_fail: | ||
742 | return_VALUE(-1); | ||
618 | } | 743 | } |
619 | 744 | ||
620 | /* count is length for one input record */ | 745 | /* count is length for one input record */ |
@@ -622,135 +747,117 @@ static ssize_t hotkey_write_config(struct file *file, | |||
622 | const char __user * buffer, | 747 | const char __user * buffer, |
623 | size_t count, loff_t * data) | 748 | size_t count, loff_t * data) |
624 | { | 749 | { |
625 | struct acpi_hotkey_list *hotkey_list = &global_hotkey_list; | 750 | char *config_record = NULL; |
626 | char config_record[MAX_CONFIG_RECORD_LEN]; | 751 | char *bus_handle = NULL; |
627 | char bus_handle[MAX_NAME_PATH_LEN]; | 752 | char *bus_method = NULL; |
628 | char bus_method[MAX_NAME_PATH_LEN]; | 753 | char *action_handle = NULL; |
629 | char action_handle[MAX_NAME_PATH_LEN]; | 754 | char *method = NULL; |
630 | char method[20]; | ||
631 | int cmd, internal_event_num, external_event_num; | 755 | int cmd, internal_event_num, external_event_num; |
632 | int ret = 0; | 756 | int ret = 0; |
633 | union acpi_hotkey *key = NULL; | 757 | union acpi_hotkey *key = NULL; |
634 | 758 | ||
635 | ACPI_FUNCTION_TRACE(("hotkey_write_config")); | 759 | ACPI_FUNCTION_TRACE(("hotkey_write_config")); |
636 | 760 | ||
637 | if (!hotkey_list || count > MAX_CONFIG_RECORD_LEN) { | 761 | config_record = (char *) kmalloc(count+1, GFP_KERNEL); |
638 | ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid arguments\n")); | 762 | if(!config_record) |
639 | return_VALUE(-EINVAL); | 763 | return_VALUE(-ENOMEM); |
640 | } | ||
641 | 764 | ||
642 | if (copy_from_user(config_record, buffer, count)) { | 765 | if (copy_from_user(config_record, buffer, count)) { |
766 | kfree(config_record); | ||
643 | ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid data \n")); | 767 | ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid data \n")); |
644 | return_VALUE(-EINVAL); | 768 | return_VALUE(-EINVAL); |
645 | } | 769 | } |
646 | config_record[count] = '\0'; | 770 | config_record[count] = 0; |
647 | 771 | ||
648 | ret = get_parms(config_record, | 772 | ret = get_parms(config_record, |
649 | &cmd, | 773 | &cmd, |
650 | bus_handle, | 774 | &bus_handle, |
651 | bus_method, | 775 | &bus_method, |
652 | action_handle, | 776 | &action_handle, |
653 | method, &internal_event_num, &external_event_num); | 777 | &method, &internal_event_num, &external_event_num); |
778 | |||
779 | kfree(config_record); | ||
780 | if(IS_OTHERS(internal_event_num)) | ||
781 | goto do_fail; | ||
654 | if (ret != 6) { | 782 | if (ret != 6) { |
783 | do_fail: | ||
784 | kfree(bus_handle); | ||
785 | kfree(bus_method); | ||
786 | kfree(action_handle); | ||
787 | kfree(method); | ||
655 | ACPI_DEBUG_PRINT((ACPI_DB_ERROR, | 788 | ACPI_DEBUG_PRINT((ACPI_DB_ERROR, |
656 | "Invalid data format ret=%d\n", ret)); | 789 | "Invalid data format ret=%d\n", ret)); |
657 | return_VALUE(-EINVAL); | 790 | return_VALUE(-EINVAL); |
658 | } | 791 | } |
659 | 792 | ||
660 | key = kmalloc(sizeof(union acpi_hotkey), GFP_KERNEL); | 793 | key = kmalloc(sizeof(union acpi_hotkey), GFP_KERNEL); |
661 | ret = init_hotkey_device(key, bus_handle, action_handle, method, | 794 | if(!key) |
795 | goto do_fail; | ||
796 | memset(key, 0, sizeof(union acpi_hotkey)); | ||
797 | if(cmd == 1) { | ||
798 | union acpi_hotkey *tmp = NULL; | ||
799 | tmp = get_hotkey_by_event(&global_hotkey_list, | ||
800 | internal_event_num); | ||
801 | if(!tmp) | ||
802 | ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid key")); | ||
803 | else | ||
804 | memcpy(key, tmp, sizeof(union acpi_hotkey)); | ||
805 | goto cont_cmd; | ||
806 | } | ||
807 | if (IS_EVENT(internal_event_num)) { | ||
808 | kfree(bus_method); | ||
809 | ret = init_hotkey_device(key, bus_handle, action_handle, method, | ||
662 | internal_event_num, external_event_num); | 810 | internal_event_num, external_event_num); |
663 | 811 | } else | |
664 | if (ret || check_hotkey_valid(key, hotkey_list)) { | 812 | ret = init_poll_hotkey_device(key, bus_handle, bus_method, |
813 | action_handle, method, | ||
814 | internal_event_num); | ||
815 | if (ret) { | ||
816 | kfree(bus_handle); | ||
817 | kfree(action_handle); | ||
818 | if(IS_EVENT(internal_event_num)) | ||
819 | free_hotkey_buffer(key); | ||
820 | else | ||
821 | free_poll_hotkey_buffer(key); | ||
665 | kfree(key); | 822 | kfree(key); |
666 | ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid hotkey \n")); | 823 | ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid hotkey \n")); |
667 | return_VALUE(-EINVAL); | 824 | return_VALUE(-EINVAL); |
668 | } | 825 | } |
669 | switch (cmd) { | ||
670 | case 0: | ||
671 | hotkey_add(key); | ||
672 | break; | ||
673 | case 1: | ||
674 | hotkey_remove(key); | ||
675 | free_hotkey_device(key); | ||
676 | break; | ||
677 | case 2: | ||
678 | hotkey_update(key); | ||
679 | break; | ||
680 | default: | ||
681 | break; | ||
682 | } | ||
683 | return_VALUE(count); | ||
684 | } | ||
685 | |||
686 | /* count is length for one input record */ | ||
687 | static ssize_t hotkey_write_poll_config(struct file *file, | ||
688 | const char __user * buffer, | ||
689 | size_t count, loff_t * data) | ||
690 | { | ||
691 | struct seq_file *m = (struct seq_file *)file->private_data; | ||
692 | struct acpi_hotkey_list *hotkey_list = | ||
693 | (struct acpi_hotkey_list *)m->private; | ||
694 | |||
695 | char config_record[MAX_CONFIG_RECORD_LEN]; | ||
696 | char polling_handle[MAX_NAME_PATH_LEN]; | ||
697 | char action_handle[MAX_NAME_PATH_LEN]; | ||
698 | char poll_method[20], action_method[20]; | ||
699 | int ret, internal_event_num, cmd, external_event_num; | ||
700 | union acpi_hotkey *key = NULL; | ||
701 | |||
702 | ACPI_FUNCTION_TRACE("hotkey_write_poll_config"); | ||
703 | |||
704 | if (!hotkey_list || count > MAX_CONFIG_RECORD_LEN) { | ||
705 | ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid arguments\n")); | ||
706 | return_VALUE(-EINVAL); | ||
707 | } | ||
708 | |||
709 | if (copy_from_user(config_record, buffer, count)) { | ||
710 | ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid data \n")); | ||
711 | return_VALUE(-EINVAL); | ||
712 | } | ||
713 | config_record[count] = '\0'; | ||
714 | 826 | ||
715 | ret = get_parms(config_record, | 827 | cont_cmd: |
716 | &cmd, | 828 | kfree(bus_handle); |
717 | polling_handle, | 829 | kfree(action_handle); |
718 | poll_method, | ||
719 | action_handle, | ||
720 | action_method, | ||
721 | &internal_event_num, &external_event_num); | ||
722 | |||
723 | if (ret != 6) { | ||
724 | ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid data format\n")); | ||
725 | return_VALUE(-EINVAL); | ||
726 | } | ||
727 | 830 | ||
728 | key = kmalloc(sizeof(union acpi_hotkey), GFP_KERNEL); | ||
729 | ret = init_poll_hotkey_device(key, polling_handle, poll_method, | ||
730 | action_handle, action_method, | ||
731 | internal_event_num); | ||
732 | if (ret || check_hotkey_valid(key, hotkey_list)) { | ||
733 | kfree(key); | ||
734 | ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid hotkey \n")); | ||
735 | return_VALUE(-EINVAL); | ||
736 | } | ||
737 | switch (cmd) { | 831 | switch (cmd) { |
738 | case 0: | 832 | case 0: |
739 | hotkey_add(key); | 833 | if(get_hotkey_by_event(&global_hotkey_list,key->link.hotkey_standard_num)) |
834 | goto fail_out; | ||
835 | else | ||
836 | hotkey_add(key); | ||
740 | break; | 837 | break; |
741 | case 1: | 838 | case 1: |
742 | hotkey_remove(key); | 839 | hotkey_remove(key); |
743 | break; | 840 | break; |
744 | case 2: | 841 | case 2: |
745 | hotkey_update(key); | 842 | if(hotkey_update(key)) |
843 | goto fail_out; | ||
746 | break; | 844 | break; |
747 | default: | 845 | default: |
846 | goto fail_out; | ||
748 | break; | 847 | break; |
749 | } | 848 | } |
750 | return_VALUE(count); | 849 | return_VALUE(count); |
850 | fail_out: | ||
851 | if(IS_EVENT(internal_event_num)) | ||
852 | free_hotkey_buffer(key); | ||
853 | else | ||
854 | free_poll_hotkey_buffer(key); | ||
855 | kfree(key); | ||
856 | ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "invalid key\n")); | ||
857 | return_VALUE(-EINVAL); | ||
751 | } | 858 | } |
752 | 859 | ||
753 | /* | 860 | /* |
754 | * This function evaluates an ACPI method, given an int as parameter, the | 861 | * This function evaluates an ACPI method, given an int as parameter, the |
755 | * method is searched within the scope of the handle, can be NULL. The output | 862 | * method is searched within the scope of the handle, can be NULL. The output |
756 | * of the method is written is output, which can also be NULL | 863 | * of the method is written is output, which can also be NULL |
@@ -775,7 +882,7 @@ static int write_acpi_int(acpi_handle handle, const char *method, int val, | |||
775 | return_VALUE(status == AE_OK); | 882 | return_VALUE(status == AE_OK); |
776 | } | 883 | } |
777 | 884 | ||
778 | static int read_acpi_int(acpi_handle handle, const char *method, int *val) | 885 | static int read_acpi_int(acpi_handle handle, const char *method, union acpi_object *val) |
779 | { | 886 | { |
780 | struct acpi_buffer output; | 887 | struct acpi_buffer output; |
781 | union acpi_object out_obj; | 888 | union acpi_object out_obj; |
@@ -786,62 +893,32 @@ static int read_acpi_int(acpi_handle handle, const char *method, int *val) | |||
786 | output.pointer = &out_obj; | 893 | output.pointer = &out_obj; |
787 | 894 | ||
788 | status = acpi_evaluate_object(handle, (char *)method, NULL, &output); | 895 | status = acpi_evaluate_object(handle, (char *)method, NULL, &output); |
789 | *val = out_obj.integer.value; | 896 | if(val){ |
897 | val->integer.value = out_obj.integer.value; | ||
898 | val->type = out_obj.type; | ||
899 | } else | ||
900 | ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "null val pointer")); | ||
790 | return_VALUE((status == AE_OK) | 901 | return_VALUE((status == AE_OK) |
791 | && (out_obj.type == ACPI_TYPE_INTEGER)); | 902 | && (out_obj.type == ACPI_TYPE_INTEGER)); |
792 | } | 903 | } |
793 | 904 | ||
794 | static acpi_handle | 905 | static union acpi_hotkey *get_hotkey_by_event(struct |
795 | get_handle_from_hotkeylist(struct acpi_hotkey_list *hotkey_list, int event_num) | 906 | acpi_hotkey_list |
907 | *hotkey_list, int event) | ||
796 | { | 908 | { |
797 | struct list_head *entries, *next; | 909 | struct list_head *entries; |
798 | |||
799 | list_for_each_safe(entries, next, hotkey_list->entries) { | ||
800 | union acpi_hotkey *key = | ||
801 | container_of(entries, union acpi_hotkey, entries); | ||
802 | if (key->link.hotkey_type == ACPI_HOTKEY_EVENT | ||
803 | && key->link.hotkey_standard_num == event_num) { | ||
804 | return (key->event_hotkey.action_handle); | ||
805 | } | ||
806 | } | ||
807 | return (NULL); | ||
808 | } | ||
809 | |||
810 | static | ||
811 | char *get_method_from_hotkeylist(struct acpi_hotkey_list *hotkey_list, | ||
812 | int event_num) | ||
813 | { | ||
814 | struct list_head *entries, *next; | ||
815 | |||
816 | list_for_each_safe(entries, next, hotkey_list->entries) { | ||
817 | union acpi_hotkey *key = | ||
818 | container_of(entries, union acpi_hotkey, entries); | ||
819 | |||
820 | if (key->link.hotkey_type == ACPI_HOTKEY_EVENT && | ||
821 | key->link.hotkey_standard_num == event_num) | ||
822 | return (key->event_hotkey.action_method); | ||
823 | } | ||
824 | return (NULL); | ||
825 | } | ||
826 | |||
827 | static struct acpi_polling_hotkey *get_hotkey_by_event(struct | ||
828 | acpi_hotkey_list | ||
829 | *hotkey_list, int event) | ||
830 | { | ||
831 | struct list_head *entries, *next; | ||
832 | 910 | ||
833 | list_for_each_safe(entries, next, hotkey_list->entries) { | 911 | list_for_each(entries, hotkey_list->entries) { |
834 | union acpi_hotkey *key = | 912 | union acpi_hotkey *key = |
835 | container_of(entries, union acpi_hotkey, entries); | 913 | container_of(entries, union acpi_hotkey, entries); |
836 | if (key->link.hotkey_type == ACPI_HOTKEY_POLLING | 914 | if (key->link.hotkey_standard_num == event) { |
837 | && key->link.hotkey_standard_num == event) { | 915 | return(key); |
838 | return (&key->poll_hotkey); | ||
839 | } | 916 | } |
840 | } | 917 | } |
841 | return (NULL); | 918 | return(NULL); |
842 | } | 919 | } |
843 | 920 | ||
844 | /* | 921 | /* |
845 | * user call AML method interface: | 922 | * user call AML method interface: |
846 | * Call convention: | 923 | * Call convention: |
847 | * echo "event_num: arg type : value" | 924 | * echo "event_num: arg type : value" |
@@ -854,48 +931,56 @@ static ssize_t hotkey_execute_aml_method(struct file *file, | |||
854 | size_t count, loff_t * data) | 931 | size_t count, loff_t * data) |
855 | { | 932 | { |
856 | struct acpi_hotkey_list *hotkey_list = &global_hotkey_list; | 933 | struct acpi_hotkey_list *hotkey_list = &global_hotkey_list; |
857 | char arg[MAX_CALL_PARM]; | 934 | char *arg; |
858 | int event, type, value; | 935 | int event,method_type,type, value; |
859 | 936 | union acpi_hotkey *key; | |
860 | char *method; | ||
861 | acpi_handle handle; | ||
862 | 937 | ||
863 | ACPI_FUNCTION_TRACE("hotkey_execte_aml_method"); | 938 | ACPI_FUNCTION_TRACE("hotkey_execte_aml_method"); |
864 | 939 | ||
865 | if (!hotkey_list || count > MAX_CALL_PARM) { | 940 | arg = (char *) kmalloc(count+1, GFP_KERNEL); |
866 | ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid argument 1")); | 941 | if(!arg) |
867 | return_VALUE(-EINVAL); | 942 | return_VALUE(-ENOMEM); |
868 | } | 943 | arg[count]=0; |
869 | 944 | ||
870 | if (copy_from_user(arg, buffer, count)) { | 945 | if (copy_from_user(arg, buffer, count)) { |
946 | kfree(arg); | ||
871 | ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid argument 2")); | 947 | ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid argument 2")); |
872 | return_VALUE(-EINVAL); | 948 | return_VALUE(-EINVAL); |
873 | } | 949 | } |
874 | 950 | ||
875 | arg[count] = '\0'; | 951 | if (sscanf(arg, "%d:%d:%d:%d", &event, &method_type, &type, &value) != 4) { |
876 | 952 | kfree(arg); | |
877 | if (sscanf(arg, "%d:%d:%d", &event, &type, &value) != 3) { | ||
878 | ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid argument 3")); | 953 | ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid argument 3")); |
879 | return_VALUE(-EINVAL); | 954 | return_VALUE(-EINVAL); |
880 | } | 955 | } |
881 | 956 | kfree(arg); | |
882 | if (type == ACPI_TYPE_INTEGER) { | 957 | if (type == ACPI_TYPE_INTEGER) { |
883 | handle = get_handle_from_hotkeylist(hotkey_list, event); | 958 | key = get_hotkey_by_event(hotkey_list, event); |
884 | method = (char *)get_method_from_hotkeylist(hotkey_list, event); | 959 | if(!key) |
960 | goto do_fail; | ||
885 | if (IS_EVENT(event)) | 961 | if (IS_EVENT(event)) |
886 | write_acpi_int(handle, method, value, NULL); | 962 | write_acpi_int(key->event_hotkey.action_handle, |
963 | key->event_hotkey.action_method, value, NULL); | ||
887 | else if (IS_POLL(event)) { | 964 | else if (IS_POLL(event)) { |
888 | struct acpi_polling_hotkey *key; | 965 | if ( method_type == POLL_METHOD ) |
889 | key = (struct acpi_polling_hotkey *) | 966 | read_acpi_int(key->poll_hotkey.poll_handle, |
890 | get_hotkey_by_event(hotkey_list, event); | 967 | key->poll_hotkey.poll_method, |
891 | read_acpi_int(handle, method, key->poll_result); | 968 | key->poll_hotkey.poll_result); |
969 | else if ( method_type == ACTION_METHOD ) | ||
970 | write_acpi_int(key->poll_hotkey.action_handle, | ||
971 | key->poll_hotkey.action_method, value, NULL); | ||
972 | else | ||
973 | goto do_fail; | ||
974 | |||
892 | } | 975 | } |
893 | } else { | 976 | } else { |
894 | ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Not supported")); | 977 | ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Not supported")); |
895 | return_VALUE(-EINVAL); | 978 | return_VALUE(-EINVAL); |
896 | } | 979 | } |
897 | |||
898 | return_VALUE(count); | 980 | return_VALUE(count); |
981 | do_fail: | ||
982 | return_VALUE(-EINVAL); | ||
983 | |||
899 | } | 984 | } |
900 | 985 | ||
901 | static int __init hotkey_init(void) | 986 | static int __init hotkey_init(void) |
@@ -928,7 +1013,7 @@ static int __init hotkey_init(void) | |||
928 | ACPI_DEBUG_PRINT((ACPI_DB_ERROR, | 1013 | ACPI_DEBUG_PRINT((ACPI_DB_ERROR, |
929 | "Hotkey: Unable to create %s entry\n", | 1014 | "Hotkey: Unable to create %s entry\n", |
930 | HOTKEY_EV_CONFIG)); | 1015 | HOTKEY_EV_CONFIG)); |
931 | return (-ENODEV); | 1016 | goto do_fail1; |
932 | } else { | 1017 | } else { |
933 | hotkey_config->proc_fops = &hotkey_config_fops; | 1018 | hotkey_config->proc_fops = &hotkey_config_fops; |
934 | hotkey_config->data = &global_hotkey_list; | 1019 | hotkey_config->data = &global_hotkey_list; |
@@ -943,7 +1028,8 @@ static int __init hotkey_init(void) | |||
943 | ACPI_DEBUG_PRINT((ACPI_DB_ERROR, | 1028 | ACPI_DEBUG_PRINT((ACPI_DB_ERROR, |
944 | "Hotkey: Unable to create %s entry\n", | 1029 | "Hotkey: Unable to create %s entry\n", |
945 | HOTKEY_EV_CONFIG)); | 1030 | HOTKEY_EV_CONFIG)); |
946 | return (-ENODEV); | 1031 | |
1032 | goto do_fail2; | ||
947 | } else { | 1033 | } else { |
948 | hotkey_poll_config->proc_fops = &hotkey_poll_config_fops; | 1034 | hotkey_poll_config->proc_fops = &hotkey_poll_config_fops; |
949 | hotkey_poll_config->data = &global_hotkey_list; | 1035 | hotkey_poll_config->data = &global_hotkey_list; |
@@ -957,7 +1043,7 @@ static int __init hotkey_init(void) | |||
957 | ACPI_DEBUG_PRINT((ACPI_DB_ERROR, | 1043 | ACPI_DEBUG_PRINT((ACPI_DB_ERROR, |
958 | "Hotkey: Unable to create %s entry\n", | 1044 | "Hotkey: Unable to create %s entry\n", |
959 | HOTKEY_ACTION)); | 1045 | HOTKEY_ACTION)); |
960 | return (-ENODEV); | 1046 | goto do_fail3; |
961 | } else { | 1047 | } else { |
962 | hotkey_action->proc_fops = &hotkey_action_fops; | 1048 | hotkey_action->proc_fops = &hotkey_action_fops; |
963 | hotkey_action->owner = THIS_MODULE; | 1049 | hotkey_action->owner = THIS_MODULE; |
@@ -970,7 +1056,7 @@ static int __init hotkey_init(void) | |||
970 | ACPI_DEBUG_PRINT((ACPI_DB_ERROR, | 1056 | ACPI_DEBUG_PRINT((ACPI_DB_ERROR, |
971 | "Hotkey: Unable to create %s entry\n", | 1057 | "Hotkey: Unable to create %s entry\n", |
972 | HOTKEY_INFO)); | 1058 | HOTKEY_INFO)); |
973 | return (-ENODEV); | 1059 | goto do_fail4; |
974 | } else { | 1060 | } else { |
975 | hotkey_info->proc_fops = &hotkey_info_fops; | 1061 | hotkey_info->proc_fops = &hotkey_info_fops; |
976 | hotkey_info->owner = THIS_MODULE; | 1062 | hotkey_info->owner = THIS_MODULE; |
@@ -979,23 +1065,33 @@ static int __init hotkey_init(void) | |||
979 | } | 1065 | } |
980 | 1066 | ||
981 | result = acpi_bus_register_driver(&hotkey_driver); | 1067 | result = acpi_bus_register_driver(&hotkey_driver); |
982 | if (result < 0) { | 1068 | if (result < 0) |
983 | remove_proc_entry(HOTKEY_PROC, acpi_root_dir); | 1069 | goto do_fail5; |
984 | return (-ENODEV); | ||
985 | } | ||
986 | global_hotkey_list.count = 0; | 1070 | global_hotkey_list.count = 0; |
987 | global_hotkey_list.entries = &hotkey_entries; | 1071 | global_hotkey_list.entries = &hotkey_entries; |
988 | 1072 | ||
989 | INIT_LIST_HEAD(&hotkey_entries); | 1073 | INIT_LIST_HEAD(&hotkey_entries); |
990 | 1074 | ||
991 | return (0); | 1075 | return (0); |
1076 | |||
1077 | do_fail5: | ||
1078 | remove_proc_entry(HOTKEY_INFO, hotkey_proc_dir); | ||
1079 | do_fail4: | ||
1080 | remove_proc_entry(HOTKEY_ACTION, hotkey_proc_dir); | ||
1081 | do_fail3: | ||
1082 | remove_proc_entry(HOTKEY_PL_CONFIG, hotkey_proc_dir); | ||
1083 | do_fail2: | ||
1084 | remove_proc_entry(HOTKEY_EV_CONFIG, hotkey_proc_dir); | ||
1085 | do_fail1: | ||
1086 | remove_proc_entry(HOTKEY_PROC, acpi_root_dir); | ||
1087 | return (-ENODEV); | ||
992 | } | 1088 | } |
993 | 1089 | ||
994 | static void __exit hotkey_exit(void) | 1090 | static void __exit hotkey_exit(void) |
995 | { | 1091 | { |
996 | struct list_head *entries, *next; | 1092 | struct list_head *entries, *next; |
997 | 1093 | ||
998 | ACPI_FUNCTION_TRACE("hotkey_remove"); | 1094 | ACPI_FUNCTION_TRACE("hotkey_exit"); |
999 | 1095 | ||
1000 | list_for_each_safe(entries, next, global_hotkey_list.entries) { | 1096 | list_for_each_safe(entries, next, global_hotkey_list.entries) { |
1001 | union acpi_hotkey *key = | 1097 | union acpi_hotkey *key = |