Pull button into test branch

2 files changed, 139 insertions, 85 deletions

diff --git a/drivers/acpi/Kconfig b/drivers/acpi/Kconfig
index 0f9d4be7ed75..0ed801229675 100644
--- a/drivers/acpi/Kconfig
+++ b/drivers/acpi/Kconfig
@@ -97,6 +97,7 @@ config ACPI_BATTERY
 
 config ACPI_BUTTON
         tristate "Button"
+        depends on INPUT
         default y
         help
           This driver handles events on the power, sleep and lid buttons.
diff --git a/drivers/acpi/button.c b/drivers/acpi/button.c
index 5ef885e82c78..ac860583c203 100644
--- a/drivers/acpi/button.c
+++ b/drivers/acpi/button.c
@@ -29,6 +29,7 @@
 #include <linux/types.h>
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
+#include <linux/input.h>
 #include <acpi/acpi_bus.h>
 #include <acpi/acpi_drivers.h>
 
@@ -62,7 +63,7 @@
 #define _COMPONENT              ACPI_BUTTON_COMPONENT
 ACPI_MODULE_NAME("acpi_button")
 
-    MODULE_AUTHOR("Paul Diefenbaugh");
+MODULE_AUTHOR("Paul Diefenbaugh");
 MODULE_DESCRIPTION(ACPI_BUTTON_DRIVER_NAME);
 MODULE_LICENSE("GPL");
 
@@ -78,12 +79,14 @@ static struct acpi_driver acpi_button_driver = {
         .ops = {
                 .add = acpi_button_add,
                 .remove = acpi_button_remove,
-                },
+        },
 };
 
 struct acpi_button {
         struct acpi_device *device;     /* Fixed button kludge */
-        u8 type;
+        unsigned int type;
+        struct input_dev *input;
+        char phys[32];                  /* for input device */
         unsigned long pushed;
 };
 
@@ -109,8 +112,7 @@ static struct proc_dir_entry *acpi_button_dir;
 
 static int acpi_button_info_seq_show(struct seq_file *seq, void *offset)
 {
-        struct acpi_button *button = (struct acpi_button *)seq->private;
-
+        struct acpi_button *button = seq->private;
 
         if (!button || !button->device)
                 return 0;
@@ -128,22 +130,17 @@ 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)
 {
-        struct acpi_button *button = (struct acpi_button *)seq->private;
+        struct acpi_button *button = seq->private;
         acpi_status status;
         unsigned long state;
 
-
         if (!button || !button->device)
                 return 0;
 
         status = acpi_evaluate_integer(button->device->handle, "_LID", NULL, &state);
-        if (ACPI_FAILURE(status)) {
-                seq_printf(seq, "state:      unsupported\n");
-        } else {
-                seq_printf(seq, "state:      %s\n",
-                           (state ? "open" : "closed"));
-        }
-
+        seq_printf(seq, "state:      %s\n",
+                   ACPI_FAILURE(status) ? "unsupported" :
+                        (state ? "open" : "closed"));
         return 0;
 }
 
