|
|
@@ -1,1042 +0,0 @@
|
|
|
-/*
|
|
|
- * hotkey.c - ACPI Hotkey Driver ($Revision: 0.2 $)
|
|
|
- *
|
|
|
- * Copyright (C) 2004 Luming Yu <luming.yu@intel.com>
|
|
|
- *
|
|
|
- * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
- *
|
|
|
- * This program is free software; you can redistribute it and/or modify
|
|
|
- * it under the terms of the GNU General Public License as published by
|
|
|
- * the Free Software Foundation; either version 2 of the License, or (at
|
|
|
- * your option) any later version.
|
|
|
- *
|
|
|
- * This program is distributed in the hope that it will be useful, but
|
|
|
- * WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
- * General Public License for more details.
|
|
|
- *
|
|
|
- * You should have received a copy of the GNU General Public License along
|
|
|
- * with this program; if not, write to the Free Software Foundation, Inc.,
|
|
|
- * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
|
|
|
- *
|
|
|
- * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
- */
|
|
|
-#include <linux/kernel.h>
|
|
|
-#include <linux/module.h>
|
|
|
-#include <linux/init.h>
|
|
|
-#include <linux/types.h>
|
|
|
-#include <linux/proc_fs.h>
|
|
|
-#include <linux/sched.h>
|
|
|
-#include <linux/kmod.h>
|
|
|
-#include <linux/seq_file.h>
|
|
|
-#include <acpi/acpi_drivers.h>
|
|
|
-#include <acpi/acpi_bus.h>
|
|
|
-#include <asm/uaccess.h>
|
|
|
-
|
|
|
-#define HOTKEY_ACPI_VERSION "0.1"
|
|
|
-
|
|
|
-#define HOTKEY_PROC "hotkey"
|
|
|
-#define HOTKEY_EV_CONFIG "event_config"
|
|
|
-#define HOTKEY_PL_CONFIG "poll_config"
|
|
|
-#define HOTKEY_ACTION "action"
|
|
|
-#define HOTKEY_INFO "info"
|
|
|
-
|
|
|
-#define ACPI_HOTK_NAME "Generic Hotkey Driver"
|
|
|
-#define ACPI_HOTK_CLASS "Hotkey"
|
|
|
-#define ACPI_HOTK_DEVICE_NAME "Hotkey"
|
|
|
-#define ACPI_HOTK_HID "Unknown?"
|
|
|
-#define ACPI_HOTKEY_COMPONENT 0x20000000
|
|
|
-
|
|
|
-#define ACPI_HOTKEY_EVENT 0x1
|
|
|
-#define ACPI_HOTKEY_POLLING 0x2
|
|
|
-#define ACPI_UNDEFINED_EVENT 0xf
|
|
|
-
|
|
|
-#define RESULT_STR_LEN 80
|
|
|
-
|
|
|
-#define ACTION_METHOD 0
|
|
|
-#define POLL_METHOD 1
|
|
|
-
|
|
|
-#define IS_EVENT(e) ((e) <= 10000 && (e) >0)
|
|
|
-#define IS_POLL(e) ((e) > 10000)
|
|
|
-#define IS_OTHERS(e) ((e)<=0 || (e)>=20000)
|
|
|
-#define _COMPONENT ACPI_HOTKEY_COMPONENT
|
|
|
-ACPI_MODULE_NAME("acpi_hotkey")
|
|
|
-
|
|
|
- MODULE_AUTHOR("luming.yu@intel.com");
|
|
|
-MODULE_DESCRIPTION(ACPI_HOTK_NAME);
|
|
|
-MODULE_LICENSE("GPL");
|
|
|
-
|
|
|
-/* standardized internal hotkey number/event */
|
|
|
-enum {
|
|
|
- /* Video Extension event */
|
|
|
- HK_EVENT_CYCLE_OUTPUT_DEVICE = 0x80,
|
|
|
- HK_EVENT_OUTPUT_DEVICE_STATUS_CHANGE,
|
|
|
- HK_EVENT_CYCLE_DISPLAY_OUTPUT,
|
|
|
- HK_EVENT_NEXT_DISPLAY_OUTPUT,
|
|
|
- HK_EVENT_PREVIOUS_DISPLAY_OUTPUT,
|
|
|
- HK_EVENT_CYCLE_BRIGHTNESS,
|
|
|
- HK_EVENT_INCREASE_BRIGHTNESS,
|
|
|
- HK_EVENT_DECREASE_BRIGHTNESS,
|
|
|
- HK_EVENT_ZERO_BRIGHTNESS,
|
|
|
- HK_EVENT_DISPLAY_DEVICE_OFF,
|
|
|
-
|
|
|
- /* Snd Card event */
|
|
|
- HK_EVENT_VOLUME_MUTE,
|
|
|
- HK_EVENT_VOLUME_INCLREASE,
|
|
|
- HK_EVENT_VOLUME_DECREASE,
|
|
|
-
|
|
|
- /* running state control */
|
|
|
- HK_EVENT_ENTERRING_S3,
|
|
|
- HK_EVENT_ENTERRING_S4,
|
|
|
- HK_EVENT_ENTERRING_S5,
|
|
|
-};
|
|
|
-
|
|
|
-enum conf_entry_enum {
|
|
|
- bus_handle = 0,
|
|
|
- bus_method = 1,
|
|
|
- action_handle = 2,
|
|
|
- method = 3,
|
|
|
- LAST_CONF_ENTRY
|
|
|
-};
|
|
|
-
|
|
|
-/* procdir we use */
|
|
|
-static struct proc_dir_entry *hotkey_proc_dir;
|
|
|
-static struct proc_dir_entry *hotkey_config;
|
|
|
-static struct proc_dir_entry *hotkey_poll_config;
|
|
|
-static struct proc_dir_entry *hotkey_action;
|
|
|
-static struct proc_dir_entry *hotkey_info;
|
|
|
-
|
|
|
-/* linkage for all type of hotkey */
|
|
|
-struct acpi_hotkey_link {
|
|
|
- struct list_head entries;
|
|
|
- int hotkey_type; /* event or polling based hotkey */
|
|
|
- int hotkey_standard_num; /* standardized hotkey(event) number */
|
|
|
-};
|
|
|
-
|
|
|
-/* event based hotkey */
|
|
|
-struct acpi_event_hotkey {
|
|
|
- struct acpi_hotkey_link hotkey_link;
|
|
|
- int flag;
|
|
|
- acpi_handle bus_handle; /* bus to install notify handler */
|
|
|
- int external_hotkey_num; /* external hotkey/event number */
|
|
|
- acpi_handle action_handle; /* acpi handle attached aml action method */
|
|
|
- char *action_method; /* action method */
|
|
|
-};
|
|
|
-
|
|
|
-/*
|
|
|
- * There are two ways to poll status
|
|
|
- * 1. directy call read_xxx method, without any arguments passed in
|
|
|
- * 2. call write_xxx method, with arguments passed in, you need
|
|
|
- * the result is saved in acpi_polling_hotkey.poll_result.
|
|
|
- * anthoer read command through polling interface.
|
|
|
- *
|
|
|
- */
|
|
|
-
|
|
|
-/* polling based hotkey */
|
|
|
-struct acpi_polling_hotkey {
|
|
|
- struct acpi_hotkey_link hotkey_link;
|
|
|
- int flag;
|
|
|
- acpi_handle poll_handle; /* acpi handle attached polling method */
|
|
|
- char *poll_method; /* poll method */
|
|
|
- acpi_handle action_handle; /* acpi handle attached action method */
|
|
|
- char *action_method; /* action method */
|
|
|
- union acpi_object *poll_result; /* polling_result */
|
|
|
- struct proc_dir_entry *proc;
|
|
|
-};
|
|
|
-
|
|
|
-/* hotkey object union */
|
|
|
-union acpi_hotkey {
|
|
|
- struct list_head entries;
|
|
|
- struct acpi_hotkey_link link;
|
|
|
- struct acpi_event_hotkey event_hotkey;
|
|
|
- struct acpi_polling_hotkey poll_hotkey;
|
|
|
-};
|
|
|
-
|
|
|
-/* hotkey object list */
|
|
|
-struct acpi_hotkey_list {
|
|
|
- struct list_head *entries;
|
|
|
- int count;
|
|
|
-};
|
|
|
-
|
|
|
-static int auto_hotkey_add(struct acpi_device *device);
|
|
|
-static int auto_hotkey_remove(struct acpi_device *device, int type);
|
|
|
-
|
|
|
-static struct acpi_driver hotkey_driver = {
|
|
|
- .name = ACPI_HOTK_NAME,
|
|
|
- .class = ACPI_HOTK_CLASS,
|
|
|
- .ids = ACPI_HOTK_HID,
|
|
|
- .ops = {
|
|
|
- .add = auto_hotkey_add,
|
|
|
- .remove = auto_hotkey_remove,
|
|
|
- },
|
|
|
-};
|
|
|
-
|
|
|
-static void free_hotkey_device(union acpi_hotkey *key);
|
|
|
-static void free_hotkey_buffer(union acpi_hotkey *key);
|
|
|
-static void free_poll_hotkey_buffer(union acpi_hotkey *key);
|
|
|
-static int hotkey_open_config(struct inode *inode, struct file *file);
|
|
|
-static int hotkey_poll_open_config(struct inode *inode, struct file *file);
|
|
|
-static ssize_t hotkey_write_config(struct file *file,
|
|
|
- const char __user * buffer,
|
|
|
- size_t count, loff_t * data);
|
|
|
-static int hotkey_info_open_fs(struct inode *inode, struct file *file);
|
|
|
-static int hotkey_action_open_fs(struct inode *inode, struct file *file);
|
|
|
-static ssize_t hotkey_execute_aml_method(struct file *file,
|
|
|
- const char __user * buffer,
|
|
|
- size_t count, loff_t * data);
|
|
|
-static int hotkey_config_seq_show(struct seq_file *seq, void *offset);
|
|
|
-static int hotkey_poll_config_seq_show(struct seq_file *seq, void *offset);
|
|
|
-static int hotkey_polling_open_fs(struct inode *inode, struct file *file);
|
|
|
-static union acpi_hotkey *get_hotkey_by_event(struct
|
|
|
- acpi_hotkey_list
|
|
|
- *hotkey_list, int event);
|
|
|
-
|
|
|
-/* event based config */
|
|
|
-static const struct file_operations hotkey_config_fops = {
|
|
|
- .open = hotkey_open_config,
|
|
|
- .read = seq_read,
|
|
|
- .write = hotkey_write_config,
|
|
|
- .llseek = seq_lseek,
|
|
|
- .release = single_release,
|
|
|
-};
|
|
|
-
|
|
|
-/* polling based config */
|
|
|
-static const struct file_operations hotkey_poll_config_fops = {
|
|
|
- .open = hotkey_poll_open_config,
|
|
|
- .read = seq_read,
|
|
|
- .write = hotkey_write_config,
|
|
|
- .llseek = seq_lseek,
|
|
|
- .release = single_release,
|
|
|
-};
|
|
|
-
|
|
|
-/* hotkey driver info */
|
|
|
-static const struct file_operations hotkey_info_fops = {
|
|
|
- .open = hotkey_info_open_fs,
|
|
|
- .read = seq_read,
|
|
|
- .llseek = seq_lseek,
|
|
|
- .release = single_release,
|
|
|
-};
|
|
|
-
|
|
|
-/* action */
|
|
|
-static const struct file_operations hotkey_action_fops = {
|
|
|
- .open = hotkey_action_open_fs,
|
|
|
- .read = seq_read,
|
|
|
- .write = hotkey_execute_aml_method,
|
|
|
- .llseek = seq_lseek,
|
|
|
- .release = single_release,
|
|
|
-};
|
|
|
-
|
|
|
-/* polling results */
|
|
|
-static const struct file_operations hotkey_polling_fops = {
|
|
|
- .open = hotkey_polling_open_fs,
|
|
|
- .read = seq_read,
|
|
|
- .llseek = seq_lseek,
|
|
|
- .release = single_release,
|
|
|
-};
|
|
|
-
|
|
|
-struct acpi_hotkey_list global_hotkey_list; /* link all ev or pl hotkey */
|
|
|
-struct list_head hotkey_entries; /* head of the list of hotkey_list */
|
|
|
-
|
|
|
-static int hotkey_info_seq_show(struct seq_file *seq, void *offset)
|
|
|
-{
|
|
|
-
|
|
|
- seq_printf(seq, "Hotkey generic driver ver: %s\n", HOTKEY_ACPI_VERSION);
|
|
|
-
|
|
|
- return 0;
|
|
|
-}
|
|
|
-
|
|
|
-static int hotkey_info_open_fs(struct inode *inode, struct file *file)
|
|
|
-{
|
|
|
- return single_open(file, hotkey_info_seq_show, PDE(inode)->data);
|
|
|
-}
|
|
|
-
|
|
|
-static char *format_result(union acpi_object *object)
|
|
|
-{
|
|
|
- char *buf;
|
|
|
-
|
|
|
- buf = kzalloc(RESULT_STR_LEN, GFP_KERNEL);
|
|
|
- if (!buf)
|
|
|
- return NULL;
|
|
|
- /* Now, just support integer type */
|
|
|
- if (object->type == ACPI_TYPE_INTEGER)
|
|
|
- sprintf(buf, "%d\n", (u32) object->integer.value);
|
|
|
- return buf;
|
|
|
-}
|
|
|
-
|
|
|
-static int hotkey_polling_seq_show(struct seq_file *seq, void *offset)
|
|
|
-{
|
|
|
- struct acpi_polling_hotkey *poll_hotkey = seq->private;
|
|
|
- char *buf;
|
|
|
-
|
|
|
-
|
|
|
- if (poll_hotkey->poll_result) {
|
|
|
- buf = format_result(poll_hotkey->poll_result);
|
|
|
- if (buf)
|
|
|
- seq_printf(seq, "%s", buf);
|
|
|
- kfree(buf);
|
|
|
- }
|
|
|
- return 0;
|
|
|
-}
|
|
|
-
|
|
|
-static int hotkey_polling_open_fs(struct inode *inode, struct file *file)
|
|
|
-{
|
|
|
- return single_open(file, hotkey_polling_seq_show, PDE(inode)->data);
|
|
|
-}
|
|
|
-
|
|
|
-static int hotkey_action_open_fs(struct inode *inode, struct file *file)
|
|
|
-{
|
|
|
- return single_open(file, hotkey_info_seq_show, PDE(inode)->data);
|
|
|
-}
|
|
|
-
|
|
|
-/* Mapping external hotkey number to standardized hotkey event num */
|
|
|
-static int hotkey_get_internal_event(int event, struct acpi_hotkey_list *list)
|
|
|
-{
|
|
|
- struct list_head *entries;
|
|
|
- int val = -1;
|
|
|
-
|
|
|
-
|
|
|
- list_for_each(entries, list->entries) {
|
|
|
- union acpi_hotkey *key =
|
|
|
- container_of(entries, union acpi_hotkey, entries);
|
|
|
- if (key->link.hotkey_type == ACPI_HOTKEY_EVENT
|
|
|
- && key->event_hotkey.external_hotkey_num == event) {
|
|
|
- val = key->link.hotkey_standard_num;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return val;
|
|
|
-}
|
|
|
-
|
|
|
-static void
|
|
|
-acpi_hotkey_notify_handler(acpi_handle handle, u32 event, void *data)
|
|
|
-{
|
|
|
- struct acpi_device *device = NULL;
|
|
|
- u32 internal_event;
|
|
|
-
|
|
|
-
|
|
|
- if (acpi_bus_get_device(handle, &device))
|
|
|
- return;
|
|
|
-
|
|
|
- internal_event = hotkey_get_internal_event(event, &global_hotkey_list);
|
|
|
- acpi_bus_generate_event(device, internal_event, 0);
|
|
|
-
|
|
|
- return;
|
|
|
-}
|
|
|
-
|
|
|
-/* Need to invent automatically hotkey add method */
|
|
|
-static int auto_hotkey_add(struct acpi_device *device)
|
|
|
-{
|
|
|
- /* Implement me */
|
|
|
- return 0;
|
|
|
-}
|
|
|
-
|
|
|
-/* Need to invent automatically hotkey remove method */
|
|
|
-static int auto_hotkey_remove(struct acpi_device *device, int type)
|
|
|
-{
|
|
|
- /* Implement me */
|
|
|
- return 0;
|
|
|
-}
|
|
|
-
|
|
|
-/* Create a proc file for each polling method */
|
|
|
-static int create_polling_proc(union acpi_hotkey *device)
|
|
|
-{
|
|
|
- struct proc_dir_entry *proc;
|
|
|
- char proc_name[80];
|
|
|
- mode_t mode;
|
|
|
-
|
|
|
- mode = S_IFREG | S_IRUGO | S_IWUGO;
|
|
|
-
|
|
|
- sprintf(proc_name, "%d", device->link.hotkey_standard_num);
|
|
|
- /*
|
|
|
- strcat(proc_name, device->poll_hotkey.poll_method);
|
|
|
- */
|
|
|
- proc = create_proc_entry(proc_name, mode, hotkey_proc_dir);
|
|
|
-
|
|
|
- if (!proc) {
|
|
|
- return -ENODEV;
|
|
|
- } else {
|
|
|
- proc->proc_fops = &hotkey_polling_fops;
|
|
|
- proc->owner = THIS_MODULE;
|
|
|
- proc->data = device;
|
|
|
- proc->uid = 0;
|
|
|
- proc->gid = 0;
|
|
|
- device->poll_hotkey.proc = proc;
|
|
|
- }
|
|
|
- return 0;
|
|
|
-}
|
|
|
-
|
|
|
-static int hotkey_add(union acpi_hotkey *device)
|
|
|
-{
|
|
|
- int status = 0;
|
|
|
- struct acpi_device *dev = NULL;
|
|
|
-
|
|
|
-
|
|
|
- if (device->link.hotkey_type == ACPI_HOTKEY_EVENT) {
|
|
|
- acpi_bus_get_device(device->event_hotkey.bus_handle, &dev);
|
|
|
- status = acpi_install_notify_handler(dev->handle,
|
|
|
- ACPI_DEVICE_NOTIFY,
|
|
|
- acpi_hotkey_notify_handler,
|
|
|
- dev);
|
|
|
- } else /* Add polling hotkey */
|
|
|
- create_polling_proc(device);
|
|
|
-
|
|
|
- global_hotkey_list.count++;
|
|
|
-
|
|
|
- list_add_tail(&device->link.entries, global_hotkey_list.entries);
|
|
|
-
|
|
|
- return status;
|
|
|
-}
|
|
|
-
|
|
|
-static int hotkey_remove(union acpi_hotkey *device)
|
|
|
-{
|
|
|
- struct list_head *entries, *next;
|
|
|
-
|
|
|
-
|
|
|
- list_for_each_safe(entries, next, global_hotkey_list.entries) {
|
|
|
- union acpi_hotkey *key =
|
|
|
- container_of(entries, union acpi_hotkey, entries);
|
|
|
- if (key->link.hotkey_standard_num ==
|
|
|
- device->link.hotkey_standard_num) {
|
|
|
- list_del(&key->link.entries);
|
|
|
- free_hotkey_device(key);
|
|
|
- global_hotkey_list.count--;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- kfree(device);
|
|
|
- return 0;
|
|
|
-}
|
|
|
-
|
|
|
-static int hotkey_update(union acpi_hotkey *key)
|
|
|
-{
|
|
|
- struct list_head *entries;
|
|
|
-
|
|
|
-
|
|
|
- list_for_each(entries, global_hotkey_list.entries) {
|
|
|
- union acpi_hotkey *tmp =
|
|
|
- container_of(entries, union acpi_hotkey, entries);
|
|
|
- if (tmp->link.hotkey_standard_num ==
|
|
|
- key->link.hotkey_standard_num) {
|
|
|
- if (key->link.hotkey_type == ACPI_HOTKEY_EVENT) {
|
|
|
- free_hotkey_buffer(tmp);
|
|
|
- tmp->event_hotkey.bus_handle =
|
|
|
- key->event_hotkey.bus_handle;
|
|
|
- tmp->event_hotkey.external_hotkey_num =
|
|
|
- key->event_hotkey.external_hotkey_num;
|
|
|
- tmp->event_hotkey.action_handle =
|
|
|
- key->event_hotkey.action_handle;
|
|
|
- tmp->event_hotkey.action_method =
|
|
|
- key->event_hotkey.action_method;
|
|
|
- kfree(key);
|
|
|
- } else {
|
|
|
- /*
|
|
|
- char proc_name[80];
|
|
|
-
|
|
|
- sprintf(proc_name, "%d", tmp->link.hotkey_standard_num);
|
|
|
- strcat(proc_name, tmp->poll_hotkey.poll_method);
|
|
|
- remove_proc_entry(proc_name,hotkey_proc_dir);
|
|
|
- */
|
|
|
- free_poll_hotkey_buffer(tmp);
|
|
|
- tmp->poll_hotkey.poll_handle =
|
|
|
- key->poll_hotkey.poll_handle;
|
|
|
- tmp->poll_hotkey.poll_method =
|
|
|
- key->poll_hotkey.poll_method;
|
|
|
- tmp->poll_hotkey.action_handle =
|
|
|
- key->poll_hotkey.action_handle;
|
|
|
- tmp->poll_hotkey.action_method =
|
|
|
- key->poll_hotkey.action_method;
|
|
|
- tmp->poll_hotkey.poll_result =
|
|
|
- key->poll_hotkey.poll_result;
|
|
|
- /*
|
|
|
- create_polling_proc(tmp);
|
|
|
- */
|
|
|
- kfree(key);
|
|
|
- }
|
|
|
- return 0;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return -ENODEV;
|
|
|
-}
|
|
|
-
|
|
|
-static void free_hotkey_device(union acpi_hotkey *key)
|
|
|
-{
|
|
|
- struct acpi_device *dev;
|
|
|
-
|
|
|
-
|
|
|
- if (key->link.hotkey_type == ACPI_HOTKEY_EVENT) {
|
|
|
- acpi_bus_get_device(key->event_hotkey.bus_handle, &dev);
|
|
|
- if (dev->handle)
|
|
|
- acpi_remove_notify_handler(dev->handle,
|
|
|
- ACPI_DEVICE_NOTIFY,
|
|
|
- acpi_hotkey_notify_handler);
|
|
|
- free_hotkey_buffer(key);
|
|
|
- } else {
|
|
|
- char proc_name[80];
|
|
|
-
|
|
|
- sprintf(proc_name, "%d", key->link.hotkey_standard_num);
|
|
|
- /*
|
|
|
- strcat(proc_name, key->poll_hotkey.poll_method);
|
|
|
- */
|
|
|
- remove_proc_entry(proc_name, hotkey_proc_dir);
|
|
|
- free_poll_hotkey_buffer(key);
|
|
|
- }
|
|
|
- kfree(key);
|
|
|
- return;
|
|
|
-}
|
|
|
-
|
|
|
-static void free_hotkey_buffer(union acpi_hotkey *key)
|
|
|
-{
|
|
|
- /* key would never be null, action method could be */
|
|
|
- kfree(key->event_hotkey.action_method);
|
|
|
-}
|
|
|
-
|
|
|
-static void free_poll_hotkey_buffer(union acpi_hotkey *key)
|
|
|
-{
|
|
|
- /* key would never be null, others could be*/
|
|
|
- kfree(key->poll_hotkey.action_method);
|
|
|
- kfree(key->poll_hotkey.poll_method);
|
|
|
- kfree(key->poll_hotkey.poll_result);
|
|
|
-}
|
|
|
-static int
|
|
|
-init_hotkey_device(union acpi_hotkey *key, char **config_entry,
|
|
|
- int std_num, int external_num)
|
|
|
-{
|
|
|
- acpi_handle tmp_handle;
|
|
|
- acpi_status status = AE_OK;
|
|
|
-
|
|
|
- if (std_num < 0 || IS_POLL(std_num) || !key)
|
|
|
- goto do_fail;
|
|
|
-
|
|
|
- if (!config_entry[bus_handle] || !config_entry[action_handle]
|
|
|
- || !config_entry[method])
|
|
|
- goto do_fail;
|
|
|
-
|
|
|
- key->link.hotkey_type = ACPI_HOTKEY_EVENT;
|
|
|
- key->link.hotkey_standard_num = std_num;
|
|
|
- key->event_hotkey.flag = 0;
|
|
|
- key->event_hotkey.action_method = config_entry[method];
|
|
|
-
|
|
|
- status = acpi_get_handle(NULL, config_entry[bus_handle],
|
|
|
- &(key->event_hotkey.bus_handle));
|
|
|
- if (ACPI_FAILURE(status))
|
|
|
- goto do_fail_zero;
|
|
|
- key->event_hotkey.external_hotkey_num = external_num;
|
|
|
- status = acpi_get_handle(NULL, config_entry[action_handle],
|
|
|
- &(key->event_hotkey.action_handle));
|
|
|
- if (ACPI_FAILURE(status))
|
|
|
- goto do_fail_zero;
|
|
|
- status = acpi_get_handle(key->event_hotkey.action_handle,
|
|
|
- config_entry[method], &tmp_handle);
|
|
|
- if (ACPI_FAILURE(status))
|
|
|
- goto do_fail_zero;
|
|
|
- return AE_OK;
|
|
|
-do_fail_zero:
|
|
|
- key->event_hotkey.action_method = NULL;
|
|
|
-do_fail:
|
|
|
- return -ENODEV;
|
|
|
-}
|
|
|
-
|
|
|
-static int
|
|
|
-init_poll_hotkey_device(union acpi_hotkey *key, char **config_entry,
|
|
|
- int std_num)
|
|
|
-{
|
|
|
- acpi_status status = AE_OK;
|
|
|
- acpi_handle tmp_handle;
|
|
|
-
|
|
|
- if (std_num < 0 || IS_EVENT(std_num) || !key)
|
|
|
- goto do_fail;
|
|
|
- if (!config_entry[bus_handle] ||!config_entry[bus_method] ||
|
|
|
- !config_entry[action_handle] || !config_entry[method])
|
|
|
- goto do_fail;
|
|
|
-
|
|
|
- key->link.hotkey_type = ACPI_HOTKEY_POLLING;
|
|
|
- key->link.hotkey_standard_num = std_num;
|
|
|
- key->poll_hotkey.flag = 0;
|
|
|
- key->poll_hotkey.poll_method = config_entry[bus_method];
|
|
|
- key->poll_hotkey.action_method = config_entry[method];
|
|
|
-
|
|
|
- status = acpi_get_handle(NULL, config_entry[bus_handle],
|
|
|
- &(key->poll_hotkey.poll_handle));
|
|
|
- if (ACPI_FAILURE(status))
|
|
|
- goto do_fail_zero;
|
|
|
- status = acpi_get_handle(key->poll_hotkey.poll_handle,
|
|
|
- config_entry[bus_method], &tmp_handle);
|
|
|
- if (ACPI_FAILURE(status))
|
|
|
- goto do_fail_zero;
|
|
|
- status =
|
|
|
- acpi_get_handle(NULL, config_entry[action_handle],
|
|
|
- &(key->poll_hotkey.action_handle));
|
|
|
- if (ACPI_FAILURE(status))
|
|
|
- goto do_fail_zero;
|
|
|
- status = acpi_get_handle(key->poll_hotkey.action_handle,
|
|
|
- config_entry[method], &tmp_handle);
|
|
|
- if (ACPI_FAILURE(status))
|
|
|
- goto do_fail_zero;
|
|
|
- key->poll_hotkey.poll_result =
|
|
|
- kmalloc(sizeof(union acpi_object), GFP_KERNEL);
|
|
|
- if (!key->poll_hotkey.poll_result)
|
|
|
- goto do_fail_zero;
|
|
|
- return AE_OK;
|
|
|
-
|
|
|
-do_fail_zero:
|
|
|
- key->poll_hotkey.poll_method = NULL;
|
|
|
- key->poll_hotkey.action_method = NULL;
|
|
|
-do_fail:
|
|
|
- return -ENODEV;
|
|
|
-}
|
|
|
-
|
|
|
-static int hotkey_open_config(struct inode *inode, struct file *file)
|
|
|
-{
|
|
|
- return (single_open
|
|
|
- (file, hotkey_config_seq_show, PDE(inode)->data));
|
|
|
-}
|
|
|
-
|
|
|
-static int hotkey_poll_open_config(struct inode *inode, struct file *file)
|
|
|
-{
|
|
|
- return (single_open
|
|
|
- (file, hotkey_poll_config_seq_show, PDE(inode)->data));
|
|
|
-}
|
|
|
-
|
|
|
-static int hotkey_config_seq_show(struct seq_file *seq, void *offset)
|
|
|
-{
|
|
|
- struct acpi_hotkey_list *hotkey_list = &global_hotkey_list;
|
|
|
- struct list_head *entries;
|
|
|
- char bus_name[ACPI_PATHNAME_MAX] = { 0 };
|
|
|
- char action_name[ACPI_PATHNAME_MAX] = { 0 };
|
|
|
- struct acpi_buffer bus = { ACPI_PATHNAME_MAX, bus_name };
|
|
|
- struct acpi_buffer act = { ACPI_PATHNAME_MAX, action_name };
|
|
|
-
|
|
|
-
|
|
|
- list_for_each(entries, hotkey_list->entries) {
|
|
|
- union acpi_hotkey *key =
|
|
|
- container_of(entries, union acpi_hotkey, entries);
|
|
|
- if (key->link.hotkey_type == ACPI_HOTKEY_EVENT) {
|
|
|
- acpi_get_name(key->event_hotkey.bus_handle,
|
|
|
- ACPI_NAME_TYPE_MAX, &bus);
|
|
|
- acpi_get_name(key->event_hotkey.action_handle,
|
|
|
- ACPI_NAME_TYPE_MAX, &act);
|
|
|
- seq_printf(seq, "%s:%s:%s:%d:%d\n", bus_name,
|
|
|
- action_name,
|
|
|
- key->event_hotkey.action_method,
|
|
|
- key->link.hotkey_standard_num,
|
|
|
- key->event_hotkey.external_hotkey_num);
|
|
|
- }
|
|
|
- }
|
|
|
- seq_puts(seq, "\n");
|
|
|
- return 0;
|
|
|
-}
|
|
|
-
|
|
|
-static int hotkey_poll_config_seq_show(struct seq_file *seq, void *offset)
|
|
|
-{
|
|
|
- struct acpi_hotkey_list *hotkey_list = &global_hotkey_list;
|
|
|
- struct list_head *entries;
|
|
|
- char bus_name[ACPI_PATHNAME_MAX] = { 0 };
|
|
|
- char action_name[ACPI_PATHNAME_MAX] = { 0 };
|
|
|
- struct acpi_buffer bus = { ACPI_PATHNAME_MAX, bus_name };
|
|
|
- struct acpi_buffer act = { ACPI_PATHNAME_MAX, action_name };
|
|
|
-
|
|
|
-
|
|
|
- list_for_each(entries, hotkey_list->entries) {
|
|
|
- union acpi_hotkey *key =
|
|
|
- container_of(entries, union acpi_hotkey, entries);
|
|
|
- if (key->link.hotkey_type == ACPI_HOTKEY_POLLING) {
|
|
|
- acpi_get_name(key->poll_hotkey.poll_handle,
|
|
|
- ACPI_NAME_TYPE_MAX, &bus);
|
|
|
- acpi_get_name(key->poll_hotkey.action_handle,
|
|
|
- ACPI_NAME_TYPE_MAX, &act);
|
|
|
- seq_printf(seq, "%s:%s:%s:%s:%d\n", bus_name,
|
|
|
- key->poll_hotkey.poll_method,
|
|
|
- action_name,
|
|
|
- key->poll_hotkey.action_method,
|
|
|
- key->link.hotkey_standard_num);
|
|
|
- }
|
|
|
- }
|
|
|
- seq_puts(seq, "\n");
|
|
|
- return 0;
|
|
|
-}
|
|
|
-
|
|
|
-static int
|
|
|
-get_parms(char *config_record, int *cmd, char **config_entry,
|
|
|
- int *internal_event_num, int *external_event_num)
|
|
|
-{
|
|
|
-/* the format of *config_record =
|
|
|
- * "1:\d+:*" : "cmd:internal_event_num"
|
|
|
- * "\d+:\w+:\w+:\w+:\w+:\d+:\d+" :
|
|
|
- * "cmd:bus_handle:bus_method:action_handle:method:internal_event_num:external_event_num"
|
|
|
- */
|
|
|
- char *tmp, *tmp1, count;
|
|
|
- int i;
|
|
|
-
|
|
|
- sscanf(config_record, "%d", cmd);
|
|
|
- if (*cmd == 1) {
|
|
|
- if (sscanf(config_record, "%d:%d", cmd, internal_event_num) !=
|
|
|
- 2)
|
|
|
- goto do_fail;
|
|
|
- else
|
|
|
- return (6);
|
|
|
- }
|
|
|
- tmp = strchr(config_record, ':');
|
|
|
- if (!tmp)
|
|
|
- goto do_fail;
|
|
|
- tmp++;
|
|
|
- for (i = 0; i < LAST_CONF_ENTRY; i++) {
|
|
|
- tmp1 = strchr(tmp, ':');
|
|
|
- if (!tmp1) {
|
|
|
- goto do_fail;
|
|
|
- }
|
|
|
- count = tmp1 - tmp;
|
|
|
- config_entry[i] = kzalloc(count + 1, GFP_KERNEL);
|
|
|
- if (!config_entry[i])
|
|
|
- goto handle_failure;
|
|
|
- strncpy(config_entry[i], tmp, count);
|
|
|
- tmp = tmp1 + 1;
|
|
|
- }
|
|
|
- if (sscanf(tmp, "%d:%d", internal_event_num, external_event_num) <= 0)
|
|
|
- goto handle_failure;
|
|
|
- if (!IS_OTHERS(*internal_event_num)) {
|
|
|
- return 6;
|
|
|
- }
|
|
|
-handle_failure:
|
|
|
- while (i-- > 0)
|
|
|
- kfree(config_entry[i]);
|
|
|
-do_fail:
|
|
|
- return -1;
|
|
|
-}
|
|
|
-
|
|
|
-/* count is length for one input record */
|
|
|
-static ssize_t hotkey_write_config(struct file *file,
|
|
|
- const char __user * buffer,
|
|
|
- size_t count, loff_t * data)
|
|
|
-{
|
|
|
- char *config_record = NULL;
|
|
|
- char *config_entry[LAST_CONF_ENTRY];
|
|
|
- int cmd, internal_event_num, external_event_num;
|
|
|
- int ret = 0;
|
|
|
- union acpi_hotkey *key = kzalloc(sizeof(union acpi_hotkey), GFP_KERNEL);
|
|
|
-
|
|
|
- if (!key)
|
|
|
- return -ENOMEM;
|
|
|
-
|
|
|
- config_record = kzalloc(count + 1, GFP_KERNEL);
|
|
|
- if (!config_record) {
|
|
|
- kfree(key);
|
|
|
- return -ENOMEM;
|
|
|
- }
|
|
|
-
|
|
|
- if (copy_from_user(config_record, buffer, count)) {
|
|
|
- kfree(config_record);
|
|
|
- kfree(key);
|
|
|
- printk(KERN_ERR PREFIX "Invalid data\n");
|
|
|
- return -EINVAL;
|
|
|
- }
|
|
|
- ret = get_parms(config_record, &cmd, config_entry,
|
|
|
- &internal_event_num, &external_event_num);
|
|
|
- kfree(config_record);
|
|
|
- if (ret != 6) {
|
|
|
- printk(KERN_ERR PREFIX "Invalid data format ret=%d\n", ret);
|
|
|
- return -EINVAL;
|
|
|
- }
|
|
|
-
|
|
|
- if (cmd == 1) {
|
|
|
- union acpi_hotkey *tmp = NULL;
|
|
|
- tmp = get_hotkey_by_event(&global_hotkey_list,
|
|
|
- internal_event_num);
|
|
|
- if (!tmp)
|
|
|
- printk(KERN_ERR PREFIX "Invalid key\n");
|
|
|
- else
|
|
|
- memcpy(key, tmp, sizeof(union acpi_hotkey));
|
|
|
- goto cont_cmd;
|
|
|
- }
|
|
|
- if (IS_EVENT(internal_event_num)) {
|
|
|
- if (init_hotkey_device(key, config_entry,
|
|
|
- internal_event_num, external_event_num))
|
|
|
- goto init_hotkey_fail;
|
|
|
- } else {
|
|
|
- if (init_poll_hotkey_device(key, config_entry,
|
|
|
- internal_event_num))
|
|
|
- goto init_poll_hotkey_fail;
|
|
|
- }
|
|
|
-cont_cmd:
|
|
|
- switch (cmd) {
|
|
|
- case 0:
|
|
|
- if (get_hotkey_by_event(&global_hotkey_list,
|
|
|
- key->link.hotkey_standard_num))
|
|
|
- goto fail_out;
|
|
|
- else
|
|
|
- hotkey_add(key);
|
|
|
- break;
|
|
|
- case 1:
|
|
|
- hotkey_remove(key);
|
|
|
- break;
|
|
|
- case 2:
|
|
|
- /* key is kfree()ed if matched*/
|
|
|
- if (hotkey_update(key))
|
|
|
- goto fail_out;
|
|
|
- break;
|
|
|
- default:
|
|
|
- goto fail_out;
|
|
|
- break;
|
|
|
- }
|
|
|
- return count;
|
|
|
-
|
|
|
-init_poll_hotkey_fail: /* failed init_poll_hotkey_device */
|
|
|
- kfree(config_entry[bus_method]);
|
|
|
- config_entry[bus_method] = NULL;
|
|
|
-init_hotkey_fail: /* failed init_hotkey_device */
|
|
|
- kfree(config_entry[method]);
|
|
|
-fail_out:
|
|
|
- kfree(config_entry[bus_handle]);
|
|
|
- kfree(config_entry[action_handle]);
|
|
|
- /* No double free since elements =NULL for error cases */
|
|
|
- if (IS_EVENT(internal_event_num)) {
|
|
|
- if (config_entry[bus_method])
|
|
|
- kfree(config_entry[bus_method]);
|
|
|
- free_hotkey_buffer(key); /* frees [method] */
|
|
|
- } else
|
|
|
- free_poll_hotkey_buffer(key); /* frees [bus_method]+[method] */
|
|
|
- kfree(key);
|
|
|
- printk(KERN_ERR PREFIX "invalid key\n");
|
|
|
- return -EINVAL;
|
|
|
-}
|
|
|
-
|
|
|
-/*
|
|
|
- * This function evaluates an ACPI method, given an int as parameter, the
|
|
|
- * method is searched within the scope of the handle, can be NULL. The output
|
|
|
- * of the method is written is output, which can also be NULL
|
|
|
- *
|
|
|
- * returns 1 if write is successful, 0 else.
|
|
|
- */
|
|
|
-static int write_acpi_int(acpi_handle handle, const char *method, int val,
|
|
|
- struct acpi_buffer *output)
|
|
|
-{
|
|
|
- struct acpi_object_list params; /* list of input parameters (an int here) */
|
|
|
- union acpi_object in_obj; /* the only param we use */
|
|
|
- acpi_status status;
|
|
|
-
|
|
|
- params.count = 1;
|
|
|
- params.pointer = &in_obj;
|
|
|
- in_obj.type = ACPI_TYPE_INTEGER;
|
|
|
- in_obj.integer.value = val;
|
|
|
-
|
|
|
- status = acpi_evaluate_object(handle, (char *)method, ¶ms, output);
|
|
|
-
|
|
|
- return (status == AE_OK);
|
|
|
-}
|
|
|
-
|
|
|
-static int read_acpi_int(acpi_handle handle, const char *method,
|
|
|
- union acpi_object *val)
|
|
|
-{
|
|
|
- struct acpi_buffer output;
|
|
|
- union acpi_object out_obj;
|
|
|
- acpi_status status;
|
|
|
-
|
|
|
- output.length = sizeof(out_obj);
|
|
|
- output.pointer = &out_obj;
|
|
|
-
|
|
|
- status = acpi_evaluate_object(handle, (char *)method, NULL, &output);
|
|
|
- if (val) {
|
|
|
- val->integer.value = out_obj.integer.value;
|
|
|
- val->type = out_obj.type;
|
|
|
- } else
|
|
|
- printk(KERN_ERR PREFIX "null val pointer\n");
|
|
|
- return ((status == AE_OK)
|
|
|
- && (out_obj.type == ACPI_TYPE_INTEGER));
|
|
|
-}
|
|
|
-
|
|
|
-static union acpi_hotkey *get_hotkey_by_event(struct
|
|
|
- acpi_hotkey_list
|
|
|
- *hotkey_list, int event)
|
|
|
-{
|
|
|
- struct list_head *entries;
|
|
|
-
|
|
|
- list_for_each(entries, hotkey_list->entries) {
|
|
|
- union acpi_hotkey *key =
|
|
|
- container_of(entries, union acpi_hotkey, entries);
|
|
|
- if (key->link.hotkey_standard_num == event) {
|
|
|
- return (key);
|
|
|
- }
|
|
|
- }
|
|
|
- return (NULL);
|
|
|
-}
|
|
|
-
|
|
|
-/*
|
|
|
- * user call AML method interface:
|
|
|
- * Call convention:
|
|
|
- * echo "event_num: arg type : value"
|
|
|
- * example: echo "1:1:30" > /proc/acpi/action
|
|
|
- * Just support 1 integer arg passing to AML method
|
|
|
- */
|
|
|
-
|
|
|
-static ssize_t hotkey_execute_aml_method(struct file *file,
|
|
|
- const char __user * buffer,
|
|
|
- size_t count, loff_t * data)
|
|
|
-{
|
|
|
- struct acpi_hotkey_list *hotkey_list = &global_hotkey_list;
|
|
|
- char *arg;
|
|
|
- int event, method_type, type, value;
|
|
|
- union acpi_hotkey *key;
|
|
|
-
|
|
|
-
|
|
|
- arg = kzalloc(count + 1, GFP_KERNEL);
|
|
|
- if (!arg)
|
|
|
- return -ENOMEM;
|
|
|
-
|
|
|
- if (copy_from_user(arg, buffer, count)) {
|
|
|
- kfree(arg);
|
|
|
- printk(KERN_ERR PREFIX "Invalid argument 2\n");
|
|
|
- return -EINVAL;
|
|
|
- }
|
|
|
-
|
|
|
- if (sscanf(arg, "%d:%d:%d:%d", &event, &method_type, &type, &value) !=
|
|
|
- 4) {
|
|
|
- kfree(arg);
|
|
|
- printk(KERN_ERR PREFIX "Invalid argument 3\n");
|
|
|
- return -EINVAL;
|
|
|
- }
|
|
|
- kfree(arg);
|
|
|
- if (type == ACPI_TYPE_INTEGER) {
|
|
|
- key = get_hotkey_by_event(hotkey_list, event);
|
|
|
- if (!key)
|
|
|
- goto do_fail;
|
|
|
- if (IS_EVENT(event))
|
|
|
- write_acpi_int(key->event_hotkey.action_handle,
|
|
|
- key->event_hotkey.action_method, value,
|
|
|
- NULL);
|
|
|
- else if (IS_POLL(event)) {
|
|
|
- if (method_type == POLL_METHOD)
|
|
|
- read_acpi_int(key->poll_hotkey.poll_handle,
|
|
|
- key->poll_hotkey.poll_method,
|
|
|
- key->poll_hotkey.poll_result);
|
|
|
- else if (method_type == ACTION_METHOD)
|
|
|
- write_acpi_int(key->poll_hotkey.action_handle,
|
|
|
- key->poll_hotkey.action_method,
|
|
|
- value, NULL);
|
|
|
- else
|
|
|
- goto do_fail;
|
|
|
-
|
|
|
- }
|
|
|
- } else {
|
|
|
- printk(KERN_WARNING "Not supported\n");
|
|
|
- return -EINVAL;
|
|
|
- }
|
|
|
- return count;
|
|
|
- do_fail:
|
|
|
- return -EINVAL;
|
|
|
-
|
|
|
-}
|
|
|
-
|
|
|
-static int __init hotkey_init(void)
|
|
|
-{
|
|
|
- int result;
|
|
|
- mode_t mode = S_IFREG | S_IRUGO | S_IWUGO;
|
|
|
-
|
|
|
-
|
|
|
- if (acpi_disabled)
|
|
|
- return -ENODEV;
|
|
|
-
|
|
|
- if (acpi_specific_hotkey_enabled) {
|
|
|
- printk("Using specific hotkey driver\n");
|
|
|
- return -ENODEV;
|
|
|
- }
|
|
|
-
|
|
|
- hotkey_proc_dir = proc_mkdir(HOTKEY_PROC, acpi_root_dir);
|
|
|
- if (!hotkey_proc_dir) {
|
|
|
- return (-ENODEV);
|
|
|
- }
|
|
|
- hotkey_proc_dir->owner = THIS_MODULE;
|
|
|
-
|
|
|
- hotkey_config =
|
|
|
- create_proc_entry(HOTKEY_EV_CONFIG, mode, hotkey_proc_dir);
|
|
|
- if (!hotkey_config) {
|
|
|
- goto do_fail1;
|
|
|
- } else {
|
|
|
- hotkey_config->proc_fops = &hotkey_config_fops;
|
|
|
- hotkey_config->data = &global_hotkey_list;
|
|
|
- hotkey_config->owner = THIS_MODULE;
|
|
|
- hotkey_config->uid = 0;
|
|
|
- hotkey_config->gid = 0;
|
|
|
- }
|
|
|
-
|
|
|
- hotkey_poll_config =
|
|
|
- create_proc_entry(HOTKEY_PL_CONFIG, mode, hotkey_proc_dir);
|
|
|
- if (!hotkey_poll_config) {
|
|
|
- goto do_fail2;
|
|
|
- } else {
|
|
|
- hotkey_poll_config->proc_fops = &hotkey_poll_config_fops;
|
|
|
- hotkey_poll_config->data = &global_hotkey_list;
|
|
|
- hotkey_poll_config->owner = THIS_MODULE;
|
|
|
- hotkey_poll_config->uid = 0;
|
|
|
- hotkey_poll_config->gid = 0;
|
|
|
- }
|
|
|
-
|
|
|
- hotkey_action = create_proc_entry(HOTKEY_ACTION, mode, hotkey_proc_dir);
|
|
|
- if (!hotkey_action) {
|
|
|
- goto do_fail3;
|
|
|
- } else {
|
|
|
- hotkey_action->proc_fops = &hotkey_action_fops;
|
|
|
- hotkey_action->owner = THIS_MODULE;
|
|
|
- hotkey_action->uid = 0;
|
|
|
- hotkey_action->gid = 0;
|
|
|
- }
|
|
|
-
|
|
|
- hotkey_info = create_proc_entry(HOTKEY_INFO, mode, hotkey_proc_dir);
|
|
|
- if (!hotkey_info) {
|
|
|
- goto do_fail4;
|
|
|
- } else {
|
|
|
- hotkey_info->proc_fops = &hotkey_info_fops;
|
|
|
- hotkey_info->owner = THIS_MODULE;
|
|
|
- hotkey_info->uid = 0;
|
|
|
- hotkey_info->gid = 0;
|
|
|
- }
|
|
|
-
|
|
|
- result = acpi_bus_register_driver(&hotkey_driver);
|
|
|
- if (result < 0)
|
|
|
- goto do_fail5;
|
|
|
- global_hotkey_list.count = 0;
|
|
|
- global_hotkey_list.entries = &hotkey_entries;
|
|
|
-
|
|
|
- INIT_LIST_HEAD(&hotkey_entries);
|
|
|
-
|
|
|
- return (0);
|
|
|
-
|
|
|
- do_fail5:
|
|
|
- remove_proc_entry(HOTKEY_INFO, hotkey_proc_dir);
|
|
|
- do_fail4:
|
|
|
- remove_proc_entry(HOTKEY_ACTION, hotkey_proc_dir);
|
|
|
- do_fail3:
|
|
|
- remove_proc_entry(HOTKEY_PL_CONFIG, hotkey_proc_dir);
|
|
|
- do_fail2:
|
|
|
- remove_proc_entry(HOTKEY_EV_CONFIG, hotkey_proc_dir);
|
|
|
- do_fail1:
|
|
|
- remove_proc_entry(HOTKEY_PROC, acpi_root_dir);
|
|
|
- return (-ENODEV);
|
|
|
-}
|
|
|
-
|
|
|
-static void __exit hotkey_exit(void)
|
|
|
-{
|
|
|
- struct list_head *entries, *next;
|
|
|
-
|
|
|
-
|
|
|
- list_for_each_safe(entries, next, global_hotkey_list.entries) {
|
|
|
- union acpi_hotkey *key =
|
|
|
- container_of(entries, union acpi_hotkey, entries);
|
|
|
-
|
|
|
- acpi_os_wait_events_complete(NULL);
|
|
|
- list_del(&key->link.entries);
|
|
|
- global_hotkey_list.count--;
|
|
|
- free_hotkey_device(key);
|
|
|
- }
|
|
|
- acpi_bus_unregister_driver(&hotkey_driver);
|
|
|
- remove_proc_entry(HOTKEY_EV_CONFIG, hotkey_proc_dir);
|
|
|
- remove_proc_entry(HOTKEY_PL_CONFIG, hotkey_proc_dir);
|
|
|
- remove_proc_entry(HOTKEY_ACTION, hotkey_proc_dir);
|
|
|
- remove_proc_entry(HOTKEY_INFO, hotkey_proc_dir);
|
|
|
- remove_proc_entry(HOTKEY_PROC, acpi_root_dir);
|
|
|
- return;
|
|
|
-}
|
|
|
-
|
|
|
-module_init(hotkey_init);
|
|
|
-module_exit(hotkey_exit);
|
Len Brown