6 files changed, 792 insertions, 125 deletions

diff --git a/drivers/platform/x86/Kconfig b/drivers/platform/x86/Kconfig
index fc5bf9d2a3f3..ec4faffe6b05 100644
--- a/drivers/platform/x86/Kconfig
+++ b/drivers/platform/x86/Kconfig
@@ -464,4 +464,16 @@ config TOSHIBA_BT_RFKILL
 
           If you have a modern Toshiba laptop with a Bluetooth and an
           RFKill switch (such as the Portege R500), say Y.
+
+config ACPI_CMPC
+        tristate "CMPC Laptop Extras"
+        depends on X86 && ACPI
+        select INPUT
+        select BACKLIGHT_CLASS_DEVICE
+        default n
+        help
+          Support for Intel Classmate PC ACPI devices, including some
+          keys as input device, backlight device, tablet and accelerometer
+          devices.
+
 endif # X86_PLATFORM_DEVICES
diff --git a/drivers/platform/x86/Makefile b/drivers/platform/x86/Makefile
index b7474b6a8bf1..9cd9fa0a27e6 100644
--- a/drivers/platform/x86/Makefile
+++ b/drivers/platform/x86/Makefile
@@ -5,6 +5,7 @@
 obj-$(CONFIG_ASUS_LAPTOP)       += asus-laptop.o
 obj-$(CONFIG_EEEPC_LAPTOP)      += eeepc-laptop.o
 obj-$(CONFIG_MSI_LAPTOP)        += msi-laptop.o
+obj-$(CONFIG_ACPI_CMPC)         += classmate-laptop.o
 obj-$(CONFIG_COMPAL_LAPTOP)     += compal-laptop.o
 obj-$(CONFIG_DELL_LAPTOP)       += dell-laptop.o
 obj-$(CONFIG_DELL_WMI)          += dell-wmi.o
