drivers/acpi/hotkey.c

   1 /*
   2  *  hotkey.c - ACPI Hotkey Driver ($Revision: 0.2 $)
   3  *
   4  *  Copyright (C) 2004 Luming Yu <luming.yu@intel.com>
   5  *
   6  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 2 of the License, or (at
  11  *  your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful, but
  14  *  WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  *  General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License along
  19  *  with this program; if not, write to the Free Software Foundation, Inc.,
  20  *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  21  *
  22  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  23  */
  24 #include <linux/kernel.h>
  25 #include <linux/module.h>
  26 #include <linux/init.h>
  27 #include <linux/types.h>
  28 #include <linux/proc_fs.h>
  29 #include <linux/sched.h>
  30 #include <linux/kmod.h>
  31 #include <linux/seq_file.h>
  32 #include <acpi/acpi_drivers.h>
  33 #include <acpi/acpi_bus.h>
  34 #include <asm/uaccess.h>
  35
  36 #define HOTKEY_ACPI_VERSION "0.1"
  37
  38 #define HOTKEY_PROC "hotkey"
  39 #define HOTKEY_EV_CONFIG    "event_config"
  40 #define HOTKEY_PL_CONFIG    "poll_config"
  41 #define HOTKEY_ACTION   "action"
  42 #define HOTKEY_INFO "info"
  43
  44 #define ACPI_HOTK_NAME          "Generic Hotkey Driver"
  45 #define ACPI_HOTK_CLASS         "Hotkey"
  46 #define ACPI_HOTK_DEVICE_NAME   "Hotkey"
  47 #define ACPI_HOTK_HID           "Unknown?"
  48 #define ACPI_HOTKEY_COMPONENT   0x20000000
  49
  50 #define ACPI_HOTKEY_EVENT   0x1
  51 #define ACPI_HOTKEY_POLLING 0x2
  52 #define ACPI_UNDEFINED_EVENT    0xf
  53
  54 #define RESULT_STR_LEN      80
  55
  56 #define ACTION_METHOD   0
  57 #define POLL_METHOD     1
  58
  59 #define IS_EVENT(e)             ((e) <= 10000 && (e) >0)
  60 #define IS_POLL(e)              ((e) > 10000)
  61 #define IS_OTHERS(e)            ((e)<=0 || (e)>=20000)
  62 #define _COMPONENT              ACPI_HOTKEY_COMPONENT
  63 ACPI_MODULE_NAME("acpi_hotkey")
  64
  65     MODULE_AUTHOR("luming.yu@intel.com");
  66 MODULE_DESCRIPTION(ACPI_HOTK_NAME);
  67 MODULE_LICENSE("GPL");
  68
  69 /*  standardized internal hotkey number/event  */
  70 enum {
  71         /* Video Extension event */
  72         HK_EVENT_CYCLE_OUTPUT_DEVICE = 0x80,
  73         HK_EVENT_OUTPUT_DEVICE_STATUS_CHANGE,
  74         HK_EVENT_CYCLE_DISPLAY_OUTPUT,
  75         HK_EVENT_NEXT_DISPLAY_OUTPUT,
  76         HK_EVENT_PREVIOUS_DISPLAY_OUTPUT,
  77         HK_EVENT_CYCLE_BRIGHTNESS,
  78         HK_EVENT_INCREASE_BRIGHTNESS,
  79         HK_EVENT_DECREASE_BRIGHTNESS,
  80         HK_EVENT_ZERO_BRIGHTNESS,
  81         HK_EVENT_DISPLAY_DEVICE_OFF,
  82
  83         /* Snd Card event */
  84         HK_EVENT_VOLUME_MUTE,
  85         HK_EVENT_VOLUME_INCLREASE,
  86         HK_EVENT_VOLUME_DECREASE,
  87
  88         /* running state control */
  89         HK_EVENT_ENTERRING_S3,
  90         HK_EVENT_ENTERRING_S4,
  91         HK_EVENT_ENTERRING_S5,
  92 };
  93
  94 /*  procdir we use */
  95 static struct proc_dir_entry *hotkey_proc_dir;
  96 static struct proc_dir_entry *hotkey_config;
  97 static struct proc_dir_entry *hotkey_poll_config;
  98 static struct proc_dir_entry *hotkey_action;
  99 static struct proc_dir_entry *hotkey_info;
 100
 101 /* linkage for all type of hotkey */
 102 struct acpi_hotkey_link {
 103         struct list_head entries;
 104         int hotkey_type;        /* event or polling based hotkey  */
 105         int hotkey_standard_num;        /* standardized hotkey(event) number */
 106 };
 107
 108 /* event based hotkey */
 109 struct acpi_event_hotkey {
 110         struct acpi_hotkey_link hotkey_link;
 111         int flag;
 112         acpi_handle bus_handle; /* bus to install notify handler */
 113         int external_hotkey_num;        /* external hotkey/event number */
 114         acpi_handle action_handle;      /* acpi handle attached aml action method */
 115         char *action_method;    /* action method */
 116 };
 117
 118 /*
 119  * There are two ways to poll status
 120  * 1. directy call read_xxx method, without any arguments passed in
 121  * 2. call write_xxx method, with arguments passed in, you need
 122  * the result is saved in acpi_polling_hotkey.poll_result.
 123  * anthoer read command through polling interface.
 124  *
 125  */
 126
 127 /* polling based hotkey */
 128 struct acpi_polling_hotkey {
 129         struct acpi_hotkey_link hotkey_link;
 130         int flag;
 131         acpi_handle poll_handle;        /* acpi handle attached polling method */
 132         char *poll_method;      /* poll method */
 133         acpi_handle action_handle;      /* acpi handle attached action method */
 134         char *action_method;    /* action method */
 135         union acpi_object *poll_result; /* polling_result */
 136         struct proc_dir_entry *proc;
 137 };
 138
 139 /* hotkey object union */
 140 union acpi_hotkey {
 141         struct list_head entries;
 142         struct acpi_hotkey_link link;
 143         struct acpi_event_hotkey event_hotkey;
 144         struct acpi_polling_hotkey poll_hotkey;
 145 };
 146
 147 /* hotkey object list */
 148 struct acpi_hotkey_list {
 149         struct list_head *entries;
 150         int count;
 151 };
 152
 153 static int auto_hotkey_add(struct acpi_device *device);
 154 static int auto_hotkey_remove(struct acpi_device *device, int type);
 155
 156 static struct acpi_driver hotkey_driver = {
 157         .name = ACPI_HOTK_NAME,
 158         .class = ACPI_HOTK_CLASS,
 159         .ids = ACPI_HOTK_HID,
 160         .ops = {
 161                 .add = auto_hotkey_add,
 162                 .remove = auto_hotkey_remove,
 163                 },
 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);
 169 static int hotkey_open_config(struct inode *inode, struct file *file);
 170 static int hotkey_poll_open_config(struct inode *inode, struct file *file);
 171 static ssize_t hotkey_write_config(struct file *file,
 172                                    const char __user * buffer,
 173                                    size_t count, loff_t * data);
 174 static int hotkey_info_open_fs(struct inode *inode, struct file *file);
 175 static int hotkey_action_open_fs(struct inode *inode, struct file *file);
 176 static ssize_t hotkey_execute_aml_method(struct file *file,
 177                                          const char __user * buffer,
 178                                          size_t count, loff_t * data);
 179 static int hotkey_config_seq_show(struct seq_file *seq, void *offset);
 180 static int hotkey_poll_config_seq_show(struct seq_file *seq, void *offset);
 181 static int hotkey_polling_open_fs(struct inode *inode, struct file *file);
 182 static union acpi_hotkey *get_hotkey_by_event(struct
 183                                               acpi_hotkey_list
 184                                               *hotkey_list, int event);
 185
 186 /* event based config */
 187 static const struct file_operations hotkey_config_fops = {
 188         .open = hotkey_open_config,
 189         .read = seq_read,
 190         .write = hotkey_write_config,
 191         .llseek = seq_lseek,
 192         .release = single_release,
 193 };
 194
 195 /* polling based config */
 196 static const struct file_operations hotkey_poll_config_fops = {
 197         .open = hotkey_poll_open_config,
 198         .read = seq_read,
 199         .write = hotkey_write_config,
 200         .llseek = seq_lseek,
 201         .release = single_release,
 202 };
 203
 204 /* hotkey driver info */
 205 static const struct file_operations hotkey_info_fops = {
 206         .open = hotkey_info_open_fs,
 207         .read = seq_read,
 208         .llseek = seq_lseek,
 209         .release = single_release,
 210 };
 211
 212 /* action */
 213 static const struct file_operations hotkey_action_fops = {
 214         .open = hotkey_action_open_fs,
 215         .read = seq_read,
 216         .write = hotkey_execute_aml_method,
 217         .llseek = seq_lseek,
 218         .release = single_release,
 219 };
 220
 221 /* polling results */
 222 static const struct file_operations hotkey_polling_fops = {
 223         .open = hotkey_polling_open_fs,
 224         .read = seq_read,
 225         .llseek = seq_lseek,
 226         .release = single_release,
 227 };
 228
 229 struct acpi_hotkey_list global_hotkey_list;     /* link all ev or pl hotkey  */
 230 struct list_head hotkey_entries;        /* head of the list of hotkey_list */
 231
 232 static int hotkey_info_seq_show(struct seq_file *seq, void *offset)
 233 {
 234
 235         seq_printf(seq, "Hotkey generic driver ver: %s\n", HOTKEY_ACPI_VERSION);
 236
 237         return 0;
 238 }
 239
 240 static int hotkey_info_open_fs(struct inode *inode, struct file *file)
 241 {
 242         return single_open(file, hotkey_info_seq_show, PDE(inode)->data);
 243 }
 244
 245 static char *format_result(union acpi_object *object)
 246 {
 247         char *buf = NULL;
 248
 249         buf = (char *)kmalloc(RESULT_STR_LEN, GFP_KERNEL);
 250         if (buf)
 251                 memset(buf, 0, RESULT_STR_LEN);
 252         else
 253                 goto do_fail;
 254
 255         /* Now, just support integer type */
 256         if (object->type == ACPI_TYPE_INTEGER)
 257                 sprintf(buf, "%d\n", (u32) object->integer.value);
 258       do_fail:
 259         return (buf);
 260 }
 261
 262 static int hotkey_polling_seq_show(struct seq_file *seq, void *offset)
 263 {
 264         struct acpi_polling_hotkey *poll_hotkey =
 265             (struct acpi_polling_hotkey *)seq->private;
 266         char *buf;
 267
 268
 269         if (poll_hotkey->poll_result) {
 270                 buf = format_result(poll_hotkey->poll_result);
 271                 if (buf)
 272                         seq_printf(seq, "%s", buf);
 273                 kfree(buf);
 274         }
 275         return 0;
 276 }
 277
 278 static int hotkey_polling_open_fs(struct inode *inode, struct file *file)
 279 {
 280         return single_open(file, hotkey_polling_seq_show, PDE(inode)->data);
 281 }
 282
 283 static int hotkey_action_open_fs(struct inode *inode, struct file *file)
 284 {
 285         return single_open(file, hotkey_info_seq_show, PDE(inode)->data);
 286 }
 287
 288 /* Mapping external hotkey number to standardized hotkey event num */
 289 static int hotkey_get_internal_event(int event, struct acpi_hotkey_list *list)
 290 {
 291         struct list_head *entries;
 292         int val = -1;
 293
 294
 295         list_for_each(entries, list->entries) {
 296                 union acpi_hotkey *key =
 297                     container_of(entries, union acpi_hotkey, entries);
 298                 if (key->link.hotkey_type == ACPI_HOTKEY_EVENT
 299                     && key->event_hotkey.external_hotkey_num == event) {
 300                         val = key->link.hotkey_standard_num;
 301                         break;
 302                 }
 303         }
 304
 305         return val;
 306 }
 307
 308 static void
 309 acpi_hotkey_notify_handler(acpi_handle handle, u32 event, void *data)
 310 {
 311         struct acpi_device *device = NULL;
 312         u32 internal_event;
 313
 314
 315         if (acpi_bus_get_device(handle, &device))
 316                 return;
 317
 318         internal_event = hotkey_get_internal_event(event, &global_hotkey_list);
 319         acpi_bus_generate_event(device, internal_event, 0);
 320
 321         return;
 322 }
 323
 324 /* Need to invent automatically hotkey add method */
 325 static int auto_hotkey_add(struct acpi_device *device)
 326 {
 327         /* Implement me */
 328         return 0;
 329 }
 330
 331 /* Need to invent automatically hotkey remove method */
 332 static int auto_hotkey_remove(struct acpi_device *device, int type)
 333 {
 334         /* Implement me */
 335         return 0;
 336 }
 337
 338 /* Create a proc file for each polling method */
 339 static int create_polling_proc(union acpi_hotkey *device)
 340 {
 341         struct proc_dir_entry *proc;
 342         char proc_name[80];
 343         mode_t mode;
 344
 345         mode = S_IFREG | S_IRUGO | S_IWUGO;
 346
 347         sprintf(proc_name, "%d", device->link.hotkey_standard_num);
 348         /*
 349            strcat(proc_name, device->poll_hotkey.poll_method);
 350          */
 351         proc = create_proc_entry(proc_name, mode, hotkey_proc_dir);
 352
 353         if (!proc) {
 354                 return -ENODEV;
 355         } else {
 356                 proc->proc_fops = &hotkey_polling_fops;
 357                 proc->owner = THIS_MODULE;
 358                 proc->data = device;
 359                 proc->uid = 0;
 360                 proc->gid = 0;
 361                 device->poll_hotkey.proc = proc;
 362         }
 363         return 0;
 364 }
 365
 366 static int hotkey_add(union acpi_hotkey *device)
 367 {
 368         int status = 0;
 369         struct acpi_device *dev = NULL;
 370
 371
 372         if (device->link.hotkey_type == ACPI_HOTKEY_EVENT) {
 373                 acpi_bus_get_device(device->event_hotkey.bus_handle, &dev);
 374                 status = acpi_install_notify_handler(dev->handle,
 375                                                      ACPI_DEVICE_NOTIFY,
 376                                                      acpi_hotkey_notify_handler,
 377                                                      dev);
 378         } else                  /* Add polling hotkey */
 379                 create_polling_proc(device);
 380
 381         global_hotkey_list.count++;
 382
 383         list_add_tail(&device->link.entries, global_hotkey_list.entries);
 384
 385         return status;
 386 }
 387
 388 static int hotkey_remove(union acpi_hotkey *device)
 389 {
 390         struct list_head *entries, *next;
 391
 392
 393         list_for_each_safe(entries, next, global_hotkey_list.entries) {
 394                 union acpi_hotkey *key =
 395                     container_of(entries, union acpi_hotkey, entries);
 396                 if (key->link.hotkey_standard_num ==
 397                     device->link.hotkey_standard_num) {
 398                         list_del(&key->link.entries);
 399                         free_hotkey_device(key);
 400                         global_hotkey_list.count--;
 401                         break;
 402                 }
 403         }
 404         kfree(device);
 405         return 0;
 406 }
 407
 408 static int hotkey_update(union acpi_hotkey *key)
 409 {
 410         struct list_head *entries;
 411
 412
 413         list_for_each(entries, global_hotkey_list.entries) {
 414                 union acpi_hotkey *tmp =
 415                     container_of(entries, union acpi_hotkey, entries);
 416                 if (tmp->link.hotkey_standard_num ==
 417                     key->link.hotkey_standard_num) {
 418                         if (key->link.hotkey_type == ACPI_HOTKEY_EVENT) {
 419                                 free_hotkey_buffer(tmp);
 420                                 tmp->event_hotkey.bus_handle =
 421                                     key->event_hotkey.bus_handle;
 422                                 tmp->event_hotkey.external_hotkey_num =
 423                                     key->event_hotkey.external_hotkey_num;
 424                                 tmp->event_hotkey.action_handle =
 425                                     key->event_hotkey.action_handle;
 426                                 tmp->event_hotkey.action_method =
 427                                     key->event_hotkey.action_method;
 428                                 kfree(key);
 429                         } else {
 430                                 /*
 431                                    char  proc_name[80];
 432
 433                                    sprintf(proc_name, "%d", tmp->link.hotkey_standard_num);
 434                                    strcat(proc_name, tmp->poll_hotkey.poll_method);
 435                                    remove_proc_entry(proc_name,hotkey_proc_dir);
 436                                  */
 437                                 free_poll_hotkey_buffer(tmp);
 438                                 tmp->poll_hotkey.poll_handle =
 439                                     key->poll_hotkey.poll_handle;
 440                                 tmp->poll_hotkey.poll_method =
 441                                     key->poll_hotkey.poll_method;
 442                                 tmp->poll_hotkey.action_handle =
 443                                     key->poll_hotkey.action_handle;
 444                                 tmp->poll_hotkey.action_method =
 445                                     key->poll_hotkey.action_method;
 446                                 tmp->poll_hotkey.poll_result =
 447                                     key->poll_hotkey.poll_result;
 448                                 /*
 449                                    create_polling_proc(tmp);
 450                                  */
 451                                 kfree(key);
 452                         }
 453                         return 0;
 454                         break;
 455                 }
 456         }
 457
 458         return -ENODEV;
 459 }
 460
 461 static void free_hotkey_device(union acpi_hotkey *key)
 462 {
 463         struct acpi_device *dev;
 464
 465
 466         if (key->link.hotkey_type == ACPI_HOTKEY_EVENT) {
 467                 acpi_bus_get_device(key->event_hotkey.bus_handle, &dev);
 468                 if (dev->handle)
 469                         acpi_remove_notify_handler(dev->handle,
 470                                                    ACPI_DEVICE_NOTIFY,
 471                                                    acpi_hotkey_notify_handler);
 472                 free_hotkey_buffer(key);
 473         } else {
 474                 char proc_name[80];
 475
 476                 sprintf(proc_name, "%d", key->link.hotkey_standard_num);
 477                 /*
 478                    strcat(proc_name, key->poll_hotkey.poll_method);
 479                  */
 480                 remove_proc_entry(proc_name, hotkey_proc_dir);
 481                 free_poll_hotkey_buffer(key);
 482         }
 483         kfree(key);
 484         return;
 485 }
 486
 487 static void free_hotkey_buffer(union acpi_hotkey *key)
 488 {
 489         kfree(key->event_hotkey.action_method);
 490 }
 491
 492 static void free_poll_hotkey_buffer(union acpi_hotkey *key)
 493 {
 494         kfree(key->poll_hotkey.action_method);
 495         kfree(key->poll_hotkey.poll_method);
 496         kfree(key->poll_hotkey.poll_result);
 497 }
 498 static int
 499 init_hotkey_device(union acpi_hotkey *key, char *bus_str, char *action_str,
 500                    char *method, int std_num, int external_num)
 501 {
 502         acpi_handle tmp_handle;
 503         acpi_status status = AE_OK;
 504
 505
 506         if (std_num < 0 || IS_POLL(std_num) || !key)
 507                 goto do_fail;
 508
 509         if (!bus_str || !action_str || !method)
 510                 goto do_fail;
 511
 512         key->link.hotkey_type = ACPI_HOTKEY_EVENT;
 513         key->link.hotkey_standard_num = std_num;
 514         key->event_hotkey.flag = 0;
 515         key->event_hotkey.action_method = method;
 516
 517         status =
 518             acpi_get_handle(NULL, bus_str, &(key->event_hotkey.bus_handle));
 519         if (ACPI_FAILURE(status))
 520                 goto do_fail;
 521         key->event_hotkey.external_hotkey_num = external_num;
 522         status =
 523             acpi_get_handle(NULL, action_str,
 524                             &(key->event_hotkey.action_handle));
 525         if (ACPI_FAILURE(status))
 526                 goto do_fail;
 527         status = acpi_get_handle(key->event_hotkey.action_handle,
 528                                  method, &tmp_handle);
 529         if (ACPI_FAILURE(status))
 530                 goto do_fail;
 531         return AE_OK;
 532       do_fail:
 533         return -ENODEV;
 534 }
 535
 536 static int
 537 init_poll_hotkey_device(union acpi_hotkey *key,
 538                         char *poll_str,
 539                         char *poll_method,
 540                         char *action_str, char *action_method, int std_num)
 541 {
 542         acpi_status status = AE_OK;
 543         acpi_handle tmp_handle;
 544
 545
 546         if (std_num < 0 || IS_EVENT(std_num) || !key)
 547                 goto do_fail;
 548
 549         if (!poll_str || !poll_method || !action_str || !action_method)
 550                 goto do_fail;
 551
 552         key->link.hotkey_type = ACPI_HOTKEY_POLLING;
 553         key->link.hotkey_standard_num = std_num;
 554         key->poll_hotkey.flag = 0;
 555         key->poll_hotkey.poll_method = poll_method;
 556         key->poll_hotkey.action_method = action_method;
 557
 558         status =
 559             acpi_get_handle(NULL, poll_str, &(key->poll_hotkey.poll_handle));
 560         if (ACPI_FAILURE(status))
 561                 goto do_fail;
 562         status = acpi_get_handle(key->poll_hotkey.poll_handle,
 563                                  poll_method, &tmp_handle);
 564         if (ACPI_FAILURE(status))
 565                 goto do_fail;
 566         status =
 567             acpi_get_handle(NULL, action_str,
 568                             &(key->poll_hotkey.action_handle));
 569         if (ACPI_FAILURE(status))
 570                 goto do_fail;
 571         status = acpi_get_handle(key->poll_hotkey.action_handle,
 572                                  action_method, &tmp_handle);
 573         if (ACPI_FAILURE(status))
 574                 goto do_fail;
 575         key->poll_hotkey.poll_result =
 576             (union acpi_object *)kmalloc(sizeof(union acpi_object), GFP_KERNEL);
 577         if (!key->poll_hotkey.poll_result)
 578                 goto do_fail;
 579         return AE_OK;
 580       do_fail:
 581         return -ENODEV;
 582 }
 583
 584 static int hotkey_open_config(struct inode *inode, struct file *file)
 585 {
 586         return (single_open
 587                      (file, hotkey_config_seq_show, PDE(inode)->data));
 588 }
 589
 590 static int hotkey_poll_open_config(struct inode *inode, struct file *file)
 591 {
 592         return (single_open
 593                      (file, hotkey_poll_config_seq_show, PDE(inode)->data));
 594 }
 595
 596 static int hotkey_config_seq_show(struct seq_file *seq, void *offset)
 597 {
 598         struct acpi_hotkey_list *hotkey_list = &global_hotkey_list;
 599         struct list_head *entries;
 600         char bus_name[ACPI_PATHNAME_MAX] = { 0 };
 601         char action_name[ACPI_PATHNAME_MAX] = { 0 };
 602         struct acpi_buffer bus = { ACPI_PATHNAME_MAX, bus_name };
 603         struct acpi_buffer act = { ACPI_PATHNAME_MAX, action_name };
 604
 605
 606         list_for_each(entries, hotkey_list->entries) {
 607                 union acpi_hotkey *key =
 608                     container_of(entries, union acpi_hotkey, entries);
 609                 if (key->link.hotkey_type == ACPI_HOTKEY_EVENT) {
 610                         acpi_get_name(key->event_hotkey.bus_handle,
 611                                       ACPI_NAME_TYPE_MAX, &bus);
 612                         acpi_get_name(key->event_hotkey.action_handle,
 613                                       ACPI_NAME_TYPE_MAX, &act);
 614                         seq_printf(seq, "%s:%s:%s:%d:%d\n", bus_name,
 615                                    action_name,
 616                                    key->event_hotkey.action_method,
 617                                    key->link.hotkey_standard_num,
 618                                    key->event_hotkey.external_hotkey_num);
 619                 }
 620         }
 621         seq_puts(seq, "\n");
 622         return 0;
 623 }
 624
 625 static int hotkey_poll_config_seq_show(struct seq_file *seq, void *offset)
 626 {
 627         struct acpi_hotkey_list *hotkey_list = &global_hotkey_list;
 628         struct list_head *entries;
 629         char bus_name[ACPI_PATHNAME_MAX] = { 0 };
 630         char action_name[ACPI_PATHNAME_MAX] = { 0 };
 631         struct acpi_buffer bus = { ACPI_PATHNAME_MAX, bus_name };
 632         struct acpi_buffer act = { ACPI_PATHNAME_MAX, action_name };
 633
 634
 635         list_for_each(entries, hotkey_list->entries) {
 636                 union acpi_hotkey *key =
 637                     container_of(entries, union acpi_hotkey, entries);
 638                 if (key->link.hotkey_type == ACPI_HOTKEY_POLLING) {
 639                         acpi_get_name(key->poll_hotkey.poll_handle,
 640                                       ACPI_NAME_TYPE_MAX, &bus);
 641                         acpi_get_name(key->poll_hotkey.action_handle,
 642                                       ACPI_NAME_TYPE_MAX, &act);
 643                         seq_printf(seq, "%s:%s:%s:%s:%d\n", bus_name,
 644                                    key->poll_hotkey.poll_method,
 645                                    action_name,
 646                                    key->poll_hotkey.action_method,
 647                                    key->link.hotkey_standard_num);
 648                 }
 649         }
 650         seq_puts(seq, "\n");
 651         return 0;
 652 }
 653
 654 static int
 655 get_parms(char *config_record,
 656           int *cmd,
 657           char **bus_handle,
 658           char **bus_method,
 659           char **action_handle,
 660           char **method, int *internal_event_num, int *external_event_num)
 661 {
 662         char *tmp, *tmp1, count;
 663
 664         sscanf(config_record, "%d", cmd);
 665
 666         if (*cmd == 1) {
 667                 if (sscanf(config_record, "%d:%d", cmd, internal_event_num) !=
 668                     2)
 669                         goto do_fail;
 670                 else
 671                         return (6);
 672         }
 673         tmp = strchr(config_record, ':');
 674         if (!tmp)
 675                 goto do_fail;
 676         tmp++;
 677         tmp1 = strchr(tmp, ':');
 678         if (!tmp1)
 679                 goto do_fail;
 680
 681         count = tmp1 - tmp;
 682         *bus_handle = (char *)kmalloc(count + 1, GFP_KERNEL);
 683         if (!*bus_handle)
 684                 goto do_fail;
 685         strncpy(*bus_handle, tmp, count);
 686         *(*bus_handle + count) = 0;
 687
 688         tmp = tmp1;
 689         tmp++;
 690         tmp1 = strchr(tmp, ':');
 691         if (!tmp1)
 692                 goto do_fail;
 693         count = tmp1 - tmp;
 694         *bus_method = (char *)kmalloc(count + 1, GFP_KERNEL);
 695         if (!*bus_method)
 696                 goto do_fail;
 697         strncpy(*bus_method, tmp, count);
 698         *(*bus_method + count) = 0;
 699
 700         tmp = tmp1;
 701         tmp++;
 702         tmp1 = strchr(tmp, ':');
 703         if (!tmp1)
 704                 goto do_fail;
 705         count = tmp1 - tmp;
 706         *action_handle = (char *)kmalloc(count + 1, GFP_KERNEL);
 707         if (!*action_handle)
 708                 goto do_fail;
 709         strncpy(*action_handle, tmp, count);
 710         *(*action_handle + count) = 0;
 711
 712         tmp = tmp1;
 713         tmp++;
 714         tmp1 = strchr(tmp, ':');
 715         if (!tmp1)
 716                 goto do_fail;
 717         count = tmp1 - tmp;
 718         *method = (char *)kmalloc(count + 1, GFP_KERNEL);
 719         if (!*method)
 720                 goto do_fail;
 721         strncpy(*method, tmp, count);
 722         *(*method + count) = 0;
 723
 724         if (sscanf(tmp1 + 1, "%d:%d", internal_event_num, external_event_num) <=
 725             0)
 726                 goto do_fail;
 727
 728         return 6;
 729       do_fail:
 730         return -1;
 731 }
 732
 733 /*  count is length for one input record */
 734 static ssize_t hotkey_write_config(struct file *file,
 735                                    const char __user * buffer,
 736                                    size_t count, loff_t * data)
 737 {
 738         char *config_record = NULL;
 739         char *bus_handle = NULL;
 740         char *bus_method = NULL;
 741         char *action_handle = NULL;
 742         char *method = NULL;
 743         int cmd, internal_event_num, external_event_num;
 744         int ret = 0;
 745         union acpi_hotkey *key = NULL;
 746
 747
 748         config_record = (char *)kmalloc(count + 1, GFP_KERNEL);
 749         if (!config_record)
 750                 return -ENOMEM;
 751
 752         if (copy_from_user(config_record, buffer, count)) {
 753                 kfree(config_record);
 754                 printk(KERN_ERR PREFIX "Invalid data\n");
 755                 return -EINVAL;
 756         }
 757         config_record[count] = 0;
 758
 759         ret = get_parms(config_record,
 760                         &cmd,
 761                         &bus_handle,
 762                         &bus_method,
 763                         &action_handle,
 764                         &method, &internal_event_num, &external_event_num);
 765
 766         kfree(config_record);
 767         if (IS_OTHERS(internal_event_num))
 768                 goto do_fail;
 769         if (ret != 6) {
 770               do_fail:
 771                 kfree(bus_handle);
 772                 kfree(bus_method);
 773                 kfree(action_handle);
 774                 kfree(method);
 775                 printk(KERN_ERR PREFIX "Invalid data format ret=%d\n", ret);
 776                 return -EINVAL;
 777         }
 778
 779         key = kmalloc(sizeof(union acpi_hotkey), GFP_KERNEL);
 780         if (!key)
 781                 goto do_fail;
 782         memset(key, 0, sizeof(union acpi_hotkey));
 783         if (cmd == 1) {
 784                 union acpi_hotkey *tmp = NULL;
 785                 tmp = get_hotkey_by_event(&global_hotkey_list,
 786                                           internal_event_num);
 787                 if (!tmp)
 788                         printk(KERN_ERR PREFIX "Invalid key\n");
 789                 else
 790                         memcpy(key, tmp, sizeof(union acpi_hotkey));
 791                 goto cont_cmd;
 792         }
 793         if (IS_EVENT(internal_event_num)) {
 794                 kfree(bus_method);
 795                 ret = init_hotkey_device(key, bus_handle, action_handle, method,
 796                                          internal_event_num,
 797                                          external_event_num);
 798         } else
 799                 ret = init_poll_hotkey_device(key, bus_handle, bus_method,
 800                                               action_handle, method,
 801                                               internal_event_num);
 802         if (ret) {
 803                 kfree(bus_handle);
 804                 kfree(action_handle);
 805                 if (IS_EVENT(internal_event_num))
 806                         free_hotkey_buffer(key);
 807                 else
 808                         free_poll_hotkey_buffer(key);
 809                 kfree(key);
 810                 printk(KERN_ERR PREFIX "Invalid hotkey\n");
 811                 return -EINVAL;
 812         }
 813
 814       cont_cmd:
 815         kfree(bus_handle);
 816         kfree(action_handle);
 817
 818         switch (cmd) {
 819         case 0:
 820                 if (get_hotkey_by_event
 821                     (&global_hotkey_list, key->link.hotkey_standard_num))
 822                         goto fail_out;
 823                 else
 824                         hotkey_add(key);
 825                 break;
 826         case 1:
 827                 hotkey_remove(key);
 828                 break;
 829         case 2:
 830                 if (hotkey_update(key))
 831                         goto fail_out;
 832                 break;
 833         default:
 834                 goto fail_out;
 835                 break;
 836         }
 837         return count;
 838       fail_out:
 839         if (IS_EVENT(internal_event_num))
 840                 free_hotkey_buffer(key);
 841         else
 842                 free_poll_hotkey_buffer(key);
 843         kfree(key);
 844         printk(KERN_ERR PREFIX "invalid key\n");
 845         return -EINVAL;
 846 }
 847
 848 /*
 849  * This function evaluates an ACPI method, given an int as parameter, the
 850  * method is searched within the scope of the handle, can be NULL. The output
 851  * of the method is written is output, which can also be NULL
 852  *
 853  * returns 1 if write is successful, 0 else.
 854  */
 855 static int write_acpi_int(acpi_handle handle, const char *method, int val,
 856                           struct acpi_buffer *output)
 857 {
 858         struct acpi_object_list params; /* list of input parameters (an int here) */
 859         union acpi_object in_obj;       /* the only param we use */
 860         acpi_status status;
 861
 862         params.count = 1;
 863         params.pointer = &in_obj;
 864         in_obj.type = ACPI_TYPE_INTEGER;
 865         in_obj.integer.value = val;
 866
 867         status = acpi_evaluate_object(handle, (char *)method, &params, output);
 868
 869         return (status == AE_OK);
 870 }
 871
 872 static int read_acpi_int(acpi_handle handle, const char *method,
 873                          union acpi_object *val)
 874 {
 875         struct acpi_buffer output;
 876         union acpi_object out_obj;
 877         acpi_status status;
 878
 879         output.length = sizeof(out_obj);
 880         output.pointer = &out_obj;
 881
 882         status = acpi_evaluate_object(handle, (char *)method, NULL, &output);
 883         if (val) {
 884                 val->integer.value = out_obj.integer.value;
 885                 val->type = out_obj.type;
 886         } else
 887                 printk(KERN_ERR PREFIX "null val pointer\n");
 888         return ((status == AE_OK)
 889                      && (out_obj.type == ACPI_TYPE_INTEGER));
 890 }
 891
 892 static union acpi_hotkey *get_hotkey_by_event(struct
 893                                               acpi_hotkey_list
 894                                               *hotkey_list, int event)
 895 {
 896         struct list_head *entries;
 897
 898         list_for_each(entries, hotkey_list->entries) {
 899                 union acpi_hotkey *key =
 900                     container_of(entries, union acpi_hotkey, entries);
 901                 if (key->link.hotkey_standard_num == event) {
 902                         return (key);
 903                 }
 904         }
 905         return (NULL);
 906 }
 907
 908 /*
 909  * user call AML method interface:
 910  * Call convention:
 911  * echo "event_num: arg type : value"
 912  * example: echo "1:1:30" > /proc/acpi/action
 913  * Just support 1 integer arg passing to AML method
 914  */
 915
 916 static ssize_t hotkey_execute_aml_method(struct file *file,
 917                                          const char __user * buffer,
 918                                          size_t count, loff_t * data)
 919 {
 920         struct acpi_hotkey_list *hotkey_list = &global_hotkey_list;
 921         char *arg;
 922         int event, method_type, type, value;
 923         union acpi_hotkey *key;
 924
 925
 926         arg = (char *)kmalloc(count + 1, GFP_KERNEL);
 927         if (!arg)
 928                 return -ENOMEM;
 929         arg[count] = 0;
 930
 931         if (copy_from_user(arg, buffer, count)) {
 932                 kfree(arg);
 933                 printk(KERN_ERR PREFIX "Invalid argument 2\n");
 934                 return -EINVAL;
 935         }
 936
 937         if (sscanf(arg, "%d:%d:%d:%d", &event, &method_type, &type, &value) !=
 938             4) {
 939                 kfree(arg);
 940                 printk(KERN_ERR PREFIX "Invalid argument 3\n");
 941                 return -EINVAL;
 942         }
 943         kfree(arg);
 944         if (type == ACPI_TYPE_INTEGER) {
 945                 key = get_hotkey_by_event(hotkey_list, event);
 946                 if (!key)
 947                         goto do_fail;
 948                 if (IS_EVENT(event))
 949                         write_acpi_int(key->event_hotkey.action_handle,
 950                                        key->event_hotkey.action_method, value,
 951                                        NULL);
 952                 else if (IS_POLL(event)) {
 953                         if (method_type == POLL_METHOD)
 954                                 read_acpi_int(key->poll_hotkey.poll_handle,
 955                                               key->poll_hotkey.poll_method,
 956                                               key->poll_hotkey.poll_result);
 957                         else if (method_type == ACTION_METHOD)
 958                                 write_acpi_int(key->poll_hotkey.action_handle,
 959                                                key->poll_hotkey.action_method,
 960                                                value, NULL);
 961                         else
 962                                 goto do_fail;
 963
 964                 }
 965         } else {
 966                 printk(KERN_WARNING "Not supported\n");
 967                 return -EINVAL;
 968         }
 969         return count;
 970       do_fail:
 971         return -EINVAL;
 972
 973 }
 974
 975 static int __init hotkey_init(void)
 976 {
 977         int result;
 978         mode_t mode = S_IFREG | S_IRUGO | S_IWUGO;
 979
 980
 981         if (acpi_disabled)
 982                 return -ENODEV;
 983
 984         if (acpi_specific_hotkey_enabled) {
 985                 printk("Using specific hotkey driver\n");
 986                 return -ENODEV;
 987         }
 988
 989         hotkey_proc_dir = proc_mkdir(HOTKEY_PROC, acpi_root_dir);
 990         if (!hotkey_proc_dir) {
 991                 return (-ENODEV);
 992         }
 993         hotkey_proc_dir->owner = THIS_MODULE;
 994
 995         hotkey_config =
 996             create_proc_entry(HOTKEY_EV_CONFIG, mode, hotkey_proc_dir);
 997         if (!hotkey_config) {
 998                 goto do_fail1;
 999         } else {
1000                 hotkey_config->proc_fops = &hotkey_config_fops;
1001                 hotkey_config->data = &global_hotkey_list;
1002                 hotkey_config->owner = THIS_MODULE;
1003                 hotkey_config->uid = 0;
1004                 hotkey_config->gid = 0;
1005         }
1006
1007         hotkey_poll_config =
1008             create_proc_entry(HOTKEY_PL_CONFIG, mode, hotkey_proc_dir);
1009         if (!hotkey_poll_config) {
1010                 goto do_fail2;
1011         } else {
1012                 hotkey_poll_config->proc_fops = &hotkey_poll_config_fops;
1013                 hotkey_poll_config->data = &global_hotkey_list;
1014                 hotkey_poll_config->owner = THIS_MODULE;
1015                 hotkey_poll_config->uid = 0;
1016                 hotkey_poll_config->gid = 0;
1017         }
1018
1019         hotkey_action = create_proc_entry(HOTKEY_ACTION, mode, hotkey_proc_dir);
1020         if (!hotkey_action) {
1021                 goto do_fail3;
1022         } else {
1023                 hotkey_action->proc_fops = &hotkey_action_fops;
1024                 hotkey_action->owner = THIS_MODULE;
1025                 hotkey_action->uid = 0;
1026                 hotkey_action->gid = 0;
1027         }
1028
1029         hotkey_info = create_proc_entry(HOTKEY_INFO, mode, hotkey_proc_dir);
1030         if (!hotkey_info) {
1031                 goto do_fail4;
1032         } else {
1033                 hotkey_info->proc_fops = &hotkey_info_fops;
1034                 hotkey_info->owner = THIS_MODULE;
1035                 hotkey_info->uid = 0;
1036                 hotkey_info->gid = 0;
1037         }
1038
1039         result = acpi_bus_register_driver(&hotkey_driver);
1040         if (result < 0)
1041                 goto do_fail5;
1042         global_hotkey_list.count = 0;
1043         global_hotkey_list.entries = &hotkey_entries;
1044
1045         INIT_LIST_HEAD(&hotkey_entries);
1046
1047         return (0);
1048
1049       do_fail5:
1050         remove_proc_entry(HOTKEY_INFO, hotkey_proc_dir);
1051       do_fail4:
1052         remove_proc_entry(HOTKEY_ACTION, hotkey_proc_dir);
1053       do_fail3:
1054         remove_proc_entry(HOTKEY_PL_CONFIG, hotkey_proc_dir);
1055       do_fail2:
1056         remove_proc_entry(HOTKEY_EV_CONFIG, hotkey_proc_dir);
1057       do_fail1:
1058         remove_proc_entry(HOTKEY_PROC, acpi_root_dir);
1059         return (-ENODEV);
1060 }
1061
1062 static void __exit hotkey_exit(void)
1063 {
1064         struct list_head *entries, *next;
1065
1066
1067         list_for_each_safe(entries, next, global_hotkey_list.entries) {
1068                 union acpi_hotkey *key =
1069                     container_of(entries, union acpi_hotkey, entries);
1070
1071                 acpi_os_wait_events_complete(NULL);
1072                 list_del(&key->link.entries);
1073                 global_hotkey_list.count--;
1074                 free_hotkey_device(key);
1075         }
1076         acpi_bus_unregister_driver(&hotkey_driver);
1077         remove_proc_entry(HOTKEY_EV_CONFIG, hotkey_proc_dir);
1078         remove_proc_entry(HOTKEY_PL_CONFIG, hotkey_proc_dir);
1079         remove_proc_entry(HOTKEY_ACTION, hotkey_proc_dir);
1080         remove_proc_entry(HOTKEY_INFO, hotkey_proc_dir);
1081         remove_proc_entry(HOTKEY_PROC, acpi_root_dir);
1082         return;
1083 }
1084
1085 module_init(hotkey_init);
1086 module_exit(hotkey_exit);