1 files changed, 53 insertions, 47 deletions

diff --git a/drivers/platform/x86/sony-laptop.c b/drivers/platform/x86/sony-laptop.c
index 3f71a605a492..1387c5f9c24d 100644
--- a/drivers/platform/x86/sony-laptop.c
+++ b/drivers/platform/x86/sony-laptop.c
@@ -58,6 +58,7 @@
 #include <linux/kfifo.h>
 #include <linux/workqueue.h>
 #include <linux/acpi.h>
+#include <linux/slab.h>
 #include <acpi/acpi_drivers.h>
 #include <acpi/acpi_bus.h>
 #include <asm/uaccess.h>
@@ -145,7 +146,7 @@ struct sony_laptop_input_s {
         struct input_dev        *key_dev;
         struct kfifo            fifo;
         spinlock_t              fifo_lock;
-        struct workqueue_struct *wq;
+        struct timer_list       release_key_timer;
 };
 
 static struct sony_laptop_input_s sony_laptop_input = {
@@ -299,20 +300,26 @@ static int sony_laptop_input_keycode_map[] = {
 };
 
 /* release buttons after a short delay if pressed */
-static void do_sony_laptop_release_key(struct work_struct *work)
+static void do_sony_laptop_release_key(unsigned long unused)
 {
         struct sony_laptop_keypress kp;
+        unsigned long flags;
+
+        spin_lock_irqsave(&sony_laptop_input.fifo_lock, flags);
 
-        while (kfifo_out_locked(&sony_laptop_input.fifo, (unsigned char *)&kp,
-                        sizeof(kp), &sony_laptop_input.fifo_lock)
-                        == sizeof(kp)) {
-                msleep(10);
+        if (kfifo_out(&sony_laptop_input.fifo,
+                      (unsigned char *)&kp, sizeof(kp)) == sizeof(kp)) {
                 input_report_key(kp.dev, kp.key, 0);
                 input_sync(kp.dev);
         }
+
+        /* If there is something in the fifo schedule next release. */
+        if (kfifo_len(&sony_laptop_input.fifo) != 0)
+                mod_timer(&sony_laptop_input.release_key_timer,
+                          jiffies + msecs_to_jiffies(10));
+
+        spin_unlock_irqrestore(&sony_laptop_input.fifo_lock, flags);
 }
-static DECLARE_WORK(sony_laptop_release_key_work,
-                do_sony_laptop_release_key);
 
 /* forward event to the input subsystem */
 static void sony_laptop_report_input_event(u8 event)
@@ -366,13 +373,13 @@ static void sony_laptop_report_input_event(u8 event)
                 /* we emit the scancode so we can always remap the key */
                 input_event(kp.dev, EV_MSC, MSC_SCAN, event);
                 input_sync(kp.dev);
-                kfifo_in_locked(&sony_laptop_input.fifo,
-                          (unsigned char *)&kp, sizeof(kp),
-                          &sony_laptop_input.fifo_lock);
 
-                if (!work_pending(&sony_laptop_release_key_work))
-                        queue_work(sony_laptop_input.wq,
-                                        &sony_laptop_release_key_work);
+                /* schedule key release */
+                kfifo_in_locked(&sony_laptop_input.fifo,
+                                (unsigned char *)&kp, sizeof(kp),
+                                &sony_laptop_input.fifo_lock);
+                mod_timer(&sony_laptop_input.release_key_timer,
+                          jiffies + msecs_to_jiffies(10));
         } else
                 dprintk("unknown input event %.2x\n", event);
 }
@@ -390,27 +397,21 @@ static int sony_laptop_setup_input(struct acpi_device *acpi_device)
 
         /* kfifo */
         spin_lock_init(&sony_laptop_input.fifo_lock);
-        error =
-         kfifo_alloc(&sony_laptop_input.fifo, SONY_LAPTOP_BUF_SIZE, GFP_KERNEL);
+        error = kfifo_alloc(&sony_laptop_input.fifo,
+                            SONY_LAPTOP_BUF_SIZE, GFP_KERNEL);
         if (error) {
                 printk(KERN_ERR DRV_PFX "kfifo_alloc failed\n");
                 goto err_dec_users;
         }
 
-        /* init workqueue */
-        sony_laptop_input.wq = create_singlethread_workqueue("sony-laptop");
-        if (!sony_laptop_input.wq) {
-                printk(KERN_ERR DRV_PFX
-                                "Unable to create workqueue.\n");
-                error = -ENXIO;
-                goto err_free_kfifo;
-        }
+        setup_timer(&sony_laptop_input.release_key_timer,
+                    do_sony_laptop_release_key, 0);
 
         /* input keys */
         key_dev = input_allocate_device();
         if (!key_dev) {
                 error = -ENOMEM;
-                goto err_destroy_wq;
+                goto err_free_kfifo;
         }
 
         key_dev->name = "Sony Vaio Keys";