diff --git a/drivers/platform/x86/classmate-laptop.c b/drivers/platform/x86/classmate-laptop.c
new file mode 100644
index 000000000000..ed90082cdf1d
--- /dev/null
+++ b/drivers/platform/x86/classmate-laptop.c
@@ -0,0 +1,609 @@
+/*
+ *  Copyright (C) 2009  Thadeu Lima de Souza Cascardo <cascardo@holoscopio.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.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/workqueue.h>
+#include <acpi/acpi_drivers.h>
+#include <linux/backlight.h>
+#include <linux/input.h>
+
+MODULE_LICENSE("GPL");
+
+
+struct cmpc_accel {
+        int sensitivity;
+};
+
+#define CMPC_ACCEL_SENSITIVITY_DEFAULT          5
+
+
+/*
+ * Generic input device code.
+ */
+
+typedef void (*input_device_init)(struct input_dev *dev);
+
+static int cmpc_add_acpi_notify_device(struct acpi_device *acpi, char *name,
+                                       input_device_init idev_init)
+{
+        struct input_dev *inputdev;
+        int error;
+
+        inputdev = input_allocate_device();
+        if (!inputdev)
+                return -ENOMEM;
+        inputdev->name = name;
+        inputdev->dev.parent = &acpi->dev;
+        idev_init(inputdev);
+        error = input_register_device(inputdev);
+        if (error) {
+                input_free_device(inputdev);
+                return error;
+        }
+        dev_set_drvdata(&acpi->dev, inputdev);
+        return 0;
+}
+
+static int cmpc_remove_acpi_notify_device(struct acpi_device *acpi)
+{
+        struct input_dev *inputdev = dev_get_drvdata(&acpi->dev);
+        input_unregister_device(inputdev);
+        return 0;
+}
+
+/*
+ * Accelerometer code.
+ */
+static acpi_status cmpc_start_accel(acpi_handle handle)
+{
+        union acpi_object param[2];
+        struct acpi_object_list input;
+        acpi_status status;
+
+        param[0].type = ACPI_TYPE_INTEGER;
+        param[0].integer.value = 0x3;
+        param[1].type = ACPI_TYPE_INTEGER;
+        input.count = 2;
+        input.pointer = param;
+        status = acpi_evaluate_object(handle, "ACMD", &input, NULL);
+        return status;
+}
+
+static acpi_status cmpc_stop_accel(acpi_handle handle)
+{
+        union acpi_object param[2];
+        struct acpi_object_list input;
+        acpi_status status;
+
+        param[0].type = ACPI_TYPE_INTEGER;
+        param[0].integer.value = 0x4;
+        param[1].type = ACPI_TYPE_INTEGER;
+        input.count = 2;
+        input.pointer = param;
+        status = acpi_evaluate_object(handle, "ACMD", &input, NULL);
+        return status;
+}
+
+static acpi_status cmpc_accel_set_sensitivity(acpi_handle handle, int val)
+{
+        union acpi_object param[2];
+        struct acpi_object_list input;
+
+        param[0].type = ACPI_TYPE_INTEGER;
+        param[0].integer.value = 0x02;
+        param[1].type = ACPI_TYPE_INTEGER;
+        param[1].integer.value = val;
+        input.count = 2;
+        input.pointer = param;
+        return acpi_evaluate_object(handle, "ACMD", &input, NULL);
+}
+
+static acpi_status cmpc_get_accel(acpi_handle handle,
+                                  unsigned char *x,
+                                  unsigned char *y,
+                                  unsigned char *z)
+{
+        union acpi_object param[2];
+        struct acpi_object_list input;
+        struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, 0 };
+        unsigned char *locs;
+        acpi_status status;
+
+        param[0].type = ACPI_TYPE_INTEGER;
+        param[0].integer.value = 0x01;
+        param[1].type = ACPI_TYPE_INTEGER;
+        input.count = 2;
+        input.pointer = param;
+        status = acpi_evaluate_object(handle, "ACMD", &input, &output);
+        if (ACPI_SUCCESS(status)) {
+                union acpi_object *obj;
+                obj = output.pointer;
+                locs = obj->buffer.pointer;
+                *x = locs[0];
+                *y = locs[1];
+                *z = locs[2];
+                kfree(output.pointer);
+        }
+        return status;
+}
+
+static void cmpc_accel_handler(struct acpi_device *dev, u32 event)
+{
+        if (event == 0x81) {
+                unsigned char x, y, z;
+                acpi_status status;
+
+                status = cmpc_get_accel(dev->handle, &x, &y, &z);
+                if (ACPI_SUCCESS(status)) {
+                        struct input_dev *inputdev = dev_get_drvdata(&dev->dev);
+
+                        input_report_abs(inputdev, ABS_X, x);
+                        input_report_abs(inputdev, ABS_Y, y);
+                        input_report_abs(inputdev, ABS_Z, z);
+                        input_sync(inputdev);
+                }
+        }
+}
+
+static ssize_t cmpc_accel_sensitivity_show(struct device *dev,
+                                           struct device_attribute *attr,
+                                           char *buf)
+{
+        struct acpi_device *acpi;
+        struct input_dev *inputdev;
+        struct cmpc_accel *accel;
+
+        acpi = to_acpi_device(dev);
+        inputdev = dev_get_drvdata(&acpi->dev);
+        accel = dev_get_drvdata(&inputdev->dev);
+
+        return sprintf(buf, "%d\n", accel->sensitivity);
+}
+
+static ssize_t cmpc_accel_sensitivity_store(struct device *dev,
+                                            struct device_attribute *attr,
+                                            const char *buf, size_t count)
+{
+        struct acpi_device *acpi;
+        struct input_dev *inputdev;
+        struct cmpc_accel *accel;
+        unsigned long sensitivity;
+        int r;
+
+        acpi = to_acpi_device(dev);
+        inputdev = dev_get_drvdata(&acpi->dev);
+        accel = dev_get_drvdata(&inputdev->dev);
+
+        r = strict_strtoul(buf, 0, &sensitivity);
+        if (r)
+                return r;
+
+        accel->sensitivity = sensitivity;
+        cmpc_accel_set_sensitivity(acpi->handle, sensitivity);
+
+        return strnlen(buf, count);
+}
+
+struct device_attribute cmpc_accel_sensitivity_attr = {
+        .attr = { .name = "sensitivity", .mode = 0660 },
+        .show = cmpc_accel_sensitivity_show,
+        .store = cmpc_accel_sensitivity_store
+};
+
+static int cmpc_accel_open(struct input_dev *input)
+{
+        struct acpi_device *acpi;
+
+        acpi = to_acpi_device(input->dev.parent);
+        if (ACPI_SUCCESS(cmpc_start_accel(acpi->handle)))
+                return 0;
+        return -EIO;
+}
+
+static void cmpc_accel_close(struct input_dev *input)
+{
+        struct acpi_device *acpi;
+
+        acpi = to_acpi_device(input->dev.parent);
+        cmpc_stop_accel(acpi->handle);
+}
+
+static void cmpc_accel_idev_init(struct input_dev *inputdev)
+{
+        set_bit(EV_ABS, inputdev->evbit);
+        input_set_abs_params(inputdev, ABS_X, 0, 255, 8, 0);
+        input_set_abs_params(inputdev, ABS_Y, 0, 255, 8, 0);
+        input_set_abs_params(inputdev, ABS_Z, 0, 255, 8, 0);
+        inputdev->open = cmpc_accel_open;
+        inputdev->close = cmpc_accel_close;
+}
+
+static int cmpc_accel_add(struct acpi_device *acpi)
+{
+        int error;
+        struct input_dev *inputdev;
+        struct cmpc_accel *accel;
+
+        accel = kmalloc(sizeof(*accel), GFP_KERNEL);
+        if (!accel)
+                return -ENOMEM;
+
+        accel->sensitivity = CMPC_ACCEL_SENSITIVITY_DEFAULT;
+        cmpc_accel_set_sensitivity(acpi->handle, accel->sensitivity);
+
+        error = device_create_file(&acpi->dev, &cmpc_accel_sensitivity_attr);
+        if (error)
+                goto failed_file;
+
+        error = cmpc_add_acpi_notify_device(acpi, "cmpc_accel",
+                                            cmpc_accel_idev_init);
+        if (error)
+                goto failed_input;
+
+        inputdev = dev_get_drvdata(&acpi->dev);
+        dev_set_drvdata(&inputdev->dev, accel);
+
+        return 0;
+
+failed_input:
+        device_remove_file(&acpi->dev, &cmpc_accel_sensitivity_attr);
+failed_file:
+        kfree(accel);
+        return error;
+}
+
+static int cmpc_accel_remove(struct acpi_device *acpi, int type)
+{
+        struct input_dev *inputdev;
+        struct cmpc_accel *accel;
+
+        inputdev = dev_get_drvdata(&acpi->dev);
+        accel = dev_get_drvdata(&inputdev->dev);
+
+        device_remove_file(&acpi->dev, &cmpc_accel_sensitivity_attr);
+        return cmpc_remove_acpi_notify_device(acpi);
+}
+
+static const struct acpi_device_id cmpc_accel_device_ids[] = {
+        {"ACCE0000", 0},
+        {"", 0}
+};
+MODULE_DEVICE_TABLE(acpi, cmpc_accel_device_ids);
+
+static struct acpi_driver cmpc_accel_acpi_driver = {
+        .owner = THIS_MODULE,
+        .name = "cmpc_accel",
+        .class = "cmpc_accel",
+        .ids = cmpc_accel_device_ids,
+        .ops = {
+                .add = cmpc_accel_add,
+                .remove = cmpc_accel_remove,
+                .notify = cmpc_accel_handler,
+        }
+};
+
+
+/*
+ * Tablet mode code.
+ */
+static acpi_status cmpc_get_tablet(acpi_handle handle,
+                                   unsigned long long *value)
+{
+        union acpi_object param;
+        struct acpi_object_list input;
+        unsigned long long output;
+        acpi_status status;
+
+        param.type = ACPI_TYPE_INTEGER;
+        param.integer.value = 0x01;
+        input.count = 1;
+        input.pointer = &param;
+        status = acpi_evaluate_integer(handle, "TCMD", &input, &output);
+        if (ACPI_SUCCESS(status))
+                *value = output;
+        return status;
+}
+
+static void cmpc_tablet_handler(struct acpi_device *dev, u32 event)
+{
+        unsigned long long val = 0;
+        struct input_dev *inputdev = dev_get_drvdata(&dev->dev);
+
+        if (event == 0x81) {
+                if (ACPI_SUCCESS(cmpc_get_tablet(dev->handle, &val)))
+                        input_report_switch(inputdev, SW_TABLET_MODE, !val);
+        }
+}
+
+static void cmpc_tablet_idev_init(struct input_dev *inputdev)
+{
+        unsigned long long val = 0;
+        struct acpi_device *acpi;
+
+        set_bit(EV_SW, inputdev->evbit);
+        set_bit(SW_TABLET_MODE, inputdev->swbit);
+
+        acpi = to_acpi_device(inputdev->dev.parent);
+        if (ACPI_SUCCESS(cmpc_get_tablet(acpi->handle, &val)))
+                input_report_switch(inputdev, SW_TABLET_MODE, !val);
+}
+
+static int cmpc_tablet_add(struct acpi_device *acpi)
+{
+        return cmpc_add_acpi_notify_device(acpi, "cmpc_tablet",
+                                           cmpc_tablet_idev_init);
+}
+
+static int cmpc_tablet_remove(struct acpi_device *acpi, int type)
+{
+        return cmpc_remove_acpi_notify_device(acpi);
+}
+
+static int cmpc_tablet_resume(struct acpi_device *acpi)
+{
+        struct input_dev *inputdev = dev_get_drvdata(&acpi->dev);
+        unsigned long long val = 0;
+        if (ACPI_SUCCESS(cmpc_get_tablet(acpi->handle, &val)))
+                input_report_switch(inputdev, SW_TABLET_MODE, !val);
+        return 0;
+}
+
+static const struct acpi_device_id cmpc_tablet_device_ids[] = {
+        {"TBLT0000", 0},
+        {"", 0}
+};
+MODULE_DEVICE_TABLE(acpi, cmpc_tablet_device_ids);
+
+static struct acpi_driver cmpc_tablet_acpi_driver = {
+        .owner = THIS_MODULE,
+        .name = "cmpc_tablet",
+        .class = "cmpc_tablet",
+        .ids = cmpc_tablet_device_ids,
+        .ops = {
+                .add = cmpc_tablet_add,
+                .remove = cmpc_tablet_remove,
+                .resume = cmpc_tablet_resume,
+                .notify = cmpc_tablet_handler,
+        }
+};
+
+
+/*
+ * Backlight code.
+ */
+
+static acpi_status cmpc_get_brightness(acpi_handle handle,
+                                       unsigned long long *value)
+{
+        union acpi_object param;
+        struct acpi_object_list input;
+        unsigned long long output;
+        acpi_status status;
+
+        param.type = ACPI_TYPE_INTEGER;
+        param.integer.value = 0xC0;
+        input.count = 1;
+        input.pointer = &param;
+        status = acpi_evaluate_integer(handle, "GRDI", &input, &output);
+        if (ACPI_SUCCESS(status))
+                *value = output;
+        return status;
+}
+
+static acpi_status cmpc_set_brightness(acpi_handle handle,
+                                       unsigned long long value)
+{
+        union acpi_object param[2];
+        struct acpi_object_list input;
+        acpi_status status;
+        unsigned long long output;
+
+        param[0].type = ACPI_TYPE_INTEGER;
+        param[0].integer.value = 0xC0;
+        param[1].type = ACPI_TYPE_INTEGER;
+        param[1].integer.value = value;
+        input.count = 2;
+        input.pointer = param;
+        status = acpi_evaluate_integer(handle, "GWRI", &input, &output);
+        return status;
+}
+
+static int cmpc_bl_get_brightness(struct backlight_device *bd)
+{
+        acpi_status status;
+        acpi_handle handle;
+        unsigned long long brightness;
+
+        handle = bl_get_data(bd);
+        status = cmpc_get_brightness(handle, &brightness);
+        if (ACPI_SUCCESS(status))
+                return brightness;
+        else
+                return -1;
+}
+
+static int cmpc_bl_update_status(struct backlight_device *bd)
+{
+        acpi_status status;
+        acpi_handle handle;
+
+        handle = bl_get_data(bd);
+        status = cmpc_set_brightness(handle, bd->props.brightness);
+        if (ACPI_SUCCESS(status))
+                return 0;
+        else
+                return -1;
+}
+
+static struct backlight_ops cmpc_bl_ops = {
+        .get_brightness = cmpc_bl_get_brightness,
+        .update_status = cmpc_bl_update_status
+};
+
+static int cmpc_bl_add(struct acpi_device *acpi)
+{
+        struct backlight_device *bd;
+
+        bd = backlight_device_register("cmpc_bl", &acpi->dev,
+                                       acpi->handle, &cmpc_bl_ops);
+        bd->props.max_brightness = 7;
+        dev_set_drvdata(&acpi->dev, bd);
+        return 0;
+}
+
+static int cmpc_bl_remove(struct acpi_device *acpi, int type)
+{
+        struct backlight_device *bd;
+
+        bd = dev_get_drvdata(&acpi->dev);
+        backlight_device_unregister(bd);
+        return 0;
+}
+
+static const struct acpi_device_id cmpc_device_ids[] = {
+        {"IPML200", 0},
+        {"", 0}
+};
+MODULE_DEVICE_TABLE(acpi, cmpc_device_ids);
+
+static struct acpi_driver cmpc_bl_acpi_driver = {
+        .owner = THIS_MODULE,
+        .name = "cmpc",
+        .class = "cmpc",
+        .ids = cmpc_device_ids,
+        .ops = {
+                .add = cmpc_bl_add,
+                .remove = cmpc_bl_remove
+        }
+};
+
+
+/*
+ * Extra keys code.
+ */
+static int cmpc_keys_codes[] = {
+        KEY_UNKNOWN,
+        KEY_WLAN,
+        KEY_SWITCHVIDEOMODE,
+        KEY_BRIGHTNESSDOWN,
+        KEY_BRIGHTNESSUP,
+        KEY_VENDOR,
+        KEY_MAX
+};
+
+static void cmpc_keys_handler(struct acpi_device *dev, u32 event)
+{
+        struct input_dev *inputdev;
+        int code = KEY_MAX;
+
+        if ((event & 0x0F) < ARRAY_SIZE(cmpc_keys_codes))
+                code = cmpc_keys_codes[event & 0x0F];
+        inputdev = dev_get_drvdata(&dev->dev);;
+        input_report_key(inputdev, code, !(event & 0x10));
+}
+
+static void cmpc_keys_idev_init(struct input_dev *inputdev)
+{
+        int i;
+
+        set_bit(EV_KEY, inputdev->evbit);
+        for (i = 0; cmpc_keys_codes[i] != KEY_MAX; i++)
+                set_bit(cmpc_keys_codes[i], inputdev->keybit);
+}
+
+static int cmpc_keys_add(struct acpi_device *acpi)
+{
+        return cmpc_add_acpi_notify_device(acpi, "cmpc_keys",
+                                           cmpc_keys_idev_init);
+}
+
+static int cmpc_keys_remove(struct acpi_device *acpi, int type)
+{
+        return cmpc_remove_acpi_notify_device(acpi);
+}
+
+static const struct acpi_device_id cmpc_keys_device_ids[] = {
+        {"FnBT0000", 0},
+        {"", 0}
+};
+MODULE_DEVICE_TABLE(acpi, cmpc_keys_device_ids);
+
+static struct acpi_driver cmpc_keys_acpi_driver = {
+        .owner = THIS_MODULE,
+        .name = "cmpc_keys",
+        .class = "cmpc_keys",
+        .ids = cmpc_keys_device_ids,
+        .ops = {
+                .add = cmpc_keys_add,
+                .remove = cmpc_keys_remove,
+                .notify = cmpc_keys_handler,
+        }
+};
+
+
+/*
+ * General init/exit code.
+ */
+
+static int cmpc_init(void)
+{
+        int r;
+
+        r = acpi_bus_register_driver(&cmpc_keys_acpi_driver);
+        if (r)
+                goto failed_keys;
+
+        r = acpi_bus_register_driver(&cmpc_bl_acpi_driver);
+        if (r)
+                goto failed_bl;
+
+        r = acpi_bus_register_driver(&cmpc_tablet_acpi_driver);
+        if (r)
+                goto failed_tablet;
+
+        r = acpi_bus_register_driver(&cmpc_accel_acpi_driver);
+        if (r)
+                goto failed_accel;
+
+        return r;
+
+failed_accel:
+        acpi_bus_unregister_driver(&cmpc_tablet_acpi_driver);
+
+failed_tablet:
+        acpi_bus_unregister_driver(&cmpc_bl_acpi_driver);
+
+failed_bl:
+        acpi_bus_unregister_driver(&cmpc_keys_acpi_driver);
+
+failed_keys:
+        return r;
+}
+
+static void cmpc_exit(void)
+{
+        acpi_bus_unregister_driver(&cmpc_accel_acpi_driver);
+        acpi_bus_unregister_driver(&cmpc_tablet_acpi_driver);
+        acpi_bus_unregister_driver(&cmpc_bl_acpi_driver);
+        acpi_bus_unregister_driver(&cmpc_keys_acpi_driver);
+}
+
+module_init(cmpc_init);
+module_exit(cmpc_exit);
diff --git a/drivers/platform/x86/fujitsu-laptop.c b/drivers/platform/x86/fujitsu-laptop.c
index 3c2d0384b43b..5f3320d468f6 100644
--- a/drivers/platform/x86/fujitsu-laptop.c
+++ b/drivers/platform/x86/fujitsu-laptop.c
@@ -164,7 +164,7 @@ struct fujitsu_hotkey_t {
         struct input_dev *input;
         char phys[32];
         struct platform_device *pf_device;
-        struct kfifo *fifo;
+        struct kfifo fifo;
         spinlock_t fifo_lock;
         int rfkill_supported;
         int rfkill_state;
@@ -824,12 +824,10 @@ static int acpi_fujitsu_hotkey_add(struct acpi_device *device)
 
         /* kfifo */
         spin_lock_init(&fujitsu_hotkey->fifo_lock);
-        fujitsu_hotkey->fifo =
-            kfifo_alloc(RINGBUFFERSIZE * sizeof(int), GFP_KERNEL,
-                        &fujitsu_hotkey->fifo_lock);
-        if (IS_ERR(fujitsu_hotkey->fifo)) {
+        error = kfifo_alloc(&fujitsu_hotkey->fifo, RINGBUFFERSIZE * sizeof(int),
+                        GFP_KERNEL);
+        if (error) {
                 printk(KERN_ERR "kfifo_alloc failed\n");
-                error = PTR_ERR(fujitsu_hotkey->fifo);
                 goto err_stop;
         }
 
@@ -934,7 +932,7 @@ err_unregister_input_dev:
 err_free_input_dev:
         input_free_device(input);
 err_free_fifo:
-        kfifo_free(fujitsu_hotkey->fifo);
+        kfifo_free(&fujitsu_hotkey->fifo);
 err_stop:
         return result;
 }
@@ -956,7 +954,7 @@ static int acpi_fujitsu_hotkey_remove(struct acpi_device *device, int type)
 
         input_free_device(input);
 
-        kfifo_free(fujitsu_hotkey->fifo);
+        kfifo_free(&fujitsu_hotkey->fifo);
 
         fujitsu_hotkey->acpi_handle = NULL;
 
@@ -1008,9 +1006,10 @@ static void acpi_fujitsu_hotkey_notify(struct acpi_device *device, u32 event)
                                 vdbg_printk(FUJLAPTOP_DBG_TRACE,
                                         "Push keycode into ringbuffer [%d]\n",
                                         keycode);
-                                status = kfifo_put(fujitsu_hotkey->fifo,
+                                status = kfifo_in_locked(&fujitsu_hotkey->fifo,
                                                    (unsigned char *)&keycode,
-                                                   sizeof(keycode));
+                                                   sizeof(keycode),
+                                                   &fujitsu_hotkey->fifo_lock);
                                 if (status != sizeof(keycode)) {
                                         vdbg_printk(FUJLAPTOP_DBG_WARN,
                                             "Could not push keycode [0x%x]\n",
@@ -1021,11 +1020,12 @@ static void acpi_fujitsu_hotkey_notify(struct acpi_device *device, u32 event)
                                 }
                         } else if (keycode == 0) {
                                 while ((status =
-                                        kfifo_get
-                                        (fujitsu_hotkey->fifo, (unsigned char *)
-                                         &keycode_r,
-                                         sizeof
-                                         (keycode_r))) == sizeof(keycode_r)) {
+                                        kfifo_out_locked(
+                                         &fujitsu_hotkey->fifo,
+                                         (unsigned char *) &keycode_r,
+                                         sizeof(keycode_r),
+                                         &fujitsu_hotkey->fifo_lock))
+                                         == sizeof(keycode_r)) {
                                         input_report_key(input, keycode_r, 0);
                                         input_sync(input);
                                         vdbg_printk(FUJLAPTOP_DBG_TRACE,
diff --git a/drivers/platform/x86/sony-laptop.c b/drivers/platform/x86/sony-laptop.c
index 7a2cc8a5c975..5af53340da6f 100644
--- a/drivers/platform/x86/sony-laptop.c
+++ b/drivers/platform/x86/sony-laptop.c
@@ -131,6 +131,7 @@ enum sony_nc_rfkill {
         N_SONY_RFKILL,
 };
 
+static int sony_rfkill_handle;
 static struct rfkill *sony_rfkill_devices[N_SONY_RFKILL];
 static int sony_rfkill_address[N_SONY_RFKILL] = {0x300, 0x500, 0x700, 0x900};
 static void sony_nc_rfkill_update(void);
@@ -142,7 +143,7 @@ struct sony_laptop_input_s {
         atomic_t                users;
         struct input_dev        *jog_dev;
         struct input_dev        *key_dev;
-        struct kfifo            *fifo;
+        struct kfifo            fifo;
         spinlock_t              fifo_lock;
         struct workqueue_struct *wq;
 };
@@ -232,6 +233,7 @@ static int sony_laptop_input_index[] = {
         56,     /* 69 SONYPI_EVENT_VOLUME_INC_PRESSED */
         57,     /* 70 SONYPI_EVENT_VOLUME_DEC_PRESSED */
         -1,     /* 71 SONYPI_EVENT_BRIGHTNESS_PRESSED */
+        58,     /* 72 SONYPI_EVENT_MEDIA_PRESSED */
 };
 
 static int sony_laptop_input_keycode_map[] = {
@@ -293,6 +295,7 @@ static int sony_laptop_input_keycode_map[] = {
         KEY_F15,        /* 55 SONYPI_EVENT_SETTINGKEY_PRESSED */
         KEY_VOLUMEUP,   /* 56 SONYPI_EVENT_VOLUME_INC_PRESSED */
         KEY_VOLUMEDOWN, /* 57 SONYPI_EVENT_VOLUME_DEC_PRESSED */
+        KEY_MEDIA,      /* 58 SONYPI_EVENT_MEDIA_PRESSED */
 };
 
 /* release buttons after a short delay if pressed */
@@ -300,8 +303,9 @@ static void do_sony_laptop_release_key(struct work_struct *work)
 {
         struct sony_laptop_keypress kp;
 
-        while (kfifo_get(sony_laptop_input.fifo, (unsigned char *)&kp,
-                         sizeof(kp)) == sizeof(kp)) {
+        while (kfifo_out_locked(&sony_laptop_input.fifo, (unsigned char *)&kp,
+                        sizeof(kp), &sony_laptop_input.fifo_lock)
+                        == sizeof(kp)) {
                 msleep(10);
                 input_report_key(kp.dev, kp.key, 0);
                 input_sync(kp.dev);
@@ -362,8 +366,9 @@ 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_put(sony_laptop_input.fifo,
-                          (unsigned char *)&kp, sizeof(kp));
+                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,
@@ -385,12 +390,10 @@ static int sony_laptop_setup_input(struct acpi_device *acpi_device)
 
         /* kfifo */
         spin_lock_init(&sony_laptop_input.fifo_lock);
-        sony_laptop_input.fifo =
-                kfifo_alloc(SONY_LAPTOP_BUF_SIZE, GFP_KERNEL,
-                            &sony_laptop_input.fifo_lock);
-        if (IS_ERR(sony_laptop_input.fifo)) {
+        error =
+         kfifo_alloc(&sony_laptop_input.fifo, SONY_LAPTOP_BUF_SIZE, GFP_KERNEL);
+        if (error) {
                 printk(KERN_ERR DRV_PFX "kfifo_alloc failed\n");
-                error = PTR_ERR(sony_laptop_input.fifo);
                 goto err_dec_users;
         }
 
@@ -474,7 +477,7 @@ err_destroy_wq:
         destroy_workqueue(sony_laptop_input.wq);
 
 err_free_kfifo:
-        kfifo_free(sony_laptop_input.fifo);
+        kfifo_free(&sony_laptop_input.fifo);
 
 err_dec_users:
         atomic_dec(&sony_laptop_input.users);
@@ -500,7 +503,7 @@ static void sony_laptop_remove_input(void)
         }
 
         destroy_workqueue(sony_laptop_input.wq);
-        kfifo_free(sony_laptop_input.fifo);
+        kfifo_free(&sony_laptop_input.fifo);
 }
 
 /*********** Platform Device ***********/
@@ -890,6 +893,8 @@ static struct sony_nc_event sony_100_events[] = {
         { 0x0C, SONYPI_EVENT_FNKEY_RELEASED },
         { 0x9f, SONYPI_EVENT_CD_EJECT_PRESSED },
         { 0x1f, SONYPI_EVENT_ANYBUTTON_RELEASED },
+        { 0xa1, SONYPI_EVENT_MEDIA_PRESSED },
+        { 0x21, SONYPI_EVENT_ANYBUTTON_RELEASED },
         { 0, 0 },
 };
 
@@ -961,7 +966,7 @@ static void sony_nc_notify(struct acpi_device *device, u32 event)
                                 else
                                         sony_laptop_report_input_event(ev);
                         }
-                } else if (sony_find_snc_handle(0x124) == ev) {
+                } else if (sony_find_snc_handle(sony_rfkill_handle) == ev) {
                         sony_nc_rfkill_update();
                         return;
                 }
@@ -1067,7 +1072,7 @@ static int sony_nc_rfkill_set(void *data, bool blocked)
         if (!blocked)
                 argument |= 0xff0000;
 
-        return sony_call_snc_handle(0x124, argument, &result);
+        return sony_call_snc_handle(sony_rfkill_handle, argument, &result);
 }
 
 static const struct rfkill_ops sony_rfkill_ops = {
@@ -1110,7 +1115,7 @@ static int sony_nc_setup_rfkill(struct acpi_device *device,
         if (!rfk)
                 return -ENOMEM;
 
-        sony_call_snc_handle(0x124, 0x200, &result);
+        sony_call_snc_handle(sony_rfkill_handle, 0x200, &result);
         hwblock = !(result & 0x1);
         rfkill_set_hw_state(rfk, hwblock);
 
@@ -1129,7 +1134,7 @@ static void sony_nc_rfkill_update()
         int result;
         bool hwblock;
 
-        sony_call_snc_handle(0x124, 0x200, &result);
+        sony_call_snc_handle(sony_rfkill_handle, 0x200, &result);
         hwblock = !(result & 0x1);
 
         for (i = 0; i < N_SONY_RFKILL; i++) {
@@ -1145,36 +1150,79 @@ static void sony_nc_rfkill_update()
                         continue;
                 }
 
-                sony_call_snc_handle(0x124, argument, &result);
+                sony_call_snc_handle(sony_rfkill_handle, argument, &result);
                 rfkill_set_states(sony_rfkill_devices[i],
                                   !(result & 0xf), false);
         }
 }
 
-static int sony_nc_rfkill_setup(struct acpi_device *device)
+static void sony_nc_rfkill_setup(struct acpi_device *device)
 {
-        int result, ret;
+        int offset;
+        u8 dev_code, i;
+        acpi_status status;
+        struct acpi_object_list params;
+        union acpi_object in_obj;
+        union acpi_object *device_enum;
+        struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 
-        if (sony_find_snc_handle(0x124) == -1)
-                return -1;
+        offset = sony_find_snc_handle(0x124);
+        if (offset == -1) {
+                offset = sony_find_snc_handle(0x135);
+                if (offset == -1)
+                        return;
+                else
+                        sony_rfkill_handle = 0x135;
+        } else
+                sony_rfkill_handle = 0x124;
+        dprintk("Found rkfill handle: 0x%.4x\n", sony_rfkill_handle);
 
-        ret = sony_call_snc_handle(0x124, 0xb00, &result);
-        if (ret) {
-                printk(KERN_INFO DRV_PFX
-                       "Unable to enumerate rfkill devices: %x\n", ret);
-                return ret;
+        /* need to read the whole buffer returned by the acpi call to SN06
+         * here otherwise we may miss some features
+         */
+        params.count = 1;
+        params.pointer = &in_obj;
+        in_obj.type = ACPI_TYPE_INTEGER;
+        in_obj.integer.value = offset;
+        status = acpi_evaluate_object(sony_nc_acpi_handle, "SN06", &params,
+                        &buffer);
+        if (ACPI_FAILURE(status)) {
+                dprintk("Radio device enumeration failed\n");
+                return;
+        }
+
+        device_enum = (union acpi_object *) buffer.pointer;
+        if (!device_enum || device_enum->type != ACPI_TYPE_BUFFER) {
+                printk(KERN_ERR "Invalid SN06 return object 0x%.2x\n",
+                                device_enum->type);
+                goto out_no_enum;
         }
 
-        if (result & 0x1)
-                sony_nc_setup_rfkill(device, SONY_WIFI);
-        if (result & 0x2)
-                sony_nc_setup_rfkill(device, SONY_BLUETOOTH);
-        if (result & 0x1c)
-                sony_nc_setup_rfkill(device, SONY_WWAN);
-        if (result & 0x20)
-                sony_nc_setup_rfkill(device, SONY_WIMAX);
+        /* the buffer is filled with magic numbers describing the devices
+         * available, 0xff terminates the enumeration
+         */
+        while ((dev_code = *(device_enum->buffer.pointer + i)) != 0xff &&
+                        i < device_enum->buffer.length) {
+                i++;
+                dprintk("Radio devices, looking at 0x%.2x\n", dev_code);
 
-        return 0;
+                if (dev_code == 0 && !sony_rfkill_devices[SONY_WIFI])
+                        sony_nc_setup_rfkill(device, SONY_WIFI);
+
+                if (dev_code == 0x10 && !sony_rfkill_devices[SONY_BLUETOOTH])
+                        sony_nc_setup_rfkill(device, SONY_BLUETOOTH);
+
+                if ((0xf0 & dev_code) == 0x20 &&
+                                !sony_rfkill_devices[SONY_WWAN])
+                        sony_nc_setup_rfkill(device, SONY_WWAN);
+
+                if (dev_code == 0x30 && !sony_rfkill_devices[SONY_WIMAX])
+                        sony_nc_setup_rfkill(device, SONY_WIMAX);
+        }
+
+out_no_enum:
+        kfree(buffer.pointer);
+        return;
 }
 
 static int sony_nc_add(struct acpi_device *device)
@@ -2079,7 +2127,7 @@ static struct attribute_group spic_attribute_group = {
 
 struct sonypi_compat_s {
         struct fasync_struct    *fifo_async;
-        struct kfifo            *fifo;
+        struct kfifo            fifo;
         spinlock_t              fifo_lock;
         wait_queue_head_t       fifo_proc_list;
         atomic_t                open_count;
@@ -2104,12 +2152,12 @@ static int sonypi_misc_open(struct inode *inode, struct file *file)
         /* Flush input queue on first open */
         unsigned long flags;
 
-        spin_lock_irqsave(sonypi_compat.fifo->lock, flags);
+        spin_lock_irqsave(&sonypi_compat.fifo_lock, flags);
 
         if (atomic_inc_return(&sonypi_compat.open_count) == 1)
-                __kfifo_reset(sonypi_compat.fifo);
+                kfifo_reset(&sonypi_compat.fifo);
 
-        spin_unlock_irqrestore(sonypi_compat.fifo->lock, flags);
+        spin_unlock_irqrestore(&sonypi_compat.fifo_lock, flags);
 
         return 0;
 }
@@ -2120,17 +2168,18 @@ static ssize_t sonypi_misc_read(struct file *file, char __user *buf,
         ssize_t ret;
         unsigned char c;
 
-        if ((kfifo_len(sonypi_compat.fifo) == 0) &&
+        if ((kfifo_len(&sonypi_compat.fifo) == 0) &&
             (file->f_flags & O_NONBLOCK))
                 return -EAGAIN;
 
         ret = wait_event_interruptible(sonypi_compat.fifo_proc_list,
-                                       kfifo_len(sonypi_compat.fifo) != 0);
+                                       kfifo_len(&sonypi_compat.fifo) != 0);
         if (ret)
                 return ret;
 
         while (ret < count &&
-               (kfifo_get(sonypi_compat.fifo, &c, sizeof(c)) == sizeof(c))) {
+               (kfifo_out_locked(&sonypi_compat.fifo, &c, sizeof(c),
+                          &sonypi_compat.fifo_lock) == sizeof(c))) {
                 if (put_user(c, buf++))
                         return -EFAULT;
                 ret++;
@@ -2147,7 +2196,7 @@ static ssize_t sonypi_misc_read(struct file *file, char __user *buf,
 static unsigned int sonypi_misc_poll(struct file *file, poll_table *wait)
 {
         poll_wait(file, &sonypi_compat.fifo_proc_list, wait);
-        if (kfifo_len(sonypi_compat.fifo))
+        if (kfifo_len(&sonypi_compat.fifo))
                 return POLLIN | POLLRDNORM;
         return 0;
 }
@@ -2309,7 +2358,8 @@ static struct miscdevice sonypi_misc_device = {
 
 static void sonypi_compat_report_event(u8 event)
 {
-        kfifo_put(sonypi_compat.fifo, (unsigned char *)&event, sizeof(event));
+        kfifo_in_locked(&sonypi_compat.fifo, (unsigned char *)&event,
+                        sizeof(event), &sonypi_compat.fifo_lock);
         kill_fasync(&sonypi_compat.fifo_async, SIGIO, POLL_IN);
         wake_up_interruptible(&sonypi_compat.fifo_proc_list);
 }
@@ -2319,11 +2369,11 @@ static int sonypi_compat_init(void)
         int error;
 
         spin_lock_init(&sonypi_compat.fifo_lock);
-        sonypi_compat.fifo = kfifo_alloc(SONY_LAPTOP_BUF_SIZE, GFP_KERNEL,
-                                         &sonypi_compat.fifo_lock);
-        if (IS_ERR(sonypi_compat.fifo)) {
+        error =
+         kfifo_alloc(&sonypi_compat.fifo, SONY_LAPTOP_BUF_SIZE, GFP_KERNEL);
+        if (error) {
                 printk(KERN_ERR DRV_PFX "kfifo_alloc failed\n");
-                return PTR_ERR(sonypi_compat.fifo);
+                return error;
         }
 
         init_waitqueue_head(&sonypi_compat.fifo_proc_list);
@@ -2342,14 +2392,14 @@ static int sonypi_compat_init(void)
         return 0;
 
 err_free_kfifo:
-        kfifo_free(sonypi_compat.fifo);
+        kfifo_free(&sonypi_compat.fifo);
         return error;
 }
 
 static void sonypi_compat_exit(void)
 {
         misc_deregister(&sonypi_misc_device);
-        kfifo_free(sonypi_compat.fifo);
+        kfifo_free(&sonypi_compat.fifo);
 }
 #else
 static int sonypi_compat_init(void) { return 0; }
diff --git a/drivers/platform/x86/tc1100-wmi.c b/drivers/platform/x86/tc1100-wmi.c
index 44166003d4ef..dd33b51c3486 100644
--- a/drivers/platform/x86/tc1100-wmi.c
+++ b/drivers/platform/x86/tc1100-wmi.c
@@ -47,22 +47,6 @@ MODULE_DESCRIPTION("HP Compaq TC1100 Tablet WMI Extras");
 MODULE_LICENSE("GPL");
 MODULE_ALIAS("wmi:C364AC71-36DB-495A-8494-B439D472A505");
 
-static int tc1100_probe(struct platform_device *device);
-static int tc1100_remove(struct platform_device *device);
-static int tc1100_suspend(struct platform_device *device, pm_message_t state);
-static int tc1100_resume(struct platform_device *device);
-
-static struct platform_driver tc1100_driver = {
-        .driver = {
-                .name = "tc1100-wmi",
-                .owner = THIS_MODULE,
-        },
-        .probe = tc1100_probe,
-        .remove = tc1100_remove,
-        .suspend = tc1100_suspend,
-        .resume = tc1100_resume,
-};
-
 static struct platform_device *tc1100_device;
 
 struct tc1100_data {
@@ -183,51 +167,35 @@ static DEVICE_ATTR(value, S_IWUGO | S_IRUGO | S_IWUSR, \
 show_set_bool(wireless, TC1100_INSTANCE_WIRELESS);
 show_set_bool(jogdial, TC1100_INSTANCE_JOGDIAL);
 
-static void remove_fs(void)
-{
-        device_remove_file(&tc1100_device->dev, &dev_attr_wireless);
-        device_remove_file(&tc1100_device->dev, &dev_attr_jogdial);
-}
-
-static int add_fs(void)
-{
-        int ret;
-
-        ret = device_create_file(&tc1100_device->dev, &dev_attr_wireless);
-        if (ret)
-                goto add_sysfs_error;
-
-        ret = device_create_file(&tc1100_device->dev, &dev_attr_jogdial);
-        if (ret)
-                goto add_sysfs_error;
-
-        return ret;
+static struct attribute *tc1100_attributes[] = {
+        &dev_attr_wireless.attr,
+        &dev_attr_jogdial.attr,
+        NULL
+};
 
-add_sysfs_error:
-        remove_fs();
-        return ret;
-}
+static struct attribute_group tc1100_attribute_group = {
+        .attrs  = tc1100_attributes,
+};
 
 /* --------------------------------------------------------------------------
                                 Driver Model
    -------------------------------------------------------------------------- */
 
-static int tc1100_probe(struct platform_device *device)
+static int __init tc1100_probe(struct platform_device *device)
 {
-        int result = 0;
-
-        result = add_fs();
-        return result;
+        return sysfs_create_group(&device->dev.kobj, &tc1100_attribute_group);
 }
 
 
-static int tc1100_remove(struct platform_device *device)
+static int __devexit tc1100_remove(struct platform_device *device)
 {
-        remove_fs();
+        sysfs_remove_group(&device->dev.kobj, &tc1100_attribute_group);
+
         return 0;
 }
 
-static int tc1100_suspend(struct platform_device *dev, pm_message_t state)
+#ifdef CONFIG_PM
+static int tc1100_suspend(struct device *dev)
 {
         int ret;
 
@@ -239,10 +207,10 @@ static int tc1100_suspend(struct platform_device *dev, pm_message_t state)
         if (ret)
                 return ret;
 
-        return ret;
+        return 0;
 }
 
-static int tc1100_resume(struct platform_device *dev)
+static int tc1100_resume(struct device *dev)
 {
         int ret;
 
@@ -254,34 +222,61 @@ static int tc1100_resume(struct platform_device *dev)
         if (ret)
                 return ret;
 
-        return ret;
+        return 0;
 }
 
+static const struct dev_pm_ops tc1100_pm_ops = {
+        .suspend        = tc1100_suspend,
+        .resume         = tc1100_resume,
+        .freeze         = tc1100_suspend,
+        .restore        = tc1100_resume,
+};
+#endif
+
+static struct platform_driver tc1100_driver = {
+        .driver = {
+                .name = "tc1100-wmi",
+                .owner = THIS_MODULE,
+#ifdef CONFIG_PM
+                .pm = &tc1100_pm_ops,
+#endif
+        },
+        .remove = __devexit_p(tc1100_remove),
+};
+
 static int __init tc1100_init(void)
 {
-        int result = 0;
+        int error;
 
         if (!wmi_has_guid(GUID))
                 return -ENODEV;
 
-        result = platform_driver_register(&tc1100_driver);
-        if (result)
-                return result;
-
         tc1100_device = platform_device_alloc("tc1100-wmi", -1);
-        platform_device_add(tc1100_device);
+        if (!tc1100_device)
+                return -ENOMEM;
+
+        error = platform_device_add(tc1100_device);
+        if (error)
+                goto err_device_put;
+
+        error = platform_driver_probe(&tc1100_driver, tc1100_probe);
+        if (error)
+                goto err_device_del;
 
         printk(TC1100_INFO "HP Compaq TC1100 Tablet WMI Extras loaded\n");
+        return 0;
 
-        return result;
+ err_device_del:
+        platform_device_del(tc1100_device);
+ err_device_put:
+        platform_device_put(tc1100_device);
+        return error;
 }
 
 static void __exit tc1100_exit(void)
 {
-        platform_device_del(tc1100_device);
+        platform_device_unregister(tc1100_device);
         platform_driver_unregister(&tc1100_driver);
-
-        printk(TC1100_INFO "HP Compaq TC1100 Tablet WMI Extras unloaded\n");
 }
 
 module_init(tc1100_init);