63 files changed, 2380 insertions, 528 deletions
diff --git a/Documentation/input/input-programming.txt b/Documentation/input/input-programming.txt
index 47fc86830cd7..81905e81585e 100644
--- a/Documentation/input/input-programming.txt
+++ b/Documentation/input/input-programming.txt
@@ -22,7 +22,7 @@ static struct input_dev *button_dev;
 static void button_interrupt(int irq, void *dummy, struct pt_regs *fp)
 {
-        input_report_key(button_dev, BTN_1, inb(BUTTON_PORT) & 1);
+        input_report_key(button_dev, BTN_0, inb(BUTTON_PORT) & 1);
        input_sync(button_dev);
 }
diff --git a/arch/arm/mach-pxa/tosa.c b/arch/arm/mach-pxa/tosa.c
index 9b26fa5edad6..f99112d50b41 100644
--- a/arch/arm/mach-pxa/tosa.c
+++ b/arch/arm/mach-pxa/tosa.c
@@ -21,6 +21,8 @@
 #include <linux/mmc/host.h>
 #include <linux/pm.h>
 #include <linux/delay.h>
+#include <linux/gpio_keys.h>
+#include <linux/input.h>
 #include <asm/setup.h>
 #include <asm/memory.h>
@@ -246,6 +248,46 @@ static struct platform_device tosakbd_device = {
        .id             = -1,
 };
+static struct gpio_keys_button tosa_gpio_keys[] = {
+        {
+                .type   = EV_PWR,
+                .code   = KEY_SUSPEND,
+                .gpio   = TOSA_GPIO_ON_KEY,
+                .desc   = "On key",
+                .wakeup = 1,
+                .active_low = 1,
+        },
+        {
+                .type   = EV_KEY,
+                .code   = TOSA_KEY_RECORD,
+                .gpio   = TOSA_GPIO_RECORD_BTN,
+                .desc   = "Record Button",
+                .wakeup = 1,
+                .active_low = 1,
+        },
+        {
+                .type   = EV_KEY,
+                .code   = TOSA_KEY_SYNC,
+                .gpio   = TOSA_GPIO_SYNC,
+                .desc   = "Sync Button",
+                .wakeup = 1,
+                .active_low = 1,
+        },
+};
+static struct gpio_keys_platform_data tosa_gpio_keys_platform_data = {
+        .buttons        = tosa_gpio_keys,
+        .nbuttons       = ARRAY_SIZE(tosa_gpio_keys),
+};
+static struct platform_device tosa_gpio_keys_device = {
+        .name   = "gpio-keys",
+        .id     = -1,
+        .dev    = {
+                .platform_data  = &tosa_gpio_keys_platform_data,
+        },
+};
 /*
 * Tosa LEDs
 */
@@ -258,6 +300,7 @@ static struct platform_device *devices[] __initdata = {
        &tosascoop_device,
        &tosascoop_jc_device,
        &tosakbd_device,
+        &tosa_gpio_keys_device,
        &tosaled_device,
 };