@@ -419,18 +420,15 @@ static int sony_laptop_setup_input(struct acpi_device *acpi_device)
         key_dev->dev.parent = &acpi_device->dev;
 
         /* Initialize the Input Drivers: special keys */
-        set_bit(EV_KEY, key_dev->evbit);
-        set_bit(EV_MSC, key_dev->evbit);
-        set_bit(MSC_SCAN, key_dev->mscbit);
+        input_set_capability(key_dev, EV_MSC, MSC_SCAN);
+
+        __set_bit(EV_KEY, key_dev->evbit);
         key_dev->keycodesize = sizeof(sony_laptop_input_keycode_map[0]);
         key_dev->keycodemax = ARRAY_SIZE(sony_laptop_input_keycode_map);
         key_dev->keycode = &sony_laptop_input_keycode_map;
-        for (i = 0; i < ARRAY_SIZE(sony_laptop_input_keycode_map); i++) {
-                if (sony_laptop_input_keycode_map[i] != KEY_RESERVED) {
-                        set_bit(sony_laptop_input_keycode_map[i],
-                                key_dev->keybit);
-                }
-        }
+        for (i = 0; i < ARRAY_SIZE(sony_laptop_input_keycode_map); i++)
+                __set_bit(sony_laptop_input_keycode_map[i], key_dev->keybit);
+        __clear_bit(KEY_RESERVED, key_dev->keybit);
 
         error = input_register_device(key_dev);
         if (error)
@@ -450,9 +448,8 @@ static int sony_laptop_setup_input(struct acpi_device *acpi_device)
         jog_dev->id.vendor = PCI_VENDOR_ID_SONY;
         key_dev->dev.parent = &acpi_device->dev;
 
-        jog_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL);
-        jog_dev->keybit[BIT_WORD(BTN_MOUSE)] = BIT_MASK(BTN_MIDDLE);
-        jog_dev->relbit[0] = BIT_MASK(REL_WHEEL);
+        input_set_capability(jog_dev, EV_KEY, BTN_MIDDLE);
+        input_set_capability(jog_dev, EV_REL, REL_WHEEL);
 
         error = input_register_device(jog_dev);
         if (error)
@@ -473,9 +470,6 @@ err_unregister_keydev:
 err_free_keydev:
         input_free_device(key_dev);
 
-err_destroy_wq:
-        destroy_workqueue(sony_laptop_input.wq);
-
 err_free_kfifo:
         kfifo_free(&sony_laptop_input.fifo);
 
@@ -486,12 +480,23 @@ err_dec_users:
 
 static void sony_laptop_remove_input(void)
 {
-        /* cleanup only after the last user has gone */
+        struct sony_laptop_keypress kp = { NULL };
+
+        /* Cleanup only after the last user has gone */
         if (!atomic_dec_and_test(&sony_laptop_input.users))
                 return;
 
-        /* flush workqueue first */
-        flush_workqueue(sony_laptop_input.wq);
+        del_timer_sync(&sony_laptop_input.release_key_timer);
+
+        /*
+         * Generate key-up events for remaining keys. Note that we don't
+         * need locking since nobody is adding new events to the kfifo.
+         */
+        while (kfifo_out(&sony_laptop_input.fifo,
+                         (unsigned char *)&kp, sizeof(kp)) == sizeof(kp)) {
+                input_report_key(kp.dev, kp.key, 0);
+                input_sync(kp.dev);
+        }
 
         /* destroy input devs */
         input_unregister_device(sony_laptop_input.key_dev);
@@ -502,7 +507,6 @@ static void sony_laptop_remove_input(void)
                 sony_laptop_input.jog_dev = NULL;
         }
 
-        destroy_workqueue(sony_laptop_input.wq);
         kfifo_free(&sony_laptop_input.fifo);
 }
 
@@ -1288,9 +1292,13 @@ static int sony_nc_add(struct acpi_device *device)
                        "controlled by ACPI video driver\n");
         } else if (ACPI_SUCCESS(acpi_get_handle(sony_nc_acpi_handle, "GBRT",
                                                 &handle))) {
+                                                        struct backlight_properties props;
+                memset(&props, 0, sizeof(struct backlight_properties));
+                props.max_brightness = SONY_MAX_BRIGHTNESS - 1;
                 sony_backlight_device = backlight_device_register("sony", NULL,
                                                                   NULL,
-                                                                  &sony_backlight_ops);
+                                                                  &sony_backlight_ops,
+                                                                  &props);
 
                 if (IS_ERR(sony_backlight_device)) {
                         printk(KERN_WARNING DRV_PFX "unable to register backlight device\n");
@@ -1299,8 +1307,6 @@ static int sony_nc_add(struct acpi_device *device)
                         sony_backlight_device->props.brightness =
                             sony_backlight_get_brightness
                             (sony_backlight_device);
-                        sony_backlight_device->props.max_brightness =
-                            SONY_MAX_BRIGHTNESS - 1;
                 }
 
         }