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;
*hotkey_list, int event);
/* event based config */
-static const struct file_operations hotkey_config_fops = {
+static struct file_operations hotkey_config_fops = {
.open = hotkey_open_config,
.read = seq_read,
.write = hotkey_write_config,
};
/* polling based config */
-static const struct file_operations hotkey_poll_config_fops = {
+static struct file_operations hotkey_poll_config_fops = {
.open = hotkey_poll_open_config,
.read = seq_read,
.write = hotkey_write_config,
};
/* hotkey driver info */
-static const struct file_operations hotkey_info_fops = {
+static struct file_operations hotkey_info_fops = {
.open = hotkey_info_open_fs,
.read = seq_read,
.llseek = seq_lseek,
};
/* action */
-static const struct file_operations hotkey_action_fops = {
+static struct file_operations hotkey_action_fops = {
.open = hotkey_action_open_fs,
.read = seq_read,
.write = hotkey_execute_aml_method,
};
/* polling results */
-static const struct file_operations hotkey_polling_fops = {
+static struct file_operations hotkey_polling_fops = {
.open = hotkey_polling_open_fs,
.read = seq_read,
.llseek = seq_lseek,
static int hotkey_info_seq_show(struct seq_file *seq, void *offset)
{
+ ACPI_FUNCTION_TRACE("hotkey_info_seq_show");
seq_printf(seq, "Hotkey generic driver ver: %s\n", HOTKEY_ACPI_VERSION);
- return 0;
+ return_VALUE(0);
}
static int hotkey_info_open_fs(struct inode *inode, struct file *file)
static char *format_result(union acpi_object *object)
{
- char *buf;
+ char *buf = NULL;
+
+ buf = (char *)kmalloc(RESULT_STR_LEN, GFP_KERNEL);
+ if (buf)
+ memset(buf, 0, RESULT_STR_LEN);
+ else
+ goto do_fail;
- 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;
+ do_fail:
+ return (buf);
}
static int hotkey_polling_seq_show(struct seq_file *seq, void *offset)
(struct acpi_polling_hotkey *)seq->private;
char *buf;
+ ACPI_FUNCTION_TRACE("hotkey_polling_seq_show");
if (poll_hotkey->poll_result) {
buf = format_result(poll_hotkey->poll_result);
seq_printf(seq, "%s", buf);
kfree(buf);
}
- return 0;
+ return_VALUE(0);
}
static int hotkey_polling_open_fs(struct inode *inode, struct file *file)
struct list_head *entries;
int val = -1;
+ ACPI_FUNCTION_TRACE("hotkey_get_internal_event");
list_for_each(entries, list->entries) {
union acpi_hotkey *key =
}
}
- return val;
+ return_VALUE(val);
}
static void
struct acpi_device *device = NULL;
u32 internal_event;
+ ACPI_FUNCTION_TRACE("acpi_hotkey_notify_handler");
if (acpi_bus_get_device(handle, &device))
- return;
+ return_VOID;
internal_event = hotkey_get_internal_event(event, &global_hotkey_list);
acpi_bus_generate_event(device, internal_event, 0);
- return;
+ return_VOID;
}
/* Need to invent automatically hotkey add method */
char proc_name[80];
mode_t mode;
+ ACPI_FUNCTION_TRACE("create_polling_proc");
mode = S_IFREG | S_IRUGO | S_IWUGO;
sprintf(proc_name, "%d", device->link.hotkey_standard_num);
proc = create_proc_entry(proc_name, mode, hotkey_proc_dir);
if (!proc) {
- return -ENODEV;
+ ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+ "Hotkey: Unable to create %s entry\n",
+ device->poll_hotkey.poll_method));
+ return_VALUE(-ENODEV);
} else {
proc->proc_fops = &hotkey_polling_fops;
proc->owner = THIS_MODULE;
proc->gid = 0;
device->poll_hotkey.proc = proc;
}
- return 0;
+ return_VALUE(0);
}
static int hotkey_add(union acpi_hotkey *device)
int status = 0;
struct acpi_device *dev = NULL;
+ ACPI_FUNCTION_TRACE("hotkey_add");
if (device->link.hotkey_type == ACPI_HOTKEY_EVENT) {
acpi_bus_get_device(device->event_hotkey.bus_handle, &dev);
list_add_tail(&device->link.entries, global_hotkey_list.entries);
- return status;
+ return_VALUE(status);
}
static int hotkey_remove(union acpi_hotkey *device)
{
struct list_head *entries, *next;
+ ACPI_FUNCTION_TRACE("hotkey_remove");
list_for_each_safe(entries, next, global_hotkey_list.entries) {
union acpi_hotkey *key =
}
}
kfree(device);
- return 0;
+ return_VALUE(0);
}
static int hotkey_update(union acpi_hotkey *key)
{
struct list_head *entries;
+ ACPI_FUNCTION_TRACE("hotkey_update");
list_for_each(entries, global_hotkey_list.entries) {
union acpi_hotkey *tmp =
*/
kfree(key);
}
- return 0;
+ return_VALUE(0);
break;
}
}
- return -ENODEV;
+ return_VALUE(-ENODEV);
}
static void free_hotkey_device(union acpi_hotkey *key)
{
struct acpi_device *dev;
+ ACPI_FUNCTION_TRACE("free_hotkey_device");
if (key->link.hotkey_type == ACPI_HOTKEY_EVENT) {
acpi_bus_get_device(key->event_hotkey.bus_handle, &dev);
free_poll_hotkey_buffer(key);
}
kfree(key);
- return;
+ return_VOID;
}
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)
+init_hotkey_device(union acpi_hotkey *key, char *bus_str, char *action_str,
+ char *method, int std_num, int external_num)
{
acpi_handle tmp_handle;
acpi_status status = AE_OK;
+ ACPI_FUNCTION_TRACE("init_hotkey_device");
+
if (std_num < 0 || IS_POLL(std_num) || !key)
goto do_fail;
- if (!config_entry[bus_handle] || !config_entry[action_handle]
- || !config_entry[method])
+ if (!bus_str || !action_str || !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];
+ key->event_hotkey.action_method = method;
- status = acpi_get_handle(NULL, config_entry[bus_handle],
- &(key->event_hotkey.bus_handle));
+ status =
+ acpi_get_handle(NULL, bus_str, &(key->event_hotkey.bus_handle));
if (ACPI_FAILURE(status))
- goto do_fail_zero;
+ goto do_fail;
key->event_hotkey.external_hotkey_num = external_num;
- status = acpi_get_handle(NULL, config_entry[action_handle],
+ status =
+ acpi_get_handle(NULL, action_str,
&(key->event_hotkey.action_handle));
if (ACPI_FAILURE(status))
- goto do_fail_zero;
+ goto do_fail;
status = acpi_get_handle(key->event_hotkey.action_handle,
- config_entry[method], &tmp_handle);
+ 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;
+ goto do_fail;
+ return_VALUE(AE_OK);
+ do_fail:
+ return_VALUE(-ENODEV);
}
static int
-init_poll_hotkey_device(union acpi_hotkey *key, char **config_entry,
- int std_num)
+init_poll_hotkey_device(union acpi_hotkey *key,
+ char *poll_str,
+ char *poll_method,
+ char *action_str, char *action_method, int std_num)
{
acpi_status status = AE_OK;
acpi_handle tmp_handle;
+ ACPI_FUNCTION_TRACE("init_poll_hotkey_device");
+
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])
+
+ if (!poll_str || !poll_method || !action_str || !action_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];
+ key->poll_hotkey.poll_method = poll_method;
+ key->poll_hotkey.action_method = action_method;
- status = acpi_get_handle(NULL, config_entry[bus_handle],
- &(key->poll_hotkey.poll_handle));
+ status =
+ acpi_get_handle(NULL, poll_str, &(key->poll_hotkey.poll_handle));
if (ACPI_FAILURE(status))
- goto do_fail_zero;
+ goto do_fail;
status = acpi_get_handle(key->poll_hotkey.poll_handle,
- config_entry[bus_method], &tmp_handle);
+ poll_method, &tmp_handle);
if (ACPI_FAILURE(status))
- goto do_fail_zero;
+ goto do_fail;
status =
- acpi_get_handle(NULL, config_entry[action_handle],
+ acpi_get_handle(NULL, action_str,
&(key->poll_hotkey.action_handle));
if (ACPI_FAILURE(status))
- goto do_fail_zero;
+ goto do_fail;
status = acpi_get_handle(key->poll_hotkey.action_handle,
- config_entry[method], &tmp_handle);
+ action_method, &tmp_handle);
if (ACPI_FAILURE(status))
- goto do_fail_zero;
+ goto do_fail;
key->poll_hotkey.poll_result =
(union acpi_object *)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;
+ goto do_fail;
+ return_VALUE(AE_OK);
+ do_fail:
+ return_VALUE(-ENODEV);
}
static int hotkey_open_config(struct inode *inode, struct file *file)
{
- return (single_open
+ ACPI_FUNCTION_TRACE("hotkey_open_config");
+ return_VALUE(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
+ ACPI_FUNCTION_TRACE("hotkey_poll_open_config");
+ return_VALUE(single_open
(file, hotkey_poll_config_seq_show, PDE(inode)->data));
}
struct acpi_buffer bus = { ACPI_PATHNAME_MAX, bus_name };
struct acpi_buffer act = { ACPI_PATHNAME_MAX, action_name };
+ ACPI_FUNCTION_TRACE(("hotkey_config_seq_show"));
list_for_each(entries, hotkey_list->entries) {
union acpi_hotkey *key =
}
}
seq_puts(seq, "\n");
- return 0;
+ return_VALUE(0);
}
static int hotkey_poll_config_seq_show(struct seq_file *seq, void *offset)
struct acpi_buffer bus = { ACPI_PATHNAME_MAX, bus_name };
struct acpi_buffer act = { ACPI_PATHNAME_MAX, action_name };
+ ACPI_FUNCTION_TRACE(("hotkey_config_seq_show"));
list_for_each(entries, hotkey_list->entries) {
union acpi_hotkey *key =
}
}
seq_puts(seq, "\n");
- return 0;
+ return_VALUE(0);
}
static int
-get_parms(char *config_record, int *cmd, char **config_entry,
- int *internal_event_num, int *external_event_num)
+get_parms(char *config_record,
+ int *cmd,
+ char **bus_handle,
+ char **bus_method,
+ char **action_handle,
+ char **method, 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;
+ ACPI_FUNCTION_TRACE(("get_parms"));
sscanf(config_record, "%d", cmd);
+
if (*cmd == 1) {
if (sscanf(config_record, "%d:%d", cmd, internal_event_num) !=
2)
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;
+ tmp1 = strchr(tmp, ':');
+ if (!tmp1)
+ goto do_fail;
+
+ count = tmp1 - tmp;
+ *bus_handle = (char *)kmalloc(count + 1, GFP_KERNEL);
+ if (!*bus_handle)
+ goto do_fail;
+ strncpy(*bus_handle, tmp, count);
+ *(*bus_handle + count) = 0;
+
+ tmp = tmp1;
+ tmp++;
+ tmp1 = strchr(tmp, ':');
+ if (!tmp1)
+ goto do_fail;
+ count = tmp1 - tmp;
+ *bus_method = (char *)kmalloc(count + 1, GFP_KERNEL);
+ if (!*bus_method)
+ goto do_fail;
+ strncpy(*bus_method, tmp, count);
+ *(*bus_method + count) = 0;
+
+ tmp = tmp1;
+ tmp++;
+ tmp1 = strchr(tmp, ':');
+ if (!tmp1)
+ goto do_fail;
+ count = tmp1 - tmp;
+ *action_handle = (char *)kmalloc(count + 1, GFP_KERNEL);
+ strncpy(*action_handle, tmp, count);
+ *(*action_handle + count) = 0;
+
+ tmp = tmp1;
+ tmp++;
+ tmp1 = strchr(tmp, ':');
+ if (!tmp1)
+ goto do_fail;
+ count = tmp1 - tmp;
+ *method = (char *)kmalloc(count + 1, GFP_KERNEL);
+ if (!*method)
+ goto do_fail;
+ strncpy(*method, tmp, count);
+ *(*method + count) = 0;
+
+ if (sscanf(tmp1 + 1, "%d:%d", internal_event_num, external_event_num) <=
+ 0)
+ goto do_fail;
+
+ return_VALUE(6);
+ do_fail:
+ return_VALUE(-1);
}
/* count is length for one input record */
size_t count, loff_t * data)
{
char *config_record = NULL;
- char *config_entry[LAST_CONF_ENTRY];
+ char *bus_handle = NULL;
+ char *bus_method = NULL;
+ char *action_handle = NULL;
+ char *method = NULL;
int cmd, internal_event_num, external_event_num;
int ret = 0;
- union acpi_hotkey *key = kzalloc(sizeof(union acpi_hotkey), GFP_KERNEL);
+ union acpi_hotkey *key = NULL;
- if (!key)
- return -ENOMEM;
+ ACPI_FUNCTION_TRACE(("hotkey_write_config"));
- config_record = kzalloc(count + 1, GFP_KERNEL);
- if (!config_record) {
- kfree(key);
- return -ENOMEM;
- }
+ config_record = (char *)kmalloc(count + 1, GFP_KERNEL);
+ if (!config_record)
+ return_VALUE(-ENOMEM);
if (copy_from_user(config_record, buffer, count)) {
kfree(config_record);
- kfree(key);
- printk(KERN_ERR PREFIX "Invalid data\n");
- return -EINVAL;
+ ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid data \n"));
+ return_VALUE(-EINVAL);
}
- ret = get_parms(config_record, &cmd, config_entry,
- &internal_event_num, &external_event_num);
+ config_record[count] = 0;
+
+ ret = get_parms(config_record,
+ &cmd,
+ &bus_handle,
+ &bus_method,
+ &action_handle,
+ &method, &internal_event_num, &external_event_num);
+
kfree(config_record);
+ if (IS_OTHERS(internal_event_num))
+ goto do_fail;
if (ret != 6) {
- printk(KERN_ERR PREFIX "Invalid data format ret=%d\n", ret);
- return -EINVAL;
+ do_fail:
+ kfree(bus_handle);
+ kfree(bus_method);
+ kfree(action_handle);
+ kfree(method);
+ ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+ "Invalid data format ret=%d\n", ret));
+ return_VALUE(-EINVAL);
}
+ key = kmalloc(sizeof(union acpi_hotkey), GFP_KERNEL);
+ if (!key)
+ goto do_fail;
+ memset(key, 0, sizeof(union acpi_hotkey));
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");
+ ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid key"));
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;
+ kfree(bus_method);
+ ret = init_hotkey_device(key, bus_handle, action_handle, method,
+ internal_event_num,
+ external_event_num);
+ } else
+ ret = init_poll_hotkey_device(key, bus_handle, bus_method,
+ action_handle, method,
+ internal_event_num);
+ if (ret) {
+ kfree(bus_handle);
+ kfree(action_handle);
+ if (IS_EVENT(internal_event_num))
+ free_hotkey_buffer(key);
+ else
+ free_poll_hotkey_buffer(key);
+ kfree(key);
+ ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid hotkey \n"));
+ return_VALUE(-EINVAL);
}
-cont_cmd:
+
+ cont_cmd:
+ kfree(bus_handle);
+ kfree(action_handle);
+
switch (cmd) {
case 0:
- if (get_hotkey_by_event(&global_hotkey_list,
- key->link.hotkey_standard_num))
+ if (get_hotkey_by_event
+ (&global_hotkey_list, key->link.hotkey_standard_num))
goto fail_out;
else
hotkey_add(key);
hotkey_remove(key);
break;
case 2:
- /* key is kfree()ed if matched*/
if (hotkey_update(key))
goto fail_out;
break;
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] */
+ return_VALUE(count);
+ fail_out:
+ if (IS_EVENT(internal_event_num))
+ free_hotkey_buffer(key);
+ else
+ free_poll_hotkey_buffer(key);
kfree(key);
- printk(KERN_ERR PREFIX "invalid key\n");
- return -EINVAL;
+ ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "invalid key\n"));
+ return_VALUE(-EINVAL);
}
/*
union acpi_object in_obj; /* the only param we use */
acpi_status status;
+ ACPI_FUNCTION_TRACE("write_acpi_int");
params.count = 1;
params.pointer = &in_obj;
in_obj.type = ACPI_TYPE_INTEGER;
status = acpi_evaluate_object(handle, (char *)method, ¶ms, output);
- return (status == AE_OK);
+ return_VALUE(status == AE_OK);
}
static int read_acpi_int(acpi_handle handle, const char *method,
union acpi_object out_obj;
acpi_status status;
+ ACPI_FUNCTION_TRACE("read_acpi_int");
output.length = sizeof(out_obj);
output.pointer = &out_obj;
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)
+ ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "null val pointer"));
+ return_VALUE((status == AE_OK)
&& (out_obj.type == ACPI_TYPE_INTEGER));
}
int event, method_type, type, value;
union acpi_hotkey *key;
+ ACPI_FUNCTION_TRACE("hotkey_execte_aml_method");
- arg = kzalloc(count + 1, GFP_KERNEL);
+ arg = (char *)kmalloc(count + 1, GFP_KERNEL);
if (!arg)
- return -ENOMEM;
+ return_VALUE(-ENOMEM);
+ arg[count] = 0;
if (copy_from_user(arg, buffer, count)) {
kfree(arg);
- printk(KERN_ERR PREFIX "Invalid argument 2\n");
- return -EINVAL;
+ ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid argument 2"));
+ return_VALUE(-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;
+ ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid argument 3"));
+ return_VALUE(-EINVAL);
}
kfree(arg);
if (type == ACPI_TYPE_INTEGER) {
}
} else {
- printk(KERN_WARNING "Not supported\n");
- return -EINVAL;
+ ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Not supported"));
+ return_VALUE(-EINVAL);
}
- return count;
+ return_VALUE(count);
do_fail:
- return -EINVAL;
+ return_VALUE(-EINVAL);
}
int result;
mode_t mode = S_IFREG | S_IRUGO | S_IWUGO;
+ ACPI_FUNCTION_TRACE("hotkey_init");
if (acpi_disabled)
return -ENODEV;
hotkey_proc_dir = proc_mkdir(HOTKEY_PROC, acpi_root_dir);
if (!hotkey_proc_dir) {
+ ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+ "Hotkey: Unable to create %s entry\n",
+ HOTKEY_PROC));
return (-ENODEV);
}
hotkey_proc_dir->owner = THIS_MODULE;
hotkey_config =
create_proc_entry(HOTKEY_EV_CONFIG, mode, hotkey_proc_dir);
if (!hotkey_config) {
+ ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+ "Hotkey: Unable to create %s entry\n",
+ HOTKEY_EV_CONFIG));
goto do_fail1;
} else {
hotkey_config->proc_fops = &hotkey_config_fops;
hotkey_poll_config =
create_proc_entry(HOTKEY_PL_CONFIG, mode, hotkey_proc_dir);
if (!hotkey_poll_config) {
+ ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+ "Hotkey: Unable to create %s entry\n",
+ HOTKEY_EV_CONFIG));
+
goto do_fail2;
} else {
hotkey_poll_config->proc_fops = &hotkey_poll_config_fops;
hotkey_action = create_proc_entry(HOTKEY_ACTION, mode, hotkey_proc_dir);
if (!hotkey_action) {
+ ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+ "Hotkey: Unable to create %s entry\n",
+ HOTKEY_ACTION));
goto do_fail3;
} else {
hotkey_action->proc_fops = &hotkey_action_fops;
hotkey_info = create_proc_entry(HOTKEY_INFO, mode, hotkey_proc_dir);
if (!hotkey_info) {
+ ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+ "Hotkey: Unable to create %s entry\n",
+ HOTKEY_INFO));
goto do_fail4;
} else {
hotkey_info->proc_fops = &hotkey_info_fops;
{
struct list_head *entries, *next;
+ ACPI_FUNCTION_TRACE("hotkey_exit");
list_for_each_safe(entries, next, global_hotkey_list.entries) {
union acpi_hotkey *key =
git://git.onelab.eu / linux-2.6.git / blobdiff