diff --git a/drivers/base/firmware_class.c b/drivers/base/firmware_class.c
index 0295855a3eef..4a1b9bfc5471 100644
--- a/drivers/base/firmware_class.c
+++ b/drivers/base/firmware_class.c
@@ -292,7 +292,8 @@ firmware_class_timeout(u_long data)
 static inline void fw_setup_device_id(struct device *f_dev, struct device *dev)
 {
-        snprintf(f_dev->bus_id, BUS_ID_SIZE, "firmware-%s", dev->bus_id);
+        /* XXX warning we should watch out for name collisions */
+        strlcpy(f_dev->bus_id, dev->bus_id, BUS_ID_SIZE);
 }
 static int fw_register_device(struct device **dev_p, const char *fw_name,
diff --git a/drivers/char/drm/i915_drv.h b/drivers/char/drm/i915_drv.h
index 37bbf6729b4e..f8308bfb2613 100644
--- a/drivers/char/drm/i915_drv.h
+++ b/drivers/char/drm/i915_drv.h
@@ -187,7 +187,7 @@ typedef struct drm_i915_private {
        u32 saveSWF2[3];
        u8 saveMSR;
        u8 saveSR[8];
-        u8 saveGR[24];
+        u8 saveGR[25];
        u8 saveAR_INDEX;
        u8 saveAR[20];
        u8 saveDACMASK;
diff --git a/drivers/char/keyboard.c b/drivers/char/keyboard.c
index fc54d234507a..4dbd3425e928 100644
--- a/drivers/char/keyboard.c
+++ b/drivers/char/keyboard.c
@@ -38,7 +38,6 @@
 #include <linux/kbd_kern.h>
 #include <linux/kbd_diacr.h>
 #include <linux/vt_kern.h>
-#include <linux/consolemap.h>
 #include <linux/sysrq.h>
 #include <linux/input.h>
 #include <linux/reboot.h>
@@ -194,7 +193,7 @@ int getkeycode(unsigned int scancode)
        int error = -ENODEV;
        list_for_each_entry(handle, &kbd_handler.h_list, h_node) {
-                error = handle->dev->getkeycode(handle->dev, scancode, &keycode);
+                error = input_get_keycode(handle->dev, scancode, &keycode);
                if (!error)
                        return keycode;
        }
@@ -208,7 +207,7 @@ int setkeycode(unsigned int scancode, unsigned int keycode)
        int error = -ENODEV;
        list_for_each_entry(handle, &kbd_handler.h_list, h_node) {
-                error = handle->dev->setkeycode(handle->dev, scancode, keycode);
+                error = input_set_keycode(handle->dev, scancode, keycode);
                if (!error)
                        break;
        }
diff --git a/drivers/input/Kconfig b/drivers/input/Kconfig
index 63512d906f02..9dea14db724c 100644
--- a/drivers/input/Kconfig
+++ b/drivers/input/Kconfig
@@ -137,6 +137,18 @@ config INPUT_EVBUG
          To compile this driver as a module, choose M here: the
          module will be called evbug.
+config INPUT_APMPOWER
+        tristate "Input Power Event -> APM Bridge" if EMBEDDED
+        depends on INPUT && APM_EMULATION
+        ---help---
+          Say Y here if you want suspend key events to trigger a user
+          requested suspend through APM. This is useful on embedded
+          systems where such behviour is desired without userspace
+          interaction. If unsure, say N.
+          To compile this driver as a module, choose M here: the
+          module will be called apm-power.
 comment "Input Device Drivers"
 source "drivers/input/keyboard/Kconfig"
diff --git a/drivers/input/Makefile b/drivers/input/Makefile
index 99af903bd3ce..2ae87b19caa8 100644
--- a/drivers/input/Makefile
+++ b/drivers/input/Makefile
@@ -22,3 +22,4 @@ obj-$(CONFIG_INPUT_TABLET)	+= tablet/
 obj-$(CONFIG_INPUT_TOUCHSCREEN) += touchscreen/
 obj-$(CONFIG_INPUT_MISC)        += misc/
+obj-$(CONFIG_INPUT_APMPOWER)    += apm-power.o
diff --git a/drivers/input/apm-power.c b/drivers/input/apm-power.c
new file mode 100644
index 000000000000..c36d110b349a
--- /dev/null
+++ b/drivers/input/apm-power.c
@@ -0,0 +1,131 @@
+/*
+ *  Input Power Event -> APM Bridge
+ *
+ *  Copyright (c) 2007 Richard Purdie
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 as
+ *  published by the Free Software Foundation.
+ *
+ */
+#include <linux/module.h>
+#include <linux/input.h>
+#include <linux/slab.h>
+#include <linux/init.h>
+#include <linux/tty.h>
+#include <linux/delay.h>
+#include <linux/pm.h>
+#include <linux/apm-emulation.h>
+static void system_power_event(unsigned int keycode)
+{
+        switch (keycode) {
+        case KEY_SUSPEND:
+                apm_queue_event(APM_USER_SUSPEND);
+                printk(KERN_INFO "apm-power: Requesting system suspend...\n");
+                break;
+        default:
+                break;
+        }
+}
+static void apmpower_event(struct input_handle *handle, unsigned int type,
+                        unsigned int code, int value)
+{
+        /* only react on key down events */
+        if (value != 1)
+                return;
+        switch (type) {
+        case EV_PWR:
+                system_power_event(code);
+                break;
+        default:
+                break;
+        }
+}
+static int apmpower_connect(struct input_handler *handler,
+                                          struct input_dev *dev,
+                                          const struct input_device_id *id)
+{
+        struct input_handle *handle;
+        int error;
+        handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
+        if (!handle)
+                return -ENOMEM;
+        handle->dev = dev;
+        handle->handler = handler;
+        handle->name = "apm-power";
+        handler->private = handle;
+        error = input_register_handle(handle);
+        if (error) {
+                printk(KERN_ERR
+                        "apm-power: Failed to register input power handler, "
+                        "error %d\n", error);
+                kfree(handle);
+                return error;
+        }
+        error = input_open_device(handle);
+        if (error) {
+                printk(KERN_ERR
+                        "apm-power: Failed to open input power device, "
+                        "error %d\n", error);
+                input_unregister_handle(handle);
+                kfree(handle);
+                return error;
+        }
+        return 0;
+}
+static void apmpower_disconnect(struct input_handle *handler)
+{
+        struct input_handle *handle = handler->private;
+        input_close_device(handle);
+        kfree(handle);
+}
+static const struct input_device_id apmpower_ids[] = {
+        {
+                .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
+                .evbit = { BIT_MASK(EV_PWR) },
+        },
+        { },
+};
+MODULE_DEVICE_TABLE(input, apmpower_ids);
+static struct input_handler apmpower_handler = {
+        .event =        apmpower_event,
+        .connect =      apmpower_connect,
+        .disconnect =   apmpower_disconnect,
+        .name =         "apm-power",
+        .id_table =     apmpower_ids,
+};
+static int __init apmpower_init(void)
+{
+        return input_register_handler(&apmpower_handler);
+}
+static void __exit apmpower_exit(void)
+{
+        input_unregister_handler(&apmpower_handler);
+}
+module_init(apmpower_init);
+module_exit(apmpower_exit);
+MODULE_AUTHOR("Richard Purdie <rpurdie@rpsys.net>");
+MODULE_DESCRIPTION("Input Power Event -> APM Bridge");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/evdev.c b/drivers/input/evdev.c
index e5b4e9bfbdc5..0727b0a12557 100644
--- a/drivers/input/evdev.c
+++ b/drivers/input/evdev.c
@@ -617,7 +617,7 @@ static long evdev_do_ioctl(struct file *file, unsigned int cmd,
                if (get_user(t, ip))
                        return -EFAULT;
-                error = dev->getkeycode(dev, t, &v);
+                error = input_get_keycode(dev, t, &v);
                if (error)
                        return error;
@@ -630,7 +630,7 @@ static long evdev_do_ioctl(struct file *file, unsigned int cmd,
                if (get_user(t, ip) || get_user(v, ip + 1))
                        return -EFAULT;
-                return dev->setkeycode(dev, t, v);
+                return input_set_keycode(dev, t, v);
        case EVIOCSFF:
                if (copy_from_user(&effect, p, sizeof(effect)))
@@ -683,7 +683,7 @@ static long evdev_do_ioctl(struct file *file, unsigned int cmd,
                                case EV_FF:  bits = dev->ffbit;  len = FF_MAX;  break;
                                case EV_SW:  bits = dev->swbit;  len = SW_MAX;  break;
                                default: return -EINVAL;
-                        }
+                                }
                                return bits_to_user(bits, len, _IOC_SIZE(cmd), p, compat_mode);
                        }
diff --git a/drivers/input/input-polldev.c b/drivers/input/input-polldev.c
index 92b359894e81..490918a5d192 100644
--- a/drivers/input/input-polldev.c
+++ b/drivers/input/input-polldev.c
@@ -60,17 +60,21 @@ static void input_polled_device_work(struct work_struct *work)
 {
        struct input_polled_dev *dev =
                container_of(work, struct input_polled_dev, work.work);
+        unsigned long delay;
        dev->poll(dev);
-        queue_delayed_work(polldev_wq, &dev->work,
-                           msecs_to_jiffies(dev->poll_interval));
+        delay = msecs_to_jiffies(dev->poll_interval);
+        if (delay >= HZ)
+                delay = round_jiffies_relative(delay);
+        queue_delayed_work(polldev_wq, &dev->work, delay);
 }
 static int input_open_polled_device(struct input_dev *input)
 {
        struct input_polled_dev *dev = input->private;
        int error;
-        unsigned long ticks;
        error = input_polldev_start_workqueue();
        if (error)
@@ -79,10 +83,8 @@ static int input_open_polled_device(struct input_dev *input)
        if (dev->flush)
                dev->flush(dev);
-        ticks = msecs_to_jiffies(dev->poll_interval);
+        queue_delayed_work(polldev_wq, &dev->work,
-        if (ticks >= HZ)
+                           msecs_to_jiffies(dev->poll_interval));
-                ticks = round_jiffies(ticks);
-        queue_delayed_work(polldev_wq, &dev->work, ticks);
        return 0;
 }
@@ -91,7 +93,7 @@ static void input_close_polled_device(struct input_dev *input)
 {
        struct input_polled_dev *dev = input->private;
-        cancel_rearming_delayed_workqueue(polldev_wq, &dev->work);
+        cancel_delayed_work_sync(&dev->work);
        input_polldev_stop_workqueue();
 }
diff --git a/drivers/input/input.c b/drivers/input/input.c
index a0be978501ff..f02c242c3114 100644
--- a/drivers/input/input.c
+++ b/drivers/input/input.c
@@ -493,7 +493,7 @@ static void input_disconnect_device(struct input_dev *dev)
        if (is_event_supported(EV_KEY, dev->evbit, EV_MAX)) {
                for (code = 0; code <= KEY_MAX; code++) {
                        if (is_event_supported(code, dev->keybit, KEY_MAX) &&
-                            test_bit(code, dev->key)) {
+                            __test_and_clear_bit(code, dev->key)) {
                                input_pass_event(dev, EV_KEY, code, 0);
                        }
                }
@@ -526,7 +526,7 @@ static int input_default_getkeycode(struct input_dev *dev,
        if (!dev->keycodesize)
                return -EINVAL;
-        if (scancode < 0 || scancode >= dev->keycodemax)
+        if (scancode >= dev->keycodemax)
                return -EINVAL;
        *keycode = input_fetch_keycode(dev, scancode);
@@ -540,10 +540,7 @@ static int input_default_setkeycode(struct input_dev *dev,
        int old_keycode;
        int i;
-        if (scancode < 0 || scancode >= dev->keycodemax)
+        if (scancode >= dev->keycodemax)
-                return -EINVAL;
-        if (keycode < 0 || keycode > KEY_MAX)
                return -EINVAL;
        if (!dev->keycodesize)
@@ -586,6 +583,75 @@ static int input_default_setkeycode(struct input_dev *dev,
        return 0;
 }
+/**
+ * input_get_keycode - retrieve keycode currently mapped to a given scancode
+ * @dev: input device which keymap is being queried
+ * @scancode: scancode (or its equivalent for device in question) for which
+ *      keycode is needed
+ * @keycode: result
+ *
+ * This function should be called by anyone interested in retrieving current
+ * keymap. Presently keyboard and evdev handlers use it.
+ */
+int input_get_keycode(struct input_dev *dev, int scancode, int *keycode)
+{
+        if (scancode < 0)
+                return -EINVAL;
+        return dev->getkeycode(dev, scancode, keycode);
+}
+EXPORT_SYMBOL(input_get_keycode);
+/**
+ * input_get_keycode - assign new keycode to a given scancode
+ * @dev: input device which keymap is being updated
+ * @scancode: scancode (or its equivalent for device in question)
+ * @keycode: new keycode to be assigned to the scancode
+ *
+ * This function should be called by anyone needing to update current
+ * keymap. Presently keyboard and evdev handlers use it.
+ */
+int input_set_keycode(struct input_dev *dev, int scancode, int keycode)
+{
+        unsigned long flags;
+        int old_keycode;
+        int retval;
+        if (scancode < 0)
+                return -EINVAL;
+        if (keycode < 0 || keycode > KEY_MAX)
+                return -EINVAL;
+        spin_lock_irqsave(&dev->event_lock, flags);
+        retval = dev->getkeycode(dev, scancode, &old_keycode);
+        if (retval)
+                goto out;
+        retval = dev->setkeycode(dev, scancode, keycode);
+        if (retval)
+                goto out;
+        /*
+         * Simulate keyup event if keycode is not present
+         * in the keymap anymore
+         */
+        if (test_bit(EV_KEY, dev->evbit) &&
+            !is_event_supported(old_keycode, dev->keybit, KEY_MAX) &&
+            __test_and_clear_bit(old_keycode, dev->key)) {
+                input_pass_event(dev, EV_KEY, old_keycode, 0);
+                if (dev->sync)
+                        input_pass_event(dev, EV_SYN, SYN_REPORT, 1);
+        }
+ out:
+        spin_unlock_irqrestore(&dev->event_lock, flags);
+        return retval;
+}
+EXPORT_SYMBOL(input_set_keycode);
 #define MATCH_BIT(bit, max) \
                for (i = 0; i < BITS_TO_LONGS(max); i++) \
@@ -755,7 +821,7 @@ static int input_devices_seq_show(struct seq_file *seq, void *v)
        return 0;
 }
-static struct seq_operations input_devices_seq_ops = {
+static const struct seq_operations input_devices_seq_ops = {
        .start  = input_devices_seq_start,
        .next   = input_devices_seq_next,
        .stop   = input_devices_seq_stop,
@@ -808,7 +874,7 @@ static int input_handlers_seq_show(struct seq_file *seq, void *v)
        return 0;
 }
-static struct seq_operations input_handlers_seq_ops = {
+static const struct seq_operations input_handlers_seq_ops = {
        .start  = input_handlers_seq_start,
        .next   = input_handlers_seq_next,
        .stop   = input_handlers_seq_stop,
@@ -1329,9 +1395,6 @@ int input_register_device(struct input_dev *dev)
        snprintf(dev->dev.bus_id, sizeof(dev->dev.bus_id),
                 "input%ld", (unsigned long) atomic_inc_return(&input_no) - 1);
-        if (dev->cdev.dev)
-                dev->dev.parent = dev->cdev.dev;
        error = device_add(&dev->dev);
        if (error)
                return error;
diff --git a/drivers/input/joystick/amijoy.c b/drivers/input/joystick/amijoy.c
index 5cf9f3610e67..deb9f825f92c 100644
--- a/drivers/input/joystick/amijoy.c
+++ b/drivers/input/joystick/amijoy.c
@@ -32,7 +32,6 @@
 #include <linux/errno.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
-#include <linux/moduleparam.h>
 #include <linux/init.h>
 #include <linux/input.h>
 #include <linux/interrupt.h>
diff --git a/drivers/input/joystick/analog.c b/drivers/input/joystick/analog.c
index 15739880afc6..f32e031dcb27 100644
--- a/drivers/input/joystick/analog.c
+++ b/drivers/input/joystick/analog.c
@@ -31,7 +31,6 @@
 #include <linux/delay.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
-#include <linux/moduleparam.h>
 #include <linux/slab.h>
 #include <linux/bitops.h>
 #include <linux/init.h>
diff --git a/drivers/input/joystick/db9.c b/drivers/input/joystick/db9.c
index a6ca9d5e252f..960e501c60c8 100644
--- a/drivers/input/joystick/db9.c
+++ b/drivers/input/joystick/db9.c
@@ -33,7 +33,6 @@
 #include <linux/kernel.h>
 #include <linux/module.h>
-#include <linux/moduleparam.h>
 #include <linux/delay.h>
 #include <linux/init.h>
 #include <linux/parport.h>
diff --git a/drivers/input/joystick/gamecon.c b/drivers/input/joystick/gamecon.c
index df2a9d02ca6c..07a32aff5a31 100644
--- a/drivers/input/joystick/gamecon.c
+++ b/drivers/input/joystick/gamecon.c
@@ -33,7 +33,6 @@
 #include <linux/kernel.h>
 #include <linux/delay.h>
 #include <linux/module.h>
-#include <linux/moduleparam.h>
 #include <linux/init.h>
 #include <linux/parport.h>
 #include <linux/input.h>
diff --git a/drivers/input/joystick/iforce/iforce-main.c b/drivers/input/joystick/iforce/iforce-main.c
index 6f826b37d9aa..a2517fa72eb8 100644
--- a/drivers/input/joystick/iforce/iforce-main.c
+++ b/drivers/input/joystick/iforce/iforce-main.c
@@ -85,7 +85,7 @@ static struct iforce_device iforce_device[] = {
 static int iforce_playback(struct input_dev *dev, int effect_id, int value)
 {
-        struct iforce* iforce = dev->private;
+        struct iforce *iforce = input_get_drvdata(dev);
        struct iforce_core_effect *core_effect = &iforce->core_effects[effect_id];
        if (value > 0)
@@ -99,7 +99,7 @@ static int iforce_playback(struct input_dev *dev, int effect_id, int value)
 static void iforce_set_gain(struct input_dev *dev, u16 gain)
 {
-        struct iforce* iforce = dev->private;
+        struct iforce *iforce = input_get_drvdata(dev);
        unsigned char data[3];
        data[0] = gain >> 9;
@@ -108,7 +108,7 @@ static void iforce_set_gain(struct input_dev *dev, u16 gain)
 static void iforce_set_autocenter(struct input_dev *dev, u16 magnitude)
 {
-        struct iforce* iforce = dev->private;
+        struct iforce *iforce = input_get_drvdata(dev);
        unsigned char data[3];
        data[0] = 0x03;
@@ -126,7 +126,7 @@ static void iforce_set_autocenter(struct input_dev *dev, u16 magnitude)
 */
 static int iforce_upload_effect(struct input_dev *dev, struct ff_effect *effect, struct ff_effect *old)
 {
-        struct iforce* iforce = dev->private;
+        struct iforce *iforce = input_get_drvdata(dev);
        struct iforce_core_effect *core_effect = &iforce->core_effects[effect->id];
        int ret;
@@ -173,7 +173,7 @@ static int iforce_upload_effect(struct input_dev *dev, struct ff_effect *effect,
 */
 static int iforce_erase_effect(struct input_dev *dev, int effect_id)
 {
-        struct iforce *iforce = dev->private;
+        struct iforce *iforce = input_get_drvdata(dev);
        struct iforce_core_effect *core_effect = &iforce->core_effects[effect_id];
        int err = 0;
@@ -191,7 +191,7 @@ static int iforce_erase_effect(struct input_dev *dev, int effect_id)
 static int iforce_open(struct input_dev *dev)
 {
-        struct iforce *iforce = dev->private;
+        struct iforce *iforce = input_get_drvdata(dev);
        switch (iforce->bus) {
 #ifdef CONFIG_JOYSTICK_IFORCE_USB
@@ -213,7 +213,7 @@ static int iforce_open(struct input_dev *dev)
 static void iforce_release(struct input_dev *dev)
 {
-        struct iforce *iforce = dev->private;
+        struct iforce *iforce = input_get_drvdata(dev);
        int i;
        if (test_bit(EV_FF, dev->evbit)) {
@@ -298,7 +298,8 @@ int iforce_init_device(struct iforce *iforce)
 #endif
        }
-        input_dev->private = iforce;
+        input_set_drvdata(input_dev, iforce);
        input_dev->name = "Unknown I-Force device";
        input_dev->open = iforce_open;
        input_dev->close = iforce_release;
diff --git a/drivers/input/joystick/turbografx.c b/drivers/input/joystick/turbografx.c
index bbebd4e2ad7f..989483f53160 100644
--- a/drivers/input/joystick/turbografx.c
+++ b/drivers/input/joystick/turbografx.c
@@ -35,7 +35,6 @@
 #include <linux/parport.h>
 #include <linux/input.h>
 #include <linux/module.h>
-#include <linux/moduleparam.h>
 #include <linux/init.h>
 #include <linux/mutex.h>
diff --git a/drivers/input/joystick/xpad.c b/drivers/input/joystick/xpad.c
index 6e9d75bd2b15..0380597249bb 100644
--- a/drivers/input/joystick/xpad.c
+++ b/drivers/input/joystick/xpad.c
@@ -75,7 +75,6 @@
 #include <linux/slab.h>
 #include <linux/stat.h>
 #include <linux/module.h>
-#include <linux/moduleparam.h>
 #include <linux/usb/input.h>
 #define DRIVER_VERSION "v0.0.6"
diff --git a/drivers/input/keyboard/Kconfig b/drivers/input/keyboard/Kconfig
index 086d58c0ccbe..8ea709be3306 100644
--- a/drivers/input/keyboard/Kconfig
+++ b/drivers/input/keyboard/Kconfig
@@ -154,6 +154,27 @@ config KEYBOARD_SPITZ
          To compile this driver as a module, choose M here: the
          module will be called spitzkbd.
+config KEYBOARD_TOSA
+        tristate "Tosa keyboard"
+        depends on MACH_TOSA
+        default y
+        help
+          Say Y here to enable the keyboard on the Sharp Zaurus SL-6000x (Tosa)
+          To compile this driver as a module, choose M here: the
+          module will be called tosakbd.
+config KEYBOARD_TOSA_USE_EXT_KEYCODES
+        bool "Tosa keyboard: use extended keycodes"
+        depends on KEYBOARD_TOSA
+        default n
+        help
+          Say Y here to enable the tosa keyboard driver to generate extended
+          (>= 127) keycodes. Be aware, that they can't be correctly interpreted
+          by either console keyboard driver or by Kdrive keybd driver.
+          Say Y only if you know, what you are doing!
 config KEYBOARD_AMIGA
        tristate "Amiga keyboard"
        depends on AMIGA
@@ -239,13 +260,13 @@ config KEYBOARD_OMAP
          module will be called omap-keypad.
 config KEYBOARD_PXA27x
-        tristate "PXA27x keyboard support"
+        tristate "PXA27x/PXA3xx keypad support"
-        depends on PXA27x
+        depends on PXA27x || PXA3xx
        help
-          Enable support for PXA27x matrix keyboard controller
+          Enable support for PXA27x/PXA3xx keypad controller
          To compile this driver as a module, choose M here: the
-          module will be called pxa27x_keyboard.
+          module will be called pxa27x_keypad.
 config KEYBOARD_AAED2000
        tristate "AAED-2000 keyboard"
diff --git a/drivers/input/keyboard/Makefile b/drivers/input/keyboard/Makefile
index e97455fdcc83..e741f4031012 100644
--- a/drivers/input/keyboard/Makefile
+++ b/drivers/input/keyboard/Makefile
@@ -15,10 +15,11 @@ obj-$(CONFIG_KEYBOARD_NEWTON)		+= newtonkbd.o
 obj-$(CONFIG_KEYBOARD_STOWAWAY)         += stowaway.o
 obj-$(CONFIG_KEYBOARD_CORGI)            += corgikbd.o
 obj-$(CONFIG_KEYBOARD_SPITZ)            += spitzkbd.o
+obj-$(CONFIG_KEYBOARD_TOSA)             += tosakbd.o
 obj-$(CONFIG_KEYBOARD_HIL)              += hil_kbd.o
 obj-$(CONFIG_KEYBOARD_HIL_OLD)          += hilkbd.o
 obj-$(CONFIG_KEYBOARD_OMAP)             += omap-keypad.o
-obj-$(CONFIG_KEYBOARD_PXA27x)           += pxa27x_keyboard.o
+obj-$(CONFIG_KEYBOARD_PXA27x)           += pxa27x_keypad.o
 obj-$(CONFIG_KEYBOARD_AAED2000)         += aaed2000_kbd.o
 obj-$(CONFIG_KEYBOARD_GPIO)             += gpio_keys.o
 obj-$(CONFIG_KEYBOARD_HP6XX)            += jornada680_kbd.o
diff --git a/drivers/input/keyboard/atkbd.c b/drivers/input/keyboard/atkbd.c
index b39c5b31e620..4a95adc4cc78 100644
--- a/drivers/input/keyboard/atkbd.c
+++ b/drivers/input/keyboard/atkbd.c
@@ -19,7 +19,6 @@
 #include <linux/delay.h>
 #include <linux/module.h>
-#include <linux/moduleparam.h>
 #include <linux/slab.h>
 #include <linux/interrupt.h>
 #include <linux/init.h>
@@ -28,6 +27,7 @@
 #include <linux/workqueue.h>
 #include <linux/libps2.h>
 #include <linux/mutex.h>
+#include <linux/dmi.h>
 #define DRIVER_DESC     "AT and PS/2 keyboard driver"
@@ -201,6 +201,7 @@ struct atkbd {
        unsigned short id;
        unsigned char keycode[512];
+        DECLARE_BITMAP(force_release_mask, 512);
        unsigned char set;
        unsigned char translated;
        unsigned char extra;
@@ -225,6 +226,11 @@ struct atkbd {
        unsigned long event_mask;
 };
+/*
+ * System-specific ketymap fixup routine
+ */
+static void (*atkbd_platform_fixup)(struct atkbd *);
 static ssize_t atkbd_attr_show_helper(struct device *dev, char *buf,
                                ssize_t (*handler)(struct atkbd *, char *));
 static ssize_t atkbd_attr_set_helper(struct device *dev, const char *buf, size_t count,
@@ -349,7 +355,7 @@ static irqreturn_t atkbd_interrupt(struct serio *serio, unsigned char data,
        struct atkbd *atkbd = serio_get_drvdata(serio);
        struct input_dev *dev = atkbd->dev;
        unsigned int code = data;
-        int scroll = 0, hscroll = 0, click = -1, add_release_event = 0;
+        int scroll = 0, hscroll = 0, click = -1;
        int value;
        unsigned char keycode;
@@ -414,14 +420,6 @@ static irqreturn_t atkbd_interrupt(struct serio *serio, unsigned char data,
                                       "Some program might be trying access hardware directly.\n",
                                       data == ATKBD_RET_ACK ? "ACK" : "NAK", serio->phys);
                        goto out;
-                case ATKBD_RET_HANGEUL:
-                case ATKBD_RET_HANJA:
-                        /*
-                         * These keys do not report release and thus need to be
-                         * flagged properly
-                         */
-                        add_release_event = 1;
-                        break;
                case ATKBD_RET_ERR:
                        atkbd->err_count++;
 #ifdef ATKBD_DEBUG
@@ -491,7 +489,7 @@ static irqreturn_t atkbd_interrupt(struct serio *serio, unsigned char data,
                        input_event(dev, EV_KEY, keycode, value);
                        input_sync(dev);
-                        if (value && add_release_event) {
+                        if (value && test_bit(code, atkbd->force_release_mask)) {
                                input_report_key(dev, keycode, 0);
                                input_sync(dev);
                        }
@@ -824,7 +822,6 @@ static void atkbd_disconnect(struct serio *serio)
        atkbd_disable(atkbd);
        /* make sure we don't have a command in flight */
-        synchronize_sched();  /* Allow atkbd_interrupt()s to complete. */
        flush_scheduled_work();
        sysfs_remove_group(&serio->dev.kobj, &atkbd_attribute_group);
@@ -834,6 +831,22 @@ static void atkbd_disconnect(struct serio *serio)
        kfree(atkbd);
 }
+/*
+ * Most special keys (Fn+F?) on Dell Latitudes do not generate release
+ * events so we have to do it ourselves.
+ */
+static void atkbd_latitude_keymap_fixup(struct atkbd *atkbd)
+{
+        const unsigned int forced_release_keys[] = {
+                0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8f, 0x93,
+        };
+        int i;
+        if (atkbd->set == 2)
+                for (i = 0; i < ARRAY_SIZE(forced_release_keys); i++)
+                        __set_bit(forced_release_keys[i],
+                                  atkbd->force_release_mask);
+}
 /*
 * atkbd_set_keycode_table() initializes keyboard's keycode table
@@ -842,17 +855,20 @@ static void atkbd_disconnect(struct serio *serio)
 static void atkbd_set_keycode_table(struct atkbd *atkbd)
 {
+        unsigned int scancode;
        int i, j;
        memset(atkbd->keycode, 0, sizeof(atkbd->keycode));
+        bitmap_zero(atkbd->force_release_mask, 512);
        if (atkbd->translated) {
                for (i = 0; i < 128; i++) {
-                        atkbd->keycode[i] = atkbd_set2_keycode[atkbd_unxlate_table[i]];
+                        scancode = atkbd_unxlate_table[i];
-                        atkbd->keycode[i | 0x80] = atkbd_set2_keycode[atkbd_unxlate_table[i] | 0x80];
+                        atkbd->keycode[i] = atkbd_set2_keycode[scancode];
+                        atkbd->keycode[i | 0x80] = atkbd_set2_keycode[scancode | 0x80];
                        if (atkbd->scroll)
                                for (j = 0; j < ARRAY_SIZE(atkbd_scroll_keys); j++)
-                                        if ((atkbd_unxlate_table[i] | 0x80) == atkbd_scroll_keys[j].set2)
+                                        if ((scancode | 0x80) == atkbd_scroll_keys[j].set2)
                                                atkbd->keycode[i | 0x80] = atkbd_scroll_keys[j].keycode;
                }
        } else if (atkbd->set == 3) {
@@ -861,12 +877,29 @@ static void atkbd_set_keycode_table(struct atkbd *atkbd)
                memcpy(atkbd->keycode, atkbd_set2_keycode, sizeof(atkbd->keycode));
                if (atkbd->scroll)
-                        for (i = 0; i < ARRAY_SIZE(atkbd_scroll_keys); i++)
+                        for (i = 0; i < ARRAY_SIZE(atkbd_scroll_keys); i++) {
-                                atkbd->keycode[atkbd_scroll_keys[i].set2] = atkbd_scroll_keys[i].keycode;
+                                scancode = atkbd_scroll_keys[i].set2;
+                                atkbd->keycode[scancode] = atkbd_scroll_keys[i].keycode;
+                }
        }
-        atkbd->keycode[atkbd_compat_scancode(atkbd, ATKBD_RET_HANGEUL)] = KEY_HANGUEL;
+/*
-        atkbd->keycode[atkbd_compat_scancode(atkbd, ATKBD_RET_HANJA)] = KEY_HANJA;
+ * HANGEUL and HANJA keys do not send release events so we need to
+ * generate such events ourselves
+ */
+        scancode = atkbd_compat_scancode(atkbd, ATKBD_RET_HANGEUL);
+        atkbd->keycode[scancode] = KEY_HANGEUL;
+        __set_bit(scancode, atkbd->force_release_mask);
+        scancode = atkbd_compat_scancode(atkbd, ATKBD_RET_HANJA);
+        atkbd->keycode[scancode] = KEY_HANJA;
+        __set_bit(scancode, atkbd->force_release_mask);
+/*
+ * Perform additional fixups
+ */
+        if (atkbd_platform_fixup)
+                atkbd_platform_fixup(atkbd);
 }
 /*
@@ -1401,9 +1434,29 @@ static ssize_t atkbd_show_err_count(struct atkbd *atkbd, char *buf)
        return sprintf(buf, "%lu\n", atkbd->err_count);
 }
+static int __init atkbd_setup_fixup(const struct dmi_system_id *id)
+{
+        atkbd_platform_fixup = id->driver_data;
+        return 0;
+}
+static struct dmi_system_id atkbd_dmi_quirk_table[] __initdata = {
+        {
+                .ident = "Dell Latitude series",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "Latitude"),
+                },
+                .callback = atkbd_setup_fixup,
+                .driver_data = atkbd_latitude_keymap_fixup,
+        },
+        { }
+};
 static int __init atkbd_init(void)
 {
+        dmi_check_system(atkbd_dmi_quirk_table);
        return serio_register_driver(&atkbd_drv);
 }
diff --git a/drivers/input/keyboard/lkkbd.c b/drivers/input/keyboard/lkkbd.c
index 1b08f4e79dd2..32e2c2605d95 100644
--- a/drivers/input/keyboard/lkkbd.c
+++ b/drivers/input/keyboard/lkkbd.c
@@ -64,7 +64,6 @@
 #include <linux/delay.h>
 #include <linux/slab.h>
 #include <linux/module.h>
-#include <linux/moduleparam.h>
 #include <linux/interrupt.h>
 #include <linux/init.h>
 #include <linux/input.h>
diff --git a/drivers/input/keyboard/pxa27x_keyboard.c b/drivers/input/keyboard/pxa27x_keyboard.c
deleted file mode 100644
index bdd64ee4c5c8..000000000000
--- a/drivers/input/keyboard/pxa27x_keyboard.c
+++ /dev/null
@@ -1,274 +0,0 @@
-/*
- * linux/drivers/input/keyboard/pxa27x_keyboard.c
- *
- * Driver for the pxa27x matrix keyboard controller.
- *
- * Created:     Feb 22, 2007
- * Author:      Rodolfo Giometti <giometti@linux.it>
- *
- * Based on a previous implementations by Kevin O'Connor
- * <kevin_at_koconnor.net> and Alex Osborne <bobofdoom@gmail.com> and
- * on some suggestions by Nicolas Pitre <nico@cam.org>.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/interrupt.h>
-#include <linux/input.h>
-#include <linux/device.h>
-#include <linux/platform_device.h>
-#include <linux/clk.h>
-#include <linux/err.h>
-#include <asm/mach-types.h>
-#include <asm/mach/arch.h>
-#include <asm/mach/map.h>
-#include <asm/arch/hardware.h>
-#include <asm/arch/pxa-regs.h>
-#include <asm/arch/irqs.h>
-#include <asm/arch/pxa27x_keyboard.h>
-#define DRIVER_NAME             "pxa27x-keyboard"
-#define KPASMKP(col)            (col/2 == 0 ? KPASMKP0 : \
-                                 col/2 == 1 ? KPASMKP1 : \
-                                 col/2 == 2 ? KPASMKP2 : KPASMKP3)
-#define KPASMKPx_MKC(row, col)  (1 << (row + 16 * (col % 2)))
-static struct clk *pxakbd_clk;
-static irqreturn_t pxakbd_irq_handler(int irq, void *dev_id)
-{
-        struct platform_device *pdev = dev_id;
-        struct pxa27x_keyboard_platform_data *pdata = pdev->dev.platform_data;
-        struct input_dev *input_dev = platform_get_drvdata(pdev);
-        unsigned long kpc = KPC;
-        int p, row, col, rel;
-        if (kpc & KPC_DI) {
-                unsigned long kpdk = KPDK;
-                if (!(kpdk & KPDK_DKP)) {
-                        /* better luck next time */
-                } else if (kpc & KPC_REE0) {
-                        unsigned long kprec = KPREC;
-                        KPREC = 0x7f;
-                        if (kprec & KPREC_OF0)
-                                rel = (kprec & 0xff) + 0x7f;
-                        else if (kprec & KPREC_UF0)
-                                rel = (kprec & 0xff) - 0x7f - 0xff;
-                        else
-                                rel = (kprec & 0xff) - 0x7f;
-                        if (rel) {
-                                input_report_rel(input_dev, REL_WHEEL, rel);
-                                input_sync(input_dev);
-                        }
-                }
-        }
-        if (kpc & KPC_MI) {
-                /* report the status of every button */
-                for (row = 0; row < pdata->nr_rows; row++) {
-                        for (col = 0; col < pdata->nr_cols; col++) {
-                                p = KPASMKP(col) & KPASMKPx_MKC(row, col) ?
-                                        1 : 0;
-                                pr_debug("keycode %x - pressed %x\n",
-                                                pdata->keycodes[row][col], p);
-                                input_report_key(input_dev,
-                                                pdata->keycodes[row][col], p);
-                        }
-                }
-                input_sync(input_dev);
-        }
-        return IRQ_HANDLED;
-}
-static int pxakbd_open(struct input_dev *dev)
-{
-        /* Set keypad control register */
-        KPC |= (KPC_ASACT |
-                KPC_MS_ALL |
-                (2 << 6) | KPC_REE0 | KPC_DK_DEB_SEL |
-                KPC_ME | KPC_MIE | KPC_DE | KPC_DIE);
-        KPC &= ~KPC_AS;         /* disable automatic scan */
-        KPC &= ~KPC_IMKP;       /* do not ignore multiple keypresses */
-        /* Set rotary count to mid-point value */
-        KPREC = 0x7F;
-        /* Enable unit clock */
-        clk_enable(pxakbd_clk);
-        return 0;
-}
-static void pxakbd_close(struct input_dev *dev)
-{
-        /* Disable clock unit */
-        clk_disable(pxakbd_clk);
-}
-#ifdef CONFIG_PM
-static int pxakbd_suspend(struct platform_device *pdev, pm_message_t state)
-{
-        struct pxa27x_keyboard_platform_data *pdata = pdev->dev.platform_data;
-        /* Save controller status */
-        pdata->reg_kpc = KPC;
-        pdata->reg_kprec = KPREC;
-        return 0;
-}
-static int pxakbd_resume(struct platform_device *pdev)
-{
-        struct pxa27x_keyboard_platform_data *pdata = pdev->dev.platform_data;
-        struct input_dev *input_dev = platform_get_drvdata(pdev);
-        mutex_lock(&input_dev->mutex);
-        if (input_dev->users) {
-                /* Restore controller status */
-                KPC = pdata->reg_kpc;
-                KPREC = pdata->reg_kprec;
-                /* Enable unit clock */
-                clk_disable(pxakbd_clk);
-                clk_enable(pxakbd_clk);
-        }
-        mutex_unlock(&input_dev->mutex);
-        return 0;
-}
-#else
-#define pxakbd_suspend  NULL
-#define pxakbd_resume   NULL
-#endif
-static int __devinit pxakbd_probe(struct platform_device *pdev)
-{
-        struct pxa27x_keyboard_platform_data *pdata = pdev->dev.platform_data;
-        struct input_dev *input_dev;
-        int i, row, col, error;
-        pxakbd_clk = clk_get(&pdev->dev, "KBDCLK");
-        if (IS_ERR(pxakbd_clk)) {
-                error = PTR_ERR(pxakbd_clk);
-                goto err_clk;
-        }
-        /* Create and register the input driver. */
-        input_dev = input_allocate_device();
-        if (!input_dev) {
-                printk(KERN_ERR "Cannot request keypad device\n");
-                error = -ENOMEM;
-                goto err_alloc;
-        }
-        input_dev->name = DRIVER_NAME;
-        input_dev->id.bustype = BUS_HOST;
-        input_dev->open = pxakbd_open;
-        input_dev->close = pxakbd_close;
-        input_dev->dev.parent = &pdev->dev;
-        input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP) |
-                BIT_MASK(EV_REL);
-        input_dev->relbit[BIT_WORD(REL_WHEEL)] = BIT_MASK(REL_WHEEL);
-        for (row = 0; row < pdata->nr_rows; row++) {
-                for (col = 0; col < pdata->nr_cols; col++) {
-                        int code = pdata->keycodes[row][col];
-                        if (code > 0)
-                                set_bit(code, input_dev->keybit);
-                }
-        }
-        error = request_irq(IRQ_KEYPAD, pxakbd_irq_handler, IRQF_DISABLED,
-                            DRIVER_NAME, pdev);
-        if (error) {
-                printk(KERN_ERR "Cannot request keypad IRQ\n");
-                goto err_free_dev;
-        }
-        platform_set_drvdata(pdev, input_dev);
-        /* Register the input device */
-        error = input_register_device(input_dev);
-        if (error)
-                goto err_free_irq;
-        /* Setup GPIOs. */
-        for (i = 0; i < pdata->nr_rows + pdata->nr_cols; i++)
-                pxa_gpio_mode(pdata->gpio_modes[i]);
-        /*
-         * Store rows/cols info into keyboard registers.
-         */
-        KPC |= (pdata->nr_rows - 1) << 26;
-        KPC |= (pdata->nr_cols - 1) << 23;
-        for (col = 0; col < pdata->nr_cols; col++)
-                KPC |= KPC_MS0 << col;
-        return 0;
- err_free_irq:
-        platform_set_drvdata(pdev, NULL);
-        free_irq(IRQ_KEYPAD, pdev);
- err_free_dev:
-        input_free_device(input_dev);
- err_alloc:
-        clk_put(pxakbd_clk);
- err_clk:
-        return error;
-}
-static int __devexit pxakbd_remove(struct platform_device *pdev)
-{
-        struct input_dev *input_dev = platform_get_drvdata(pdev);
-        input_unregister_device(input_dev);
-        free_irq(IRQ_KEYPAD, pdev);
-        clk_put(pxakbd_clk);
-        platform_set_drvdata(pdev, NULL);
-        return 0;
-}
-static struct platform_driver pxakbd_driver = {
-        .probe          = pxakbd_probe,
-        .remove         = __devexit_p(pxakbd_remove),
-        .suspend        = pxakbd_suspend,
-        .resume         = pxakbd_resume,
-        .driver         = {
-                .name   = DRIVER_NAME,
-        },
-};
-static int __init pxakbd_init(void)
-{
-        return platform_driver_register(&pxakbd_driver);
-}
-static void __exit pxakbd_exit(void)
-{
-        platform_driver_unregister(&pxakbd_driver);
-}
-module_init(pxakbd_init);
-module_exit(pxakbd_exit);
-MODULE_DESCRIPTION("PXA27x Matrix Keyboard Driver");
-MODULE_LICENSE("GPL");
diff --git a/drivers/input/keyboard/pxa27x_keypad.c b/drivers/input/keyboard/pxa27x_keypad.c
new file mode 100644
index 000000000000..6224c2fb3b65
--- /dev/null
+++ b/drivers/input/keyboard/pxa27x_keypad.c
@@ -0,0 +1,572 @@
+/*
+ * linux/drivers/input/keyboard/pxa27x_keypad.c
+ *
+ * Driver for the pxa27x matrix keyboard controller.
+ *
+ * Created:     Feb 22, 2007
+ * Author:      Rodolfo Giometti <giometti@linux.it>
+ *
+ * Based on a previous implementations by Kevin O'Connor
+ * <kevin_at_koconnor.net> and Alex Osborne <bobofdoom@gmail.com> and
+ * on some suggestions by Nicolas Pitre <nico@cam.org>.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/input.h>
+#include <linux/device.h>
+#include <linux/platform_device.h>
+#include <linux/clk.h>
+#include <linux/err.h>
+#include <asm/mach-types.h>
+#include <asm/mach/arch.h>
+#include <asm/mach/map.h>
+#include <asm/arch/hardware.h>
+#include <asm/arch/pxa27x_keypad.h>
+/*
+ * Keypad Controller registers
+ */
+#define KPC             0x0000 /* Keypad Control register */
+#define KPDK            0x0008 /* Keypad Direct Key register */
+#define KPREC           0x0010 /* Keypad Rotary Encoder register */
+#define KPMK            0x0018 /* Keypad Matrix Key register */
+#define KPAS            0x0020 /* Keypad Automatic Scan register */
+/* Keypad Automatic Scan Multiple Key Presser register 0-3 */
+#define KPASMKP0        0x0028
+#define KPASMKP1        0x0030
+#define KPASMKP2        0x0038
+#define KPASMKP3        0x0040
+#define KPKDI           0x0048
+/* bit definitions */
+#define KPC_MKRN(n)     ((((n) & 0x7) - 1) << 26) /* matrix key row number */
+#define KPC_MKCN(n)     ((((n) & 0x7) - 1) << 23) /* matrix key column number */
+#define KPC_DKN(n)      ((((n) & 0x7) - 1) << 6)  /* direct key number */
+#define KPC_AS          (0x1 << 30)  /* Automatic Scan bit */
+#define KPC_ASACT       (0x1 << 29)  /* Automatic Scan on Activity */
+#define KPC_MI          (0x1 << 22)  /* Matrix interrupt bit */
+#define KPC_IMKP        (0x1 << 21)  /* Ignore Multiple Key Press */
+#define KPC_MS(n)       (0x1 << (13 + (n)))     /* Matrix scan line 'n' */
+#define KPC_MS_ALL      (0xff << 13)
+#define KPC_ME          (0x1 << 12)  /* Matrix Keypad Enable */
+#define KPC_MIE         (0x1 << 11)  /* Matrix Interrupt Enable */
+#define KPC_DK_DEB_SEL  (0x1 <<  9)  /* Direct Keypad Debounce Select */
+#define KPC_DI          (0x1 <<  5)  /* Direct key interrupt bit */
+#define KPC_RE_ZERO_DEB (0x1 <<  4)  /* Rotary Encoder Zero Debounce */
+#define KPC_REE1        (0x1 <<  3)  /* Rotary Encoder1 Enable */
+#define KPC_REE0        (0x1 <<  2)  /* Rotary Encoder0 Enable */
+#define KPC_DE          (0x1 <<  1)  /* Direct Keypad Enable */
+#define KPC_DIE         (0x1 <<  0)  /* Direct Keypad interrupt Enable */
+#define KPDK_DKP        (0x1 << 31)
+#define KPDK_DK(n)      ((n) & 0xff)
+#define KPREC_OF1       (0x1 << 31)
+#define kPREC_UF1       (0x1 << 30)
+#define KPREC_OF0       (0x1 << 15)
+#define KPREC_UF0       (0x1 << 14)
+#define KPREC_RECOUNT0(n)       ((n) & 0xff)
+#define KPREC_RECOUNT1(n)       (((n) >> 16) & 0xff)
+#define KPMK_MKP        (0x1 << 31)
+#define KPAS_SO         (0x1 << 31)
+#define KPASMKPx_SO     (0x1 << 31)
+#define KPAS_MUKP(n)    (((n) >> 26) & 0x1f)
+#define KPAS_RP(n)      (((n) >> 4) & 0xf)
+#define KPAS_CP(n)      ((n) & 0xf)
+#define KPASMKP_MKC_MASK        (0xff)
+#define keypad_readl(off)       __raw_readl(keypad->mmio_base + (off))
+#define keypad_writel(off, v)   __raw_writel((v), keypad->mmio_base + (off))
+#define MAX_MATRIX_KEY_NUM      (8 * 8)
+struct pxa27x_keypad {
+        struct pxa27x_keypad_platform_data *pdata;
+        struct clk *clk;
+        struct input_dev *input_dev;
+        void __iomem *mmio_base;
+        /* matrix key code map */
+        unsigned int matrix_keycodes[MAX_MATRIX_KEY_NUM];
+        /* state row bits of each column scan */
+        uint32_t matrix_key_state[MAX_MATRIX_KEY_COLS];
+        uint32_t direct_key_state;
+        unsigned int direct_key_mask;
+        int rotary_rel_code[2];
+        int rotary_up_key[2];
+        int rotary_down_key[2];
+};
+static void pxa27x_keypad_build_keycode(struct pxa27x_keypad *keypad)
+{
+        struct pxa27x_keypad_platform_data *pdata = keypad->pdata;
+        struct input_dev *input_dev = keypad->input_dev;
+        unsigned int *key;
+        int i;
+        key = &pdata->matrix_key_map[0];
+        for (i = 0; i < pdata->matrix_key_map_size; i++, key++) {
+                int row = ((*key) >> 28) & 0xf;
+                int col = ((*key) >> 24) & 0xf;
+                int code = (*key) & 0xffffff;
+                keypad->matrix_keycodes[(row << 3) + col] = code;
+                set_bit(code, input_dev->keybit);
+        }
+        keypad->rotary_up_key[0] = pdata->rotary0_up_key;
+        keypad->rotary_up_key[1] = pdata->rotary1_up_key;
+        keypad->rotary_down_key[0] = pdata->rotary0_down_key;
+        keypad->rotary_down_key[1] = pdata->rotary1_down_key;
+        keypad->rotary_rel_code[0] = pdata->rotary0_rel_code;
+        keypad->rotary_rel_code[1] = pdata->rotary1_rel_code;
+        if (pdata->rotary0_up_key && pdata->rotary0_down_key) {
+                set_bit(pdata->rotary0_up_key, input_dev->keybit);
+                set_bit(pdata->rotary0_down_key, input_dev->keybit);
+        } else
+                set_bit(pdata->rotary0_rel_code, input_dev->relbit);
+        if (pdata->rotary1_up_key && pdata->rotary1_down_key) {
+                set_bit(pdata->rotary1_up_key, input_dev->keybit);
+                set_bit(pdata->rotary1_down_key, input_dev->keybit);
+        } else
+                set_bit(pdata->rotary1_rel_code, input_dev->relbit);
+}
+static inline unsigned int lookup_matrix_keycode(
+                struct pxa27x_keypad *keypad, int row, int col)
+{
+        return keypad->matrix_keycodes[(row << 3) + col];
+}
+static void pxa27x_keypad_scan_matrix(struct pxa27x_keypad *keypad)
+{
+        struct pxa27x_keypad_platform_data *pdata = keypad->pdata;
+        int row, col, num_keys_pressed = 0;
+        uint32_t new_state[MAX_MATRIX_KEY_COLS];
+        uint32_t kpas = keypad_readl(KPAS);
+        num_keys_pressed = KPAS_MUKP(kpas);
+        memset(new_state, 0, sizeof(new_state));
+        if (num_keys_pressed == 0)
+                goto scan;
+        if (num_keys_pressed == 1) {
+                col = KPAS_CP(kpas);
+                row = KPAS_RP(kpas);
+                /* if invalid row/col, treat as no key pressed */
+                if (col >= pdata->matrix_key_cols ||
+                    row >= pdata->matrix_key_rows)
+                        goto scan;
+                new_state[col] = (1 << row);
+                goto scan;
+        }
+        if (num_keys_pressed > 1) {
+                uint32_t kpasmkp0 = keypad_readl(KPASMKP0);
+                uint32_t kpasmkp1 = keypad_readl(KPASMKP1);
+                uint32_t kpasmkp2 = keypad_readl(KPASMKP2);
+                uint32_t kpasmkp3 = keypad_readl(KPASMKP3);
+                new_state[0] = kpasmkp0 & KPASMKP_MKC_MASK;
+                new_state[1] = (kpasmkp0 >> 16) & KPASMKP_MKC_MASK;
+                new_state[2] = kpasmkp1 & KPASMKP_MKC_MASK;
+                new_state[3] = (kpasmkp1 >> 16) & KPASMKP_MKC_MASK;
+                new_state[4] = kpasmkp2 & KPASMKP_MKC_MASK;
+                new_state[5] = (kpasmkp2 >> 16) & KPASMKP_MKC_MASK;
+                new_state[6] = kpasmkp3 & KPASMKP_MKC_MASK;
+                new_state[7] = (kpasmkp3 >> 16) & KPASMKP_MKC_MASK;
+        }
+scan:
+        for (col = 0; col < pdata->matrix_key_cols; col++) {
+                uint32_t bits_changed;
+                bits_changed = keypad->matrix_key_state[col] ^ new_state[col];
+                if (bits_changed == 0)
+                        continue;
+                for (row = 0; row < pdata->matrix_key_rows; row++) {
+                        if ((bits_changed & (1 << row)) == 0)
+                                continue;
+                        input_report_key(keypad->input_dev,
+                                lookup_matrix_keycode(keypad, row, col),
+                                new_state[col] & (1 << row));
+                }
+        }
+        input_sync(keypad->input_dev);
+        memcpy(keypad->matrix_key_state, new_state, sizeof(new_state));
+}
+#define DEFAULT_KPREC   (0x007f007f)
+static inline int rotary_delta(uint32_t kprec)
+{
+        if (kprec & KPREC_OF0)
+                return (kprec & 0xff) + 0x7f;
+        else if (kprec & KPREC_UF0)
+                return (kprec & 0xff) - 0x7f - 0xff;
+        else
+                return (kprec & 0xff) - 0x7f;
+}
+static void report_rotary_event(struct pxa27x_keypad *keypad, int r, int delta)
+{
+        struct input_dev *dev = keypad->input_dev;
+        if (delta == 0)
+                return;
+        if (keypad->rotary_up_key[r] && keypad->rotary_down_key[r]) {
+                int keycode = (delta > 0) ? keypad->rotary_up_key[r] :
+                                            keypad->rotary_down_key[r];
+                /* simulate a press-n-release */
+                input_report_key(dev, keycode, 1);
+                input_sync(dev);
+                input_report_key(dev, keycode, 0);
+                input_sync(dev);
+        } else {
+                input_report_rel(dev, keypad->rotary_rel_code[r], delta);
+                input_sync(dev);
+        }
+}
+static void pxa27x_keypad_scan_rotary(struct pxa27x_keypad *keypad)
+{
+        struct pxa27x_keypad_platform_data *pdata = keypad->pdata;
+        uint32_t kprec;
+        /* read and reset to default count value */
+        kprec = keypad_readl(KPREC);
+        keypad_writel(KPREC, DEFAULT_KPREC);
+        if (pdata->enable_rotary0)
+                report_rotary_event(keypad, 0, rotary_delta(kprec));
+        if (pdata->enable_rotary1)
+                report_rotary_event(keypad, 1, rotary_delta(kprec >> 16));
+}
+static void pxa27x_keypad_scan_direct(struct pxa27x_keypad *keypad)
+{
+        struct pxa27x_keypad_platform_data *pdata = keypad->pdata;
+        unsigned int new_state;
+        uint32_t kpdk, bits_changed;
+        int i;
+        kpdk = keypad_readl(KPDK);
+        if (pdata->enable_rotary0 || pdata->enable_rotary1)
+                pxa27x_keypad_scan_rotary(keypad);
+        if (pdata->direct_key_map == NULL)
+                return;
+        new_state = KPDK_DK(kpdk) & keypad->direct_key_mask;
+        bits_changed = keypad->direct_key_state ^ new_state;
+        if (bits_changed == 0)
+                return;
+        for (i = 0; i < pdata->direct_key_num; i++) {
+                if (bits_changed & (1 << i))
+                        input_report_key(keypad->input_dev,
+                                        pdata->direct_key_map[i],
+                                        (new_state & (1 << i)));
+        }
+        input_sync(keypad->input_dev);
+        keypad->direct_key_state = new_state;
+}
+static irqreturn_t pxa27x_keypad_irq_handler(int irq, void *dev_id)
+{
+        struct pxa27x_keypad *keypad = dev_id;
+        unsigned long kpc = keypad_readl(KPC);
+        if (kpc & KPC_DI)
+                pxa27x_keypad_scan_direct(keypad);
+        if (kpc & KPC_MI)
+                pxa27x_keypad_scan_matrix(keypad);
+        return IRQ_HANDLED;
+}
+static void pxa27x_keypad_config(struct pxa27x_keypad *keypad)
+{
+        struct pxa27x_keypad_platform_data *pdata = keypad->pdata;
+        unsigned int mask = 0, direct_key_num = 0;
+        unsigned long kpc = 0;
+        /* enable matrix keys with automatic scan */
+        if (pdata->matrix_key_rows && pdata->matrix_key_cols) {
+                kpc |= KPC_ASACT | KPC_MIE | KPC_ME | KPC_MS_ALL;
+                kpc |= KPC_MKRN(pdata->matrix_key_rows) |
+                       KPC_MKCN(pdata->matrix_key_cols);
+        }
+        /* enable rotary key, debounce interval same as direct keys */
+        if (pdata->enable_rotary0) {
+                mask |= 0x03;
+                direct_key_num = 2;
+                kpc |= KPC_REE0;
+        }
+        if (pdata->enable_rotary1) {
+                mask |= 0x0c;
+                direct_key_num = 4;
+                kpc |= KPC_REE1;
+        }
+        if (pdata->direct_key_num > direct_key_num)
+                direct_key_num = pdata->direct_key_num;
+        keypad->direct_key_mask = ((2 << direct_key_num) - 1) & ~mask;
+        /* enable direct key */
+        if (direct_key_num)
+                kpc |= KPC_DE | KPC_DIE | KPC_DKN(direct_key_num);
+        keypad_writel(KPC, kpc | KPC_RE_ZERO_DEB);
+        keypad_writel(KPREC, DEFAULT_KPREC);
+        keypad_writel(KPKDI, pdata->debounce_interval);
+}
+static int pxa27x_keypad_open(struct input_dev *dev)
+{
+        struct pxa27x_keypad *keypad = input_get_drvdata(dev);
+        /* Enable unit clock */
+        clk_enable(keypad->clk);
+        pxa27x_keypad_config(keypad);
+        return 0;
+}
+static void pxa27x_keypad_close(struct input_dev *dev)
+{
+        struct pxa27x_keypad *keypad = input_get_drvdata(dev);
+        /* Disable clock unit */
+        clk_disable(keypad->clk);
+}
+#ifdef CONFIG_PM
+static int pxa27x_keypad_suspend(struct platform_device *pdev, pm_message_t state)
+{
+        struct pxa27x_keypad *keypad = platform_get_drvdata(pdev);
+        clk_disable(keypad->clk);
+        return 0;
+}
+static int pxa27x_keypad_resume(struct platform_device *pdev)
+{
+        struct pxa27x_keypad *keypad = platform_get_drvdata(pdev);
+        struct input_dev *input_dev = keypad->input_dev;
+        mutex_lock(&input_dev->mutex);
+        if (input_dev->users) {
+                /* Enable unit clock */
+                clk_enable(keypad->clk);
+                pxa27x_keypad_config(keypad);
+        }
+        mutex_unlock(&input_dev->mutex);
+        return 0;
+}
+#else
+#define pxa27x_keypad_suspend   NULL
+#define pxa27x_keypad_resume    NULL
+#endif
+#define res_size(res)   ((res)->end - (res)->start + 1)
+static int __devinit pxa27x_keypad_probe(struct platform_device *pdev)
+{
+        struct pxa27x_keypad *keypad;
+        struct input_dev *input_dev;
+        struct resource *res;
+        int irq, error;
+        keypad = kzalloc(sizeof(struct pxa27x_keypad), GFP_KERNEL);
+        if (keypad == NULL) {
+                dev_err(&pdev->dev, "failed to allocate driver data\n");
+                return -ENOMEM;
+        }
+        keypad->pdata = pdev->dev.platform_data;
+        if (keypad->pdata == NULL) {
+                dev_err(&pdev->dev, "no platform data defined\n");
+                error = -EINVAL;
+                goto failed_free;
+        }
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0) {
+                dev_err(&pdev->dev, "failed to get keypad irq\n");
+                error = -ENXIO;
+                goto failed_free;
+        }
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (res == NULL) {
+                dev_err(&pdev->dev, "failed to get I/O memory\n");
+                error = -ENXIO;
+                goto failed_free;
+        }
+        res = request_mem_region(res->start, res_size(res), pdev->name);
+        if (res == NULL) {
+                dev_err(&pdev->dev, "failed to request I/O memory\n");
+                error = -EBUSY;
+                goto failed_free;
+        }
+        keypad->mmio_base = ioremap(res->start, res_size(res));
+        if (keypad->mmio_base == NULL) {
+                dev_err(&pdev->dev, "failed to remap I/O memory\n");
+                error = -ENXIO;
+                goto failed_free_mem;
+        }
+        keypad->clk = clk_get(&pdev->dev, "KBDCLK");
+        if (IS_ERR(keypad->clk)) {
+                dev_err(&pdev->dev, "failed to get keypad clock\n");
+                error = PTR_ERR(keypad->clk);
+                goto failed_free_io;
+        }
+        /* Create and register the input driver. */
+        input_dev = input_allocate_device();
+        if (!input_dev) {
+                dev_err(&pdev->dev, "failed to allocate input device\n");
+                error = -ENOMEM;
+                goto failed_put_clk;
+        }
+        input_dev->name = pdev->name;
+        input_dev->id.bustype = BUS_HOST;
+        input_dev->open = pxa27x_keypad_open;
+        input_dev->close = pxa27x_keypad_close;
+        input_dev->dev.parent = &pdev->dev;
+        keypad->input_dev = input_dev;
+        input_set_drvdata(input_dev, keypad);
+        input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP) |
+                BIT_MASK(EV_REL);
+        pxa27x_keypad_build_keycode(keypad);
+        platform_set_drvdata(pdev, keypad);
+        error = request_irq(irq, pxa27x_keypad_irq_handler, IRQF_DISABLED,
+                            pdev->name, keypad);
+        if (error) {
+                dev_err(&pdev->dev, "failed to request IRQ\n");
+                goto failed_free_dev;
+        }
+        /* Register the input device */
+        error = input_register_device(input_dev);
+        if (error) {
+                dev_err(&pdev->dev, "failed to register input device\n");
+                goto failed_free_irq;
+        }
+        return 0;
+failed_free_irq:
+        free_irq(irq, pdev);
+        platform_set_drvdata(pdev, NULL);
+failed_free_dev:
+        input_free_device(input_dev);
+failed_put_clk:
+        clk_put(keypad->clk);
+failed_free_io:
+        iounmap(keypad->mmio_base);
+failed_free_mem:
+        release_mem_region(res->start, res_size(res));
+failed_free:
+        kfree(keypad);
+        return error;
+}
+static int __devexit pxa27x_keypad_remove(struct platform_device *pdev)
+{
+        struct pxa27x_keypad *keypad = platform_get_drvdata(pdev);
+        struct resource *res;
+        free_irq(platform_get_irq(pdev, 0), pdev);
+        clk_disable(keypad->clk);
+        clk_put(keypad->clk);
+        input_unregister_device(keypad->input_dev);
+        input_free_device(keypad->input_dev);
+        iounmap(keypad->mmio_base);
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        release_mem_region(res->start, res_size(res));
+        platform_set_drvdata(pdev, NULL);
+        kfree(keypad);
+        return 0;
+}
+static struct platform_driver pxa27x_keypad_driver = {
+        .probe          = pxa27x_keypad_probe,
+        .remove         = __devexit_p(pxa27x_keypad_remove),
+        .suspend        = pxa27x_keypad_suspend,
+        .resume         = pxa27x_keypad_resume,
+        .driver         = {
+                .name   = "pxa27x-keypad",
+        },
+};
+static int __init pxa27x_keypad_init(void)
+{
+        return platform_driver_register(&pxa27x_keypad_driver);
+}
+static void __exit pxa27x_keypad_exit(void)
+{
+        platform_driver_unregister(&pxa27x_keypad_driver);
+}
+module_init(pxa27x_keypad_init);
+module_exit(pxa27x_keypad_exit);
+MODULE_DESCRIPTION("PXA27x Keypad Controller Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/keyboard/tosakbd.c b/drivers/input/keyboard/tosakbd.c
new file mode 100644
index 000000000000..3884d1e3f070
--- /dev/null
+++ b/drivers/input/keyboard/tosakbd.c
@@ -0,0 +1,415 @@
+/*
+ *  Keyboard driver for Sharp Tosa models (SL-6000x)
+ *
+ *  Copyright (c) 2005 Dirk Opfer
+ *  Copyright (c) 2007 Dmitry Baryshkov
+ *
+ *  Based on xtkbd.c/locomkbd.c/corgikbd.c
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 as
+ *  published by the Free Software Foundation.
+ *
+ */
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/input.h>
+#include <linux/delay.h>
+#include <linux/interrupt.h>
+#include <asm/arch/gpio.h>
+#include <asm/arch/tosa.h>
+#define KB_ROWMASK(r)           (1 << (r))
+#define SCANCODE(r, c)          (((r)<<4) + (c) + 1)
+#define NR_SCANCODES            SCANCODE(TOSA_KEY_SENSE_NUM - 1, TOSA_KEY_STROBE_NUM - 1) + 1
+#define SCAN_INTERVAL           (HZ/10)
+#define KB_DISCHARGE_DELAY      10
+#define KB_ACTIVATE_DELAY       10
+static unsigned int tosakbd_keycode[NR_SCANCODES] = {
+0,
+0, KEY_W, 0, 0, 0, KEY_K, KEY_BACKSPACE, KEY_P,
+0, 0, 0, 0, 0, 0, 0, 0,
+KEY_Q, KEY_E, KEY_T, KEY_Y, 0, KEY_O, KEY_I, KEY_COMMA,
+0, 0, 0, 0, 0, 0, 0, 0,
+KEY_A, KEY_D, KEY_G, KEY_U, 0, KEY_L, KEY_ENTER, KEY_DOT,
+0, 0, 0, 0, 0, 0, 0, 0,
+KEY_Z, KEY_C, KEY_V, KEY_J, TOSA_KEY_ADDRESSBOOK, TOSA_KEY_CANCEL, TOSA_KEY_CENTER, TOSA_KEY_OK,
+KEY_LEFTSHIFT, 0, 0, 0, 0, 0, 0, 0,
+KEY_S, KEY_R, KEY_B, KEY_N, TOSA_KEY_CALENDAR, TOSA_KEY_HOMEPAGE, KEY_LEFTCTRL, TOSA_KEY_LIGHT,
+0, KEY_RIGHTSHIFT, 0, 0, 0, 0, 0, 0,
+KEY_TAB, KEY_SLASH, KEY_H, KEY_M, TOSA_KEY_MENU, 0, KEY_UP, 0,
+0, 0, TOSA_KEY_FN, 0, 0, 0, 0, 0,
+KEY_X, KEY_F, KEY_SPACE, KEY_APOSTROPHE, TOSA_KEY_MAIL, KEY_LEFT, KEY_DOWN, KEY_RIGHT,
+0, 0, 0,
+};
+struct tosakbd {
+        unsigned int keycode[ARRAY_SIZE(tosakbd_keycode)];
+        struct input_dev *input;
+        spinlock_t lock; /* protect kbd scanning */
+        struct timer_list timer;
+};
+/* Helper functions for reading the keyboard matrix
+ * Note: We should really be using pxa_gpio_mode to alter GPDR but it
+ *       requires a function call per GPIO bit which is excessive
+ *       when we need to access 12 bits at once, multiple times.
+ * These functions must be called within local_irq_save()/local_irq_restore()
+ * or similar.
+ */
+#define GET_ROWS_STATUS(c)      ((GPLR2 & TOSA_GPIO_ALL_SENSE_BIT) >> TOSA_GPIO_ALL_SENSE_RSHIFT)
+static inline void tosakbd_discharge_all(void)
+{
+        /* STROBE All HiZ */
+        GPCR1  = TOSA_GPIO_HIGH_STROBE_BIT;
+        GPDR1 &= ~TOSA_GPIO_HIGH_STROBE_BIT;
+        GPCR2  = TOSA_GPIO_LOW_STROBE_BIT;
+        GPDR2 &= ~TOSA_GPIO_LOW_STROBE_BIT;
+}
+static inline void tosakbd_activate_all(void)
+{
+        /* STROBE ALL -> High */
+        GPSR1  = TOSA_GPIO_HIGH_STROBE_BIT;
+        GPDR1 |= TOSA_GPIO_HIGH_STROBE_BIT;
+        GPSR2  = TOSA_GPIO_LOW_STROBE_BIT;
+        GPDR2 |= TOSA_GPIO_LOW_STROBE_BIT;
+        udelay(KB_DISCHARGE_DELAY);
+        /* STATE CLEAR */
+        GEDR2 |= TOSA_GPIO_ALL_SENSE_BIT;
+}
+static inline void tosakbd_activate_col(int col)
+{
+        if (col <= 5) {
+                /* STROBE col -> High, not col -> HiZ */
+                GPSR1 = TOSA_GPIO_STROBE_BIT(col);
+                GPDR1 = (GPDR1 & ~TOSA_GPIO_HIGH_STROBE_BIT) | TOSA_GPIO_STROBE_BIT(col);
+        } else {
+                /* STROBE col -> High, not col -> HiZ */
+                GPSR2 = TOSA_GPIO_STROBE_BIT(col);
+                GPDR2 = (GPDR2 & ~TOSA_GPIO_LOW_STROBE_BIT) | TOSA_GPIO_STROBE_BIT(col);
+        }
+}
+static inline void tosakbd_reset_col(int col)
+{
+        if (col <= 5) {
+                /* STROBE col -> Low */
+                GPCR1 = TOSA_GPIO_STROBE_BIT(col);
+                /* STROBE col -> out, not col -> HiZ */
+                GPDR1 = (GPDR1 & ~TOSA_GPIO_HIGH_STROBE_BIT) | TOSA_GPIO_STROBE_BIT(col);
+        } else {
+                /* STROBE col -> Low */
+                GPCR2 = TOSA_GPIO_STROBE_BIT(col);
+                /* STROBE col -> out, not col -> HiZ */
+                GPDR2 = (GPDR2 & ~TOSA_GPIO_LOW_STROBE_BIT) | TOSA_GPIO_STROBE_BIT(col);
+        }
+}
+/*
+ * The tosa keyboard only generates interrupts when a key is pressed.
+ * So when a key is pressed, we enable a timer.  This timer scans the
+ * keyboard, and this is how we detect when the key is released.
+ */
+/* Scan the hardware keyboard and push any changes up through the input layer */
+static void tosakbd_scankeyboard(struct platform_device *dev)
+{
+        struct tosakbd *tosakbd = platform_get_drvdata(dev);
+        unsigned int row, col, rowd;
+        unsigned long flags;
+        unsigned int num_pressed = 0;
+        spin_lock_irqsave(&tosakbd->lock, flags);
+        for (col = 0; col < TOSA_KEY_STROBE_NUM; col++) {
+                /*
+                 * Discharge the output driver capacitatance
+                 * in the keyboard matrix. (Yes it is significant..)
+                 */
+                tosakbd_discharge_all();
+                udelay(KB_DISCHARGE_DELAY);
+                tosakbd_activate_col(col);
+                udelay(KB_ACTIVATE_DELAY);
+                rowd = GET_ROWS_STATUS(col);
+                for (row = 0; row < TOSA_KEY_SENSE_NUM; row++) {
+                        unsigned int scancode, pressed;
+                        scancode = SCANCODE(row, col);
+                        pressed = rowd & KB_ROWMASK(row);
+                        if (pressed && !tosakbd->keycode[scancode])
+                                dev_warn(&dev->dev,
+                                                "unhandled scancode: 0x%02x\n",
+                                                scancode);
+                        input_report_key(tosakbd->input,
+                                        tosakbd->keycode[scancode],
+                                        pressed);
+                        if (pressed)
+                                num_pressed++;
+                }
+                tosakbd_reset_col(col);
+        }
+        tosakbd_activate_all();
+        input_sync(tosakbd->input);
+        /* if any keys are pressed, enable the timer */
+        if (num_pressed)
+                mod_timer(&tosakbd->timer, jiffies + SCAN_INTERVAL);
+        spin_unlock_irqrestore(&tosakbd->lock, flags);
+}
+/*
+ * tosa keyboard interrupt handler.
+ */
+static irqreturn_t tosakbd_interrupt(int irq, void *__dev)
+{
+        struct platform_device *dev = __dev;
+        struct tosakbd *tosakbd = platform_get_drvdata(dev);
+        if (!timer_pending(&tosakbd->timer)) {
+                /** wait chattering delay **/
+                udelay(20);
+                tosakbd_scankeyboard(dev);
+        }
+        return IRQ_HANDLED;
+}
+/*
+ * tosa timer checking for released keys
+ */
+static void tosakbd_timer_callback(unsigned long __dev)
+{
+        struct platform_device *dev = (struct platform_device *)__dev;
+        tosakbd_scankeyboard(dev);
+}
+#ifdef CONFIG_PM
+static int tosakbd_suspend(struct platform_device *dev, pm_message_t state)
+{
+        struct tosakbd *tosakbd = platform_get_drvdata(dev);
+        del_timer_sync(&tosakbd->timer);
+        return 0;
+}
+static int tosakbd_resume(struct platform_device *dev)
+{
+        tosakbd_scankeyboard(dev);
+        return 0;
+}
+#else
+#define tosakbd_suspend         NULL
+#define tosakbd_resume          NULL
+#endif
+static int __devinit tosakbd_probe(struct platform_device *pdev) {
+        int i;
+        struct tosakbd *tosakbd;
+        struct input_dev *input_dev;
+        int error;
+        tosakbd = kzalloc(sizeof(struct tosakbd), GFP_KERNEL);
+        if (!tosakbd)
+                return -ENOMEM;
+        input_dev = input_allocate_device();
+        if (!input_dev) {
+                kfree(tosakbd);
+                return -ENOMEM;
+        }
+        platform_set_drvdata(pdev, tosakbd);
+        spin_lock_init(&tosakbd->lock);
+        /* Init Keyboard rescan timer */
+        init_timer(&tosakbd->timer);
+        tosakbd->timer.function = tosakbd_timer_callback;
+        tosakbd->timer.data = (unsigned long) pdev;
+        tosakbd->input = input_dev;
+        input_set_drvdata(input_dev, tosakbd);
+        input_dev->name = "Tosa Keyboard";
+        input_dev->phys = "tosakbd/input0";
+        input_dev->dev.parent = &pdev->dev;
+        input_dev->id.bustype = BUS_HOST;
+        input_dev->id.vendor = 0x0001;
+        input_dev->id.product = 0x0001;
+        input_dev->id.version = 0x0100;
+        input_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_REP);
+        input_dev->keycode = tosakbd->keycode;
+        input_dev->keycodesize = sizeof(unsigned int);
+        input_dev->keycodemax = ARRAY_SIZE(tosakbd_keycode);
+        memcpy(tosakbd->keycode, tosakbd_keycode, sizeof(tosakbd_keycode));
+        for (i = 0; i < ARRAY_SIZE(tosakbd_keycode); i++)
+                __set_bit(tosakbd->keycode[i], input_dev->keybit);
+        clear_bit(0, input_dev->keybit);
+        /* Setup sense interrupts - RisingEdge Detect, sense lines as inputs */
+        for (i = 0; i < TOSA_KEY_SENSE_NUM; i++) {
+                int gpio = TOSA_GPIO_KEY_SENSE(i);
+                int irq;
+                error = gpio_request(gpio, "tosakbd");
+                if (error < 0) {
+                        printk(KERN_ERR "tosakbd: failed to request GPIO %d, "
+                                " error %d\n", gpio, error);
+                        goto fail;
+                }
+                error = gpio_direction_input(TOSA_GPIO_KEY_SENSE(i));
+                if (error < 0) {
+                        printk(KERN_ERR "tosakbd: failed to configure input"
+                                " direction for GPIO %d, error %d\n",
+                                gpio, error);
+                        gpio_free(gpio);
+                        goto fail;
+                }
+                irq = gpio_to_irq(gpio);
+                if (irq < 0) {
+                        error = irq;
+                        printk(KERN_ERR "gpio-keys: Unable to get irq number"
+                                " for GPIO %d, error %d\n",
+                                gpio, error);
+                        gpio_free(gpio);
+                        goto fail;
+                }
+                error = request_irq(irq, tosakbd_interrupt,
+                                        IRQF_DISABLED | IRQF_TRIGGER_RISING,
+                                        "tosakbd", pdev);
+                if (error) {
+                        printk("tosakbd: Can't get IRQ: %d: error %d!\n",
+                                        irq, error);
+                        gpio_free(gpio);
+                        goto fail;
+                }
+        }
+        /* Set Strobe lines as outputs - set high */
+        for (i = 0; i < TOSA_KEY_STROBE_NUM; i++) {
+                int gpio = TOSA_GPIO_KEY_STROBE(i);
+                error = gpio_request(gpio, "tosakbd");
+                if (error < 0) {
+                        printk(KERN_ERR "tosakbd: failed to request GPIO %d, "
+                                " error %d\n", gpio, error);
+                        goto fail2;
+                }
+                error = gpio_direction_output(gpio, 1);
+                if (error < 0) {
+                        printk(KERN_ERR "tosakbd: failed to configure input"
+                                " direction for GPIO %d, error %d\n",
+                                gpio, error);
+                        gpio_free(gpio);
+                        goto fail;
+                }
+        }
+        error = input_register_device(input_dev);
+        if (error) {
+                printk(KERN_ERR "tosakbd: Unable to register input device, "
+                        "error: %d\n", error);
+                goto fail;
+        }
+        printk(KERN_INFO "input: Tosa Keyboard Registered\n");
+        return 0;
+fail2:
+        while (--i >= 0)
+                gpio_free(TOSA_GPIO_KEY_STROBE(i));
+        i = TOSA_KEY_SENSE_NUM;
+fail:
+        while (--i >= 0) {
+                free_irq(gpio_to_irq(TOSA_GPIO_KEY_SENSE(i)), pdev);
+                gpio_free(TOSA_GPIO_KEY_SENSE(i));
+        }
+        platform_set_drvdata(pdev, NULL);
+        input_free_device(input_dev);
+        kfree(tosakbd);
+        return error;
+}
+static int __devexit tosakbd_remove(struct platform_device *dev) {
+        int i;
+        struct tosakbd *tosakbd = platform_get_drvdata(dev);
+        for (i = 0; i < TOSA_KEY_STROBE_NUM; i++)
+                gpio_free(TOSA_GPIO_KEY_STROBE(i));
+        for (i = 0; i < TOSA_KEY_SENSE_NUM; i++) {
+                free_irq(gpio_to_irq(TOSA_GPIO_KEY_SENSE(i)), dev);
+                gpio_free(TOSA_GPIO_KEY_SENSE(i));
+        }
+        del_timer_sync(&tosakbd->timer);
+        input_unregister_device(tosakbd->input);
+        kfree(tosakbd);
+        return 0;
+}
+static struct platform_driver tosakbd_driver = {
+        .probe          = tosakbd_probe,
+        .remove         = __devexit_p(tosakbd_remove),
+        .suspend        = tosakbd_suspend,
+        .resume         = tosakbd_resume,
+        .driver         = {
+                .name   = "tosa-keyboard",
+        },
+};
+static int __devinit tosakbd_init(void)
+{
+        return platform_driver_register(&tosakbd_driver);
+}
+static void __exit tosakbd_exit(void)
+{
+        platform_driver_unregister(&tosakbd_driver);
+}
+module_init(tosakbd_init);
+module_exit(tosakbd_exit);
+MODULE_AUTHOR("Dirk Opfer <Dirk@Opfer-Online.de>");
+MODULE_DESCRIPTION("Tosa Keyboard Driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/input/misc/Kconfig b/drivers/input/misc/Kconfig
index 8f5c7b90187d..8b10d9f23bef 100644
--- a/drivers/input/misc/Kconfig
+++ b/drivers/input/misc/Kconfig
@@ -40,6 +40,20 @@ config INPUT_M68K_BEEP
        tristate "M68k Beeper support"
        depends on M68K
+config INPUT_APANEL
+        tristate "Fujitsu Lifebook Application Panel buttons"
+        depends on X86
+        select I2C_I801
+        select INPUT_POLLDEV
+        select CHECK_SIGNATURE
+        help
+         Say Y here for support of the Application Panel buttons, used on
+         Fujitsu Lifebook. These are attached to the mainboard through
+         an SMBus interface managed by the I2C Intel ICH (i801) driver.
+         To compile this driver as a module, choose M here: the module will
+         be called apanel.
 config INPUT_IXP4XX_BEEPER
        tristate "IXP4XX Beeper support"
        depends on ARCH_IXP4XX
diff --git a/drivers/input/misc/Makefile b/drivers/input/misc/Makefile
index 3585b5038418..ebd39f291d25 100644
--- a/drivers/input/misc/Makefile
+++ b/drivers/input/misc/Makefile
@@ -18,3 +18,4 @@ obj-$(CONFIG_INPUT_POWERMATE)		+= powermate.o
 obj-$(CONFIG_INPUT_YEALINK)             += yealink.o
 obj-$(CONFIG_HP_SDC_RTC)                += hp_sdc_rtc.o
 obj-$(CONFIG_INPUT_UINPUT)              += uinput.o
+obj-$(CONFIG_INPUT_APANEL)              += apanel.o
diff --git a/drivers/input/misc/apanel.c b/drivers/input/misc/apanel.c
new file mode 100644
index 000000000000..9531d8c7444f
--- /dev/null
+++ b/drivers/input/misc/apanel.c
@@ -0,0 +1,378 @@
+/*
+ *  Fujitsu Lifebook Application Panel button drive
+ *
+ *  Copyright (C) 2007 Stephen Hemminger <shemminger@linux-foundation.org>
+ *  Copyright (C) 2001-2003 Jochen Eisinger <jochen@penguin-breeder.org>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published by
+ * the Free Software Foundation.
+ *
+ * Many Fujitsu Lifebook laptops have a small panel of buttons that are
+ * accessible via the i2c/smbus interface. This driver polls those
+ * buttons and generates input events.
+ *
+ * For more details see:
+ *      http://apanel.sourceforge.net/tech.php
+ */
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/ioport.h>
+#include <linux/io.h>
+#include <linux/module.h>
+#include <linux/input-polldev.h>
+#include <linux/i2c.h>
+#include <linux/workqueue.h>
+#include <linux/leds.h>
+#define APANEL_NAME     "Fujitsu Application Panel"
+#define APANEL_VERSION  "1.3.1"
+#define APANEL          "apanel"
+/* How often we poll keys - msecs */
+#define POLL_INTERVAL_DEFAULT   1000
+/* Magic constants in BIOS that tell about buttons */
+enum apanel_devid {
+        APANEL_DEV_NONE   = 0,
+        APANEL_DEV_APPBTN = 1,
+        APANEL_DEV_CDBTN  = 2,
+        APANEL_DEV_LCD    = 3,
+        APANEL_DEV_LED    = 4,
+        APANEL_DEV_MAX,
+};
+enum apanel_chip {
+        CHIP_NONE    = 0,
+        CHIP_OZ992C  = 1,
+        CHIP_OZ163T  = 2,
+        CHIP_OZ711M3 = 4,
+};
+/* Result of BIOS snooping/probing -- what features are supported */
+static enum apanel_chip device_chip[APANEL_DEV_MAX];
+#define MAX_PANEL_KEYS  12
+struct apanel {
+        struct input_polled_dev *ipdev;
+        struct i2c_client client;
+        unsigned short keymap[MAX_PANEL_KEYS];
+        u16    nkeys;
+        u16    led_bits;
+        struct work_struct led_work;
+        struct led_classdev mail_led;
+};
+static int apanel_probe(struct i2c_adapter *, int, int);
+/* for now, we only support one address */
+static unsigned short normal_i2c[] = {0, I2C_CLIENT_END};
+static unsigned short ignore = I2C_CLIENT_END;
+static struct i2c_client_address_data addr_data = {
+        .normal_i2c     = normal_i2c,
+        .probe          = &ignore,
+        .ignore         = &ignore,
+};
+static void report_key(struct input_dev *input, unsigned keycode)
+{
+        pr_debug(APANEL ": report key %#x\n", keycode);
+        input_report_key(input, keycode, 1);
+        input_sync(input);
+        input_report_key(input, keycode, 0);
+        input_sync(input);
+}
+/* Poll for key changes
+ *
+ * Read Application keys via SMI
+ *  A (0x4), B (0x8), Internet (0x2), Email (0x1).
+ *
+ * CD keys:
+ * Forward (0x100), Rewind (0x200), Stop (0x400), Pause (0x800)
+ */
+static void apanel_poll(struct input_polled_dev *ipdev)
+{
+        struct apanel *ap = ipdev->private;
+        struct input_dev *idev = ipdev->input;
+        u8 cmd = device_chip[APANEL_DEV_APPBTN] == CHIP_OZ992C ? 0 : 8;
+        s32 data;
+        int i;
+        data = i2c_smbus_read_word_data(&ap->client, cmd);
+        if (data < 0)
+                return; /* ignore errors (due to ACPI??) */
+        /* write back to clear latch */
+        i2c_smbus_write_word_data(&ap->client, cmd, 0);
+        if (!data)
+                return;
+        dev_dbg(&idev->dev, APANEL ": data %#x\n", data);
+        for (i = 0; i < idev->keycodemax; i++)
+                if ((1u << i) & data)
+                        report_key(idev, ap->keymap[i]);
+}
+/* Track state changes of LED */
+static void led_update(struct work_struct *work)
+{
+        struct apanel *ap = container_of(work, struct apanel, led_work);
+        i2c_smbus_write_word_data(&ap->client, 0x10, ap->led_bits);
+}
+static void mail_led_set(struct led_classdev *led,
+                         enum led_brightness value)
+{
+        struct apanel *ap = container_of(led, struct apanel, mail_led);
+        if (value != LED_OFF)
+                ap->led_bits |= 0x8000;
+        else
+                ap->led_bits &= ~0x8000;
+        schedule_work(&ap->led_work);
+}
+static int apanel_detach_client(struct i2c_client *client)
+{
+        struct apanel *ap = i2c_get_clientdata(client);
+        if (device_chip[APANEL_DEV_LED] != CHIP_NONE)
+                led_classdev_unregister(&ap->mail_led);
+        input_unregister_polled_device(ap->ipdev);
+        i2c_detach_client(&ap->client);
+        input_free_polled_device(ap->ipdev);
+        return 0;
+}
+/* Function is invoked for every i2c adapter. */
+static int apanel_attach_adapter(struct i2c_adapter *adap)
+{
+        dev_dbg(&adap->dev, APANEL ": attach adapter id=%d\n", adap->id);
+        /* Our device is connected only to i801 on laptop */
+        if (adap->id != I2C_HW_SMBUS_I801)
+                return -ENODEV;
+        return i2c_probe(adap, &addr_data, apanel_probe);
+}
+static void apanel_shutdown(struct i2c_client *client)
+{
+        apanel_detach_client(client);
+}
+static struct i2c_driver apanel_driver = {
+        .driver = {
+                .name = APANEL,
+        },
+        .attach_adapter = &apanel_attach_adapter,
+        .detach_client  = &apanel_detach_client,
+        .shutdown       = &apanel_shutdown,
+};
+static struct apanel apanel = {
+        .client = {
+                .driver = &apanel_driver,
+                .name   = APANEL,
+        },
+        .keymap = {
+                [0] = KEY_MAIL,
+                [1] = KEY_WWW,
+                [2] = KEY_PROG2,
+                [3] = KEY_PROG1,
+                [8] = KEY_FORWARD,
+                [9] = KEY_REWIND,
+                [10] = KEY_STOPCD,
+                [11] = KEY_PLAYPAUSE,
+        },
+        .mail_led = {
+                .name = "mail:blue",
+                .brightness_set = mail_led_set,
+        },
+};
+/* NB: Only one panel on the i2c. */
+static int apanel_probe(struct i2c_adapter *bus, int address, int kind)
+{
+        struct apanel *ap;
+        struct input_polled_dev *ipdev;
+        struct input_dev *idev;
+        u8 cmd = device_chip[APANEL_DEV_APPBTN] == CHIP_OZ992C ? 0 : 8;
+        int i, err = -ENOMEM;
+        dev_dbg(&bus->dev, APANEL ": probe adapter %p addr %d kind %d\n",
+                bus, address, kind);
+        ap = &apanel;
+        ipdev = input_allocate_polled_device();
+        if (!ipdev)
+                goto out1;
+        ap->ipdev = ipdev;
+        ap->client.adapter = bus;
+        ap->client.addr = address;
+        i2c_set_clientdata(&ap->client, ap);
+        err = i2c_attach_client(&ap->client);
+        if (err)
+                goto out2;
+        err = i2c_smbus_write_word_data(&ap->client, cmd, 0);
+        if (err) {
+                dev_warn(&ap->client.dev, APANEL ": smbus write error %d\n",
+                         err);
+                goto out3;
+        }
+        ipdev->poll = apanel_poll;
+        ipdev->poll_interval = POLL_INTERVAL_DEFAULT;
+        ipdev->private = ap;
+        idev = ipdev->input;
+        idev->name = APANEL_NAME " buttons";
+        idev->phys = "apanel/input0";
+        idev->id.bustype = BUS_HOST;
+        idev->dev.parent = &ap->client.dev;
+        set_bit(EV_KEY, idev->evbit);
+        idev->keycode = ap->keymap;
+        idev->keycodesize = sizeof(ap->keymap[0]);
+        idev->keycodemax = (device_chip[APANEL_DEV_CDBTN] != CHIP_NONE) ? 12 : 4;
+        for (i = 0; i < idev->keycodemax; i++)
+                if (ap->keymap[i])
+                        set_bit(ap->keymap[i], idev->keybit);
+        err = input_register_polled_device(ipdev);
+        if (err)
+                goto out3;
+        INIT_WORK(&ap->led_work, led_update);
+        if (device_chip[APANEL_DEV_LED] != CHIP_NONE) {
+                err = led_classdev_register(&ap->client.dev, &ap->mail_led);
+                if (err)
+                        goto out4;
+        }
+        return 0;
+out4:
+        input_unregister_polled_device(ipdev);
+out3:
+        i2c_detach_client(&ap->client);
+out2:
+        input_free_polled_device(ipdev);
+out1:
+        return err;
+}
+/* Scan the system ROM for the signature "FJKEYINF" */
+static __init const void __iomem *bios_signature(const void __iomem *bios)
+{
+        ssize_t offset;
+        const unsigned char signature[] = "FJKEYINF";
+        for (offset = 0; offset < 0x10000; offset += 0x10) {
+                if (check_signature(bios + offset, signature,
+                                    sizeof(signature)-1))
+                        return bios + offset;
+        }
+        pr_notice(APANEL ": Fujitsu BIOS signature '%s' not found...\n",
+                  signature);
+        return NULL;
+}
+static int __init apanel_init(void)
+{
+        void __iomem *bios;
+        const void __iomem *p;
+        u8 devno;
+        int found = 0;
+        bios = ioremap(0xF0000, 0x10000); /* Can't fail */
+        p = bios_signature(bios);
+        if (!p) {
+                iounmap(bios);
+                return -ENODEV;
+        }
+        /* just use the first address */
+        p += 8;
+        normal_i2c[0] = readb(p+3) >> 1;
+        for ( ; (devno = readb(p)) & 0x7f; p += 4) {
+                unsigned char method, slave, chip;
+                method = readb(p + 1);
+                chip = readb(p + 2);
+                slave = readb(p + 3) >> 1;
+                if (slave != normal_i2c[0]) {
+                        pr_notice(APANEL ": only one SMBus slave "
+                                  "address supported, skiping device...\n");
+                        continue;
+                }
+                /* translate alternative device numbers */
+                switch (devno) {
+                case 6:
+                        devno = APANEL_DEV_APPBTN;
+                        break;
+                case 7:
+                        devno = APANEL_DEV_LED;
+                        break;
+                }
+                if (devno >= APANEL_DEV_MAX)
+                        pr_notice(APANEL ": unknown device %u found\n", devno);
+                else if (device_chip[devno] != CHIP_NONE)
+                        pr_warning(APANEL ": duplicate entry for devno %u\n", devno);
+                else if (method != 1 && method != 2 && method != 4) {
+                        pr_notice(APANEL ": unknown method %u for devno %u\n",
+                                  method, devno);
+                } else {
+                        device_chip[devno] = (enum apanel_chip) chip;
+                        ++found;
+                }
+        }
+        iounmap(bios);
+        if (found == 0) {
+                pr_info(APANEL ": no input devices reported by BIOS\n");
+                return -EIO;
+        }
+        return i2c_add_driver(&apanel_driver);
+}
+module_init(apanel_init);
+static void __exit apanel_cleanup(void)
+{
+        i2c_del_driver(&apanel_driver);
+}
+module_exit(apanel_cleanup);
+MODULE_AUTHOR("Stephen Hemminger <shemminger@linux-foundation.org>");
+MODULE_DESCRIPTION(APANEL_NAME " driver");
+MODULE_LICENSE("GPL");
+MODULE_VERSION(APANEL_VERSION);
+MODULE_ALIAS("dmi:*:svnFUJITSU:pnLifeBook*:pvr*:rvnFUJITSU:*");
+MODULE_ALIAS("dmi:*:svnFUJITSU:pnLifebook*:pvr*:rvnFUJITSU:*");
diff --git a/drivers/input/misc/ati_remote.c b/drivers/input/misc/ati_remote.c
index 3a7937481ad8..f3b86c2b0797 100644
--- a/drivers/input/misc/ati_remote.c
+++ b/drivers/input/misc/ati_remote.c
@@ -90,7 +90,6 @@
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/module.h>
-#include <linux/moduleparam.h>
 #include <linux/usb/input.h>
 #include <linux/wait.h>
 #include <linux/jiffies.h>
diff --git a/drivers/input/misc/atlas_btns.c b/drivers/input/misc/atlas_btns.c
index 4e3ad657ed80..1b871917340a 100644
--- a/drivers/input/misc/atlas_btns.c
+++ b/drivers/input/misc/atlas_btns.c
@@ -29,9 +29,10 @@
 #include <asm/uaccess.h>
 #include <acpi/acpi_drivers.h>
-#define ACPI_ATLAS_NAME                 "Atlas ACPI"
+#define ACPI_ATLAS_NAME         "Atlas ACPI"
-#define ACPI_ATLAS_CLASS                "Atlas"
+#define ACPI_ATLAS_CLASS        "Atlas"
+static unsigned short atlas_keymap[16];
 static struct input_dev *input_dev;
 /* button handling code */
@@ -50,12 +51,15 @@ static acpi_status acpi_atlas_button_handler(u32 function,
                      void *handler_context, void *region_context)
 {
        acpi_status status;
-        int keycode;
        if (function == ACPI_WRITE) {
-                keycode = KEY_F1 + (address & 0x0F);
+                int code = address & 0x0f;
-                input_report_key(input_dev, keycode, !(address & 0x10));
+                int key_down = !(address & 0x10);
+                input_event(input_dev, EV_MSC, MSC_SCAN, code);
+                input_report_key(input_dev, atlas_keymap[code], key_down);
                input_sync(input_dev);
                status = 0;
        } else {
                printk(KERN_WARNING "atlas: shrugged on unexpected function"
@@ -70,6 +74,7 @@ static acpi_status acpi_atlas_button_handler(u32 function,
 static int atlas_acpi_button_add(struct acpi_device *device)
 {
        acpi_status status;
+        int i;
        int err;
        input_dev = input_allocate_device();
@@ -81,17 +86,19 @@ static int atlas_acpi_button_add(struct acpi_device *device)
        input_dev->name = "Atlas ACPI button driver";
        input_dev->phys = "ASIM0000/atlas/input0";
        input_dev->id.bustype = BUS_HOST;
-        input_dev->evbit[BIT_WORD(EV_KEY)] = BIT_MASK(EV_KEY);
+        input_dev->keycode = atlas_keymap;
+        input_dev->keycodesize = sizeof(unsigned short);
-        set_bit(KEY_F1, input_dev->keybit);
+        input_dev->keycodemax = ARRAY_SIZE(atlas_keymap);
-        set_bit(KEY_F2, input_dev->keybit);
-        set_bit(KEY_F3, input_dev->keybit);
+        input_set_capability(input_dev, EV_MSC, MSC_SCAN);
-        set_bit(KEY_F4, input_dev->keybit);
+        __set_bit(EV_KEY, input_dev->evbit);
-        set_bit(KEY_F5, input_dev->keybit);
+        for (i = 0; i < ARRAY_SIZE(atlas_keymap); i++) {
-        set_bit(KEY_F6, input_dev->keybit);
+                if (i < 9) {
-        set_bit(KEY_F7, input_dev->keybit);
+                        atlas_keymap[i] = KEY_F1 + i;
-        set_bit(KEY_F8, input_dev->keybit);
+                        __set_bit(KEY_F1 + i, input_dev->keybit);
-        set_bit(KEY_F9, input_dev->keybit);
+                } else
+                        atlas_keymap[i] = KEY_RESERVED;
+        }
        err = input_register_device(input_dev);
        if (err) {
diff --git a/drivers/input/misc/cobalt_btns.c b/drivers/input/misc/cobalt_btns.c
index 1aef97ed5e84..4833b1a82623 100644
--- a/drivers/input/misc/cobalt_btns.c
+++ b/drivers/input/misc/cobalt_btns.c
@@ -27,55 +27,48 @@
 #define BUTTONS_COUNT_THRESHOLD 3
 #define BUTTONS_STATUS_MASK     0xfe000000
+static const unsigned short cobalt_map[] = {
+        KEY_RESERVED,
+        KEY_RESTART,
+        KEY_LEFT,
+        KEY_UP,
+        KEY_DOWN,
+        KEY_RIGHT,
+        KEY_ENTER,
+        KEY_SELECT
+};
 struct buttons_dev {
        struct input_polled_dev *poll_dev;
+        unsigned short keymap[ARRAY_SIZE(cobalt_map)];
+        int count[ARRAY_SIZE(cobalt_map)];
        void __iomem *reg;
 };
-struct buttons_map {
-        uint32_t mask;
-        int keycode;
-        int count;
-};
-static struct buttons_map buttons_map[] = {
-        { 0x02000000, KEY_RESTART, },
-        { 0x04000000, KEY_LEFT, },
-        { 0x08000000, KEY_UP, },
-        { 0x10000000, KEY_DOWN, },
-        { 0x20000000, KEY_RIGHT, },
-        { 0x40000000, KEY_ENTER, },
-        { 0x80000000, KEY_SELECT, },
-};
 static void handle_buttons(struct input_polled_dev *dev)
 {
-        struct buttons_map *button = buttons_map;
        struct buttons_dev *bdev = dev->private;
        struct input_dev *input = dev->input;
        uint32_t status;
        int i;
-        status = readl(bdev->reg);
+        status = ~readl(bdev->reg) >> 24;
-        status = ~status & BUTTONS_STATUS_MASK;
-        for (i = 0; i < ARRAY_SIZE(buttons_map); i++) {
+        for (i = 0; i < ARRAY_SIZE(bdev->keymap); i++) {
-                if (status & button->mask) {
+                if (status & (1UL << i)) {
-                        button->count++;
+                        if (++bdev->count[i] == BUTTONS_COUNT_THRESHOLD) {
+                                input_event(input, EV_MSC, MSC_SCAN, i);
+                                input_report_key(input, bdev->keymap[i], 1);
+                                input_sync(input);
+                        }
                } else {
-                        if (button->count >= BUTTONS_COUNT_THRESHOLD) {
+                        if (bdev->count[i] >= BUTTONS_COUNT_THRESHOLD) {
-                                input_report_key(input, button->keycode, 0);
+                                input_event(input, EV_MSC, MSC_SCAN, i);
+                                input_report_key(input, bdev->keymap[i], 0);
                                input_sync(input);
                        }
-                        button->count = 0;
+                        bdev->count[i] = 0;
-                }
-                if (button->count == BUTTONS_COUNT_THRESHOLD) {
-                        input_report_key(input, button->keycode, 1);
-                        input_sync(input);
                }
-                button++;
        }
 }
@@ -94,6 +87,8 @@ static int __devinit cobalt_buttons_probe(struct platform_device *pdev)
                goto err_free_mem;
        }
+        memcpy(bdev->keymap, cobalt_map, sizeof(bdev->keymap));
        poll_dev->private = bdev;
        poll_dev->poll = handle_buttons;
        poll_dev->poll_interval = BUTTONS_POLL_INTERVAL;
@@ -104,11 +99,15 @@ static int __devinit cobalt_buttons_probe(struct platform_device *pdev)
        input->id.bustype = BUS_HOST;
        input->cdev.dev = &pdev->dev;
-        input->evbit[0] = BIT_MASK(EV_KEY);
+        input->keycode = pdev->keymap;
-        for (i = 0; i < ARRAY_SIZE(buttons_map); i++) {
+        input->keycodemax = ARRAY_SIZE(pdev->keymap);
-                set_bit(buttons_map[i].keycode, input->keybit);
+        input->keycodesize = sizeof(unsigned short);
-                buttons_map[i].count = 0;
-        }
+        input_set_capability(input, EV_MSC, MSC_SCAN);
+        __set_bit(EV_KEY, input->evbit);
+        for (i = 0; i < ARRAY_SIZE(buttons_map); i++)
+                __set_bit(input->keycode[i], input->keybit);
+        __clear_bit(KEY_RESERVED, input->keybit);
        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
        if (!res) {
diff --git a/drivers/input/misc/keyspan_remote.c b/drivers/input/misc/keyspan_remote.c
index fd74347047dd..952938a8e991 100644
--- a/drivers/input/misc/keyspan_remote.c
+++ b/drivers/input/misc/keyspan_remote.c
@@ -16,7 +16,6 @@
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/module.h>
-#include <linux/moduleparam.h>
 #include <linux/usb/input.h>
 #define DRIVER_VERSION  "v0.1"
@@ -46,53 +45,12 @@ MODULE_PARM_DESC(debug, "Enable extra debug messages and information");
 #define RECV_SIZE       8       /* The UIA-11 type have a 8 byte limit. */
-/* table of devices that work with this driver */
-static struct usb_device_id keyspan_table[] = {
-        { USB_DEVICE(USB_KEYSPAN_VENDOR_ID, USB_KEYSPAN_PRODUCT_UIA11) },
-        { }                                     /* Terminating entry */
-};
-/* Structure to store all the real stuff that a remote sends to us. */
-struct keyspan_message {
-        u16     system;
-        u8      button;
-        u8      toggle;
-};
-/* Structure used for all the bit testing magic needed to be done. */
-struct bit_tester {
-        u32     tester;
-        int     len;
-        int     pos;
-        int     bits_left;
-        u8      buffer[32];
-};
-/* Structure to hold all of our driver specific stuff */
-struct usb_keyspan {
-        char                            name[128];
-        char                            phys[64];
-        struct usb_device*              udev;
-        struct input_dev                *input;
-        struct usb_interface*           interface;
-        struct usb_endpoint_descriptor* in_endpoint;
-        struct urb*                     irq_urb;
-        int                             open;
-        dma_addr_t                      in_dma;
-        unsigned char*                  in_buffer;
-        /* variables used to parse messages from remote. */
-        struct bit_tester               data;
-        int                             stage;
-        int                             toggle;
-};
 /*
 * Table that maps the 31 possible keycodes to input keys.
 * Currently there are 15 and 17 button models so RESERVED codes
 * are blank areas in the mapping.
 */
-static const int keyspan_key_table[] = {
+static const unsigned short keyspan_key_table[] = {
        KEY_RESERVED,           /* 0 is just a place holder. */
        KEY_RESERVED,
        KEY_STOP,
@@ -127,6 +85,48 @@ static const int keyspan_key_table[] = {
        KEY_MENU
 };
+/* table of devices that work with this driver */
+static struct usb_device_id keyspan_table[] = {
+        { USB_DEVICE(USB_KEYSPAN_VENDOR_ID, USB_KEYSPAN_PRODUCT_UIA11) },
+        { }                                     /* Terminating entry */
+};
+/* Structure to store all the real stuff that a remote sends to us. */
+struct keyspan_message {
+        u16     system;
+        u8      button;
+        u8      toggle;
+};
+/* Structure used for all the bit testing magic needed to be done. */
+struct bit_tester {
+        u32     tester;
+        int     len;
+        int     pos;
+        int     bits_left;
+        u8      buffer[32];
+};
+/* Structure to hold all of our driver specific stuff */
+struct usb_keyspan {
+        char                            name[128];
+        char                            phys[64];
+        unsigned short                  keymap[ARRAY_SIZE(keyspan_key_table)];
+        struct usb_device               *udev;
+        struct input_dev                *input;
+        struct usb_interface            *interface;
+        struct usb_endpoint_descriptor  *in_endpoint;
+        struct urb*                     irq_urb;
+        int                             open;
+        dma_addr_t                      in_dma;
+        unsigned char                   *in_buffer;
+        /* variables used to parse messages from remote. */
+        struct bit_tester               data;
+        int                             stage;
+        int                             toggle;
+};
 static struct usb_driver keyspan_driver;
 /*
@@ -173,6 +173,15 @@ static int keyspan_load_tester(struct usb_keyspan* dev, int bits_needed)
        return 0;
 }
+static void keyspan_report_button(struct usb_keyspan *remote, int button, int press)
+{
+        struct input_dev *input = remote->input;
+        input_event(input, EV_MSC, MSC_SCAN, button);
+        input_report_key(input, remote->keymap[button], press);
+        input_sync(input);
+}
 /*
 * Routine that handles all the logic needed to parse out the message from the remote.
 */
@@ -311,9 +320,8 @@ static void keyspan_check_data(struct usb_keyspan *remote)
                        __FUNCTION__, message.system, message.button, message.toggle);
                if (message.toggle != remote->toggle) {
-                        input_report_key(remote->input, keyspan_key_table[message.button], 1);
+                        keyspan_report_button(remote, message.button, 1);
-                        input_report_key(remote->input, keyspan_key_table[message.button], 0);
+                        keyspan_report_button(remote, message.button, 0);
-                        input_sync(remote->input);
                        remote->toggle = message.toggle;
                }
@@ -491,16 +499,21 @@ static int keyspan_probe(struct usb_interface *interface, const struct usb_devic
        usb_make_path(udev, remote->phys, sizeof(remote->phys));
        strlcat(remote->phys, "/input0", sizeof(remote->phys));
+        memcpy(remote->keymap, keyspan_key_table, sizeof(remote->keymap));
        input_dev->name = remote->name;
        input_dev->phys = remote->phys;
        usb_to_input_id(udev, &input_dev->id);
        input_dev->dev.parent = &interface->dev;
+        input_dev->keycode = remote->keymap;
+        input_dev->keycodesize = sizeof(unsigned short);
+        input_dev->keycodemax = ARRAY_SIZE(remote->keymap);
-        input_dev->evbit[0] = BIT_MASK(EV_KEY);         /* We will only report KEY events. */
+        input_set_capability(input_dev, EV_MSC, MSC_SCAN);
+        __set_bit(EV_KEY, input_dev->evbit);
        for (i = 0; i < ARRAY_SIZE(keyspan_key_table); i++)
-                if (keyspan_key_table[i] != KEY_RESERVED)
+                __set_bit(keyspan_key_table[i], input_dev->keybit);
-                        set_bit(keyspan_key_table[i], input_dev->keybit);
+        __clear_bit(KEY_RESERVED, input_dev->keybit);
        input_set_drvdata(input_dev, remote);
@@ -508,12 +521,14 @@ static int keyspan_probe(struct usb_interface *interface, const struct usb_devic
        input_dev->close = keyspan_close;
        /*
-         * Initialize the URB to access the device. The urb gets sent to the device in keyspan_open()
+         * Initialize the URB to access the device.
+         * The urb gets sent to the device in keyspan_open()
         */
        usb_fill_int_urb(remote->irq_urb,
-                         remote->udev, usb_rcvintpipe(remote->udev, remote->in_endpoint->bEndpointAddress),
+                         remote->udev,
+                         usb_rcvintpipe(remote->udev, endpoint->bEndpointAddress),
                         remote->in_buffer, RECV_SIZE, keyspan_irq_recv, remote,
-                         remote->in_endpoint->bInterval);
+                         endpoint->bInterval);
        remote->irq_urb->transfer_dma = remote->in_dma;
        remote->irq_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
diff --git a/drivers/input/mouse/inport.c b/drivers/input/mouse/inport.c
index 26ec09529b51..06c35fc553c0 100644
--- a/drivers/input/mouse/inport.c
+++ b/drivers/input/mouse/inport.c
@@ -35,7 +35,6 @@
 */
 #include <linux/module.h>
-#include <linux/moduleparam.h>
 #include <linux/ioport.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
diff --git a/drivers/input/mouse/logibm.c b/drivers/input/mouse/logibm.c
index 37e7c75b43bd..9ea895593b27 100644
--- a/drivers/input/mouse/logibm.c
+++ b/drivers/input/mouse/logibm.c
@@ -36,7 +36,6 @@
 */
 #include <linux/module.h>
-#include <linux/moduleparam.h>
 #include <linux/delay.h>
 #include <linux/ioport.h>
 #include <linux/init.h>
diff --git a/drivers/input/mouse/psmouse-base.c b/drivers/input/mouse/psmouse-base.c
index b8628252e10c..f5a6be1d3c46 100644
--- a/drivers/input/mouse/psmouse-base.c
+++ b/drivers/input/mouse/psmouse-base.c
@@ -13,7 +13,6 @@
 #include <linux/delay.h>
 #include <linux/module.h>
-#include <linux/moduleparam.h>
 #include <linux/slab.h>
 #include <linux/interrupt.h>
 #include <linux/input.h>
diff --git a/drivers/input/mouse/trackpoint.c b/drivers/input/mouse/trackpoint.c
index 9ab5b5ea809d..26b845fc186a 100644
--- a/drivers/input/mouse/trackpoint.c
+++ b/drivers/input/mouse/trackpoint.c
@@ -11,7 +11,6 @@
 #include <linux/delay.h>
 #include <linux/serio.h>
 #include <linux/module.h>
-#include <linux/moduleparam.h>
 #include <linux/input.h>
 #include <linux/libps2.h>
 #include <linux/proc_fs.h>
diff --git a/drivers/input/mousedev.c b/drivers/input/mousedev.c
index be83516c776c..bbbe5e81adc1 100644
--- a/drivers/input/mousedev.c
+++ b/drivers/input/mousedev.c
@@ -16,7 +16,6 @@
 #include <linux/slab.h>
 #include <linux/poll.h>
 #include <linux/module.h>
-#include <linux/moduleparam.h>
 #include <linux/init.h>
 #include <linux/input.h>
 #include <linux/random.h>
@@ -1033,7 +1032,7 @@ static const struct input_device_id mousedev_ids[] = {
                .flags = INPUT_DEVICE_ID_MATCH_EVBIT |
                        INPUT_DEVICE_ID_MATCH_KEYBIT |
                        INPUT_DEVICE_ID_MATCH_ABSBIT,
-                .evbit = { BIT(EV_KEY) | BIT(EV_ABS) | BIT(EV_SYN) },
+                .evbit = { BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS) },
                .keybit = { [BIT_WORD(BTN_LEFT)] = BIT_MASK(BTN_LEFT) },
                .absbit = { BIT_MASK(ABS_X) | BIT_MASK(ABS_Y) },
        },      /* Mouse-like device with absolute X and Y but ordinary
diff --git a/drivers/input/serio/i8042-x86ia64io.h b/drivers/input/serio/i8042-x86ia64io.h
index c5e68dcd88ac..662e84482c26 100644
--- a/drivers/input/serio/i8042-x86ia64io.h
+++ b/drivers/input/serio/i8042-x86ia64io.h
@@ -63,7 +63,7 @@ static inline void i8042_write_command(int val)
        outb(val, I8042_COMMAND_REG);
 }
-#if defined(__i386__)
+#if defined(__i386__) || defined(__x86_64__)
 #include <linux/dmi.h>
@@ -186,6 +186,13 @@ static struct dmi_system_id __initdata i8042_dmi_nomux_table[] = {
                },
        },
        {
+                .ident = "Fujitsu-Siemens Amilo Pro 2010",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Pro V2010"),
+                },
+        },
+        {
                /*
                 * No data is coming from the touchscreen unless KBC
                 * is in legacy mode.
@@ -277,6 +284,57 @@ static struct dmi_system_id __initdata i8042_dmi_nomux_table[] = {
 #endif
+#ifdef CONFIG_X86
+#include <linux/dmi.h>
+/*
+ * Some Wistron based laptops need us to explicitly enable the 'Dritek
+ * keyboard extension' to make their extra keys start generating scancodes.
+ * Originally, this was just confined to older laptops, but a few Acer laptops
+ * have turned up in 2007 that also need this again.
+ */
+static struct dmi_system_id __initdata i8042_dmi_dritek_table[] = {
+        {
+                .ident = "Acer Aspire 5630",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5630"),
+                },
+        },
+        {
+                .ident = "Acer Aspire 5650",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5650"),
+                },
+        },
+        {
+                .ident = "Acer Aspire 5680",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5680"),
+                },
+        },
+        {
+                .ident = "Acer Aspire 9110",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 9110"),
+                },
+        },
+        {
+                .ident = "Acer TravelMate 2490",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 2490"),
+                },
+        },
+        { }
+};
+#endif /* CONFIG_X86 */
 #ifdef CONFIG_PNP
 #include <linux/pnp.h>
@@ -512,7 +570,7 @@ static int __init i8042_platform_init(void)
        i8042_reset = 1;
 #endif
-#if defined(__i386__)
+#if defined(__i386__) || defined(__x86_64__)
        if (dmi_check_system(i8042_dmi_noloop_table))
                i8042_noloop = 1;
@@ -520,6 +578,11 @@ static int __init i8042_platform_init(void)
                i8042_nomux = 1;
 #endif
+#ifdef CONFIG_X86
+        if (dmi_check_system(i8042_dmi_dritek_table))
+                i8042_dritek = 1;
+#endif /* CONFIG_X86 */
        return retval;
 }
diff --git a/drivers/input/serio/i8042.c b/drivers/input/serio/i8042.c
index 1a0cea3c5294..2763394869d2 100644
--- a/drivers/input/serio/i8042.c
+++ b/drivers/input/serio/i8042.c
@@ -12,7 +12,6 @@
 #include <linux/delay.h>
 #include <linux/module.h>
-#include <linux/moduleparam.h>
 #include <linux/interrupt.h>
 #include <linux/ioport.h>
 #include <linux/init.h>
@@ -64,6 +63,12 @@ static unsigned int i8042_blink_frequency = 500;
 module_param_named(panicblink, i8042_blink_frequency, uint, 0600);
 MODULE_PARM_DESC(panicblink, "Frequency with which keyboard LEDs should blink when kernel panics");
+#ifdef CONFIG_X86
+static unsigned int i8042_dritek;
+module_param_named(dritek, i8042_dritek, bool, 0);
+MODULE_PARM_DESC(dritek, "Force enable the Dritek keyboard extension");
+#endif
 #ifdef CONFIG_PNP
 static int i8042_nopnp;
 module_param_named(nopnp, i8042_nopnp, bool, 0);
@@ -280,7 +285,14 @@ static void i8042_stop(struct serio *serio)
        struct i8042_port *port = serio->port_data;
        port->exists = 0;
-        synchronize_sched();
+        /*
+         * We synchronize with both AUX and KBD IRQs because there is
+         * a (very unlikely) chance that AUX IRQ is raised for KBD port
+         * and vice versa.
+         */
+        synchronize_irq(I8042_AUX_IRQ);
+        synchronize_irq(I8042_KBD_IRQ);
        port->serio = NULL;
 }
@@ -1139,6 +1151,7 @@ static int __devinit i8042_setup_kbd(void)
 static int __devinit i8042_probe(struct platform_device *dev)
 {
        int error;
+        char param;
        error = i8042_controller_selftest();
        if (error)
@@ -1159,7 +1172,14 @@ static int __devinit i8042_probe(struct platform_device *dev)
                if (error)
                        goto out_fail;
        }
+#ifdef CONFIG_X86
+        if (i8042_dritek) {
+                param = 0x90;
+                error = i8042_command(&param, 0x1059);
+                if (error)
+                        goto out_fail;
+        }
+#endif
 /*
 * Ok, everything is ready, let's register all serio ports
 */
diff --git a/drivers/input/serio/libps2.c b/drivers/input/serio/libps2.c
index 10d9d74ae43a..b819239d74dc 100644
--- a/drivers/input/serio/libps2.c
+++ b/drivers/input/serio/libps2.c
@@ -13,7 +13,6 @@
 #include <linux/delay.h>
 #include <linux/module.h>
-#include <linux/moduleparam.h>
 #include <linux/slab.h>
 #include <linux/interrupt.h>
 #include <linux/input.h>
diff --git a/drivers/input/touchscreen/ads7846.c b/drivers/input/touchscreen/ads7846.c
index fd9c5d51870a..58934a40f5ce 100644
--- a/drivers/input/touchscreen/ads7846.c
+++ b/drivers/input/touchscreen/ads7846.c
@@ -116,6 +116,7 @@ struct ads7846 {
 // FIXME remove "irq_disabled"
        unsigned                irq_disabled:1; /* P: lock */
        unsigned                disabled:1;
+        unsigned                is_suspended:1;
        int                     (*filter)(void *data, int data_idx, int *val);
        void                    *filter_data;
@@ -203,7 +204,7 @@ static void ads7846_disable(struct ads7846 *ts);
 static int device_suspended(struct device *dev)
 {
        struct ads7846 *ts = dev_get_drvdata(dev);
-        return dev->power.power_state.event != PM_EVENT_ON || ts->disabled;
+        return ts->is_suspended || ts->disabled;
 }
 static int ads7846_read12_ser(struct device *dev, unsigned command)
@@ -794,7 +795,7 @@ static int ads7846_suspend(struct spi_device *spi, pm_message_t message)
        spin_lock_irq(&ts->lock);
-        spi->dev.power.power_state = message;
+        ts->is_suspended = 1;
        ads7846_disable(ts);
        spin_unlock_irq(&ts->lock);
@@ -809,7 +810,7 @@ static int ads7846_resume(struct spi_device *spi)
        spin_lock_irq(&ts->lock);
-        spi->dev.power.power_state = PMSG_ON;
+        ts->is_suspended = 0;
        ads7846_enable(ts);
        spin_unlock_irq(&ts->lock);
@@ -871,7 +872,6 @@ static int __devinit ads7846_probe(struct spi_device *spi)
        }
        dev_set_drvdata(&spi->dev, ts);
-        spi->dev.power.power_state = PMSG_ON;
        ts->spi = spi;
        ts->input = input_dev;
diff --git a/drivers/input/touchscreen/mk712.c b/drivers/input/touchscreen/mk712.c
index 80a658868706..efd3aebaba5f 100644
--- a/drivers/input/touchscreen/mk712.c
+++ b/drivers/input/touchscreen/mk712.c
@@ -36,7 +36,6 @@
 */
 #include <linux/module.h>
-#include <linux/moduleparam.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/errno.h>
diff --git a/drivers/input/touchscreen/ucb1400_ts.c b/drivers/input/touchscreen/ucb1400_ts.c
index 986a8365e37f..607f9933aa1f 100644
--- a/drivers/input/touchscreen/ucb1400_ts.c
+++ b/drivers/input/touchscreen/ucb1400_ts.c
@@ -15,7 +15,6 @@
 */
 #include <linux/module.h>
-#include <linux/moduleparam.h>
 #include <linux/init.h>
 #include <linux/completion.h>
 #include <linux/delay.h>
diff --git a/drivers/media/video/usbvideo/konicawc.c b/drivers/media/video/usbvideo/konicawc.c
index 3e93f8058770..719b17ce83f8 100644
--- a/drivers/media/video/usbvideo/konicawc.c
+++ b/drivers/media/video/usbvideo/konicawc.c
@@ -241,8 +241,6 @@ static void konicawc_register_input(struct konicawc *cam, struct usb_device *dev
        input_dev->evbit[0] = BIT_MASK(EV_KEY);
        input_dev->keybit[BIT_WORD(BTN_0)] = BIT_MASK(BTN_0);
-        input_dev->private = cam;
        error = input_register_device(cam->input);
        if (error) {
                warn("Failed to register camera's input device, err: %d\n",
diff --git a/drivers/media/video/usbvideo/quickcam_messenger.c b/drivers/media/video/usbvideo/quickcam_messenger.c
index 5e7b79501370..a2acba0bcc47 100644
--- a/drivers/media/video/usbvideo/quickcam_messenger.c
+++ b/drivers/media/video/usbvideo/quickcam_messenger.c
@@ -105,8 +105,6 @@ static void qcm_register_input(struct qcm *cam, struct usb_device *dev)
        input_dev->evbit[0] = BIT_MASK(EV_KEY);
        input_dev->keybit[BIT_WORD(BTN_0)] = BIT_MASK(BTN_0);
-        input_dev->private = cam;
        error = input_register_device(cam->input);
        if (error) {
                warn("Failed to register camera's input device, err: %d\n",
diff --git a/fs/ocfs2/cluster/tcp_internal.h b/fs/ocfs2/cluster/tcp_internal.h
index b2e832aca567..d25b9af28500 100644
--- a/fs/ocfs2/cluster/tcp_internal.h
+++ b/fs/ocfs2/cluster/tcp_internal.h
@@ -38,6 +38,15 @@
 * locking semantics of the file system using the protocol.  It should 
 * be somewhere else, I'm sure, but right now it isn't.
 *
+ * With version 11, we separate out the filesystem locking portion.  The
+ * filesystem now has a major.minor version it negotiates.  Version 11
+ * introduces this negotiation to the o2dlm protocol, and as such the
+ * version here in tcp_internal.h should not need to be bumped for
+ * filesystem locking changes.
+ *
+ * New in version 11
+ *      - Negotiation of filesystem locking in the dlm join.
+ *
 * New in version 10:
 *      - Meta/data locks combined
 *
@@ -66,7 +75,7 @@
 *      - full 64 bit i_size in the metadata lock lvbs
 *      - introduction of "rw" lock and pushing meta/data locking down
 */
-#define O2NET_PROTOCOL_VERSION 10ULL
+#define O2NET_PROTOCOL_VERSION 11ULL
 struct o2net_handshake {
        __be64  protocol_version;
        __be64  connector_id;
diff --git a/fs/ocfs2/dlm/dlmapi.h b/fs/ocfs2/dlm/dlmapi.h
index cfd5cb65cab0..b5786a787fab 100644
--- a/fs/ocfs2/dlm/dlmapi.h
+++ b/fs/ocfs2/dlm/dlmapi.h
@@ -193,7 +193,12 @@ enum dlm_status dlmunlock(struct dlm_ctxt *dlm,
                          dlm_astunlockfunc_t *unlockast,
                          void *data);
-struct dlm_ctxt * dlm_register_domain(const char *domain, u32 key);
+struct dlm_protocol_version {
+        u8 pv_major;
+        u8 pv_minor;
+};
+struct dlm_ctxt * dlm_register_domain(const char *domain, u32 key,
+                                      struct dlm_protocol_version *fs_proto);
 void dlm_unregister_domain(struct dlm_ctxt *dlm);
diff --git a/fs/ocfs2/dlm/dlmcommon.h b/fs/ocfs2/dlm/dlmcommon.h
index e90b92f9ece1..9843ee17ea27 100644
--- a/fs/ocfs2/dlm/dlmcommon.h
+++ b/fs/ocfs2/dlm/dlmcommon.h
@@ -142,6 +142,12 @@ struct dlm_ctxt
        spinlock_t work_lock;
        struct list_head dlm_domain_handlers;
        struct list_head        dlm_eviction_callbacks;
+        /* The filesystem specifies this at domain registration.  We
+         * cache it here to know what to tell other nodes. */
+        struct dlm_protocol_version fs_locking_proto;
+        /* This is the inter-dlm communication version */
+        struct dlm_protocol_version dlm_locking_proto;
 };
 static inline struct hlist_head *dlm_lockres_hash(struct dlm_ctxt *dlm, unsigned i)
@@ -589,10 +595,24 @@ struct dlm_proxy_ast
 #define DLM_PROXY_AST_MAX_LEN  (sizeof(struct dlm_proxy_ast)+DLM_LVB_LEN)
 #define DLM_MOD_KEY (0x666c6172)
-enum dlm_query_join_response {
+enum dlm_query_join_response_code {
        JOIN_DISALLOW = 0,
        JOIN_OK,
        JOIN_OK_NO_MAP,
+        JOIN_PROTOCOL_MISMATCH,
+};
+union dlm_query_join_response {
+        u32 intval;
+        struct {
+                u8 code;        /* Response code.  dlm_minor and fs_minor
+                                   are only valid if this is JOIN_OK */
+                u8 dlm_minor;   /* The minor version of the protocol the
+                                   dlm is speaking. */
+                u8 fs_minor;    /* The minor version of the protocol the
+                                   filesystem is speaking. */
+                u8 reserved;
+        } packet;
 };
 struct dlm_lock_request
@@ -633,6 +653,8 @@ struct dlm_query_join_request
        u8 node_idx;
        u8 pad1[2];
        u8 name_len;
+        struct dlm_protocol_version dlm_proto;
+        struct dlm_protocol_version fs_proto;
        u8 domain[O2NM_MAX_NAME_LEN];
        u8 node_map[BITS_TO_BYTES(O2NM_MAX_NODES)];
 };
diff --git a/fs/ocfs2/dlm/dlmdomain.c b/fs/ocfs2/dlm/dlmdomain.c
index 6954565b8ccb..638d2ebb892b 100644
--- a/fs/ocfs2/dlm/dlmdomain.c
+++ b/fs/ocfs2/dlm/dlmdomain.c
@@ -123,6 +123,17 @@ DEFINE_SPINLOCK(dlm_domain_lock);
 LIST_HEAD(dlm_domains);
 static DECLARE_WAIT_QUEUE_HEAD(dlm_domain_events);
+/*
+ * The supported protocol version for DLM communication.  Running domains
+ * will have a negotiated version with the same major number and a minor
+ * number equal or smaller.  The dlm_ctxt->dlm_locking_proto field should
+ * be used to determine what a running domain is actually using.
+ */
+static const struct dlm_protocol_version dlm_protocol = {
+        .pv_major = 1,
+        .pv_minor = 0,
+};
 #define DLM_DOMAIN_BACKOFF_MS 200
 static int dlm_query_join_handler(struct o2net_msg *msg, u32 len, void *data,
@@ -133,6 +144,8 @@ static int dlm_cancel_join_handler(struct o2net_msg *msg, u32 len, void *data,
                                   void **ret_data);
 static int dlm_exit_domain_handler(struct o2net_msg *msg, u32 len, void *data,
                                   void **ret_data);
+static int dlm_protocol_compare(struct dlm_protocol_version *existing,
+                                struct dlm_protocol_version *request);
 static void dlm_unregister_domain_handlers(struct dlm_ctxt *dlm);
@@ -668,11 +681,45 @@ void dlm_unregister_domain(struct dlm_ctxt *dlm)
 }
 EXPORT_SYMBOL_GPL(dlm_unregister_domain);
+static int dlm_query_join_proto_check(char *proto_type, int node,
+                                      struct dlm_protocol_version *ours,
+                                      struct dlm_protocol_version *request)
+{
+        int rc;
+        struct dlm_protocol_version proto = *request;
+        if (!dlm_protocol_compare(ours, &proto)) {
+                mlog(0,
+                     "node %u wanted to join with %s locking protocol "
+                     "%u.%u, we respond with %u.%u\n",
+                     node, proto_type,
+                     request->pv_major,
+                     request->pv_minor,
+                     proto.pv_major, proto.pv_minor);
+                request->pv_minor = proto.pv_minor;
+                rc = 0;
+        } else {
+                mlog(ML_NOTICE,
+                     "Node %u wanted to join with %s locking "
+                     "protocol %u.%u, but we have %u.%u, disallowing\n",
+                     node, proto_type,
+                     request->pv_major,
+                     request->pv_minor,
+                     ours->pv_major,
+                     ours->pv_minor);
+                rc = 1;
+        }
+        return rc;
+}
 static int dlm_query_join_handler(struct o2net_msg *msg, u32 len, void *data,
                                  void **ret_data)
 {
        struct dlm_query_join_request *query;
-        enum dlm_query_join_response response;
+        union dlm_query_join_response response = {
+                .packet.code = JOIN_DISALLOW,
+        };
        struct dlm_ctxt *dlm = NULL;
        u8 nodenum;
@@ -690,11 +737,11 @@ static int dlm_query_join_handler(struct o2net_msg *msg, u32 len, void *data,
                mlog(0, "node %u is not in our live map yet\n",
                     query->node_idx);
-                response = JOIN_DISALLOW;
+                response.packet.code = JOIN_DISALLOW;
                goto respond;
        }
-        response = JOIN_OK_NO_MAP;
+        response.packet.code = JOIN_OK_NO_MAP;
        spin_lock(&dlm_domain_lock);
        dlm = __dlm_lookup_domain_full(query->domain, query->name_len);
@@ -713,7 +760,7 @@ static int dlm_query_join_handler(struct o2net_msg *msg, u32 len, void *data,
                                mlog(0, "disallow join as node %u does not "
                                     "have node %u in its nodemap\n",
                                     query->node_idx, nodenum);
-                                response = JOIN_DISALLOW;
+                                response.packet.code = JOIN_DISALLOW;
                                goto unlock_respond;
                        }
                }
@@ -733,30 +780,48 @@ static int dlm_query_join_handler(struct o2net_msg *msg, u32 len, void *data,
                        /*If this is a brand new context and we
                         * haven't started our join process yet, then
                         * the other node won the race. */
-                        response = JOIN_OK_NO_MAP;
+                        response.packet.code = JOIN_OK_NO_MAP;
                } else if (dlm->joining_node != DLM_LOCK_RES_OWNER_UNKNOWN) {
                        /* Disallow parallel joins. */
-                        response = JOIN_DISALLOW;
+                        response.packet.code = JOIN_DISALLOW;
                } else if (dlm->reco.state & DLM_RECO_STATE_ACTIVE) {
                        mlog(0, "node %u trying to join, but recovery "
                             "is ongoing.\n", bit);
-                        response = JOIN_DISALLOW;
+                        response.packet.code = JOIN_DISALLOW;
                } else if (test_bit(bit, dlm->recovery_map)) {
                        mlog(0, "node %u trying to join, but it "
                             "still needs recovery.\n", bit);
-                        response = JOIN_DISALLOW;
+                        response.packet.code = JOIN_DISALLOW;
                } else if (test_bit(bit, dlm->domain_map)) {
                        mlog(0, "node %u trying to join, but it "
                             "is still in the domain! needs recovery?\n",
                             bit);
-                        response = JOIN_DISALLOW;
+                        response.packet.code = JOIN_DISALLOW;
                } else {
                        /* Alright we're fully a part of this domain
                         * so we keep some state as to who's joining
                         * and indicate to him that needs to be fixed
                         * up. */
-                        response = JOIN_OK;
-                        __dlm_set_joining_node(dlm, query->node_idx);
+                        /* Make sure we speak compatible locking protocols.  */
+                        if (dlm_query_join_proto_check("DLM", bit,
+                                                       &dlm->dlm_locking_proto,
+                                                       &query->dlm_proto)) {
+                                response.packet.code =
+                                        JOIN_PROTOCOL_MISMATCH;
+                        } else if (dlm_query_join_proto_check("fs", bit,
+                                                              &dlm->fs_locking_proto,
+                                                              &query->fs_proto)) {
+                                response.packet.code =
+                                        JOIN_PROTOCOL_MISMATCH;
+                        } else {
+                                response.packet.dlm_minor =
+                                        query->dlm_proto.pv_minor;
+                                response.packet.fs_minor =
+                                        query->fs_proto.pv_minor;
+                                response.packet.code = JOIN_OK;
+                                __dlm_set_joining_node(dlm, query->node_idx);
+                        }
                }
                spin_unlock(&dlm->spinlock);
@@ -765,9 +830,9 @@ unlock_respond:
        spin_unlock(&dlm_domain_lock);
 respond:
-        mlog(0, "We respond with %u\n", response);
+        mlog(0, "We respond with %u\n", response.packet.code);
-        return response;
+        return response.intval;
 }
 static int dlm_assert_joined_handler(struct o2net_msg *msg, u32 len, void *data,
@@ -899,10 +964,11 @@ static int dlm_send_join_cancels(struct dlm_ctxt *dlm,
 static int dlm_request_join(struct dlm_ctxt *dlm,
                            int node,
-                            enum dlm_query_join_response *response)
+                            enum dlm_query_join_response_code *response)
 {
-        int status, retval;
+        int status;
        struct dlm_query_join_request join_msg;
+        union dlm_query_join_response join_resp;
        mlog(0, "querying node %d\n", node);
@@ -910,12 +976,15 @@ static int dlm_request_join(struct dlm_ctxt *dlm,
        join_msg.node_idx = dlm->node_num;
        join_msg.name_len = strlen(dlm->name);
        memcpy(join_msg.domain, dlm->name, join_msg.name_len);
+        join_msg.dlm_proto = dlm->dlm_locking_proto;
+        join_msg.fs_proto = dlm->fs_locking_proto;
        /* copy live node map to join message */
        byte_copymap(join_msg.node_map, dlm->live_nodes_map, O2NM_MAX_NODES);
        status = o2net_send_message(DLM_QUERY_JOIN_MSG, DLM_MOD_KEY, &join_msg,
-                                    sizeof(join_msg), node, &retval);
+                                    sizeof(join_msg), node,
+                                    &join_resp.intval);
        if (status < 0 && status != -ENOPROTOOPT) {
                mlog_errno(status);
                goto bail;
@@ -928,14 +997,41 @@ static int dlm_request_join(struct dlm_ctxt *dlm,
        if (status == -ENOPROTOOPT) {
                status = 0;
                *response = JOIN_OK_NO_MAP;
-        } else if (retval == JOIN_DISALLOW ||
+        } else if (join_resp.packet.code == JOIN_DISALLOW ||
-                   retval == JOIN_OK ||
+                   join_resp.packet.code == JOIN_OK_NO_MAP) {
-                   retval == JOIN_OK_NO_MAP) {
+                *response = join_resp.packet.code;
-                *response = retval;
+        } else if (join_resp.packet.code == JOIN_PROTOCOL_MISMATCH) {
+                mlog(ML_NOTICE,
+                     "This node requested DLM locking protocol %u.%u and "
+                     "filesystem locking protocol %u.%u.  At least one of "
+                     "the protocol versions on node %d is not compatible, "
+                     "disconnecting\n",
+                     dlm->dlm_locking_proto.pv_major,
+                     dlm->dlm_locking_proto.pv_minor,
+                     dlm->fs_locking_proto.pv_major,
+                     dlm->fs_locking_proto.pv_minor,
+                     node);
+                status = -EPROTO;
+                *response = join_resp.packet.code;
+        } else if (join_resp.packet.code == JOIN_OK) {
+                *response = join_resp.packet.code;
+                /* Use the same locking protocol as the remote node */
+                dlm->dlm_locking_proto.pv_minor =
+                        join_resp.packet.dlm_minor;
+                dlm->fs_locking_proto.pv_minor =
+                        join_resp.packet.fs_minor;
+                mlog(0,
+                     "Node %d responds JOIN_OK with DLM locking protocol "
+                     "%u.%u and fs locking protocol %u.%u\n",
+                     node,
+                     dlm->dlm_locking_proto.pv_major,
+                     dlm->dlm_locking_proto.pv_minor,
+                     dlm->fs_locking_proto.pv_major,
+                     dlm->fs_locking_proto.pv_minor);
        } else {
                status = -EINVAL;
-                mlog(ML_ERROR, "invalid response %d from node %u\n", retval,
+                mlog(ML_ERROR, "invalid response %d from node %u\n",
-                     node);
+                     join_resp.packet.code, node);
        }
        mlog(0, "status %d, node %d response is %d\n", status, node,
@@ -1008,7 +1104,7 @@ struct domain_join_ctxt {
 static int dlm_should_restart_join(struct dlm_ctxt *dlm,
                                   struct domain_join_ctxt *ctxt,
-                                   enum dlm_query_join_response response)
+                                   enum dlm_query_join_response_code response)
 {
        int ret;
@@ -1034,7 +1130,7 @@ static int dlm_try_to_join_domain(struct dlm_ctxt *dlm)
 {
        int status = 0, tmpstat, node;
        struct domain_join_ctxt *ctxt;
-        enum dlm_query_join_response response = JOIN_DISALLOW;
+        enum dlm_query_join_response_code response = JOIN_DISALLOW;
        mlog_entry("%p", dlm);
@@ -1450,10 +1546,38 @@ leave:
 }
 /*
- * dlm_register_domain: one-time setup per "domain"
+ * Compare a requested locking protocol version against the current one.
+ *
+ * If the major numbers are different, they are incompatible.
+ * If the current minor is greater than the request, they are incompatible.
+ * If the current minor is less than or equal to the request, they are
+ * compatible, and the requester should run at the current minor version.
+ */
+static int dlm_protocol_compare(struct dlm_protocol_version *existing,
+                                struct dlm_protocol_version *request)
+{
+        if (existing->pv_major != request->pv_major)
+                return 1;
+        if (existing->pv_minor > request->pv_minor)
+                return 1;
+        if (existing->pv_minor < request->pv_minor)
+                request->pv_minor = existing->pv_minor;
+        return 0;
+}
+/*
+ * dlm_register_domain: one-time setup per "domain".
+ *
+ * The filesystem passes in the requested locking version via proto.
+ * If registration was successful, proto will contain the negotiated
+ * locking protocol.
 */
 struct dlm_ctxt * dlm_register_domain(const char *domain,
-                               u32 key)
+                               u32 key,
+                               struct dlm_protocol_version *fs_proto)
 {
        int ret;
        struct dlm_ctxt *dlm = NULL;
@@ -1496,6 +1620,15 @@ retry:
                        goto retry;
                }
+                if (dlm_protocol_compare(&dlm->fs_locking_proto, fs_proto)) {
+                        mlog(ML_ERROR,
+                             "Requested locking protocol version is not "
+                             "compatible with already registered domain "
+                             "\"%s\"\n", domain);
+                        ret = -EPROTO;
+                        goto leave;
+                }
                __dlm_get(dlm);
                dlm->num_joins++;
@@ -1526,6 +1659,13 @@ retry:
        list_add_tail(&dlm->list, &dlm_domains);
        spin_unlock(&dlm_domain_lock);
+        /*
+         * Pass the locking protocol version into the join.  If the join
+         * succeeds, it will have the negotiated protocol set.
+         */
+        dlm->dlm_locking_proto = dlm_protocol;
+        dlm->fs_locking_proto = *fs_proto;
        ret = dlm_join_domain(dlm);
        if (ret) {
                mlog_errno(ret);
@@ -1533,6 +1673,9 @@ retry:
                goto leave;
        }
+        /* Tell the caller what locking protocol we negotiated */
+        *fs_proto = dlm->fs_locking_proto;
        ret = 0;
 leave:
        if (new_ctxt)
diff --git a/fs/ocfs2/dlm/dlmfs.c b/fs/ocfs2/dlm/dlmfs.c
index 6639baab0798..61a000f8524c 100644
--- a/fs/ocfs2/dlm/dlmfs.c
+++ b/fs/ocfs2/dlm/dlmfs.c
@@ -60,6 +60,8 @@
 #define MLOG_MASK_PREFIX ML_DLMFS
 #include "cluster/masklog.h"
+#include "ocfs2_lockingver.h"
 static const struct super_operations dlmfs_ops;
 static const struct file_operations dlmfs_file_operations;
 static const struct inode_operations dlmfs_dir_inode_operations;
@@ -70,6 +72,16 @@ static struct kmem_cache *dlmfs_inode_cache;
 struct workqueue_struct *user_dlm_worker;
 /*
+ * This is the userdlmfs locking protocol version.
+ *
+ * See fs/ocfs2/dlmglue.c for more details on locking versions.
+ */
+static const struct dlm_protocol_version user_locking_protocol = {
+        .pv_major = OCFS2_LOCKING_PROTOCOL_MAJOR,
+        .pv_minor = OCFS2_LOCKING_PROTOCOL_MINOR,
+};
+/*
 * decodes a set of open flags into a valid lock level and a set of flags.
 * returns < 0 if we have invalid flags
 * flags which mean something to us:
@@ -416,6 +428,7 @@ static int dlmfs_mkdir(struct inode * dir,
        struct qstr *domain = &dentry->d_name;
        struct dlmfs_inode_private *ip;
        struct dlm_ctxt *dlm;
+        struct dlm_protocol_version proto = user_locking_protocol;
        mlog(0, "mkdir %.*s\n", domain->len, domain->name);
@@ -435,7 +448,7 @@ static int dlmfs_mkdir(struct inode * dir,
        ip = DLMFS_I(inode);
-        dlm = user_dlm_register_context(domain);
+        dlm = user_dlm_register_context(domain, &proto);
        if (IS_ERR(dlm)) {
                status = PTR_ERR(dlm);
                mlog(ML_ERROR, "Error %d could not register domain \"%.*s\"\n",
diff --git a/fs/ocfs2/dlm/userdlm.c b/fs/ocfs2/dlm/userdlm.c
index 7d2f578b267d..4cb1d3dae250 100644
--- a/fs/ocfs2/dlm/userdlm.c
+++ b/fs/ocfs2/dlm/userdlm.c
@@ -645,7 +645,8 @@ bail:
        return status;
 }
-struct dlm_ctxt *user_dlm_register_context(struct qstr *name)
+struct dlm_ctxt *user_dlm_register_context(struct qstr *name,
+                                           struct dlm_protocol_version *proto)
 {
        struct dlm_ctxt *dlm;
        u32 dlm_key;
@@ -661,7 +662,7 @@ struct dlm_ctxt *user_dlm_register_context(struct qstr *name)
        snprintf(domain, name->len + 1, "%.*s", name->len, name->name);
-        dlm = dlm_register_domain(domain, dlm_key);
+        dlm = dlm_register_domain(domain, dlm_key, proto);
        if (IS_ERR(dlm))
                mlog_errno(PTR_ERR(dlm));
diff --git a/fs/ocfs2/dlm/userdlm.h b/fs/ocfs2/dlm/userdlm.h
index c400e93bbf79..39ec27738499 100644
--- a/fs/ocfs2/dlm/userdlm.h
+++ b/fs/ocfs2/dlm/userdlm.h
@@ -83,7 +83,8 @@ void user_dlm_write_lvb(struct inode *inode,
 void user_dlm_read_lvb(struct inode *inode,
                       char *val,
                       unsigned int len);
-struct dlm_ctxt *user_dlm_register_context(struct qstr *name);
+struct dlm_ctxt *user_dlm_register_context(struct qstr *name,
+                                           struct dlm_protocol_version *proto);
 void user_dlm_unregister_context(struct dlm_ctxt *dlm);
 struct dlmfs_inode_private {
diff --git a/fs/ocfs2/dlmglue.c b/fs/ocfs2/dlmglue.c
index 3867244fb144..351130c9b734 100644
--- a/fs/ocfs2/dlmglue.c
+++ b/fs/ocfs2/dlmglue.c
@@ -43,6 +43,7 @@
 #include <cluster/masklog.h>
 #include "ocfs2.h"
+#include "ocfs2_lockingver.h"
 #include "alloc.h"
 #include "dcache.h"
@@ -258,6 +259,31 @@ static struct ocfs2_lock_res_ops ocfs2_flock_lops = {
        .flags          = 0,
 };
+/*
+ * This is the filesystem locking protocol version.
+ *
+ * Whenever the filesystem does new things with locks (adds or removes a
+ * lock, orders them differently, does different things underneath a lock),
+ * the version must be changed.  The protocol is negotiated when joining
+ * the dlm domain.  A node may join the domain if its major version is
+ * identical to all other nodes and its minor version is greater than
+ * or equal to all other nodes.  When its minor version is greater than
+ * the other nodes, it will run at the minor version specified by the
+ * other nodes.
+ *
+ * If a locking change is made that will not be compatible with older
+ * versions, the major number must be increased and the minor version set
+ * to zero.  If a change merely adds a behavior that can be disabled when
+ * speaking to older versions, the minor version must be increased.  If a
+ * change adds a fully backwards compatible change (eg, LVB changes that
+ * are just ignored by older versions), the version does not need to be
+ * updated.
+ */
+const struct dlm_protocol_version ocfs2_locking_protocol = {
+        .pv_major = OCFS2_LOCKING_PROTOCOL_MAJOR,
+        .pv_minor = OCFS2_LOCKING_PROTOCOL_MINOR,
+};
 static inline int ocfs2_is_inode_lock(struct ocfs2_lock_res *lockres)
 {
        return lockres->l_type == OCFS2_LOCK_TYPE_META ||
@@ -2506,7 +2532,8 @@ int ocfs2_dlm_init(struct ocfs2_super *osb)
        dlm_key = crc32_le(0, osb->uuid_str, strlen(osb->uuid_str));
        /* for now, uuid == domain */
-        dlm = dlm_register_domain(osb->uuid_str, dlm_key);
+        dlm = dlm_register_domain(osb->uuid_str, dlm_key,
+                                  &osb->osb_locking_proto);
        if (IS_ERR(dlm)) {
                status = PTR_ERR(dlm);
                mlog_errno(status);
diff --git a/fs/ocfs2/dlmglue.h b/fs/ocfs2/dlmglue.h
index 5f17243ba501..1d5b0699d0a9 100644
--- a/fs/ocfs2/dlmglue.h
+++ b/fs/ocfs2/dlmglue.h
@@ -116,4 +116,5 @@ void ocfs2_wake_downconvert_thread(struct ocfs2_super *osb);
 struct ocfs2_dlm_debug *ocfs2_new_dlm_debug(void);
 void ocfs2_put_dlm_debug(struct ocfs2_dlm_debug *dlm_debug);
+extern const struct dlm_protocol_version ocfs2_locking_protocol;
 #endif  /* DLMGLUE_H */
diff --git a/fs/ocfs2/ocfs2.h b/fs/ocfs2/ocfs2.h
index d08480580470..e8b7292e0152 100644
--- a/fs/ocfs2/ocfs2.h
+++ b/fs/ocfs2/ocfs2.h
@@ -251,6 +251,7 @@ struct ocfs2_super
        struct ocfs2_lock_res osb_rename_lockres;
        struct dlm_eviction_cb osb_eviction_cb;
        struct ocfs2_dlm_debug *osb_dlm_debug;
+        struct dlm_protocol_version osb_locking_proto;
        struct dentry *osb_debug_root;
diff --git a/fs/ocfs2/ocfs2_lockingver.h b/fs/ocfs2/ocfs2_lockingver.h
new file mode 100644
index 000000000000..82d5eeac0fff
--- /dev/null
+++ b/fs/ocfs2/ocfs2_lockingver.h
@@ -0,0 +1,30 @@
+/* -*- mode: c; c-basic-offset: 8; -*-
+ * vim: noexpandtab sw=8 ts=8 sts=0:
+ *
+ * ocfs2_lockingver.h
+ *
+ * Defines OCFS2 Locking version values.
+ *
+ * Copyright (C) 2008 Oracle.  All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License, version 2, as published by the Free Software Foundation.
+ *
+ * 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.
+ */
+#ifndef OCFS2_LOCKINGVER_H
+#define OCFS2_LOCKINGVER_H
+/*
+ * The protocol version for ocfs2 cluster locking.  See dlmglue.c for
+ * more details.
+ */
+#define OCFS2_LOCKING_PROTOCOL_MAJOR 1
+#define OCFS2_LOCKING_PROTOCOL_MINOR 0
+#endif  /* OCFS2_LOCKINGVER_H */
diff --git a/fs/ocfs2/super.c b/fs/ocfs2/super.c
index 01fe40ee5ea9..bec75aff3d9f 100644
--- a/fs/ocfs2/super.c
+++ b/fs/ocfs2/super.c
@@ -1355,6 +1355,7 @@ static int ocfs2_initialize_super(struct super_block *sb,
        sb->s_fs_info = osb;
        sb->s_op = &ocfs2_sops;
        sb->s_export_op = &ocfs2_export_ops;
+        osb->osb_locking_proto = ocfs2_locking_protocol;
        sb->s_time_gran = 1;
        sb->s_flags |= MS_NOATIME;
        /* this is needed to support O_LARGEFILE */
diff --git a/fs/partitions/check.c b/fs/partitions/check.c
index 739da701ae7b..9a64045ff845 100644
--- a/fs/partitions/check.c
+++ b/fs/partitions/check.c
@@ -319,6 +319,14 @@ void delete_partition(struct gendisk *disk, int part)
        put_device(&p->dev);
 }
+static ssize_t whole_disk_show(struct device *dev,
+                               struct device_attribute *attr, char *buf)
+{
+        return 0;
+}
+static DEVICE_ATTR(whole_disk, S_IRUSR | S_IRGRP | S_IROTH,
+                   whole_disk_show, NULL);
 void add_partition(struct gendisk *disk, int part, sector_t start, sector_t len, int flags)
 {
        struct hd_struct *p;
@@ -352,13 +360,8 @@ void add_partition(struct gendisk *disk, int part, sector_t start, sector_t len,
        device_add(&p->dev);
        partition_sysfs_add_subdir(p);
        p->dev.uevent_suppress = 0;
-        if (flags & ADDPART_FLAG_WHOLEDISK) {
+        if (flags & ADDPART_FLAG_WHOLEDISK)
-                static struct attribute addpartattr = {
+                err = device_create_file(&p->dev, &dev_attr_whole_disk);
-                        .name = "whole_disk",
-                        .mode = S_IRUSR | S_IRGRP | S_IROTH,
-                };
-                err = sysfs_create_file(&p->dev.kobj, &addpartattr);
-        }
        /* suppress uevent if the disk supresses it */
        if (!disk->dev.uevent_suppress)
diff --git a/fs/sysfs/group.c b/fs/sysfs/group.c
index 0871c3dadce1..477904915032 100644
--- a/fs/sysfs/group.c
+++ b/fs/sysfs/group.c
@@ -77,7 +77,12 @@ void sysfs_remove_group(struct kobject * kobj,
        if (grp->name) {
                sd = sysfs_get_dirent(dir_sd, grp->name);
-                BUG_ON(!sd);
+                if (!sd) {
+                        printk(KERN_WARNING "sysfs group %p not found for "
+                                "kobject '%s'\n", grp, kobject_name(kobj));
+                        WARN_ON(!sd);
+                        return;
+                }
        } else
                sd = sysfs_get(dir_sd);
diff --git a/include/asm-arm/arch-pxa/pxa27x_keyboard.h b/include/asm-arm/arch-pxa/pxa27x_keyboard.h
deleted file mode 100644
index 3aaff923b2ca..000000000000
--- a/include/asm-arm/arch-pxa/pxa27x_keyboard.h
+++ /dev/null
@@ -1,13 +0,0 @@
-#define PXAKBD_MAXROW           8
-#define PXAKBD_MAXCOL           8
-struct pxa27x_keyboard_platform_data {
-        int nr_rows, nr_cols;
-        int keycodes[PXAKBD_MAXROW][PXAKBD_MAXCOL];
-        int gpio_modes[PXAKBD_MAXROW + PXAKBD_MAXCOL];
-#ifdef CONFIG_PM
-        u32 reg_kpc;
-        u32 reg_kprec;
-#endif
-};
diff --git a/include/asm-arm/arch-pxa/pxa27x_keypad.h b/include/asm-arm/arch-pxa/pxa27x_keypad.h
new file mode 100644
index 000000000000..644f7609b523
--- /dev/null
+++ b/include/asm-arm/arch-pxa/pxa27x_keypad.h
@@ -0,0 +1,56 @@
+#ifndef __ASM_ARCH_PXA27x_KEYPAD_H
+#define __ASM_ARCH_PXA27x_KEYPAD_H
+#include <linux/input.h>
+#define MAX_MATRIX_KEY_ROWS     (8)
+#define MAX_MATRIX_KEY_COLS     (8)
+/* pxa3xx keypad platform specific parameters
+ *
+ * NOTE:
+ * 1. direct_key_num indicates the number of keys in the direct keypad
+ *    _plus_ the number of rotary-encoder sensor inputs,  this can be
+ *    left as 0 if only rotary encoders are enabled,  the driver will
+ *    automatically calculate this
+ *
+ * 2. direct_key_map is the key code map for the direct keys, if rotary
+ *    encoder(s) are enabled, direct key 0/1(2/3) will be ignored
+ *
+ * 3. rotary can be either interpreted as a relative input event (e.g.
+ *    REL_WHEEL/REL_HWHEEL) or specific keys (e.g. UP/DOWN/LEFT/RIGHT)
+ *
+ * 4. matrix key and direct key will use the same debounce_interval by
+ *    default, which should be sufficient in most cases
+ */
+struct pxa27x_keypad_platform_data {
+        /* code map for the matrix keys */
+        unsigned int    matrix_key_rows;
+        unsigned int    matrix_key_cols;
+        unsigned int    *matrix_key_map;
+        int             matrix_key_map_size;
+        /* direct keys */
+        int             direct_key_num;
+        unsigned int    direct_key_map[8];
+        /* rotary encoders 0 */
+        int             enable_rotary0;
+        int             rotary0_rel_code;
+        int             rotary0_up_key;
+        int             rotary0_down_key;
+        /* rotary encoders 1 */
+        int             enable_rotary1;
+        int             rotary1_rel_code;
+        int             rotary1_up_key;
+        int             rotary1_down_key;
+        /* key debounce interval */
+        unsigned int    debounce_interval;
+};
+#define KEY(row, col, val)      (((row) << 28) | ((col) << 24) | (val))
+#endif /* __ASM_ARCH_PXA27x_KEYPAD_H */
diff --git a/include/asm-arm/arch-pxa/tosa.h b/include/asm-arm/arch-pxa/tosa.h
index c3364a2c4758..c05e4faf85a6 100644
--- a/include/asm-arm/arch-pxa/tosa.h
+++ b/include/asm-arm/arch-pxa/tosa.h
@@ -163,4 +163,34 @@
 extern struct platform_device tosascoop_jc_device;
 extern struct platform_device tosascoop_device;
+#define TOSA_KEY_SYNC           KEY_102ND /* ??? */
+#ifndef CONFIG_KEYBOARD_TOSA_USE_EXT_KEYCODES
+#define TOSA_KEY_RECORD         KEY_YEN
+#define TOSA_KEY_ADDRESSBOOK    KEY_KATAKANA
+#define TOSA_KEY_CANCEL         KEY_ESC
+#define TOSA_KEY_CENTER         KEY_HIRAGANA
+#define TOSA_KEY_OK             KEY_HENKAN
+#define TOSA_KEY_CALENDAR       KEY_KATAKANAHIRAGANA
+#define TOSA_KEY_HOMEPAGE       KEY_HANGEUL
+#define TOSA_KEY_LIGHT          KEY_MUHENKAN
+#define TOSA_KEY_MENU           KEY_HANJA
+#define TOSA_KEY_FN             KEY_RIGHTALT
+#define TOSA_KEY_MAIL           KEY_ZENKAKUHANKAKU
+#else
+#define TOSA_KEY_RECORD         KEY_RECORD
+#define TOSA_KEY_ADDRESSBOOK    KEY_ADDRESSBOOK
+#define TOSA_KEY_CANCEL         KEY_CANCEL
+#define TOSA_KEY_CENTER         KEY_SELECT /* ??? */
+#define TOSA_KEY_OK             KEY_OK
+#define TOSA_KEY_CALENDAR       KEY_CALENDAR
+#define TOSA_KEY_HOMEPAGE       KEY_HOMEPAGE
+#define TOSA_KEY_LIGHT          KEY_KBDILLUMTOGGLE
+#define TOSA_KEY_MENU           KEY_MENU
+#define TOSA_KEY_FN             KEY_FN
+#define TOSA_KEY_MAIL           KEY_MAIL
+#endif
 #endif /* _ASM_ARCH_TOSA_H_ */
diff --git a/include/linux/input.h b/include/linux/input.h
index 056a17a4f34f..1bdc39a8c76c 100644
--- a/include/linux/input.h
+++ b/include/linux/input.h
@@ -1020,7 +1020,6 @@ struct ff_effect {
 * @going_away: marks devices that are in a middle of unregistering and
 *      causes input_open_device*() fail with -ENODEV.
 * @dev: driver model's view of this device
- * @cdev: union for struct device pointer
 * @h_list: list of input handles associated with the device. When
 *      accessing the list dev->mutex must be held
 * @node: used to place the device onto input_dev_list
@@ -1085,9 +1084,6 @@ struct input_dev {
        int going_away;
        struct device dev;
-        union {                 /* temporarily so while we switching to struct device */
-                struct device *dev;
-        } cdev;
        struct list_head        h_list;
        struct list_head        node;
@@ -1311,6 +1307,9 @@ static inline void input_set_abs_params(struct input_dev *dev, int axis, int min
        dev->absbit[BIT_WORD(axis)] |= BIT_MASK(axis);
 }
+int input_get_keycode(struct input_dev *dev, int scancode, int *keycode);
+int input_set_keycode(struct input_dev *dev, int scancode, int keycode);
 extern struct class input_class;
 /**