Kernel/linux-stable
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git synced 2025-01-09 14:43:16 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge branch 'bjorn.button' into release

Browse Source
This commit is contained in:
Len Brown 2009-04-24 10:42:29 -04:00
commit 1162cf6bc6
1 changed files with 44 additions and 96 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

140
drivers/acpi/button.c
View File

@ -1,5 +1,5 @@
/* /*
* acpi_button.c - ACPI Button Driver ($Revision: 30 $) * button.c - ACPI Button Driver
* *
* Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com> * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
* Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com> * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
@ -41,17 +41,13 @@
#define ACPI_BUTTON_SUBCLASS_POWER "power" #define ACPI_BUTTON_SUBCLASS_POWER "power"
#define ACPI_BUTTON_HID_POWER "PNP0C0C" #define ACPI_BUTTON_HID_POWER "PNP0C0C"
#define ACPI_BUTTON_DEVICE_NAME_POWER "Power Button (CM)" #define ACPI_BUTTON_DEVICE_NAME_POWER "Power Button"
#define ACPI_BUTTON_DEVICE_NAME_POWERF "Power Button (FF)"
#define ACPI_BUTTON_TYPE_POWER 0x01 #define ACPI_BUTTON_TYPE_POWER 0x01
#define ACPI_BUTTON_TYPE_POWERF 0x02
#define ACPI_BUTTON_SUBCLASS_SLEEP "sleep" #define ACPI_BUTTON_SUBCLASS_SLEEP "sleep"
#define ACPI_BUTTON_HID_SLEEP "PNP0C0E" #define ACPI_BUTTON_HID_SLEEP "PNP0C0E"
#define ACPI_BUTTON_DEVICE_NAME_SLEEP "Sleep Button (CM)" #define ACPI_BUTTON_DEVICE_NAME_SLEEP "Sleep Button"
#define ACPI_BUTTON_DEVICE_NAME_SLEEPF "Sleep Button (FF)"
#define ACPI_BUTTON_TYPE_SLEEP 0x03 #define ACPI_BUTTON_TYPE_SLEEP 0x03
#define ACPI_BUTTON_TYPE_SLEEPF 0x04
#define ACPI_BUTTON_SUBCLASS_LID "lid" #define ACPI_BUTTON_SUBCLASS_LID "lid"
#define ACPI_BUTTON_HID_LID "PNP0C0D" #define ACPI_BUTTON_HID_LID "PNP0C0D"
@ -95,7 +91,6 @@ static struct acpi_driver acpi_button_driver = {
}; };
struct acpi_button { struct acpi_button {
struct acpi_device *device; /* Fixed button kludge */
unsigned int type; unsigned int type;
struct input_dev *input; struct input_dev *input;
char phys[32]; /* for input device */ char phys[32]; /* for input device */
@ -126,14 +121,10 @@ static struct proc_dir_entry *acpi_button_dir;
static int acpi_button_info_seq_show(struct seq_file *seq, void *offset) static int acpi_button_info_seq_show(struct seq_file *seq, void *offset)
{ {
struct acpi_button *button = seq->private; struct acpi_device *device = seq->private;
if (!button || !button->device)
return 0;
seq_printf(seq, "type: %s\n", seq_printf(seq, "type: %s\n",
acpi_device_name(button->device)); acpi_device_name(device));
return 0; return 0;
} }
@ -144,14 +135,11 @@ static int acpi_button_info_open_fs(struct inode *inode, struct file *file)
static int acpi_button_state_seq_show(struct seq_file *seq, void *offset) static int acpi_button_state_seq_show(struct seq_file *seq, void *offset)
{ {
struct acpi_button *button = seq->private; struct acpi_device *device = seq->private;
acpi_status status; acpi_status status;
unsigned long long state; unsigned long long state;
if (!button || !button->device) status = acpi_evaluate_integer(device->handle, "_LID", NULL, &state);
return 0;
status = acpi_evaluate_integer(button->device->handle, "_LID", NULL, &state);
seq_printf(seq, "state: %s\n", seq_printf(seq, "state: %s\n",
ACPI_FAILURE(status) ? "unsupported" : ACPI_FAILURE(status) ? "unsupported" :
(state ? "open" : "closed")); (state ? "open" : "closed"));
@ -169,24 +157,17 @@ static struct proc_dir_entry *acpi_lid_dir;
static int acpi_button_add_fs(struct acpi_device *device) static int acpi_button_add_fs(struct acpi_device *device)
{ {
struct acpi_button *button = acpi_driver_data(device);
struct proc_dir_entry *entry = NULL; struct proc_dir_entry *entry = NULL;
struct acpi_button *button;
if (!device || !acpi_driver_data(device))
return -EINVAL;
button = acpi_driver_data(device);
switch (button->type) { switch (button->type) {
case ACPI_BUTTON_TYPE_POWER: case ACPI_BUTTON_TYPE_POWER:
case ACPI_BUTTON_TYPE_POWERF:
if (!acpi_power_dir) if (!acpi_power_dir)
acpi_power_dir = proc_mkdir(ACPI_BUTTON_SUBCLASS_POWER, acpi_power_dir = proc_mkdir(ACPI_BUTTON_SUBCLASS_POWER,
acpi_button_dir); acpi_button_dir);
entry = acpi_power_dir; entry = acpi_power_dir;
break; break;
case ACPI_BUTTON_TYPE_SLEEP: case ACPI_BUTTON_TYPE_SLEEP:
case ACPI_BUTTON_TYPE_SLEEPF:
if (!acpi_sleep_dir) if (!acpi_sleep_dir)
acpi_sleep_dir = proc_mkdir(ACPI_BUTTON_SUBCLASS_SLEEP, acpi_sleep_dir = proc_mkdir(ACPI_BUTTON_SUBCLASS_SLEEP,
acpi_button_dir); acpi_button_dir);
@ -210,8 +191,7 @@ static int acpi_button_add_fs(struct acpi_device *device)
/* 'info' [R] */ /* 'info' [R] */
entry = proc_create_data(ACPI_BUTTON_FILE_INFO, entry = proc_create_data(ACPI_BUTTON_FILE_INFO,
S_IRUGO, acpi_device_dir(device), S_IRUGO, acpi_device_dir(device),
&acpi_button_info_fops, &acpi_button_info_fops, device);
acpi_driver_data(device));
if (!entry) if (!entry)
return -ENODEV; return -ENODEV;
@ -219,8 +199,7 @@ static int acpi_button_add_fs(struct acpi_device *device)
if (button->type == ACPI_BUTTON_TYPE_LID) { if (button->type == ACPI_BUTTON_TYPE_LID) {
entry = proc_create_data(ACPI_BUTTON_FILE_STATE, entry = proc_create_data(ACPI_BUTTON_FILE_STATE,
S_IRUGO, acpi_device_dir(device), S_IRUGO, acpi_device_dir(device),
&acpi_button_state_fops, &acpi_button_state_fops, device);
acpi_driver_data(device));
if (!entry) if (!entry)
return -ENODEV; return -ENODEV;
} }
@ -250,15 +229,16 @@ static int acpi_button_remove_fs(struct acpi_device *device)
/* -------------------------------------------------------------------------- /* --------------------------------------------------------------------------
Driver Interface Driver Interface
-------------------------------------------------------------------------- */ -------------------------------------------------------------------------- */
static int acpi_lid_send_state(struct acpi_button *button) static int acpi_lid_send_state(struct acpi_device *device)
{ {
struct acpi_button *button = acpi_driver_data(device);
unsigned long long state; unsigned long long state;
acpi_status status; acpi_status status;
status = acpi_evaluate_integer(button->device->handle, "_LID", NULL, status = acpi_evaluate_integer(device->handle, "_LID", NULL, &state);
&state);
if (ACPI_FAILURE(status)) if (ACPI_FAILURE(status))
return -ENODEV; return -ENODEV;
/* input layer checks if event is redundant */ /* input layer checks if event is redundant */
input_report_switch(button->input, SW_LID, !state); input_report_switch(button->input, SW_LID, !state);
input_sync(button->input); input_sync(button->input);
@ -270,9 +250,6 @@ static void acpi_button_notify(struct acpi_device *device, u32 event)
struct acpi_button *button = acpi_driver_data(device); struct acpi_button *button = acpi_driver_data(device);
struct input_dev *input; struct input_dev *input;
if (!button || !button->device)
return;
switch (event) { switch (event) {
case ACPI_FIXED_HARDWARE_EVENT: case ACPI_FIXED_HARDWARE_EVENT:
event = ACPI_BUTTON_NOTIFY_STATUS; event = ACPI_BUTTON_NOTIFY_STATUS;
@ -280,7 +257,7 @@ static void acpi_button_notify(struct acpi_device *device, u32 event)
case ACPI_BUTTON_NOTIFY_STATUS: case ACPI_BUTTON_NOTIFY_STATUS:
input = button->input; input = button->input;
if (button->type == ACPI_BUTTON_TYPE_LID) { if (button->type == ACPI_BUTTON_TYPE_LID) {
acpi_lid_send_state(button); acpi_lid_send_state(device);
} else { } else {
int keycode = test_bit(KEY_SLEEP, input->keybit) ? int keycode = test_bit(KEY_SLEEP, input->keybit) ?
KEY_SLEEP : KEY_POWER; KEY_SLEEP : KEY_POWER;
@ -291,43 +268,35 @@ static void acpi_button_notify(struct acpi_device *device, u32 event)
input_sync(input); input_sync(input);
} }
acpi_bus_generate_proc_event(button->device, event, acpi_bus_generate_proc_event(device, event, ++button->pushed);
++button->pushed);
break; break;
default: default:
ACPI_DEBUG_PRINT((ACPI_DB_INFO, ACPI_DEBUG_PRINT((ACPI_DB_INFO,
"Unsupported event [0x%x]\n", event)); "Unsupported event [0x%x]\n", event));
break; break;
} }
return;
} }
static int acpi_button_resume(struct acpi_device *device) static int acpi_button_resume(struct acpi_device *device)
{ {
struct acpi_button *button; struct acpi_button *button = acpi_driver_data(device);
if (!device)
return -EINVAL; if (button->type == ACPI_BUTTON_TYPE_LID)
button = acpi_driver_data(device); return acpi_lid_send_state(device);
if (button && button->type == ACPI_BUTTON_TYPE_LID)
return acpi_lid_send_state(button);
return 0; return 0;
} }
static int acpi_button_add(struct acpi_device *device) static int acpi_button_add(struct acpi_device *device)
{ {
int error;
struct acpi_button *button; struct acpi_button *button;
struct input_dev *input; struct input_dev *input;
char *hid, *name, *class;
if (!device) int error;
return -EINVAL;
button = kzalloc(sizeof(struct acpi_button), GFP_KERNEL); button = kzalloc(sizeof(struct acpi_button), GFP_KERNEL);
if (!button) if (!button)
return -ENOMEM; return -ENOMEM;
button->device = device;
device->driver_data = button; device->driver_data = button;
button->input = input = input_allocate_device(); button->input = input = input_allocate_device();
@ -336,40 +305,29 @@ static int acpi_button_add(struct acpi_device *device)
goto err_free_button; goto err_free_button;
} }
/* hid = acpi_device_hid(device);
* Determine the button type (via hid), as fixed-feature buttons name = acpi_device_name(device);
* need to be handled a bit differently than generic-space. class = acpi_device_class(device);
*/
if (!strcmp(acpi_device_hid(device), ACPI_BUTTON_HID_POWER)) { if (!strcmp(hid, ACPI_BUTTON_HID_POWER) ||
!strcmp(hid, ACPI_BUTTON_HID_POWERF)) {
button->type = ACPI_BUTTON_TYPE_POWER; button->type = ACPI_BUTTON_TYPE_POWER;
strcpy(acpi_device_name(device), ACPI_BUTTON_DEVICE_NAME_POWER); strcpy(name, ACPI_BUTTON_DEVICE_NAME_POWER);
sprintf(acpi_device_class(device), "%s/%s", sprintf(class, "%s/%s",
ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_POWER); ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_POWER);
} else if (!strcmp(acpi_device_hid(device), ACPI_BUTTON_HID_POWERF)) { } else if (!strcmp(hid, ACPI_BUTTON_HID_SLEEP) ||
button->type = ACPI_BUTTON_TYPE_POWERF; !strcmp(hid, ACPI_BUTTON_HID_SLEEPF)) {
strcpy(acpi_device_name(device),
ACPI_BUTTON_DEVICE_NAME_POWERF);
sprintf(acpi_device_class(device), "%s/%s",
ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_POWER);
} else if (!strcmp(acpi_device_hid(device), ACPI_BUTTON_HID_SLEEP)) {
button->type = ACPI_BUTTON_TYPE_SLEEP; button->type = ACPI_BUTTON_TYPE_SLEEP;
strcpy(acpi_device_name(device), ACPI_BUTTON_DEVICE_NAME_SLEEP); strcpy(name, ACPI_BUTTON_DEVICE_NAME_SLEEP);
sprintf(acpi_device_class(device), "%s/%s", sprintf(class, "%s/%s",
ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_SLEEP); ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_SLEEP);
} else if (!strcmp(acpi_device_hid(device), ACPI_BUTTON_HID_SLEEPF)) { } else if (!strcmp(hid, ACPI_BUTTON_HID_LID)) {
button->type = ACPI_BUTTON_TYPE_SLEEPF;
strcpy(acpi_device_name(device),
ACPI_BUTTON_DEVICE_NAME_SLEEPF);
sprintf(acpi_device_class(device), "%s/%s",
ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_SLEEP);
} else if (!strcmp(acpi_device_hid(device), ACPI_BUTTON_HID_LID)) {
button->type = ACPI_BUTTON_TYPE_LID; button->type = ACPI_BUTTON_TYPE_LID;
strcpy(acpi_device_name(device), ACPI_BUTTON_DEVICE_NAME_LID); strcpy(name, ACPI_BUTTON_DEVICE_NAME_LID);
sprintf(acpi_device_class(device), "%s/%s", sprintf(class, "%s/%s",
ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_LID); ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_LID);
} else { } else {
printk(KERN_ERR PREFIX "Unsupported hid [%s]\n", printk(KERN_ERR PREFIX "Unsupported hid [%s]\n", hid);
acpi_device_hid(device));
error = -ENODEV; error = -ENODEV;
goto err_free_input; goto err_free_input;
} }
@ -378,10 +336,9 @@ static int acpi_button_add(struct acpi_device *device)
if (error) if (error)
goto err_free_input; goto err_free_input;
snprintf(button->phys, sizeof(button->phys), snprintf(button->phys, sizeof(button->phys), "%s/button/input0", hid);
"%s/button/input0", acpi_device_hid(device));
input->name = acpi_device_name(device); input->name = name;
input->phys = button->phys; input->phys = button->phys;
input->id.bustype = BUS_HOST; input->id.bustype = BUS_HOST;
input->id.product = button->type; input->id.product = button->type;
@ -389,13 +346,11 @@ static int acpi_button_add(struct acpi_device *device)
switch (button->type) { switch (button->type) {
case ACPI_BUTTON_TYPE_POWER: case ACPI_BUTTON_TYPE_POWER:
case ACPI_BUTTON_TYPE_POWERF:
input->evbit[0] = BIT_MASK(EV_KEY); input->evbit[0] = BIT_MASK(EV_KEY);
set_bit(KEY_POWER, input->keybit); set_bit(KEY_POWER, input->keybit);
break; break;
case ACPI_BUTTON_TYPE_SLEEP: case ACPI_BUTTON_TYPE_SLEEP:
case ACPI_BUTTON_TYPE_SLEEPF:
input->evbit[0] = BIT_MASK(EV_KEY); input->evbit[0] = BIT_MASK(EV_KEY);
set_bit(KEY_SLEEP, input->keybit); set_bit(KEY_SLEEP, input->keybit);
break; break;
@ -410,7 +365,7 @@ static int acpi_button_add(struct acpi_device *device)
if (error) if (error)
goto err_remove_fs; goto err_remove_fs;
if (button->type == ACPI_BUTTON_TYPE_LID) if (button->type == ACPI_BUTTON_TYPE_LID)
acpi_lid_send_state(button); acpi_lid_send_state(device);
if (device->wakeup.flags.valid) { if (device->wakeup.flags.valid) {
/* Button's GPE is run-wake GPE */ /* Button's GPE is run-wake GPE */
@ -422,9 +377,7 @@ static int acpi_button_add(struct acpi_device *device)
device->wakeup.state.enabled = 1; device->wakeup.state.enabled = 1;
} }
printk(KERN_INFO PREFIX "%s [%s]\n", printk(KERN_INFO PREFIX "%s [%s]\n", name, acpi_device_bid(device));
acpi_device_name(device), acpi_device_bid(device));
return 0; return 0;
err_remove_fs: err_remove_fs:
@ -438,17 +391,11 @@ static int acpi_button_add(struct acpi_device *device)
static int acpi_button_remove(struct acpi_device *device, int type) static int acpi_button_remove(struct acpi_device *device, int type)
{ {
struct acpi_button *button; struct acpi_button *button = acpi_driver_data(device);
if (!device || !acpi_driver_data(device))
return -EINVAL;
button = acpi_driver_data(device);
acpi_button_remove_fs(device); acpi_button_remove_fs(device);
input_unregister_device(button->input); input_unregister_device(button->input);
kfree(button); kfree(button);
return 0; return 0;
} }
@ -459,6 +406,7 @@ static int __init acpi_button_init(void)
acpi_button_dir = proc_mkdir(ACPI_BUTTON_CLASS, acpi_root_dir); acpi_button_dir = proc_mkdir(ACPI_BUTTON_CLASS, acpi_root_dir);
if (!acpi_button_dir) if (!acpi_button_dir)
return -ENODEV; return -ENODEV;
result = acpi_bus_register_driver(&acpi_button_driver); result = acpi_bus_register_driver(&acpi_button_driver);
if (result < 0) { if (result < 0) {
remove_proc_entry(ACPI_BUTTON_CLASS, acpi_root_dir); remove_proc_entry(ACPI_BUTTON_CLASS, acpi_root_dir);