@@ -159,8 +156,7 @@ static struct proc_dir_entry *acpi_lid_dir;
 static int acpi_button_add_fs(struct acpi_device *device)
 {
         struct proc_dir_entry *entry = NULL;
-        struct acpi_button *button = NULL;
-
+        struct acpi_button *button;
 
         if (!device || !acpi_driver_data(device))
                 return -EINVAL;
@@ -228,10 +224,8 @@ static int acpi_button_add_fs(struct acpi_device *device)
 
 static int acpi_button_remove_fs(struct acpi_device *device)
 {
-        struct acpi_button *button = NULL;
-
+        struct acpi_button *button = acpi_driver_data(device);
 
-        button = acpi_driver_data(device);
         if (acpi_device_dir(device)) {
                 if (button->type == ACPI_BUTTON_TYPE_LID)
                         remove_proc_entry(ACPI_BUTTON_FILE_STATE,
@@ -253,14 +247,34 @@ static int acpi_button_remove_fs(struct acpi_device *device)
 
 static void acpi_button_notify(acpi_handle handle, u32 event, void *data)
 {
-        struct acpi_button *button = (struct acpi_button *)data;
-
+        struct acpi_button *button = data;
+        struct input_dev *input;
 
         if (!button || !button->device)
                 return;
 
         switch (event) {
         case ACPI_BUTTON_NOTIFY_STATUS:
+                input = button->input;
+
+                if (button->type == ACPI_BUTTON_TYPE_LID) {
+                        struct acpi_handle *handle = button->device->handle;
+                        unsigned long state;
+
+                        if (!ACPI_FAILURE(acpi_evaluate_integer(handle, "_LID",
+                                                                NULL, &state)))
+                                input_report_switch(input, SW_LID, !state);
+
+                } else {
+                        int keycode = test_bit(KEY_SLEEP, input->keybit) ?
+                                                KEY_SLEEP : KEY_POWER;
+
+                        input_report_key(input, keycode, 1);
+                        input_sync(input);
+                        input_report_key(input, keycode, 0);
+                }
+                input_sync(input);
+
                 acpi_bus_generate_event(button->device, event,
                                         ++button->pushed);
                 break;
@@ -275,8 +289,7 @@ static void acpi_button_notify(acpi_handle handle, u32 event, void *data)
 
 static acpi_status acpi_button_notify_fixed(void *data)
 {
-        struct acpi_button *button = (struct acpi_button *)data;
-
+        struct acpi_button *button = data;
 
         if (!button)
                 return AE_BAD_PARAMETER;
@@ -286,24 +299,75 @@ static acpi_status acpi_button_notify_fixed(void *data)
         return AE_OK;
 }
 
-static int acpi_button_add(struct acpi_device *device)
+static int acpi_button_install_notify_handlers(struct acpi_button *button)
 {
-        int result = 0;
-        acpi_status status = AE_OK;
-        struct acpi_button *button = NULL;
+        acpi_status status;
 
+        switch (button->type) {
+        case ACPI_BUTTON_TYPE_POWERF:
+                status =
+                    acpi_install_fixed_event_handler(ACPI_EVENT_POWER_BUTTON,
+                                                     acpi_button_notify_fixed,
+                                                     button);
+                break;
+        case ACPI_BUTTON_TYPE_SLEEPF:
+                status =
+                    acpi_install_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON,
+                                                     acpi_button_notify_fixed,
+                                                     button);
+                break;
+        default:
+                status = acpi_install_notify_handler(button->device->handle,
+                                                     ACPI_DEVICE_NOTIFY,
+                                                     acpi_button_notify,
+                                                     button);
+                break;
+        }
+
+        return ACPI_FAILURE(status) ? -ENODEV : 0;
+}
+
+static void acpi_button_remove_notify_handlers(struct acpi_button *button)
+{
+        switch (button->type) {
+        case ACPI_BUTTON_TYPE_POWERF:
+                acpi_remove_fixed_event_handler(ACPI_EVENT_POWER_BUTTON,
+                                                acpi_button_notify_fixed);
+                break;
+        case ACPI_BUTTON_TYPE_SLEEPF:
+                acpi_remove_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON,
+                                                acpi_button_notify_fixed);
+                break;
+        default:
+                acpi_remove_notify_handler(button->device->handle,
+                                           ACPI_DEVICE_NOTIFY,
+                                           acpi_button_notify);
+                break;
+        }
+}
+
+static int acpi_button_add(struct acpi_device *device)
+{
+        int error;
+        struct acpi_button *button;
+        struct input_dev *input;
 
         if (!device)
                 return -EINVAL;
 
-        button = kmalloc(sizeof(struct acpi_button), GFP_KERNEL);
+        button = kzalloc(sizeof(struct acpi_button), GFP_KERNEL);
         if (!button)
                 return -ENOMEM;
-        memset(button, 0, sizeof(struct acpi_button));
 
         button->device = device;
         acpi_driver_data(device) = button;
 
+        button->input = input = input_allocate_device();
+        if (!input) {
+                error = -ENOMEM;
+                goto err_free_button;
+        }
+
         /*
          * Determine the button type (via hid), as fixed-feature buttons
          * need to be handled a bit differently than generic-space.
@@ -338,39 +402,48 @@ static int acpi_button_add(struct acpi_device *device)
         } else {
                 printk(KERN_ERR PREFIX "Unsupported hid [%s]\n",
                             acpi_device_hid(device));
-                result = -ENODEV;
-                goto end;
+                error = -ENODEV;
+                goto err_free_input;
         }
 
-        result = acpi_button_add_fs(device);
-        if (result)
-                goto end;
+        error = acpi_button_add_fs(device);
+        if (error)
+                goto err_free_input;
+
+        error = acpi_button_install_notify_handlers(button);
+        if (error)
+                goto err_remove_fs;
+
+        snprintf(button->phys, sizeof(button->phys),
+                 "%s/button/input0", acpi_device_hid(device));
+
+        input->name = acpi_device_name(device);
+        input->phys = button->phys;
+        input->id.bustype = BUS_HOST;
+        input->id.product = button->type;
 
         switch (button->type) {
+        case ACPI_BUTTON_TYPE_POWER:
         case ACPI_BUTTON_TYPE_POWERF:
-                status =
-                    acpi_install_fixed_event_handler(ACPI_EVENT_POWER_BUTTON,
-                                                     acpi_button_notify_fixed,
-                                                     button);
+                input->evbit[0] = BIT(EV_KEY);
+                set_bit(KEY_POWER, input->keybit);
                 break;
+
+        case ACPI_BUTTON_TYPE_SLEEP:
         case ACPI_BUTTON_TYPE_SLEEPF:
-                status =
-                    acpi_install_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON,
-                                                     acpi_button_notify_fixed,
-                                                     button);
+                input->evbit[0] = BIT(EV_KEY);
+                set_bit(KEY_SLEEP, input->keybit);
                 break;
-        default:
-                status = acpi_install_notify_handler(device->handle,
-                                                     ACPI_DEVICE_NOTIFY,
-                                                     acpi_button_notify,
-                                                     button);
+
+        case ACPI_BUTTON_TYPE_LID:
+                input->evbit[0] = BIT(EV_SW);
+                set_bit(SW_LID, input->swbit);
                 break;
         }
 
-        if (ACPI_FAILURE(status)) {
-                result = -ENODEV;
-                goto end;
-        }
+        error = input_register_device(input);
+        if (error)
+                goto err_remove_handlers;
 
         if (device->wakeup.flags.valid) {
                 /* Button's GPE is run-wake GPE */
@@ -385,47 +458,31 @@ static int acpi_button_add(struct acpi_device *device)
         printk(KERN_INFO PREFIX "%s [%s]\n",
                acpi_device_name(device), acpi_device_bid(device));
 
-      end:
-        if (result) {
-                acpi_button_remove_fs(device);
-                kfree(button);
-        }
+        return 0;
 
-        return result;
+ err_remove_handlers:
+        acpi_button_remove_notify_handlers(button);
+ err_remove_fs:
+        acpi_button_remove_fs(device);
+ err_free_input:
+        input_free_device(input);
+ err_free_button:
+        kfree(button);
+        return error;
 }
 
 static int acpi_button_remove(struct acpi_device *device, int type)
 {
-        acpi_status status = 0;
-        struct acpi_button *button = NULL;
-
+        struct acpi_button *button;
 
         if (!device || !acpi_driver_data(device))
                 return -EINVAL;
 
         button = acpi_driver_data(device);
 
-        /* Unregister for device notifications. */
-        switch (button->type) {
-        case ACPI_BUTTON_TYPE_POWERF:
-                status =
-                    acpi_remove_fixed_event_handler(ACPI_EVENT_POWER_BUTTON,
-                                                    acpi_button_notify_fixed);
-                break;
-        case ACPI_BUTTON_TYPE_SLEEPF:
-                status =
-                    acpi_remove_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON,
-                                                    acpi_button_notify_fixed);
-                break;
-        default:
-                status = acpi_remove_notify_handler(device->handle,
-                                                    ACPI_DEVICE_NOTIFY,
-                                                    acpi_button_notify);
-                break;
-        }
-
+        acpi_button_remove_notify_handlers(button);
         acpi_button_remove_fs(device);
-
+        input_unregister_device(button->input);
         kfree(button);
 
         return 0;
@@ -433,8 +490,7 @@ static int acpi_button_remove(struct acpi_device *device, int type)
 
 static int __init acpi_button_init(void)
 {
-        int result = 0;
-
+        int result;
 
         acpi_button_dir = proc_mkdir(ACPI_BUTTON_CLASS, acpi_root_dir);
         if (!acpi_button_dir)
@@ -451,7 +507,6 @@ static int __init acpi_button_init(void)
 
 static void __exit acpi_button_exit(void)
 {
-
         acpi_bus_unregister_driver(&acpi_button_driver);
 
         if (acpi_power_dir)
@@ -461,8 +516,6 @@ static void __exit acpi_button_exit(void)
         if (acpi_lid_dir)
                 remove_proc_entry(ACPI_BUTTON_SUBCLASS_LID, acpi_button_dir);
         remove_proc_entry(ACPI_BUTTON_CLASS, acpi_root_dir);
-
-        return;
 }
 
 module_init(acpi_button_init);