167 files changed, 17404 insertions, 5588 deletions

diff --git a/drivers/input/Kconfig b/drivers/input/Kconfig
index 07c2cd43109c..23e82e46656d 100644
--- a/drivers/input/Kconfig
+++ b/drivers/input/Kconfig
@@ -6,7 +6,7 @@ menu "Input device support"
         depends on !S390
 
 config INPUT
-        tristate "Generic input layer (needed for keyboard, mouse, ...)" if EMBEDDED
+        tristate "Generic input layer (needed for keyboard, mouse, ...)" if EXPERT
         default y
         help
           Say Y here if you have any input device (mouse, keyboard, tablet,
@@ -67,7 +67,7 @@ config INPUT_SPARSEKMAP
 comment "Userland interfaces"
 
 config INPUT_MOUSEDEV
-        tristate "Mouse interface" if EMBEDDED
+        tristate "Mouse interface" if EXPERT
         default y
         help
           Say Y here if you want your mouse to be accessible as char devices
@@ -150,7 +150,7 @@ config INPUT_EVBUG
           module will be called evbug.
 
 config INPUT_APMPOWER
-        tristate "Input Power Event -> APM Bridge" if EMBEDDED
+        tristate "Input Power Event -> APM Bridge" if EXPERT
         depends on INPUT && APM_EMULATION
         help
           Say Y here if you want suspend key events to trigger a user
@@ -161,16 +161,6 @@ config INPUT_APMPOWER
           To compile this driver as a module, choose M here: the
           module will be called apm-power.
 
-config XEN_KBDDEV_FRONTEND
-        tristate "Xen virtual keyboard and mouse support"
-        depends on XEN_FBDEV_FRONTEND
-        default y
-        select XEN_XENBUS_FRONTEND
-        help
-          This driver implements the front-end of the Xen virtual
-          keyboard and mouse device driver.  It communicates with a back-end
-          in another domain.
-
 comment "Input Device Drivers"
 
 source "drivers/input/keyboard/Kconfig"
diff --git a/drivers/input/Makefile b/drivers/input/Makefile
index 7ad212d31f99..0c789490e0b3 100644
--- a/drivers/input/Makefile
+++ b/drivers/input/Makefile
@@ -5,7 +5,7 @@
 # Each configuration option enables a list of files.
 
 obj-$(CONFIG_INPUT)             += input-core.o
-input-core-objs := input.o input-compat.o ff-core.o
+input-core-y := input.o input-compat.o input-mt.o ff-core.o
 
 obj-$(CONFIG_INPUT_FF_MEMLESS)  += ff-memless.o
 obj-$(CONFIG_INPUT_POLLDEV)     += input-polldev.o
@@ -24,5 +24,3 @@ obj-$(CONFIG_INPUT_TOUCHSCREEN)	+= touchscreen/
 obj-$(CONFIG_INPUT_MISC)        += misc/
 
 obj-$(CONFIG_INPUT_APMPOWER)    += apm-power.o
-
-obj-$(CONFIG_XEN_KBDDEV_FRONTEND)       += xen-kbdfront.o
diff --git a/drivers/input/apm-power.c b/drivers/input/apm-power.c
index 7d61a9660806..e90ee3d30613 100644
--- a/drivers/input/apm-power.c
+++ b/drivers/input/apm-power.c
@@ -9,6 +9,8 @@
  *
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/module.h>
 #include <linux/input.h>
 #include <linux/slab.h>
@@ -23,8 +25,7 @@ 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");
+                pr_info("Requesting system suspend...\n");
                 break;
         default:
                 break;
@@ -65,18 +66,15 @@ static int apmpower_connect(struct input_handler *handler,
 
         error = input_register_handle(handle);
         if (error) {
-                printk(KERN_ERR
-                        "apm-power: Failed to register input power handler, "
-                        "error %d\n", error);
+                pr_err("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);
+                pr_err("Failed to open input power device, error %d\n", error);
                 input_unregister_handle(handle);
                 kfree(handle);
                 return error;
diff --git a/drivers/input/evbug.c b/drivers/input/evbug.c
index f7c5c14ec12a..cd4e6679d61a 100644
--- a/drivers/input/evbug.c
+++ b/drivers/input/evbug.c
@@ -26,6 +26,8 @@
  * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/input.h>
@@ -38,8 +40,8 @@ MODULE_LICENSE("GPL");
 
 static void evbug_event(struct input_handle *handle, unsigned int type, unsigned int code, int value)
 {
-        printk(KERN_DEBUG "evbug.c: Event. Dev: %s, Type: %d, Code: %d, Value: %d\n",
-                dev_name(&handle->dev->dev), type, code, value);
+        printk(KERN_DEBUG pr_fmt("Event. Dev: %s, Type: %d, Code: %d, Value: %d\n"),
+               dev_name(&handle->dev->dev), type, code, value);
 }
 
 static int evbug_connect(struct input_handler *handler, struct input_dev *dev,
@@ -64,10 +66,10 @@ static int evbug_connect(struct input_handler *handler, struct input_dev *dev,
         if (error)
                 goto err_unregister_handle;
 
-        printk(KERN_DEBUG "evbug.c: Connected device: %s (%s at %s)\n",
-                dev_name(&dev->dev),
-                dev->name ?: "unknown",
-                dev->phys ?: "unknown");
+        printk(KERN_DEBUG pr_fmt("Connected device: %s (%s at %s)\n"),
+               dev_name(&dev->dev),
+               dev->name ?: "unknown",
+               dev->phys ?: "unknown");
 
         return 0;
 
@@ -80,8 +82,8 @@ static int evbug_connect(struct input_handler *handler, struct input_dev *dev,
 
 static void evbug_disconnect(struct input_handle *handle)
 {
-        printk(KERN_DEBUG "evbug.c: Disconnected device: %s\n",
-                dev_name(&handle->dev->dev));
+        printk(KERN_DEBUG pr_fmt("Disconnected device: %s\n"),
+               dev_name(&handle->dev->dev));
 
         input_close_device(handle);
         input_unregister_handle(handle);
diff --git a/drivers/input/evdev.c b/drivers/input/evdev.c
index 9ddafc30f432..4cf25347b015 100644
--- a/drivers/input/evdev.c
+++ b/drivers/input/evdev.c
@@ -8,6 +8,8 @@
  * the Free Software Foundation.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #define EVDEV_MINOR_BASE        64
 #define EVDEV_MINORS            32
 #define EVDEV_MIN_BUFFER_SIZE   64U
@@ -28,7 +30,7 @@ struct evdev {
         int minor;
         struct input_handle handle;
         wait_queue_head_t wait;
-        struct evdev_client *grab;
+        struct evdev_client __rcu *grab;
         struct list_head client_list;
         spinlock_t client_lock; /* protects client_list */
         struct mutex mutex;
@@ -37,13 +39,14 @@ struct evdev {
 };
 
 struct evdev_client {
-        int head;
-        int tail;
+        unsigned int head;
+        unsigned int tail;
+        unsigned int packet_head; /* [future] position of the first element of next packet */
         spinlock_t buffer_lock; /* protects access to buffer, head and tail */
         struct fasync_struct *fasync;
         struct evdev *evdev;
         struct list_head node;
-        int bufsize;
+        unsigned int bufsize;
         struct input_event buffer[];
 };
 
@@ -53,20 +56,33 @@ static DEFINE_MUTEX(evdev_table_mutex);
 static void evdev_pass_event(struct evdev_client *client,
                              struct input_event *event)
 {
-        /*
-         * Interrupts are disabled, just acquire the lock.
-         * Make sure we don't leave with the client buffer
-         * "empty" by having client->head == client->tail.
-         */
+        /* Interrupts are disabled, just acquire the lock. */
         spin_lock(&client->buffer_lock);
-        do {
-                client->buffer[client->head++] = *event;
-                client->head &= client->bufsize - 1;
-        } while (client->head == client->tail);
-        spin_unlock(&client->buffer_lock);
 
-        if (event->type == EV_SYN)
+        client->buffer[client->head++] = *event;
+        client->head &= client->bufsize - 1;
+
+        if (unlikely(client->head == client->tail)) {
+                /*
+                 * This effectively "drops" all unconsumed events, leaving
+                 * EV_SYN/SYN_DROPPED plus the newest event in the queue.
+                 */
+                client->tail = (client->head - 2) & (client->bufsize - 1);
+
+                client->buffer[client->tail].time = event->time;
+                client->buffer[client->tail].type = EV_SYN;
+                client->buffer[client->tail].code = SYN_DROPPED;
+                client->buffer[client->tail].value = 0;
+
+                client->packet_head = client->tail;
+        }
+
+        if (event->type == EV_SYN && event->code == SYN_REPORT) {
+                client->packet_head = client->head;
                 kill_fasync(&client->fasync, SIGIO, POLL_IN);
+        }
+
+        spin_unlock(&client->buffer_lock);
 }
 
 /*
@@ -95,7 +111,8 @@ static void evdev_event(struct input_handle *handle,
 
         rcu_read_unlock();
 
-        wake_up_interruptible(&evdev->wait);
+        if (type == EV_SYN && code == SYN_REPORT)
+                wake_up_interruptible(&evdev->wait);
 }
 
 static int evdev_fasync(int fd, struct file *file, int on)
@@ -148,7 +165,6 @@ static int evdev_grab(struct evdev *evdev, struct evdev_client *client)
                 return error;
 
         rcu_assign_pointer(evdev->grab, client);
-        synchronize_rcu();
 
         return 0;
 }
@@ -171,7 +187,6 @@ static void evdev_attach_client(struct evdev *evdev,
         spin_lock(&evdev->client_lock);
         list_add_tail_rcu(&client->node, &evdev->client_list);
         spin_unlock(&evdev->client_lock);
-        synchronize_rcu();
 }
 
 static void evdev_detach_client(struct evdev *evdev,
@@ -319,6 +334,9 @@ static ssize_t evdev_write(struct file *file, const char __user *buffer,
         struct input_event event;
         int retval;
 
+        if (count < input_event_size())
+                return -EINVAL;
+
         retval = mutex_lock_interruptible(&evdev->mutex);
         if (retval)
                 return retval;
@@ -328,17 +346,16 @@ static ssize_t evdev_write(struct file *file, const char __user *buffer,
                 goto out;
         }
 
-        while (retval < count) {
-
+        do {
                 if (input_event_from_user(buffer + retval, &event)) {
                         retval = -EFAULT;
                         goto out;
                 }
+                retval += input_event_size();
 
                 input_inject_event(&evdev->handle,
                                    event.type, event.code, event.value);
-                retval += input_event_size();
-        }
+        } while (retval + input_event_size() <= count);
 
  out:
         mutex_unlock(&evdev->mutex);
@@ -374,12 +391,12 @@ static ssize_t evdev_read(struct file *file, char __user *buffer,
         if (count < input_event_size())
                 return -EINVAL;
 
-        if (client->head == client->tail && evdev->exist &&
+        if (client->packet_head == client->tail && evdev->exist &&
             (file->f_flags & O_NONBLOCK))
                 return -EAGAIN;
 
         retval = wait_event_interruptible(evdev->wait,
-                client->head != client->tail || !evdev->exist);
+                client->packet_head != client->tail || !evdev->exist);
         if (retval)
                 return retval;
 
@@ -408,7 +425,7 @@ static unsigned int evdev_poll(struct file *file, poll_table *wait)
         poll_wait(file, &evdev->wait, wait);
 
         mask = evdev->exist ? POLLOUT | POLLWRNORM : POLLHUP | POLLERR;
-        if (client->head != client->tail)
+        if (client->packet_head != client->tail)
                 mask |= POLLIN | POLLRDNORM;
 
         return mask;
@@ -522,18 +539,88 @@ static int handle_eviocgbit(struct input_dev *dev,
         if (type == EV_KEY && size == OLD_KEY_MAX) {
                 len = OLD_KEY_MAX;
                 if (printk_timed_ratelimit(&keymax_warn_time, 10 * 1000))
-                        printk(KERN_WARNING
-                                "evdev.c(EVIOCGBIT): Suspicious buffer size %u, "
-                                "limiting output to %zu bytes. See "
-                                "http://userweb.kernel.org/~dtor/eviocgbit-bug.html\n",
-                                OLD_KEY_MAX,
-                                BITS_TO_LONGS(OLD_KEY_MAX) * sizeof(long));
+                        pr_warning("(EVIOCGBIT): Suspicious buffer size %u, "
+                                   "limiting output to %zu bytes. See "
+                                   "http://userweb.kernel.org/~dtor/eviocgbit-bug.html\n",
+                                   OLD_KEY_MAX,
+                                   BITS_TO_LONGS(OLD_KEY_MAX) * sizeof(long));
         }
 
         return bits_to_user(bits, len, size, p, compat_mode);
 }
 #undef OLD_KEY_MAX
 
+static int evdev_handle_get_keycode(struct input_dev *dev, void __user *p)
+{
+        struct input_keymap_entry ke = {
+                .len    = sizeof(unsigned int),
+                .flags  = 0,
+        };
+        int __user *ip = (int __user *)p;
+        int error;
+
+        /* legacy case */
+        if (copy_from_user(ke.scancode, p, sizeof(unsigned int)))
+                return -EFAULT;
+
+        error = input_get_keycode(dev, &ke);
+        if (error)
+                return error;
+
+        if (put_user(ke.keycode, ip + 1))
+                return -EFAULT;
+
+        return 0;
+}
+
+static int evdev_handle_get_keycode_v2(struct input_dev *dev, void __user *p)
+{
+        struct input_keymap_entry ke;
+        int error;
+
+        if (copy_from_user(&ke, p, sizeof(ke)))
+                return -EFAULT;
+
+        error = input_get_keycode(dev, &ke);
+        if (error)
+                return error;
+
+        if (copy_to_user(p, &ke, sizeof(ke)))
+                return -EFAULT;
+
+        return 0;
+}
+
+static int evdev_handle_set_keycode(struct input_dev *dev, void __user *p)
+{
+        struct input_keymap_entry ke = {
+                .len    = sizeof(unsigned int),
+                .flags  = 0,
+        };
+        int __user *ip = (int __user *)p;
+
+        if (copy_from_user(ke.scancode, p, sizeof(unsigned int)))
+                return -EFAULT;
+
+        if (get_user(ke.keycode, ip + 1))
+                return -EFAULT;
+
+        return input_set_keycode(dev, &ke);
+}
+
+static int evdev_handle_set_keycode_v2(struct input_dev *dev, void __user *p)
+{
+        struct input_keymap_entry ke;
+
+        if (copy_from_user(&ke, p, sizeof(ke)))
+                return -EFAULT;
+
+        if (ke.len > sizeof(ke.scancode))
+                return -EINVAL;
+
+        return input_set_keycode(dev, &ke);
+}
+
 static long evdev_do_ioctl(struct file *file, unsigned int cmd,
                            void __user *p, int compat_mode)
 {
@@ -580,25 +667,6 @@ static long evdev_do_ioctl(struct file *file, unsigned int cmd,
 
                 return 0;
 
-        case EVIOCGKEYCODE:
-                if (get_user(t, ip))
-                        return -EFAULT;
-
-                error = input_get_keycode(dev, t, &v);
-                if (error)
-                        return error;
-
-                if (put_user(v, ip + 1))
-                        return -EFAULT;
-
-                return 0;
-
-        case EVIOCSKEYCODE:
-                if (get_user(t, ip) || get_user(v, ip + 1))
-                        return -EFAULT;
-
-                return input_set_keycode(dev, t, v);
-
         case EVIOCRMFF:
                 return input_ff_erase(dev, (int)(unsigned long) p, file);
 
@@ -614,15 +682,30 @@ static long evdev_do_ioctl(struct file *file, unsigned int cmd,
                         return evdev_grab(evdev, client);
                 else
                         return evdev_ungrab(evdev, client);
+
+        case EVIOCGKEYCODE:
+                return evdev_handle_get_keycode(dev, p);
+
+        case EVIOCSKEYCODE:
+                return evdev_handle_set_keycode(dev, p);
+
+        case EVIOCGKEYCODE_V2:
+                return evdev_handle_get_keycode_v2(dev, p);
+
+        case EVIOCSKEYCODE_V2:
+                return evdev_handle_set_keycode_v2(dev, p);
         }
 
         size = _IOC_SIZE(cmd);
 
         /* Now check variable-length commands */
 #define EVIOC_MASK_SIZE(nr)     ((nr) & ~(_IOC_SIZEMASK << _IOC_SIZESHIFT))
-
         switch (EVIOC_MASK_SIZE(cmd)) {
 
+        case EVIOCGPROP(0):
+                return bits_to_user(dev->propbit, INPUT_PROP_MAX,
+                                    size, p, compat_mode);
+
         case EVIOCGKEY(0):
                 return bits_to_user(dev->key, KEY_MAX, size, p, compat_mode);
 
@@ -767,7 +850,8 @@ static const struct file_operations evdev_fops = {
         .compat_ioctl   = evdev_ioctl_compat,
 #endif
         .fasync         = evdev_fasync,
-        .flush          = evdev_flush
+        .flush          = evdev_flush,
+        .llseek         = no_llseek,
 };
 
 static int evdev_install_chrdev(struct evdev *evdev)
@@ -833,7 +917,7 @@ static int evdev_connect(struct input_handler *handler, struct input_dev *dev,
                         break;
 
         if (minor == EVDEV_MINORS) {
-                printk(KERN_ERR "evdev: no more free evdev devices\n");
+                pr_err("no more free evdev devices\n");
                 return -ENFILE;
         }
 
diff --git a/drivers/input/ff-core.c b/drivers/input/ff-core.c
index 03078c08309a..3367f760d75a 100644
--- a/drivers/input/ff-core.c
+++ b/drivers/input/ff-core.c
@@ -23,7 +23,7 @@
 
 /* #define DEBUG */
 
-#define debug(format, arg...) pr_debug("ff-core: " format "\n", ## arg)
+#define pr_fmt(fmt) KBUILD_BASENAME ": " fmt
 
 #include <linux/input.h>
 #include <linux/module.h>
@@ -116,7 +116,7 @@ int input_ff_upload(struct input_dev *dev, struct ff_effect *effect,
 
         if (effect->type < FF_EFFECT_MIN || effect->type > FF_EFFECT_MAX ||
             !test_bit(effect->type, dev->ffbit)) {
-                debug("invalid or not supported effect type in upload");
+                pr_debug("invalid or not supported effect type in upload\n");
                 return -EINVAL;
         }
 
@@ -124,7 +124,7 @@ int input_ff_upload(struct input_dev *dev, struct ff_effect *effect,
             (effect->u.periodic.waveform < FF_WAVEFORM_MIN ||
              effect->u.periodic.waveform > FF_WAVEFORM_MAX ||
              !test_bit(effect->u.periodic.waveform, dev->ffbit))) {
-                debug("invalid or not supported wave form in upload");
+                pr_debug("invalid or not supported wave form in upload\n");
                 return -EINVAL;
         }
 
@@ -246,7 +246,7 @@ static int flush_effects(struct input_dev *dev, struct file *file)
         struct ff_device *ff = dev->ff;
         int i;
 
-        debug("flushing now");
+        pr_debug("flushing now\n");
 
         mutex_lock(&ff->mutex);
 
@@ -315,8 +315,7 @@ int input_ff_create(struct input_dev *dev, int max_effects)
         int i;
 
         if (!max_effects) {
-                printk(KERN_ERR
-                       "ff-core: cannot allocate device without any effects\n");
+                pr_err("cannot allocate device without any effects\n");
                 return -EINVAL;
         }
 
diff --git a/drivers/input/ff-memless.c b/drivers/input/ff-memless.c
index 1d881c96ba8f..117a59aaa70e 100644
--- a/drivers/input/ff-memless.c
+++ b/drivers/input/ff-memless.c
@@ -23,7 +23,7 @@
 
 /* #define DEBUG */
 
-#define debug(format, arg...) pr_debug("ff-memless: " format "\n", ## arg)
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 
 #include <linux/slab.h>
 #include <linux/input.h>
@@ -129,7 +129,7 @@ static void ml_schedule_timer(struct ml_device *ml)
         int events = 0;
         int i;
 
-        debug("calculating next timer");
+        pr_debug("calculating next timer\n");
 
         for (i = 0; i < FF_MEMLESS_EFFECTS; i++) {
 
@@ -149,10 +149,10 @@ static void ml_schedule_timer(struct ml_device *ml)
         }
 
         if (!events) {
-                debug("no actions");
+                pr_debug("no actions\n");
                 del_timer(&ml->timer);
         } else {
-                debug("timer set");
+                pr_debug("timer set\n");
                 mod_timer(&ml->timer, earliest);
         }
 }
@@ -173,8 +173,8 @@ static int apply_envelope(struct ml_effect_state *state, int value,
         if (envelope->attack_length &&
             time_before(now,
                         state->play_at + msecs_to_jiffies(envelope->attack_length))) {
-                debug("value = 0x%x, attack_level = 0x%x", value,
-                      envelope->attack_level);
+                pr_debug("value = 0x%x, attack_level = 0x%x\n",
+                         value, envelope->attack_level);
                 time_from_level = jiffies_to_msecs(now - state->play_at);
                 time_of_envelope = envelope->attack_length;
                 envelope_level = min_t(__s16, envelope->attack_level, 0x7fff);
@@ -191,13 +191,13 @@ static int apply_envelope(struct ml_effect_state *state, int value,
 
         difference = abs(value) - envelope_level;
 
-        debug("difference = %d", difference);
-        debug("time_from_level = 0x%x", time_from_level);
-        debug("time_of_envelope = 0x%x", time_of_envelope);
+        pr_debug("difference = %d\n", difference);
+        pr_debug("time_from_level = 0x%x\n", time_from_level);
+        pr_debug("time_of_envelope = 0x%x\n", time_of_envelope);
 
         difference = difference * time_from_level / time_of_envelope;
 
-        debug("difference = %d", difference);
+        pr_debug("difference = %d\n", difference);
 
         return value < 0 ?
                 -(difference + envelope_level) : (difference + envelope_level);
@@ -215,8 +215,7 @@ static int get_compatible_type(struct ff_device *ff, int effect_type)
         if (effect_type == FF_PERIODIC && test_bit(FF_RUMBLE, ff->ffbit))
                 return FF_RUMBLE;
 
-        printk(KERN_ERR
-               "ff-memless: invalid type in get_compatible_type()\n");
+        pr_err("invalid type in get_compatible_type()\n");
 
         return 0;
 }
@@ -312,7 +311,7 @@ static void ml_combine_effects(struct ff_effect *effect,
                 break;
 
         default:
-                printk(KERN_ERR "ff-memless: invalid type in ml_combine_effects()\n");
+                pr_err("invalid type in ml_combine_effects()\n");
                 break;
         }
 
@@ -406,7 +405,7 @@ static void ml_effect_timer(unsigned long timer_data)
         struct ml_device *ml = dev->ff->private;
         unsigned long flags;
 
-        debug("timer: updating effects");
+        pr_debug("timer: updating effects\n");
 
         spin_lock_irqsave(&dev->event_lock, flags);
         ml_play_effects(ml);
@@ -438,7 +437,7 @@ static int ml_ff_playback(struct input_dev *dev, int effect_id, int value)
         struct ml_effect_state *state = &ml->states[effect_id];
 
         if (value > 0) {
-                debug("initiated play");
+                pr_debug("initiated play\n");
 
                 __set_bit(FF_EFFECT_STARTED, &state->flags);
                 state->count = value;
@@ -449,7 +448,7 @@ static int ml_ff_playback(struct input_dev *dev, int effect_id, int value)
                 state->adj_at = state->play_at;
 
         } else {
-                debug("initiated stop");
+                pr_debug("initiated stop\n");
 
                 if (test_bit(FF_EFFECT_PLAYING, &state->flags))
                         __set_bit(FF_EFFECT_ABORTING, &state->flags);
diff --git a/drivers/input/gameport/emu10k1-gp.c b/drivers/input/gameport/emu10k1-gp.c
index 7392992da424..422aa0a6b77f 100644
--- a/drivers/input/gameport/emu10k1-gp.c
+++ b/drivers/input/gameport/emu10k1-gp.c
@@ -59,44 +59,52 @@ MODULE_DEVICE_TABLE(pci, emu_tbl);
 
 static int __devinit emu_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 {
-        int ioport, iolen;
         struct emu *emu;
         struct gameport *port;
-
-        if (pci_enable_device(pdev))
-                return -EBUSY;
-
-        ioport = pci_resource_start(pdev, 0);
-        iolen = pci_resource_len(pdev, 0);
-
-        if (!request_region(ioport, iolen, "emu10k1-gp"))
-                return -EBUSY;
+        int error;
 
         emu = kzalloc(sizeof(struct emu), GFP_KERNEL);
         port = gameport_allocate_port();
         if (!emu || !port) {
                 printk(KERN_ERR "emu10k1-gp: Memory allocation failed\n");
-                release_region(ioport, iolen);
-                kfree(emu);
-                gameport_free_port(port);
-                return -ENOMEM;
+                error = -ENOMEM;
+                goto err_out_free;
         }
 
-        emu->io = ioport;
-        emu->size = iolen;
+        error = pci_enable_device(pdev);
+        if (error)
+                goto err_out_free;
+
+        emu->io = pci_resource_start(pdev, 0);
+        emu->size = pci_resource_len(pdev, 0);
+
         emu->dev = pdev;
         emu->gameport = port;
 
         gameport_set_name(port, "EMU10K1");
         gameport_set_phys(port, "pci%s/gameport0", pci_name(pdev));
         port->dev.parent = &pdev->dev;
-        port->io = ioport;
+        port->io = emu->io;
+
+        if (!request_region(emu->io, emu->size, "emu10k1-gp")) {
+                printk(KERN_ERR "emu10k1-gp: unable to grab region 0x%x-0x%x\n",
+                        emu->io, emu->io + emu->size - 1);
+                error = -EBUSY;
+                goto err_out_disable_dev;
+        }
 
         pci_set_drvdata(pdev, emu);
 
         gameport_register_port(port);
 
         return 0;
+
+ err_out_disable_dev:
+        pci_disable_device(pdev);
+ err_out_free:
+        gameport_free_port(port);
+        kfree(emu);
+        return error;
 }
 
 static void __devexit emu_remove(struct pci_dev *pdev)
@@ -106,6 +114,8 @@ static void __devexit emu_remove(struct pci_dev *pdev)
         gameport_unregister_port(emu->gameport);
         release_region(emu->io, emu->size);
         kfree(emu);
+
+        pci_disable_device(pdev);
 }
 
 static struct pci_driver emu_driver = {
diff --git a/drivers/input/gameport/fm801-gp.c b/drivers/input/gameport/fm801-gp.c
index 14d3f3e208a2..a3b70ff21018 100644
--- a/drivers/input/gameport/fm801-gp.c
+++ b/drivers/input/gameport/fm801-gp.c
@@ -133,11 +133,11 @@ static void __devexit fm801_gp_remove(struct pci_dev *pci)
 {
         struct fm801_gp *gp = pci_get_drvdata(pci);
 
-        if (gp) {
-                gameport_unregister_port(gp->gameport);
-                release_resource(gp->res_port);
-                kfree(gp);
-        }
+        gameport_unregister_port(gp->gameport);
+        release_resource(gp->res_port);
+        kfree(gp);
+
+        pci_disable_device(pci);
 }
 
 static const struct pci_device_id fm801_gp_id_table[] = {
diff --git a/drivers/input/gameport/gameport.c b/drivers/input/gameport/gameport.c
index 46239e47a260..5b8f59d6c3e8 100644
--- a/drivers/input/gameport/gameport.c
+++ b/drivers/input/gameport/gameport.c
@@ -18,13 +18,11 @@
 #include <linux/ioport.h>
 #include <linux/init.h>
 #include <linux/gameport.h>
-#include <linux/wait.h>
 #include <linux/slab.h>
 #include <linux/delay.h>
-#include <linux/kthread.h>
+#include <linux/workqueue.h>
 #include <linux/sched.h>        /* HZ */
 #include <linux/mutex.h>
-#include <linux/freezer.h>
 
 /*#include <asm/io.h>*/
 
@@ -123,7 +121,7 @@ static int gameport_measure_speed(struct gameport *gameport)
         }
 
         gameport_close(gameport);
-        return (cpu_data(raw_smp_processor_id()).loops_per_jiffy *
+        return (this_cpu_read(cpu_info.loops_per_jiffy) *
                 (unsigned long)HZ / (1000 / 50)) / (tx < 1 ? 1 : tx);
 
 #else
@@ -234,58 +232,22 @@ struct gameport_event {
 
 static DEFINE_SPINLOCK(gameport_event_lock);    /* protects gameport_event_list */
 static LIST_HEAD(gameport_event_list);
-static DECLARE_WAIT_QUEUE_HEAD(gameport_wait);
-static struct task_struct *gameport_task;
 
-static int gameport_queue_event(void *object, struct module *owner,
-                                enum gameport_event_type event_type)
+static struct gameport_event *gameport_get_event(void)
 {
+        struct gameport_event *event = NULL;
         unsigned long flags;
-        struct gameport_event *event;
-        int retval = 0;
 
         spin_lock_irqsave(&gameport_event_lock, flags);
 
-        /*
-         * Scan event list for the other events for the same gameport port,
-         * starting with the most recent one. If event is the same we
-         * do not need add new one. If event is of different type we
-         * need to add this event and should not look further because
-         * we need to preseve sequence of distinct events.
-         */
-        list_for_each_entry_reverse(event, &gameport_event_list, node) {
-                if (event->object == object) {
-                        if (event->type == event_type)
-                                goto out;
-                        break;
-                }
-        }
-
-        event = kmalloc(sizeof(struct gameport_event), GFP_ATOMIC);
-        if (!event) {
-                pr_err("Not enough memory to queue event %d\n", event_type);
-                retval = -ENOMEM;
-                goto out;
-        }
-
-        if (!try_module_get(owner)) {
-                pr_warning("Can't get module reference, dropping event %d\n",
-                           event_type);
-                kfree(event);
-                retval = -EINVAL;
-                goto out;
+        if (!list_empty(&gameport_event_list)) {
+                event = list_first_entry(&gameport_event_list,
+                                         struct gameport_event, node);
+                list_del_init(&event->node);
         }
 
-        event->type = event_type;
-        event->object = object;
-        event->owner = owner;
-
-        list_add_tail(&event->node, &gameport_event_list);
-        wake_up(&gameport_wait);
-
-out:
         spin_unlock_irqrestore(&gameport_event_lock, flags);
-        return retval;
+        return event;
 }
 
 static void gameport_free_event(struct gameport_event *event)
@@ -319,24 +281,8 @@ static void gameport_remove_duplicate_events(struct gameport_event *event)
         spin_unlock_irqrestore(&gameport_event_lock, flags);
 }
 
-static struct gameport_event *gameport_get_event(void)
-{
-        struct gameport_event *event = NULL;
-        unsigned long flags;
-
-        spin_lock_irqsave(&gameport_event_lock, flags);
-
-        if (!list_empty(&gameport_event_list)) {
-                event = list_first_entry(&gameport_event_list,
-                                         struct gameport_event, node);
-                list_del_init(&event->node);
-        }
-
-        spin_unlock_irqrestore(&gameport_event_lock, flags);
-        return event;
-}
 
-static void gameport_handle_event(void)
+static void gameport_handle_events(struct work_struct *work)
 {
         struct gameport_event *event;
 
@@ -368,6 +314,59 @@ static void gameport_handle_event(void)
         mutex_unlock(&gameport_mutex);
 }
 
+static DECLARE_WORK(gameport_event_work, gameport_handle_events);
+
+static int gameport_queue_event(void *object, struct module *owner,
+                                enum gameport_event_type event_type)
+{
+        unsigned long flags;
+        struct gameport_event *event;
+        int retval = 0;
+
+        spin_lock_irqsave(&gameport_event_lock, flags);
+
+        /*
+         * Scan event list for the other events for the same gameport port,
+         * starting with the most recent one. If event is the same we
+         * do not need add new one. If event is of different type we
+         * need to add this event and should not look further because
+         * we need to preserve sequence of distinct events.
+         */
+        list_for_each_entry_reverse(event, &gameport_event_list, node) {
+                if (event->object == object) {
+                        if (event->type == event_type)
+                                goto out;
+                        break;
+                }
+        }
+
+        event = kmalloc(sizeof(struct gameport_event), GFP_ATOMIC);
+        if (!event) {
+                pr_err("Not enough memory to queue event %d\n", event_type);
+                retval = -ENOMEM;
+                goto out;
+        }
+
+        if (!try_module_get(owner)) {
+                pr_warning("Can't get module reference, dropping event %d\n",
+                           event_type);
+                kfree(event);
+                retval = -EINVAL;
+                goto out;
+        }
+
+        event->type = event_type;
+        event->object = object;
+        event->owner = owner;
+
+        list_add_tail(&event->node, &gameport_event_list);
+        queue_work(system_long_wq, &gameport_event_work);
+
+out:
+        spin_unlock_irqrestore(&gameport_event_lock, flags);
+        return retval;
+}
+
 /*
  * Remove all events that have been submitted for a given object,
  * be it a gameport port or a driver.
@@ -419,19 +418,6 @@ static struct gameport *gameport_get_pending_child(struct gameport *parent)
         return child;
 }
 
-static int gameport_thread(void *nothing)
-{
-        set_freezable();
-        do {
-                gameport_handle_event();
-                wait_event_freezable(gameport_wait,
-                        kthread_should_stop() || !list_empty(&gameport_event_list));
-        } while (!kthread_should_stop());
-
-        return 0;
-}
-
-
 /*
  * Gameport port operations
  */
@@ -814,13 +800,6 @@ static int __init gameport_init(void)
                 return error;
         }
 
-        gameport_task = kthread_run(gameport_thread, NULL, "kgameportd");
-        if (IS_ERR(gameport_task)) {
-                bus_unregister(&gameport_bus);
-                error = PTR_ERR(gameport_task);
-                pr_err("Failed to start kgameportd, error: %d\n", error);
-                return error;
-        }
 
         return 0;
 }
@@ -828,7 +807,12 @@ static int __init gameport_init(void)
 static void __exit gameport_exit(void)
 {
         bus_unregister(&gameport_bus);
-        kthread_stop(gameport_task);
+
+        /*
+         * There should not be any outstanding events but work may
+         * still be scheduled so simply cancel it.
+         */
+        cancel_work_sync(&gameport_event_work);
 }
 
 subsys_initcall(gameport_init);
diff --git a/drivers/input/input-compat.h b/drivers/input/input-compat.h
index 4d8ea32e8a00..22be27b424de 100644
--- a/drivers/input/input-compat.h
+++ b/drivers/input/input-compat.h
@@ -19,7 +19,7 @@
 
 /* Note to the author of this code: did it ever occur to
    you why the ifdefs are needed? Think about it again. -AK */
-#ifdef CONFIG_X86_64
+#if defined(CONFIG_X86_64) || defined(CONFIG_TILE)
 #  define INPUT_COMPAT_TEST is_compat_task()
 #elif defined(CONFIG_S390)
 #  define INPUT_COMPAT_TEST test_thread_flag(TIF_31BIT)
diff --git a/drivers/input/input-mt.c b/drivers/input/input-mt.c
new file mode 100644
index 000000000000..c48c81f0308d
--- /dev/null
+++ b/drivers/input/input-mt.c
@@ -0,0 +1,170 @@
+/*
+ * Input Multitouch Library
+ *
+ * Copyright (c) 2008-2010 Henrik Rydberg
+ *
+ * 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/input/mt.h>
+#include <linux/slab.h>
+
+#define TRKID_SGN       ((TRKID_MAX + 1) >> 1)
+
+/**
+ * input_mt_init_slots() - initialize MT input slots
+ * @dev: input device supporting MT events and finger tracking
+ * @num_slots: number of slots used by the device
+ *
+ * This function allocates all necessary memory for MT slot handling
+ * in the input device, prepares the ABS_MT_SLOT and
+ * ABS_MT_TRACKING_ID events for use and sets up appropriate buffers.
+ * May be called repeatedly. Returns -EINVAL if attempting to
+ * reinitialize with a different number of slots.
+ */
+int input_mt_init_slots(struct input_dev *dev, unsigned int num_slots)
+{
+        int i;
+
+        if (!num_slots)
+                return 0;
+        if (dev->mt)
+                return dev->mtsize != num_slots ? -EINVAL : 0;
+
+        dev->mt = kcalloc(num_slots, sizeof(struct input_mt_slot), GFP_KERNEL);
+        if (!dev->mt)
+                return -ENOMEM;
+
+        dev->mtsize = num_slots;
+        input_set_abs_params(dev, ABS_MT_SLOT, 0, num_slots - 1, 0, 0);
+        input_set_abs_params(dev, ABS_MT_TRACKING_ID, 0, TRKID_MAX, 0, 0);
+        input_set_events_per_packet(dev, 6 * num_slots);
+
+        /* Mark slots as 'unused' */
+        for (i = 0; i < num_slots; i++)
+                input_mt_set_value(&dev->mt[i], ABS_MT_TRACKING_ID, -1);
+
+        return 0;
+}
+EXPORT_SYMBOL(input_mt_init_slots);
+
+/**
+ * input_mt_destroy_slots() - frees the MT slots of the input device
+ * @dev: input device with allocated MT slots
+ *
+ * This function is only needed in error path as the input core will
+ * automatically free the MT slots when the device is destroyed.
+ */
+void input_mt_destroy_slots(struct input_dev *dev)
+{
+        kfree(dev->mt);
+        dev->mt = NULL;
+        dev->mtsize = 0;
+        dev->slot = 0;
+        dev->trkid = 0;
+}
+EXPORT_SYMBOL(input_mt_destroy_slots);
+
+/**
+ * input_mt_report_slot_state() - report contact state
+ * @dev: input device with allocated MT slots
+ * @tool_type: the tool type to use in this slot
+ * @active: true if contact is active, false otherwise
+ *
+ * Reports a contact via ABS_MT_TRACKING_ID, and optionally
+ * ABS_MT_TOOL_TYPE. If active is true and the slot is currently
+ * inactive, or if the tool type is changed, a new tracking id is
+ * assigned to the slot. The tool type is only reported if the
+ * corresponding absbit field is set.
+ */
+void input_mt_report_slot_state(struct input_dev *dev,
+                                unsigned int tool_type, bool active)
+{
+        struct input_mt_slot *mt;
+        int id;
+
+        if (!dev->mt || !active) {
+                input_event(dev, EV_ABS, ABS_MT_TRACKING_ID, -1);
+                return;
+        }
+
+        mt = &dev->mt[dev->slot];
+        id = input_mt_get_value(mt, ABS_MT_TRACKING_ID);
+        if (id < 0 || input_mt_get_value(mt, ABS_MT_TOOL_TYPE) != tool_type)
+                id = input_mt_new_trkid(dev);
+
+        input_event(dev, EV_ABS, ABS_MT_TRACKING_ID, id);
+        input_event(dev, EV_ABS, ABS_MT_TOOL_TYPE, tool_type);
+}
+EXPORT_SYMBOL(input_mt_report_slot_state);
+
+/**
+ * input_mt_report_finger_count() - report contact count
+ * @dev: input device with allocated MT slots
+ * @count: the number of contacts
+ *
+ * Reports the contact count via BTN_TOOL_FINGER, BTN_TOOL_DOUBLETAP,
+ * BTN_TOOL_TRIPLETAP and BTN_TOOL_QUADTAP.
+ *
+ * The input core ensures only the KEY events already setup for
+ * this device will produce output.
+ */
+void input_mt_report_finger_count(struct input_dev *dev, int count)
+{
+        input_event(dev, EV_KEY, BTN_TOOL_FINGER, count == 1);
+        input_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, count == 2);
+        input_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, count == 3);
+        input_event(dev, EV_KEY, BTN_TOOL_QUADTAP, count == 4);
+}
+EXPORT_SYMBOL(input_mt_report_finger_count);
+
+/**
+ * input_mt_report_pointer_emulation() - common pointer emulation
+ * @dev: input device with allocated MT slots
+ * @use_count: report number of active contacts as finger count
+ *
+ * Performs legacy pointer emulation via BTN_TOUCH, ABS_X, ABS_Y and
+ * ABS_PRESSURE. Touchpad finger count is emulated if use_count is true.
+ *
+ * The input core ensures only the KEY and ABS axes already setup for
+ * this device will produce output.
+ */
+void input_mt_report_pointer_emulation(struct input_dev *dev, bool use_count)
+{
+        struct input_mt_slot *oldest = 0;
+        int oldid = dev->trkid;
+        int count = 0;
+        int i;
+
+        for (i = 0; i < dev->mtsize; ++i) {
+                struct input_mt_slot *ps = &dev->mt[i];
+                int id = input_mt_get_value(ps, ABS_MT_TRACKING_ID);
+
+                if (id < 0)
+                        continue;
+                if ((id - oldid) & TRKID_SGN) {
+                        oldest = ps;
+                        oldid = id;
+                }
+                count++;
+        }
+
+        input_event(dev, EV_KEY, BTN_TOUCH, count > 0);
+        if (use_count)
+                input_mt_report_finger_count(dev, count);
+
+        if (oldest) {
+                int x = input_mt_get_value(oldest, ABS_MT_POSITION_X);
+                int y = input_mt_get_value(oldest, ABS_MT_POSITION_Y);
+                int p = input_mt_get_value(oldest, ABS_MT_PRESSURE);
+
+                input_event(dev, EV_ABS, ABS_X, x);
+                input_event(dev, EV_ABS, ABS_Y, y);
+                input_event(dev, EV_ABS, ABS_PRESSURE, p);
+        } else {
+                input_event(dev, EV_ABS, ABS_PRESSURE, 0);
+        }
+}
+EXPORT_SYMBOL(input_mt_report_pointer_emulation);
diff --git a/drivers/input/input-polldev.c b/drivers/input/input-polldev.c
index 10c9b0a845f0..b1aabde87523 100644
--- a/drivers/input/input-polldev.c
+++ b/drivers/input/input-polldev.c
@@ -8,9 +8,12 @@
  * the Free Software Foundation.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/jiffies.h>
 #include <linux/slab.h>
 #include <linux/mutex.h>
+#include <linux/workqueue.h>
 #include <linux/input-polldev.h>
 
 MODULE_AUTHOR("Dmitry Torokhov <dtor@mail.ru>");
@@ -18,45 +21,6 @@ MODULE_DESCRIPTION("Generic implementation of a polled input device");
 MODULE_LICENSE("GPL v2");
 MODULE_VERSION("0.1");
 
-static DEFINE_MUTEX(polldev_mutex);
-static int polldev_users;
-static struct workqueue_struct *polldev_wq;
-
-static int input_polldev_start_workqueue(void)
-{
-        int retval;
-
-        retval = mutex_lock_interruptible(&polldev_mutex);
-        if (retval)
-                return retval;
-
-        if (!polldev_users) {
-                polldev_wq = create_singlethread_workqueue("ipolldevd");
-                if (!polldev_wq) {
-                        printk(KERN_ERR "input-polldev: failed to create "
-                                "ipolldevd workqueue\n");
-                        retval = -ENOMEM;
-                        goto out;
-                }
-        }
-
-        polldev_users++;
-
- out:
-        mutex_unlock(&polldev_mutex);
-        return retval;
-}
-
-static void input_polldev_stop_workqueue(void)
-{
-        mutex_lock(&polldev_mutex);
-
-        if (!--polldev_users)
-                destroy_workqueue(polldev_wq);
-
-        mutex_unlock(&polldev_mutex);
-}
-
 static void input_polldev_queue_work(struct input_polled_dev *dev)
 {
         unsigned long delay;
@@ -65,7 +29,7 @@ static void input_polldev_queue_work(struct input_polled_dev *dev)
         if (delay >= HZ)
                 delay = round_jiffies_relative(delay);
 
-        queue_delayed_work(polldev_wq, &dev->work, delay);
+        queue_delayed_work(system_freezable_wq, &dev->work, delay);
 }
 
 static void input_polled_device_work(struct work_struct *work)
@@ -80,18 +44,13 @@ static void input_polled_device_work(struct work_struct *work)
 static int input_open_polled_device(struct input_dev *input)
 {
         struct input_polled_dev *dev = input_get_drvdata(input);
-        int error;
-
-        error = input_polldev_start_workqueue();
-        if (error)
-                return error;
 
         if (dev->open)
                 dev->open(dev);
 
         /* Only start polling if polling is enabled */
         if (dev->poll_interval > 0)
-                queue_delayed_work(polldev_wq, &dev->work, 0);
+                queue_delayed_work(system_freezable_wq, &dev->work, 0);
 
         return 0;
 }
@@ -101,13 +60,6 @@ static void input_close_polled_device(struct input_dev *input)
         struct input_polled_dev *dev = input_get_drvdata(input);
 
         cancel_delayed_work_sync(&dev->work);
-        /*
-         * Clean up work struct to remove references to the workqueue.
-         * It may be destroyed by the next call. This causes problems
-         * at next device open-close in case of poll_interval == 0.
-         */
-        INIT_DELAYED_WORK(&dev->work, dev->work.work.func);
-        input_polldev_stop_workqueue();
 
         if (dev->close)
                 dev->close(dev);
@@ -191,7 +143,7 @@ static struct attribute_group input_polldev_attribute_group = {
 };
 
 /**
- * input_allocate_polled_device - allocated memory polled device
+ * input_allocate_polled_device - allocate memory for polled device
  *
  * The function allocates memory for a polled device and also
  * for an input device associated with this polled device.
@@ -238,7 +190,7 @@ EXPORT_SYMBOL(input_free_polled_device);
  * with input layer. The device should be allocated with call to
  * input_allocate_polled_device(). Callers should also set up poll()
  * method and set up capabilities (id, name, phys, bits) of the
- * corresponing input_dev structure.
+ * corresponding input_dev structure.
  */
 int input_register_polled_device(struct input_polled_dev *dev)
 {
@@ -294,4 +246,3 @@ void input_unregister_polled_device(struct input_polled_dev *dev)
         input_unregister_device(dev->input);
 }
 EXPORT_SYMBOL(input_unregister_polled_device);
-
diff --git a/drivers/input/input.c b/drivers/input/input.c
index ab6982056518..da38d97a51b1 100644
--- a/drivers/input/input.c
+++ b/drivers/input/input.c
@@ -10,9 +10,11 @@
  * the Free Software Foundation.
  */
 
+#define pr_fmt(fmt) KBUILD_BASENAME ": " fmt
+
 #include <linux/init.h>
 #include <linux/types.h>
-#include <linux/input.h>
+#include <linux/input/mt.h>
 #include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/random.h>
@@ -24,7 +26,6 @@
 #include <linux/device.h>
 #include <linux/mutex.h>
 #include <linux/rcupdate.h>
-#include <linux/smp_lock.h>
 #include "input-compat.h"
 
 MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>");
@@ -171,7 +172,7 @@ static int input_handle_abs_event(struct input_dev *dev,
         if (code == ABS_MT_SLOT) {
                 /*
                  * "Stage" the event; we'll flush it later, when we
-                 * get actiual touch data.
+                 * get actual touch data.
                  */
                 if (*pval >= 0 && *pval < dev->mtsize)
                         dev->slot = *pval;
@@ -188,7 +189,7 @@ static int input_handle_abs_event(struct input_dev *dev,
                 pold = &mtslot->abs[code - ABS_MT_FIRST];
         } else {
                 /*
-                 * Bypass filtering for multitouch events when
+                 * Bypass filtering for multi-touch events when
                  * not employing slots.
                  */
                 pold = NULL;
@@ -450,7 +451,6 @@ int input_grab_device(struct input_handle *handle)
         }
 
         rcu_assign_pointer(dev->grab, handle);
-        synchronize_rcu();
 
  out:
         mutex_unlock(&dev->mutex);
@@ -634,78 +634,141 @@ static void input_disconnect_device(struct input_dev *dev)
         spin_unlock_irq(&dev->event_lock);
 }
 
-static int input_fetch_keycode(struct input_dev *dev, int scancode)
+/**
+ * input_scancode_to_scalar() - converts scancode in &struct input_keymap_entry
+ * @ke: keymap entry containing scancode to be converted.
+ * @scancode: pointer to the location where converted scancode should
+ *      be stored.
+ *
+ * This function is used to convert scancode stored in &struct keymap_entry
+ * into scalar form understood by legacy keymap handling methods. These
+ * methods expect scancodes to be represented as 'unsigned int'.
+ */
+int input_scancode_to_scalar(const struct input_keymap_entry *ke,
+                             unsigned int *scancode)
+{
+        switch (ke->len) {
+        case 1:
+                *scancode = *((u8 *)ke->scancode);
+                break;
+
+        case 2:
+                *scancode = *((u16 *)ke->scancode);
+                break;
+
+        case 4:
+                *scancode = *((u32 *)ke->scancode);
+                break;
+
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL(input_scancode_to_scalar);
+
+/*
+ * Those routines handle the default case where no [gs]etkeycode() is
+ * defined. In this case, an array indexed by the scancode is used.
+ */
+
+static unsigned int input_fetch_keycode(struct input_dev *dev,
+                                        unsigned int index)
 {
         switch (dev->keycodesize) {
-                case 1:
-                        return ((u8 *)dev->keycode)[scancode];
+        case 1:
+                return ((u8 *)dev->keycode)[index];
 
-                case 2:
-                        return ((u16 *)dev->keycode)[scancode];
+        case 2:
+                return ((u16 *)dev->keycode)[index];
 
-                default:
-                        return ((u32 *)dev->keycode)[scancode];
+        default:
+                return ((u32 *)dev->keycode)[index];
         }
 }
 
 static int input_default_getkeycode(struct input_dev *dev,
-                                    unsigned int scancode,
-                                    unsigned int *keycode)
+                                    struct input_keymap_entry *ke)
 {
+        unsigned int index;
+        int error;
+
         if (!dev->keycodesize)
                 return -EINVAL;
 
-        if (scancode >= dev->keycodemax)
+        if (ke->flags & INPUT_KEYMAP_BY_INDEX)
+                index = ke->index;
+        else {
+                error = input_scancode_to_scalar(ke, &index);
+                if (error)
+                        return error;
+        }
+
+        if (index >= dev->keycodemax)
                 return -EINVAL;
 
-        *keycode = input_fetch_keycode(dev, scancode);
+        ke->keycode = input_fetch_keycode(dev, index);
+        ke->index = index;
+        ke->len = sizeof(index);
+        memcpy(ke->scancode, &index, sizeof(index));
 
         return 0;
 }
 
 static int input_default_setkeycode(struct input_dev *dev,
-                                    unsigned int scancode,
-                                    unsigned int keycode)
+                                    const struct input_keymap_entry *ke,
+                                    unsigned int *old_keycode)
 {
-        int old_keycode;
+        unsigned int index;
+        int error;
         int i;
 
-        if (scancode >= dev->keycodemax)
+        if (!dev->keycodesize)
                 return -EINVAL;
 
-        if (!dev->keycodesize)
+        if (ke->flags & INPUT_KEYMAP_BY_INDEX) {
+                index = ke->index;
+        } else {
+                error = input_scancode_to_scalar(ke, &index);
+                if (error)
+                        return error;
+        }
+
+        if (index >= dev->keycodemax)
                 return -EINVAL;
 
-        if (dev->keycodesize < sizeof(keycode) && (keycode >> (dev->keycodesize * 8)))
+        if (dev->keycodesize < sizeof(ke->keycode) &&
+                        (ke->keycode >> (dev->keycodesize * 8)))
                 return -EINVAL;
 
         switch (dev->keycodesize) {
                 case 1: {
                         u8 *k = (u8 *)dev->keycode;
-                        old_keycode = k[scancode];
-                        k[scancode] = keycode;
+                        *old_keycode = k[index];
+                        k[index] = ke->keycode;
                         break;
                 }
                 case 2: {
                         u16 *k = (u16 *)dev->keycode;
-                        old_keycode = k[scancode];
-                        k[scancode] = keycode;
+                        *old_keycode = k[index];
+                        k[index] = ke->keycode;
                         break;
                 }
                 default: {
                         u32 *k = (u32 *)dev->keycode;
-                        old_keycode = k[scancode];
-                        k[scancode] = keycode;
+                        *old_keycode = k[index];
+                        k[index] = ke->keycode;
                         break;
                 }
         }
 
-        __clear_bit(old_keycode, dev->keybit);
-        __set_bit(keycode, dev->keybit);
+        __clear_bit(*old_keycode, dev->keybit);
+        __set_bit(ke->keycode, dev->keybit);
 
         for (i = 0; i < dev->keycodemax; i++) {
-                if (input_fetch_keycode(dev, i) == old_keycode) {
-                        __set_bit(old_keycode, dev->keybit);
+                if (input_fetch_keycode(dev, i) == *old_keycode) {
+                        __set_bit(*old_keycode, dev->keybit);
                         break; /* Setting the bit twice is useless, so break */
                 }
         }
@@ -716,21 +779,18 @@ static int input_default_setkeycode(struct input_dev *dev,
 /**
  * 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
+ * @ke: keymap entry
  *
  * This function should be called by anyone interested in retrieving current
- * keymap. Presently keyboard and evdev handlers use it.
+ * keymap. Presently evdev handlers use it.
  */
-int input_get_keycode(struct input_dev *dev,
-                      unsigned int scancode, unsigned int *keycode)
+int input_get_keycode(struct input_dev *dev, struct input_keymap_entry *ke)
 {
         unsigned long flags;
         int retval;
 
         spin_lock_irqsave(&dev->event_lock, flags);
-        retval = dev->getkeycode(dev, scancode, keycode);
+        retval = dev->getkeycode(dev, ke);
         spin_unlock_irqrestore(&dev->event_lock, flags);
 
         return retval;
@@ -738,31 +798,26 @@ int input_get_keycode(struct input_dev *dev,
 EXPORT_SYMBOL(input_get_keycode);
 
 /**
- * input_get_keycode - assign new keycode to a given scancode
+ * input_set_keycode - attribute a 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
+ * @ke: new keymap entry
  *
  * 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,
-                      unsigned int scancode, unsigned int keycode)
+                      const struct input_keymap_entry *ke)
 {
         unsigned long flags;
         unsigned int old_keycode;
         int retval;
 
-        if (keycode > KEY_MAX)
+        if (ke->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);
+        retval = dev->setkeycode(dev, ke, &old_keycode);
         if (retval)
                 goto out;
 
@@ -848,10 +903,8 @@ static int input_attach_handler(struct input_dev *dev, struct input_handler *han
 
         error = handler->connect(handler, dev, id);
         if (error && error != -ENODEV)
-                printk(KERN_ERR
-                        "input: failed to attach handler %s to device %s, "
-                        "error: %d\n",
-                        handler->name, kobject_name(&dev->dev.kobj), error);
+                pr_err("failed to attach handler %s to device %s, error: %d\n",
+                       handler->name, kobject_name(&dev->dev.kobj), error);
 
         return error;
 }
@@ -999,6 +1052,8 @@ static int input_devices_seq_show(struct seq_file *seq, void *v)
                 seq_printf(seq, "%s ", handle->name);
         seq_putc(seq, '\n');
 
+        input_seq_print_bitmap(seq, "PROP", dev->propbit, INPUT_PROP_MAX);
+
         input_seq_print_bitmap(seq, "EV", dev->evbit, EV_MAX);
         if (test_bit(EV_KEY, dev->evbit))
                 input_seq_print_bitmap(seq, "KEY", dev->keybit, KEY_MAX);
@@ -1222,11 +1277,26 @@ static ssize_t input_dev_show_modalias(struct device *dev,
 }
 static DEVICE_ATTR(modalias, S_IRUGO, input_dev_show_modalias, NULL);
 
+static int input_print_bitmap(char *buf, int buf_size, unsigned long *bitmap,
+                              int max, int add_cr);
+
+static ssize_t input_dev_show_properties(struct device *dev,
+                                         struct device_attribute *attr,
+                                         char *buf)
+{
+        struct input_dev *input_dev = to_input_dev(dev);
+        int len = input_print_bitmap(buf, PAGE_SIZE, input_dev->propbit,
+                                     INPUT_PROP_MAX, true);
+        return min_t(int, len, PAGE_SIZE);
+}
+static DEVICE_ATTR(properties, S_IRUGO, input_dev_show_properties, NULL);
+
 static struct attribute *input_dev_attrs[] = {
         &dev_attr_name.attr,
         &dev_attr_phys.attr,
         &dev_attr_uniq.attr,
         &dev_attr_modalias.attr,
+        &dev_attr_properties.attr,
         NULL
 };
 
@@ -1360,7 +1430,7 @@ static int input_add_uevent_bm_var(struct kobj_uevent_env *env,
 {
         int len;
 
-        if (add_uevent_var(env, "%s=", name))
+        if (add_uevent_var(env, "%s", name))
                 return -ENOMEM;
 
         len = input_print_bitmap(&env->buf[env->buflen - 1],
@@ -1426,6 +1496,8 @@ static int input_dev_uevent(struct device *device, struct kobj_uevent_env *env)
         if (dev->uniq)
                 INPUT_ADD_HOTPLUG_VAR("UNIQ=\"%s\"", dev->uniq);
 
+        INPUT_ADD_HOTPLUG_BM_VAR("PROP=", dev->propbit, INPUT_PROP_MAX);
+
         INPUT_ADD_HOTPLUG_BM_VAR("EV=", dev->evbit, EV_MAX);
         if (test_bit(EV_KEY, dev->evbit))
                 INPUT_ADD_HOTPLUG_BM_VAR("KEY=", dev->keybit, KEY_MAX);
@@ -1469,8 +1541,7 @@ static int input_dev_uevent(struct device *device, struct kobj_uevent_env *env)
                 }                                                       \
         } while (0)
 
-#ifdef CONFIG_PM
-static void input_dev_reset(struct input_dev *dev, bool activate)
+static void input_dev_toggle(struct input_dev *dev, bool activate)
 {
         if (!dev->event)
                 return;
@@ -1484,12 +1555,44 @@ static void input_dev_reset(struct input_dev *dev, bool activate)
         }
 }
 
+/**
+ * input_reset_device() - reset/restore the state of input device
+ * @dev: input device whose state needs to be reset
+ *
+ * This function tries to reset the state of an opened input device and
+ * bring internal state and state if the hardware in sync with each other.
+ * We mark all keys as released, restore LED state, repeat rate, etc.
+ */
+void input_reset_device(struct input_dev *dev)
+{
+        mutex_lock(&dev->mutex);
+
+        if (dev->users) {
+                input_dev_toggle(dev, true);
+
+                /*
+                 * Keys that have been pressed at suspend time are unlikely
+                 * to be still pressed when we resume.
+                 */
+                spin_lock_irq(&dev->event_lock);
+                input_dev_release_keys(dev);
+                spin_unlock_irq(&dev->event_lock);
+        }
+
+        mutex_unlock(&dev->mutex);
+}
+EXPORT_SYMBOL(input_reset_device);
+
+#ifdef CONFIG_PM
 static int input_dev_suspend(struct device *dev)
 {
         struct input_dev *input_dev = to_input_dev(dev);
 
         mutex_lock(&input_dev->mutex);
-        input_dev_reset(input_dev, false);
+
+        if (input_dev->users)
+                input_dev_toggle(input_dev, false);
+
         mutex_unlock(&input_dev->mutex);
 
         return 0;
@@ -1499,18 +1602,7 @@ static int input_dev_resume(struct device *dev)
 {
         struct input_dev *input_dev = to_input_dev(dev);
 
-        mutex_lock(&input_dev->mutex);
-        input_dev_reset(input_dev, true);
-
-        /*
-         * Keys that have been pressed at suspend time are unlikely
-         * to be still pressed when we resume.
-         */
-        spin_lock_irq(&input_dev->event_lock);
-        input_dev_release_keys(input_dev);
-        spin_unlock_irq(&input_dev->event_lock);
-
-        mutex_unlock(&input_dev->mutex);
+        input_reset_device(input_dev);
 
         return 0;
 }
@@ -1595,52 +1687,6 @@ void input_free_device(struct input_dev *dev)
 EXPORT_SYMBOL(input_free_device);
 
 /**
- * input_mt_create_slots() - create MT input slots
- * @dev: input device supporting MT events and finger tracking
- * @num_slots: number of slots used by the device
- *
- * This function allocates all necessary memory for MT slot handling in the
- * input device, and adds ABS_MT_SLOT to the device capabilities. All slots
- * are initially marked as unused iby setting ABS_MT_TRACKING_ID to -1.
- */
-int input_mt_create_slots(struct input_dev *dev, unsigned int num_slots)
-{
-        int i;
-
-        if (!num_slots)
-                return 0;
-
-        dev->mt = kcalloc(num_slots, sizeof(struct input_mt_slot), GFP_KERNEL);
-        if (!dev->mt)
-                return -ENOMEM;
-
-        dev->mtsize = num_slots;
-        input_set_abs_params(dev, ABS_MT_SLOT, 0, num_slots - 1, 0, 0);
-
-        /* Mark slots as 'unused' */
-        for (i = 0; i < num_slots; i++)
-                dev->mt[i].abs[ABS_MT_TRACKING_ID - ABS_MT_FIRST] = -1;
-
-        return 0;
-}
-EXPORT_SYMBOL(input_mt_create_slots);
-
-/**
- * input_mt_destroy_slots() - frees the MT slots of the input device
- * @dev: input device with allocated MT slots
- *
- * This function is only needed in error path as the input core will
- * automatically free the MT slots when the device is destroyed.
- */
-void input_mt_destroy_slots(struct input_dev *dev)
-{
-        kfree(dev->mt);
-        dev->mt = NULL;
-        dev->mtsize = 0;
-}
-EXPORT_SYMBOL(input_mt_destroy_slots);
-
-/**
  * input_set_capability - mark device as capable of a certain event
  * @dev: device that is capable of emitting or accepting event
  * @type: type of the event (EV_KEY, EV_REL, etc...)
@@ -1689,9 +1735,8 @@ void input_set_capability(struct input_dev *dev, unsigned int type, unsigned int
                 break;
 
         default:
-                printk(KERN_ERR
-                        "input_set_capability: unknown type %u (code %u)\n",
-                        type, code);
+                pr_err("input_set_capability: unknown type %u (code %u)\n",
+                       type, code);
                 dump_stack();
                 return;
         }
@@ -1700,6 +1745,42 @@ void input_set_capability(struct input_dev *dev, unsigned int type, unsigned int
 }
 EXPORT_SYMBOL(input_set_capability);
 
+static unsigned int input_estimate_events_per_packet(struct input_dev *dev)
+{
+        int mt_slots;
+        int i;
+        unsigned int events;
+
+        if (dev->mtsize) {
+                mt_slots = dev->mtsize;
+        } else if (test_bit(ABS_MT_TRACKING_ID, dev->absbit)) {
+                mt_slots = dev->absinfo[ABS_MT_TRACKING_ID].maximum -
+                           dev->absinfo[ABS_MT_TRACKING_ID].minimum + 1,
+                mt_slots = clamp(mt_slots, 2, 32);
+        } else if (test_bit(ABS_MT_POSITION_X, dev->absbit)) {
+                mt_slots = 2;
+        } else {
+                mt_slots = 0;
+        }
+
+        events = mt_slots + 1; /* count SYN_MT_REPORT and SYN_REPORT */
+
+        for (i = 0; i < ABS_CNT; i++) {
+                if (test_bit(i, dev->absbit)) {
+                        if (input_is_mt_axis(i))
+                                events += mt_slots;
+                        else
+                                events++;
+                }
+        }
+
+        for (i = 0; i < REL_CNT; i++)
+                if (test_bit(i, dev->relbit))
+                        events++;
+
+        return events;
+}
+
 #define INPUT_CLEANSE_BITMASK(dev, type, bits)                          \
         do {                                                            \
                 if (!test_bit(EV_##type, dev->evbit))                   \
@@ -1747,6 +1828,10 @@ int input_register_device(struct input_dev *dev)
         /* Make sure that bitmasks not mentioned in dev->evbit are clean. */
         input_cleanse_bitmasks(dev);
 
+        if (!dev->hint_events_per_packet)
+                dev->hint_events_per_packet =
+                                input_estimate_events_per_packet(dev);
+
         /*
          * If delay and period are pre-set by the driver, then autorepeating
          * is handled by the driver itself and we don't do it in input.c.
@@ -1773,8 +1858,9 @@ int input_register_device(struct input_dev *dev)
                 return error;
 
         path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
-        printk(KERN_INFO "input: %s as %s\n",
-                dev->name ? dev->name : "Unspecified device", path ? path : "N/A");
+        pr_info("%s as %s\n",
+                dev->name ? dev->name : "Unspecified device",
+                path ? path : "N/A");
         kfree(path);
 
         error = mutex_lock_interruptible(&input_mutex);
@@ -2047,6 +2133,7 @@ out:
 static const struct file_operations input_fops = {
         .owner = THIS_MODULE,
         .open = input_open_file,
+        .llseek = noop_llseek,
 };
 
 static int __init input_init(void)
@@ -2055,7 +2142,7 @@ static int __init input_init(void)
 
         err = class_register(&input_class);
         if (err) {
-                printk(KERN_ERR "input: unable to register input_dev class\n");
+                pr_err("unable to register input_dev class\n");
                 return err;
         }
 
@@ -2065,7 +2152,7 @@ static int __init input_init(void)
 
         err = register_chrdev(INPUT_MAJOR, "input", &input_fops);
         if (err) {
-                printk(KERN_ERR "input: unable to register char major %d", INPUT_MAJOR);
+                pr_err("unable to register char major %d", INPUT_MAJOR);
                 goto fail2;
         }
 
diff --git a/drivers/input/joydev.c b/drivers/input/joydev.c
index 22239e988498..c24ec2d5f926 100644
--- a/drivers/input/joydev.c
+++ b/drivers/input/joydev.c
@@ -10,6 +10,8 @@
  * (at your option) any later version.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <asm/io.h>
 #include <asm/system.h>
 #include <linux/delay.h>
@@ -178,7 +180,6 @@ static void joydev_attach_client(struct joydev *joydev,
         spin_lock(&joydev->client_lock);
         list_add_tail_rcu(&client->node, &joydev->client_list);
         spin_unlock(&joydev->client_lock);
-        synchronize_rcu();
 }
 
 static void joydev_detach_client(struct joydev *joydev,
@@ -739,6 +740,7 @@ static const struct file_operations joydev_fops = {
         .compat_ioctl   = joydev_compat_ioctl,
 #endif
         .fasync         = joydev_fasync,
+        .llseek         = no_llseek,
 };
 
 static int joydev_install_chrdev(struct joydev *joydev)
@@ -755,7 +757,7 @@ static void joydev_remove_chrdev(struct joydev *joydev)
 }
 
 /*
- * Mark device non-existant. This disables writes, ioctls and
+ * Mark device non-existent. This disables writes, ioctls and
  * prevents new users from opening the device. Already posted
  * blocking reads will stay, however new ones will fail.
  */
@@ -774,7 +776,7 @@ static void joydev_cleanup(struct joydev *joydev)
         joydev_hangup(joydev);
         joydev_remove_chrdev(joydev);
 
-        /* joydev is marked dead so noone else accesses joydev->open */
+        /* joydev is marked dead so no one else accesses joydev->open */
         if (joydev->open)
                 input_close_device(handle);
 }
@@ -805,7 +807,7 @@ static int joydev_connect(struct input_handler *handler, struct input_dev *dev,
                         break;
 
         if (minor == JOYDEV_MINORS) {
-                printk(KERN_ERR "joydev: no more free joydev devices\n");
+                pr_err("no more free joydev devices\n");
                 return -ENFILE;
         }
 
diff --git a/drivers/input/joystick/Kconfig b/drivers/input/joystick/Kconfig
index 5b596165b571..56eb471b5576 100644
--- a/drivers/input/joystick/Kconfig
+++ b/drivers/input/joystick/Kconfig
@@ -255,6 +255,16 @@ config JOYSTICK_AMIGA
           To compile this driver as a module, choose M here: the
           module will be called amijoy.
 
+config JOYSTICK_AS5011
+        tristate "Austria Microsystem AS5011 joystick"
+        depends on I2C
+        help
+          Say Y here if you have an AS5011 digital joystick connected to your
+          system.
+
+          To compile this driver as a module, choose M here: the
+          module will be called as5011.
+
 config JOYSTICK_JOYDUMP
         tristate "Gameport data dumper"
         select GAMEPORT
diff --git a/drivers/input/joystick/Makefile b/drivers/input/joystick/Makefile
index f3a8cbe2abb6..92dc0de9dfed 100644
--- a/drivers/input/joystick/Makefile
+++ b/drivers/input/joystick/Makefile
@@ -7,6 +7,7 @@
 obj-$(CONFIG_JOYSTICK_A3D)              += a3d.o
 obj-$(CONFIG_JOYSTICK_ADI)              += adi.o
 obj-$(CONFIG_JOYSTICK_AMIGA)            += amijoy.o
+obj-$(CONFIG_JOYSTICK_AS5011)           += as5011.o
 obj-$(CONFIG_JOYSTICK_ANALOG)           += analog.o
 obj-$(CONFIG_JOYSTICK_COBRA)            += cobra.o
 obj-$(CONFIG_JOYSTICK_DB9)              += db9.o
diff --git a/drivers/input/joystick/a3d.c b/drivers/input/joystick/a3d.c
index d259b41354b8..1639ab2b94b7 100644
--- a/drivers/input/joystick/a3d.c
+++ b/drivers/input/joystick/a3d.c
@@ -3,7 +3,7 @@
  */
 
 /*
- * FP-Gaming Assasin 3D joystick driver for Linux
+ * FP-Gaming Assassin 3D joystick driver for Linux
  */
 
 /*
@@ -34,7 +34,7 @@
 #include <linux/input.h>
 #include <linux/jiffies.h>
 
-#define DRIVER_DESC     "FP-Gaming Assasin 3D joystick driver"
+#define DRIVER_DESC     "FP-Gaming Assassin 3D joystick driver"
 
 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
 MODULE_DESCRIPTION(DRIVER_DESC);
diff --git a/drivers/input/joystick/as5011.c b/drivers/input/joystick/as5011.c
new file mode 100644
index 000000000000..f6732b57ca07
--- /dev/null
+++ b/drivers/input/joystick/as5011.c
@@ -0,0 +1,367 @@
+/*
+ * Copyright (c) 2010, 2011 Fabien Marteau <fabien.marteau@armadeus.com>
+ * Sponsored by ARMadeus Systems
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * Driver for Austria Microsystems joysticks AS5011
+ *
+ * TODO:
+ *      - Power on the chip when open() and power down when close()
+ *      - Manage power mode
+ */
+
+#include <linux/i2c.h>
+#include <linux/interrupt.h>
+#include <linux/input.h>
+#include <linux/gpio.h>
+#include <linux/delay.h>
+#include <linux/input/as5011.h>
+#include <linux/slab.h>
+
+#define DRIVER_DESC "Driver for Austria Microsystems AS5011 joystick"
+#define MODULE_DEVICE_ALIAS "as5011"
+
+MODULE_AUTHOR("Fabien Marteau <fabien.marteau@armadeus.com>");
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_LICENSE("GPL");
+
+/* registers */
+#define AS5011_CTRL1            0x76
+#define AS5011_CTRL2            0x75
+#define AS5011_XP               0x43
+#define AS5011_XN               0x44
+#define AS5011_YP               0x53
+#define AS5011_YN               0x54
+#define AS5011_X_REG            0x41
+#define AS5011_Y_REG            0x42
+#define AS5011_X_RES_INT        0x51
+#define AS5011_Y_RES_INT        0x52
+
+/* CTRL1 bits */
+#define AS5011_CTRL1_LP_PULSED          0x80
+#define AS5011_CTRL1_LP_ACTIVE          0x40
+#define AS5011_CTRL1_LP_CONTINUE        0x20
+#define AS5011_CTRL1_INT_WUP_EN         0x10
+#define AS5011_CTRL1_INT_ACT_EN         0x08
+#define AS5011_CTRL1_EXT_CLK_EN         0x04
+#define AS5011_CTRL1_SOFT_RST           0x02
+#define AS5011_CTRL1_DATA_VALID         0x01
+
+/* CTRL2 bits */
+#define AS5011_CTRL2_EXT_SAMPLE_EN      0x08
+#define AS5011_CTRL2_RC_BIAS_ON         0x04
+#define AS5011_CTRL2_INV_SPINNING       0x02
+
+#define AS5011_MAX_AXIS 80
+#define AS5011_MIN_AXIS (-80)
+#define AS5011_FUZZ     8
+#define AS5011_FLAT     40
+
+struct as5011_device {
+        struct input_dev *input_dev;
+        struct i2c_client *i2c_client;
+        unsigned int button_gpio;
+        unsigned int button_irq;
+        unsigned int axis_irq;
+};
+
+static int as5011_i2c_write(struct i2c_client *client,
+                            uint8_t aregaddr,
+                            uint8_t avalue)
+{
+        uint8_t data[2] = { aregaddr, avalue };
+        struct i2c_msg msg = {
+                client->addr, I2C_M_IGNORE_NAK, 2, (uint8_t *)data
+        };
+        int error;
+
+        error = i2c_transfer(client->adapter, &msg, 1);
+        return error < 0 ? error : 0;
+}
+
+static int as5011_i2c_read(struct i2c_client *client,
+                           uint8_t aregaddr, signed char *value)
+{
+        uint8_t data[2] = { aregaddr };
+        struct i2c_msg msg_set[2] = {
+                { client->addr, I2C_M_REV_DIR_ADDR, 1, (uint8_t *)data },
+                { client->addr, I2C_M_RD | I2C_M_NOSTART, 1, (uint8_t *)data }
+        };
+        int error;
+
+        error = i2c_transfer(client->adapter, msg_set, 2);
+        if (error < 0)
+                return error;
+
+        *value = data[0] & 0x80 ? -1 * (1 + ~data[0]) : data[0];
+        return 0;
+}
+
+static irqreturn_t as5011_button_interrupt(int irq, void *dev_id)
+{
+        struct as5011_device *as5011 = dev_id;
+        int val = gpio_get_value_cansleep(as5011->button_gpio);
+
+        input_report_key(as5011->input_dev, BTN_JOYSTICK, !val);
+        input_sync(as5011->input_dev);
+
+        return IRQ_HANDLED;
+}
+
+static irqreturn_t as5011_axis_interrupt(int irq, void *dev_id)
+{
+        struct as5011_device *as5011 = dev_id;
+        int error;
+        signed char x, y;
+
+        error = as5011_i2c_read(as5011->i2c_client, AS5011_X_RES_INT, &x);
+        if (error < 0)
+                goto out;
+
+        error = as5011_i2c_read(as5011->i2c_client, AS5011_Y_RES_INT, &y);
+        if (error < 0)
+                goto out;
+
+        input_report_abs(as5011->input_dev, ABS_X, x);
+        input_report_abs(as5011->input_dev, ABS_Y, y);
+        input_sync(as5011->input_dev);
+
+out:
+        return IRQ_HANDLED;
+}
+
+static int __devinit as5011_configure_chip(struct as5011_device *as5011,
+                                const struct as5011_platform_data *plat_dat)
+{
+        struct i2c_client *client = as5011->i2c_client;
+        int error;
+        signed char value;
+
+        /* chip soft reset */
+        error = as5011_i2c_write(client, AS5011_CTRL1,
+                                 AS5011_CTRL1_SOFT_RST);
+        if (error < 0) {
+                dev_err(&client->dev, "Soft reset failed\n");
+                return error;
+        }
+
+        mdelay(10);
+
+        error = as5011_i2c_write(client, AS5011_CTRL1,
+                                 AS5011_CTRL1_LP_PULSED |
+                                 AS5011_CTRL1_LP_ACTIVE |
+                                 AS5011_CTRL1_INT_ACT_EN);
+        if (error < 0) {
+                dev_err(&client->dev, "Power config failed\n");
+                return error;
+        }
+
+        error = as5011_i2c_write(client, AS5011_CTRL2,
+                                 AS5011_CTRL2_INV_SPINNING);
+        if (error < 0) {
+                dev_err(&client->dev, "Can't invert spinning\n");
+                return error;
+        }
+
+        /* write threshold */
+        error = as5011_i2c_write(client, AS5011_XP, plat_dat->xp);
+        if (error < 0) {
+                dev_err(&client->dev, "Can't write threshold\n");
+                return error;
+        }
+
+        error = as5011_i2c_write(client, AS5011_XN, plat_dat->xn);
+        if (error < 0) {
+                dev_err(&client->dev, "Can't write threshold\n");
+                return error;
+        }
+
+        error = as5011_i2c_write(client, AS5011_YP, plat_dat->yp);
+        if (error < 0) {
+                dev_err(&client->dev, "Can't write threshold\n");
+                return error;
+        }
+
+        error = as5011_i2c_write(client, AS5011_YN, plat_dat->yn);
+        if (error < 0) {
+                dev_err(&client->dev, "Can't write threshold\n");
+                return error;
+        }
+
+        /* to free irq gpio in chip */
+        error = as5011_i2c_read(client, AS5011_X_RES_INT, &value);
+        if (error < 0) {
+                dev_err(&client->dev, "Can't read i2c X resolution value\n");
+                return error;
+        }
+
+        return 0;
+}
+
+static int __devinit as5011_probe(struct i2c_client *client,
+                                const struct i2c_device_id *id)
+{
+        const struct as5011_platform_data *plat_data;
+        struct as5011_device *as5011;
+        struct input_dev *input_dev;
+        int irq;
+        int error;
+
+        plat_data = client->dev.platform_data;
+        if (!plat_data)
+                return -EINVAL;
+
+        if (!plat_data->axis_irq) {
+                dev_err(&client->dev, "No axis IRQ?\n");
+                return -EINVAL;
+        }
+
+        if (!i2c_check_functionality(client->adapter,
+                                     I2C_FUNC_PROTOCOL_MANGLING)) {
+                dev_err(&client->dev,
+                        "need i2c bus that supports protocol mangling\n");
+                return -ENODEV;
+        }
+
+        as5011 = kmalloc(sizeof(struct as5011_device), GFP_KERNEL);
+        input_dev = input_allocate_device();
+        if (!as5011 || !input_dev) {
+                dev_err(&client->dev,
+                        "Can't allocate memory for device structure\n");
+                error = -ENOMEM;
+                goto err_free_mem;
+        }
+
+        as5011->i2c_client = client;
+        as5011->input_dev = input_dev;
+        as5011->button_gpio = plat_data->button_gpio;
+        as5011->axis_irq = plat_data->axis_irq;
+
+        input_dev->name = "Austria Microsystem as5011 joystick";
+        input_dev->id.bustype = BUS_I2C;
+        input_dev->dev.parent = &client->dev;
+
+        __set_bit(EV_KEY, input_dev->evbit);
+        __set_bit(EV_ABS, input_dev->evbit);
+        __set_bit(BTN_JOYSTICK, input_dev->keybit);
+
+        input_set_abs_params(input_dev, ABS_X,
+                AS5011_MIN_AXIS, AS5011_MAX_AXIS, AS5011_FUZZ, AS5011_FLAT);
+        input_set_abs_params(as5011->input_dev, ABS_Y,
+                AS5011_MIN_AXIS, AS5011_MAX_AXIS, AS5011_FUZZ, AS5011_FLAT);
+
+        error = gpio_request(as5011->button_gpio, "AS5011 button");
+        if (error < 0) {
+                dev_err(&client->dev, "Failed to request button gpio\n");
+                goto err_free_mem;
+        }
+
+        irq = gpio_to_irq(as5011->button_gpio);
+        if (irq < 0) {
+                dev_err(&client->dev,
+                        "Failed to get irq number for button gpio\n");
+                goto err_free_button_gpio;
+        }
+
+        as5011->button_irq = irq;
+
+        error = request_threaded_irq(as5011->button_irq,
+                                     NULL, as5011_button_interrupt,
+                                     IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
+                                     "as5011_button", as5011);
+        if (error < 0) {
+                dev_err(&client->dev,
+                        "Can't allocate button irq %d\n", as5011->button_irq);
+                goto err_free_button_gpio;
+        }
+
+        error = as5011_configure_chip(as5011, plat_data);
+        if (error)
+                goto err_free_button_irq;
+
+        error = request_threaded_irq(as5011->axis_irq, NULL,
+                                     as5011_axis_interrupt,
+                                     plat_data->axis_irqflags,
+                                     "as5011_joystick", as5011);
+        if (error) {
+                dev_err(&client->dev,
+                        "Can't allocate axis irq %d\n", plat_data->axis_irq);
+                goto err_free_button_irq;
+        }
+
+        error = input_register_device(as5011->input_dev);
+        if (error) {
+                dev_err(&client->dev, "Failed to register input device\n");
+                goto err_free_axis_irq;
+        }
+
+        i2c_set_clientdata(client, as5011);
+
+        return 0;
+
+err_free_axis_irq:
+        free_irq(as5011->axis_irq, as5011);
+err_free_button_irq:
+        free_irq(as5011->button_irq, as5011);
+err_free_button_gpio:
+        gpio_free(as5011->button_gpio);
+err_free_mem:
+        input_free_device(input_dev);
+        kfree(as5011);
+
+        return error;
+}
+
+static int __devexit as5011_remove(struct i2c_client *client)
+{
+        struct as5011_device *as5011 = i2c_get_clientdata(client);
+
+        free_irq(as5011->axis_irq, as5011);
+        free_irq(as5011->button_irq, as5011);
+        gpio_free(as5011->button_gpio);
+
+        input_unregister_device(as5011->input_dev);
+        kfree(as5011);
+
+        return 0;
+}
+
+static const struct i2c_device_id as5011_id[] = {
+        { MODULE_DEVICE_ALIAS, 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, as5011_id);
+
+static struct i2c_driver as5011_driver = {
+        .driver = {
+                .name = "as5011",
+        },
+        .probe          = as5011_probe,
+        .remove         = __devexit_p(as5011_remove),
+        .id_table       = as5011_id,
+};
+
+static int __init as5011_init(void)
+{
+        return i2c_add_driver(&as5011_driver);
+}
+module_init(as5011_init);
+
+static void __exit as5011_exit(void)
+{
+        i2c_del_driver(&as5011_driver);
+}
+module_exit(as5011_exit);
diff --git a/drivers/input/joystick/gamecon.c b/drivers/input/joystick/gamecon.c
index 0ffaf2c77a19..e68e49786483 100644
--- a/drivers/input/joystick/gamecon.c
+++ b/drivers/input/joystick/gamecon.c
@@ -521,9 +521,8 @@ static void gc_multi_process_packet(struct gc *gc)
  * PSX support
  *
  * See documentation at:
- *      http://www.dim.com/~mackys/psxmemcard/ps-eng2.txt
+ *      http://www.geocities.co.jp/Playtown/2004/psx/ps_eng.txt 
  *      http://www.gamesx.com/controldata/psxcont/psxcont.htm
- *      ftp://milano.usal.es/pablo/
  *
  */
 
diff --git a/drivers/input/joystick/iforce/Makefile b/drivers/input/joystick/iforce/Makefile
index 74daff49ab6e..bc5bda22f15e 100644
--- a/drivers/input/joystick/iforce/Makefile
+++ b/drivers/input/joystick/iforce/Makefile
@@ -4,17 +4,8 @@
 # By Johann Deneux <johann.deneux@gmail.com>
 #
 
-# Goal definition
-iforce-objs     := iforce-ff.o iforce-main.o iforce-packets.o
-
 obj-$(CONFIG_JOYSTICK_IFORCE)   += iforce.o
 
-ifeq ($(CONFIG_JOYSTICK_IFORCE_232),y)
-        iforce-objs += iforce-serio.o
-endif
-
-ifeq ($(CONFIG_JOYSTICK_IFORCE_USB),y)
-        iforce-objs += iforce-usb.o
-endif
-
-EXTRA_CFLAGS = -Werror-implicit-function-declaration
+iforce-y := iforce-ff.o iforce-main.o iforce-packets.o
+iforce-$(CONFIG_JOYSTICK_IFORCE_232)    += iforce-serio.o
+iforce-$(CONFIG_JOYSTICK_IFORCE_USB)    += iforce-usb.o
diff --git a/drivers/input/joystick/turbografx.c b/drivers/input/joystick/turbografx.c
index d53b9e900234..27b6a3ce18ca 100644
--- a/drivers/input/joystick/turbografx.c
+++ b/drivers/input/joystick/turbografx.c
@@ -245,6 +245,7 @@ static struct tgfx __init *tgfx_probe(int parport, int *n_buttons, int n_devs)
                 goto err_free_tgfx;
         }
 
+        parport_put_port(pp);
         return tgfx;
 
  err_free_dev:
diff --git a/drivers/input/joystick/xpad.c b/drivers/input/joystick/xpad.c
index f9fb7fa10af3..56abf3d0e911 100644
--- a/drivers/input/joystick/xpad.c
+++ b/drivers/input/joystick/xpad.c
@@ -543,21 +543,25 @@ exit:
 static int xpad_init_output(struct usb_interface *intf, struct usb_xpad *xpad)
 {
         struct usb_endpoint_descriptor *ep_irq_out;
-        int error = -ENOMEM;
+        int error;
 
         if (xpad->xtype != XTYPE_XBOX360 && xpad->xtype != XTYPE_XBOX)
                 return 0;
 
         xpad->odata = usb_alloc_coherent(xpad->udev, XPAD_PKT_LEN,
                                          GFP_KERNEL, &xpad->odata_dma);
-        if (!xpad->odata)
+        if (!xpad->odata) {
+                error = -ENOMEM;
                 goto fail1;
+        }
 
         mutex_init(&xpad->odata_mutex);
 
         xpad->irq_out = usb_alloc_urb(0, GFP_KERNEL);
-        if (!xpad->irq_out)
+        if (!xpad->irq_out) {
+                error = -ENOMEM;
                 goto fail2;
+        }
 
         ep_irq_out = &intf->cur_altsetting->endpoint[1].desc;
         usb_fill_int_urb(xpad->irq_out, xpad->udev,
@@ -728,7 +732,7 @@ static void xpad_led_disconnect(struct usb_xpad *xpad)
 
         if (xpad_led) {
                 led_classdev_unregister(&xpad_led->led_cdev);
-                kfree(xpad_led->name);
+                kfree(xpad_led);
         }
 }
 #else
@@ -756,8 +760,9 @@ static void xpad_close(struct input_dev *dev)
 {
         struct usb_xpad *xpad = input_get_drvdata(dev);
 
-        if(xpad->xtype != XTYPE_XBOX360W)
+        if (xpad->xtype != XTYPE_XBOX360W)
                 usb_kill_urb(xpad->irq_in);
+
         xpad_stop_output(xpad);
 }
 
@@ -789,8 +794,7 @@ static int xpad_probe(struct usb_interface *intf, const struct usb_device_id *id
         struct usb_xpad *xpad;
         struct input_dev *input_dev;
         struct usb_endpoint_descriptor *ep_irq_in;
-        int i;
-        int error = -ENOMEM;
+        int i, error;
 
         for (i = 0; xpad_device[i].idVendor; i++) {
                 if ((le16_to_cpu(udev->descriptor.idVendor) == xpad_device[i].idVendor) &&
@@ -800,17 +804,23 @@ static int xpad_probe(struct usb_interface *intf, const struct usb_device_id *id
 
         xpad = kzalloc(sizeof(struct usb_xpad), GFP_KERNEL);
         input_dev = input_allocate_device();
-        if (!xpad || !input_dev)
+        if (!xpad || !input_dev) {
+                error = -ENOMEM;
                 goto fail1;
+        }
 
         xpad->idata = usb_alloc_coherent(udev, XPAD_PKT_LEN,
                                          GFP_KERNEL, &xpad->idata_dma);
-        if (!xpad->idata)
+        if (!xpad->idata) {
+                error = -ENOMEM;
                 goto fail1;
+        }
 
         xpad->irq_in = usb_alloc_urb(0, GFP_KERNEL);
-        if (!xpad->irq_in)
+        if (!xpad->irq_in) {
+                error = -ENOMEM;
                 goto fail2;
+        }
 
         xpad->udev = udev;
         xpad->mapping = xpad_device[i].mapping;
@@ -887,15 +897,15 @@ static int xpad_probe(struct usb_interface *intf, const struct usb_device_id *id
 
         error = xpad_init_output(intf, xpad);
         if (error)
-                goto fail2;
+                goto fail3;
 
         error = xpad_init_ff(xpad);
         if (error)
-                goto fail3;
+                goto fail4;
 
         error = xpad_led_probe(xpad);
         if (error)
-                goto fail3;
+                goto fail5;
 
         ep_irq_in = &intf->cur_altsetting->endpoint[0].desc;
         usb_fill_int_urb(xpad->irq_in, udev,
@@ -907,34 +917,26 @@ static int xpad_probe(struct usb_interface *intf, const struct usb_device_id *id
 
         error = input_register_device(xpad->dev);
         if (error)
-                goto fail4;
+                goto fail6;
 
         usb_set_intfdata(intf, xpad);
 
-        /*
-         * Submit the int URB immediatly rather than waiting for open
-         * because we get status messages from the device whether
-         * or not any controllers are attached.  In fact, it's
-         * exactly the message that a controller has arrived that
-         * we're waiting for.
-         */
         if (xpad->xtype == XTYPE_XBOX360W) {
-                xpad->irq_in->dev = xpad->udev;
-                error = usb_submit_urb(xpad->irq_in, GFP_KERNEL);
-                if (error)
-                        goto fail4;
-
                 /*
                  * Setup the message to set the LEDs on the
                  * controller when it shows up
                  */
                 xpad->bulk_out = usb_alloc_urb(0, GFP_KERNEL);
-                if(!xpad->bulk_out)
-                        goto fail5;
+                if (!xpad->bulk_out) {
+                        error = -ENOMEM;
+                        goto fail7;
+                }
 
                 xpad->bdata = kzalloc(XPAD_PKT_LEN, GFP_KERNEL);
-                if(!xpad->bdata)
-                        goto fail6;
+                if (!xpad->bdata) {
+                        error = -ENOMEM;
+                        goto fail8;
+                }
 
                 xpad->bdata[2] = 0x08;
                 switch (intf->cur_altsetting->desc.bInterfaceNumber) {
@@ -955,14 +957,31 @@ static int xpad_probe(struct usb_interface *intf, const struct usb_device_id *id
                 usb_fill_bulk_urb(xpad->bulk_out, udev,
                                 usb_sndbulkpipe(udev, ep_irq_in->bEndpointAddress),
                                 xpad->bdata, XPAD_PKT_LEN, xpad_bulk_out, xpad);
+
+                /*
+                 * Submit the int URB immediately rather than waiting for open
+                 * because we get status messages from the device whether
+                 * or not any controllers are attached.  In fact, it's
+                 * exactly the message that a controller has arrived that
+                 * we're waiting for.
+                 */
+                xpad->irq_in->dev = xpad->udev;
+                error = usb_submit_urb(xpad->irq_in, GFP_KERNEL);
+                if (error)
+                        goto fail9;
         }
 
         return 0;
 
- fail6: usb_free_urb(xpad->bulk_out);
- fail5: usb_kill_urb(xpad->irq_in);
- fail4: usb_free_urb(xpad->irq_in);
- fail3: xpad_deinit_output(xpad);
+ fail9: kfree(xpad->bdata);
+ fail8: usb_free_urb(xpad->bulk_out);
+ fail7: input_unregister_device(input_dev);
+        input_dev = NULL;
+ fail6: xpad_led_disconnect(xpad);
+ fail5: if (input_dev)
+                input_ff_destroy(input_dev);
+ fail4: xpad_deinit_output(xpad);
+ fail3: usb_free_urb(xpad->irq_in);
  fail2: usb_free_coherent(udev, XPAD_PKT_LEN, xpad->idata, xpad->idata_dma);
  fail1: input_free_device(input_dev);
         kfree(xpad);
@@ -974,21 +993,24 @@ static void xpad_disconnect(struct usb_interface *intf)
 {
         struct usb_xpad *xpad = usb_get_intfdata (intf);
 
-        usb_set_intfdata(intf, NULL);
-        if (xpad) {
-                xpad_led_disconnect(xpad);
-                input_unregister_device(xpad->dev);
-                xpad_deinit_output(xpad);
-                if (xpad->xtype == XTYPE_XBOX360W) {
-                        usb_kill_urb(xpad->bulk_out);
-                        usb_free_urb(xpad->bulk_out);
-                        usb_kill_urb(xpad->irq_in);
-                }
-                usb_free_urb(xpad->irq_in);
-                usb_free_coherent(xpad->udev, XPAD_PKT_LEN,
-                                xpad->idata, xpad->idata_dma);
-                kfree(xpad);
+        xpad_led_disconnect(xpad);
+        input_unregister_device(xpad->dev);
+        xpad_deinit_output(xpad);
+
+        if (xpad->xtype == XTYPE_XBOX360W) {
+                usb_kill_urb(xpad->bulk_out);
+                usb_free_urb(xpad->bulk_out);
+                usb_kill_urb(xpad->irq_in);
         }
+
+        usb_free_urb(xpad->irq_in);
+        usb_free_coherent(xpad->udev, XPAD_PKT_LEN,
+                        xpad->idata, xpad->idata_dma);
+
+        kfree(xpad->bdata);
+        kfree(xpad);
+
+        usb_set_intfdata(intf, NULL);
 }
 
 static struct usb_driver xpad_driver = {
@@ -1000,10 +1022,7 @@ static struct usb_driver xpad_driver = {
 
 static int __init usb_xpad_init(void)
 {
-        int result = usb_register(&xpad_driver);
-        if (result == 0)
-                printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
-        return result;
+        return usb_register(&xpad_driver);
 }
 
 static void __exit usb_xpad_exit(void)
diff --git a/drivers/input/keyboard/Kconfig b/drivers/input/keyboard/Kconfig
index 9cc488d21490..b4dee9d5a055 100644
--- a/drivers/input/keyboard/Kconfig
+++ b/drivers/input/keyboard/Kconfig
@@ -2,7 +2,7 @@
 # Input core configuration
 #
 menuconfig INPUT_KEYBOARD
-        bool "Keyboards" if EMBEDDED || !X86
+        bool "Keyboards" if EXPERT || !X86
         default y
         help
           Say Y here, and a list of supported keyboards will be displayed.
@@ -12,18 +12,6 @@ menuconfig INPUT_KEYBOARD
 
 if INPUT_KEYBOARD
 
-config KEYBOARD_AAED2000
-        tristate "AAED-2000 keyboard"
-        depends on MACH_AAED2000
-        select INPUT_POLLDEV
-        default y
-        help
-          Say Y here to enable the keyboard on the Agilent AAED-2000
-          development board.
-
-          To compile this driver as a module, choose M here: the
-          module will be called aaed2000_kbd.
-
 config KEYBOARD_ADP5520
         tristate "Keypad Support for ADP5520 PMIC"
         depends on PMIC_ADP5520
@@ -44,6 +32,16 @@ config KEYBOARD_ADP5588
           To compile this driver as a module, choose M here: the
           module will be called adp5588-keys.
 
+config KEYBOARD_ADP5589
+        tristate "ADP5589 I2C QWERTY Keypad and IO Expander"
+        depends on I2C
+        help
+          Say Y here if you want to use a ADP5589 attached to your
+          system I2C bus.
+
+          To compile this driver as a module, choose M here: the
+          module will be called adp5589-keys.
+
 config KEYBOARD_AMIGA
         tristate "Amiga keyboard"
         depends on AMIGA
@@ -69,7 +67,7 @@ config KEYBOARD_ATARI
           module will be called atakbd.
 
 config KEYBOARD_ATKBD
-        tristate "AT keyboard" if EMBEDDED || !X86
+        tristate "AT keyboard" if EXPERT || !X86
         default y
         select SERIO
         select SERIO_LIBPS2
@@ -124,6 +122,16 @@ config KEYBOARD_ATKBD_RDI_KEYCODES
           right-hand column will be interpreted as the key shown in the
           left-hand column.
 
+config KEYBOARD_QT1070
+       tristate "Atmel AT42QT1070 Touch Sensor Chip"
+       depends on I2C
+       help
+         Say Y here if you want to use Atmel AT42QT1070 QTouch
+         Sensor chip as input device.
+
+         To compile this driver as a module, choose M here:
+         the module will be called qt1070
+
 config KEYBOARD_QT2160
         tristate "Atmel AT42QT2160 Touch Sensor Chip"
         depends on I2C && EXPERIMENTAL
@@ -179,21 +187,39 @@ config KEYBOARD_GPIO
           To compile this driver as a module, choose M here: the
           module will be called gpio_keys.
 
+config KEYBOARD_GPIO_POLLED
+        tristate "Polled GPIO buttons"
+        depends on GENERIC_GPIO
+        select INPUT_POLLDEV
+        help
+          This driver implements support for buttons connected
+          to GPIO pins that are not capable of generating interrupts.
+
+          Say Y here if your device has buttons connected
+          directly to such GPIO pins.  Your board-specific
+          setup logic must also provide a platform device,
+          with configuration data saying which GPIOs are used.
+
+          To compile this driver as a module, choose M here: the
+          module will be called gpio_keys_polled.
+
 config KEYBOARD_TCA6416
-        tristate "TCA6416 Keypad Support"
+        tristate "TCA6416/TCA6408A Keypad Support"
         depends on I2C
         help
           This driver implements basic keypad functionality
-          for keys connected through TCA6416 IO expander
+          for keys connected through TCA6416/TCA6408A IO expanders.
 
           Say Y here if your device has keys connected to
-          TCA6416 IO expander. Your board-specific setup logic
+          TCA6416/TCA6408A IO expander. Your board-specific setup logic
           must also provide pin-mask details(of which TCA6416 pins
           are used for keypad).
 
-          If enabled the complete TCA6416 device will be managed through
+          If enabled the entire TCA6416 device will be managed through
           this driver.
 
+          To compile this driver as a module, choose M here: the
+          module will be called tca6416_keypad.
 
 config KEYBOARD_MATRIX
         tristate "GPIO driven matrix keypad support"
@@ -309,6 +335,18 @@ config KEYBOARD_MCS
           To compile this driver as a module, choose M here: the
           module will be called mcs_touchkey.
 
+config KEYBOARD_MPR121
+        tristate "Freescale MPR121 Touchkey"
+        depends on I2C
+        help
+          Say Y here if you have Freescale MPR121 touchkey controller
+          chip in your system.
+
+          If unsure, say N.
+
+          To compile this driver as a module, choose M here: the
+          module will be called mpr121_touchkey.
+
 config KEYBOARD_IMX
         tristate "IMX keypad support"
         depends on ARCH_MXC
@@ -327,6 +365,26 @@ config KEYBOARD_NEWTON
           To compile this driver as a module, choose M here: the
           module will be called newtonkbd.
 
+config KEYBOARD_NOMADIK
+        tristate "ST-Ericsson Nomadik SKE keyboard"
+        depends on PLAT_NOMADIK
+        help
+          Say Y here if you want to use a keypad provided on the SKE controller
+          used on the Ux500 and Nomadik platforms
+
+          To compile this driver as a module, choose M here: the
+          module will be called nmk-ske-keypad.
+
+config KEYBOARD_TEGRA
+        tristate "NVIDIA Tegra internal matrix keyboard controller support"
+        depends on ARCH_TEGRA
+        help
+          Say Y here if you want to use a matrix keyboard connected directly
+          to the internal keyboard controller on Tegra SoCs.
+
+          To compile this driver as a module, choose M here: the
+          module will be called tegra-kbc.
+
 config KEYBOARD_OPENCORES
         tristate "OpenCores Keyboard Controller"
         help
@@ -338,7 +396,7 @@ config KEYBOARD_OPENCORES
 
 config KEYBOARD_PXA27x
         tristate "PXA27x/PXA3xx keypad support"
-        depends on PXA27x || PXA3xx
+        depends on PXA27x || PXA3xx || ARCH_MMP
         help
           Enable support for PXA27x/PXA3xx keypad controller.
 
@@ -354,6 +412,17 @@ config KEYBOARD_PXA930_ROTARY
           To compile this driver as a module, choose M here: the
           module will be called pxa930_rotary.
 
+config KEYBOARD_PMIC8XXX
+        tristate "Qualcomm PMIC8XXX keypad support"
+        depends on MFD_PM8XXX
+        help
+          Say Y here if you want to enable the driver for the PMIC8XXX
+          keypad provided as a reference design from Qualcomm. This is intended
+          to support upto 18x8 matrix based keypad design.
+
+          To compile this driver as a module, choose M here: the module will
+          be called pmic8xxx-keypad.
+
 config KEYBOARD_SAMSUNG
         tristate "Samsung keypad support"
         depends on SAMSUNG_DEV_KEYPAD
@@ -424,6 +493,43 @@ config KEYBOARD_OMAP
           To compile this driver as a module, choose M here: the
           module will be called omap-keypad.
 
+config KEYBOARD_OMAP4
+        tristate "TI OMAP4 keypad support"
+        depends on ARCH_OMAP4
+        help
+          Say Y here if you want to use the OMAP4 keypad.
+
+          To compile this driver as a module, choose M here: the
+          module will be called omap4-keypad.
+
+config KEYBOARD_SPEAR
+        tristate "ST SPEAR keyboard support"
+        depends on PLAT_SPEAR
+        help
+          Say Y here if you want to use the SPEAR keyboard.
+
+          To compile this driver as a module, choose M here: the
+          module will be called spear-keboard.
+
+config KEYBOARD_TC3589X
+        tristate "TC3589X Keypad support"
+        depends on MFD_TC3589X
+        help
+          Say Y here if you want to use the keypad controller on
+          TC35892/3 I/O expander.
+
+          To compile this driver as a module, choose M here: the
+          module will be called tc3589x-keypad.
+
+config KEYBOARD_TNETV107X
+        tristate "TI TNETV107X keypad support"
+        depends on ARCH_DAVINCI_TNETV107X
+        help
+          Say Y here if you want to use the TNETV107X keypad.
+
+          To compile this driver as a module, choose M here: the
+          module will be called tnetv107x-keypad.
+
 config KEYBOARD_TWL4030
         tristate "TI TWL4030/TWL5030/TPS659x0 keypad support"
         depends on TWL4030_CORE
diff --git a/drivers/input/keyboard/Makefile b/drivers/input/keyboard/Makefile
index 504b591be0cd..ddde0fd476f7 100644
--- a/drivers/input/keyboard/Makefile
+++ b/drivers/input/keyboard/Makefile
@@ -4,9 +4,9 @@
 
 # Each configuration option enables a list of files.
 
-obj-$(CONFIG_KEYBOARD_AAED2000)         += aaed2000_kbd.o
 obj-$(CONFIG_KEYBOARD_ADP5520)          += adp5520-keys.o
 obj-$(CONFIG_KEYBOARD_ADP5588)          += adp5588-keys.o
+obj-$(CONFIG_KEYBOARD_ADP5589)          += adp5589-keys.o
 obj-$(CONFIG_KEYBOARD_AMIGA)            += amikbd.o
 obj-$(CONFIG_KEYBOARD_ATARI)            += atakbd.o
 obj-$(CONFIG_KEYBOARD_ATKBD)            += atkbd.o
@@ -14,6 +14,7 @@ obj-$(CONFIG_KEYBOARD_BFIN)		+= bf54x-keys.o
 obj-$(CONFIG_KEYBOARD_DAVINCI)          += davinci_keyscan.o
 obj-$(CONFIG_KEYBOARD_EP93XX)           += ep93xx_keypad.o
 obj-$(CONFIG_KEYBOARD_GPIO)             += gpio_keys.o
+obj-$(CONFIG_KEYBOARD_GPIO_POLLED)      += gpio_keys_polled.o
 obj-$(CONFIG_KEYBOARD_TCA6416)          += tca6416-keypad.o
 obj-$(CONFIG_KEYBOARD_HIL)              += hil_kbd.o
 obj-$(CONFIG_KEYBOARD_HIL_OLD)          += hilkbd.o
@@ -27,17 +28,26 @@ obj-$(CONFIG_KEYBOARD_MAPLE)		+= maple_keyb.o
 obj-$(CONFIG_KEYBOARD_MATRIX)           += matrix_keypad.o
 obj-$(CONFIG_KEYBOARD_MAX7359)          += max7359_keypad.o
 obj-$(CONFIG_KEYBOARD_MCS)              += mcs_touchkey.o
+obj-$(CONFIG_KEYBOARD_MPR121)           += mpr121_touchkey.o
 obj-$(CONFIG_KEYBOARD_NEWTON)           += newtonkbd.o
+obj-$(CONFIG_KEYBOARD_NOMADIK)          += nomadik-ske-keypad.o
 obj-$(CONFIG_KEYBOARD_OMAP)             += omap-keypad.o
+obj-$(CONFIG_KEYBOARD_OMAP4)            += omap4-keypad.o
 obj-$(CONFIG_KEYBOARD_OPENCORES)        += opencores-kbd.o
+obj-$(CONFIG_KEYBOARD_PMIC8XXX)         += pmic8xxx-keypad.o
 obj-$(CONFIG_KEYBOARD_PXA27x)           += pxa27x_keypad.o
 obj-$(CONFIG_KEYBOARD_PXA930_ROTARY)    += pxa930_rotary.o
+obj-$(CONFIG_KEYBOARD_QT1070)           += qt1070.o
 obj-$(CONFIG_KEYBOARD_QT2160)           += qt2160.o
 obj-$(CONFIG_KEYBOARD_SAMSUNG)          += samsung-keypad.o
 obj-$(CONFIG_KEYBOARD_SH_KEYSC)         += sh_keysc.o
+obj-$(CONFIG_KEYBOARD_SPEAR)            += spear-keyboard.o
 obj-$(CONFIG_KEYBOARD_STMPE)            += stmpe-keypad.o
 obj-$(CONFIG_KEYBOARD_STOWAWAY)         += stowaway.o
 obj-$(CONFIG_KEYBOARD_SUNKBD)           += sunkbd.o
+obj-$(CONFIG_KEYBOARD_TC3589X)          += tc3589x-keypad.o
+obj-$(CONFIG_KEYBOARD_TEGRA)            += tegra-kbc.o
+obj-$(CONFIG_KEYBOARD_TNETV107X)        += tnetv107x-keypad.o
 obj-$(CONFIG_KEYBOARD_TWL4030)          += twl4030_keypad.o
 obj-$(CONFIG_KEYBOARD_XTKBD)            += xtkbd.o
 obj-$(CONFIG_KEYBOARD_W90P910)          += w90p910_keypad.o
diff --git a/drivers/input/keyboard/aaed2000_kbd.c b/drivers/input/keyboard/aaed2000_kbd.c
deleted file mode 100644
index 18222a689a03..000000000000
--- a/drivers/input/keyboard/aaed2000_kbd.c
+++ /dev/null
@@ -1,186 +0,0 @@
-/*
- *  Keyboard driver for the AAED-2000 dev board
- *
- *  Copyright (c) 2006 Nicolas Bellido Y Ortega
- *
- *  Based on 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/delay.h>
-#include <linux/platform_device.h>
-#include <linux/init.h>
-#include <linux/input-polldev.h>
-#include <linux/interrupt.h>
-#include <linux/jiffies.h>
-#include <linux/module.h>
-#include <linux/slab.h>
-
-#include <mach/hardware.h>
-#include <mach/aaed2000.h>
-
-#define KB_ROWS                 12
-#define KB_COLS                 8
-#define KB_ROWMASK(r)           (1 << (r))
-#define SCANCODE(r,c)           (((c) * KB_ROWS) + (r))
-#define NR_SCANCODES            (KB_COLS * KB_ROWS)
-
-#define SCAN_INTERVAL           (50) /* ms */
-#define KB_ACTIVATE_DELAY       (20) /* us */
-
-static unsigned char aaedkbd_keycode[NR_SCANCODES] = {
-        KEY_9, KEY_0, KEY_MINUS, KEY_EQUAL, KEY_BACKSPACE, 0, KEY_SPACE, KEY_KP6, 0, KEY_KPDOT, 0, 0,
-        KEY_K, KEY_M, KEY_O, KEY_DOT, KEY_SLASH, 0, KEY_F, 0, 0, 0, KEY_LEFTSHIFT, 0,
-        KEY_I, KEY_P, KEY_LEFTBRACE, KEY_RIGHTBRACE, KEY_BACKSLASH, 0, 0, 0, 0, 0, KEY_RIGHTSHIFT, 0,
-        KEY_8, KEY_L, KEY_SEMICOLON, KEY_APOSTROPHE, KEY_ENTER, 0, 0, 0, 0, 0, 0, 0,
-        KEY_J, KEY_H, KEY_B, KEY_KP8, KEY_KP4, 0, KEY_C, KEY_D, KEY_S, KEY_A, 0, KEY_CAPSLOCK,
-        KEY_Y, KEY_U, KEY_N, KEY_T, 0, 0, KEY_R, KEY_E, KEY_W, KEY_Q, 0, KEY_TAB,
-        KEY_7, KEY_6, KEY_G, 0, KEY_5, 0, KEY_4, KEY_3, KEY_2, KEY_1, 0, KEY_GRAVE,
-        0, 0, KEY_COMMA, 0, KEY_KP2, 0, KEY_V, KEY_LEFTALT, KEY_X, KEY_Z, 0, KEY_LEFTCTRL
-};
-
-struct aaedkbd {
-        unsigned char keycode[ARRAY_SIZE(aaedkbd_keycode)];
-        struct input_polled_dev *poll_dev;
-        int kbdscan_state[KB_COLS];
-        int kbdscan_count[KB_COLS];
-};
-
-#define KBDSCAN_STABLE_COUNT 2
-
-static void aaedkbd_report_col(struct aaedkbd *aaedkbd,
-                                unsigned int col, unsigned int rowd)
-{
-        unsigned int scancode, pressed;
-        unsigned int row;
-
-        for (row = 0; row < KB_ROWS; row++) {
-                scancode = SCANCODE(row, col);
-                pressed = rowd & KB_ROWMASK(row);
-
-                input_report_key(aaedkbd->poll_dev->input,
-                                 aaedkbd->keycode[scancode], pressed);
-        }
-}
-
-/* Scan the hardware keyboard and push any changes up through the input layer */
-static void aaedkbd_poll(struct input_polled_dev *dev)
-{
-        struct aaedkbd *aaedkbd = dev->private;
-        unsigned int col, rowd;
-
-        col = 0;
-        do {
-                AAEC_GPIO_KSCAN = col + 8;
-                udelay(KB_ACTIVATE_DELAY);
-                rowd = AAED_EXT_GPIO & AAED_EGPIO_KBD_SCAN;
-
-                if (rowd != aaedkbd->kbdscan_state[col]) {
-                        aaedkbd->kbdscan_count[col] = 0;
-                        aaedkbd->kbdscan_state[col] = rowd;
-                } else if (++aaedkbd->kbdscan_count[col] >= KBDSCAN_STABLE_COUNT) {
-                        aaedkbd_report_col(aaedkbd, col, rowd);
-                        col++;
-                }
-        } while (col < KB_COLS);
-
-        AAEC_GPIO_KSCAN = 0x07;
-        input_sync(dev->input);
-}
-
-static int __devinit aaedkbd_probe(struct platform_device *pdev)
-{
-        struct aaedkbd *aaedkbd;
-        struct input_polled_dev *poll_dev;
-        struct input_dev *input_dev;
-        int i;
-        int error;
-
-        aaedkbd = kzalloc(sizeof(struct aaedkbd), GFP_KERNEL);
-        poll_dev = input_allocate_polled_device();
-        if (!aaedkbd || !poll_dev) {
-                error = -ENOMEM;
-                goto fail;
-        }
-
-        platform_set_drvdata(pdev, aaedkbd);
-
-        aaedkbd->poll_dev = poll_dev;
-        memcpy(aaedkbd->keycode, aaedkbd_keycode, sizeof(aaedkbd->keycode));
-
-        poll_dev->private = aaedkbd;
-        poll_dev->poll = aaedkbd_poll;
-        poll_dev->poll_interval = SCAN_INTERVAL;
-
-        input_dev = poll_dev->input;
-        input_dev->name = "AAED-2000 Keyboard";
-        input_dev->phys = "aaedkbd/input0";
-        input_dev->id.bustype = BUS_HOST;
-        input_dev->id.vendor = 0x0001;
-        input_dev->id.product = 0x0001;
-        input_dev->id.version = 0x0100;
-        input_dev->dev.parent = &pdev->dev;
-
-        input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP);
-        input_dev->keycode = aaedkbd->keycode;
-        input_dev->keycodesize = sizeof(unsigned char);
-        input_dev->keycodemax = ARRAY_SIZE(aaedkbd_keycode);
-
-        for (i = 0; i < ARRAY_SIZE(aaedkbd_keycode); i++)
-                set_bit(aaedkbd->keycode[i], input_dev->keybit);
-        clear_bit(0, input_dev->keybit);
-
-        error = input_register_polled_device(aaedkbd->poll_dev);
-        if (error)
-                goto fail;
-
-        return 0;
-
- fail:  kfree(aaedkbd);
-        input_free_polled_device(poll_dev);
-        return error;
-}
-
-static int __devexit aaedkbd_remove(struct platform_device *pdev)
-{
-        struct aaedkbd *aaedkbd = platform_get_drvdata(pdev);
-
-        input_unregister_polled_device(aaedkbd->poll_dev);
-        input_free_polled_device(aaedkbd->poll_dev);
-        kfree(aaedkbd);
-
-        return 0;
-}
-
-/* work with hotplug and coldplug */
-MODULE_ALIAS("platform:aaed2000-keyboard");
-
-static struct platform_driver aaedkbd_driver = {
-        .probe          = aaedkbd_probe,
-        .remove         = __devexit_p(aaedkbd_remove),
-        .driver         = {
-                .name   = "aaed2000-keyboard",
-                .owner  = THIS_MODULE,
-        },
-};
-
-static int __init aaedkbd_init(void)
-{
-        return platform_driver_register(&aaedkbd_driver);
-}
-
-static void __exit aaedkbd_exit(void)
-{
-        platform_driver_unregister(&aaedkbd_driver);
-}
-
-module_init(aaedkbd_init);
-module_exit(aaedkbd_exit);
-
-MODULE_AUTHOR("Nicolas Bellido Y Ortega");
-MODULE_DESCRIPTION("AAED-2000 Keyboard Driver");
-MODULE_LICENSE("GPL v2");
diff --git a/drivers/input/keyboard/adp5588-keys.c b/drivers/input/keyboard/adp5588-keys.c
index d6918cb966c0..af45d275f686 100644
--- a/drivers/input/keyboard/adp5588-keys.c
+++ b/drivers/input/keyboard/adp5588-keys.c
@@ -4,7 +4,7 @@
  *               I2C QWERTY Keypad and IO Expander
  * Bugs: Enter bugs at http://blackfin.uclinux.org/
  *
- * Copyright (C) 2008-2009 Analog Devices Inc.
+ * Copyright (C) 2008-2010 Analog Devices Inc.
  * Licensed under the GPL-2 or later.
  */
 
@@ -24,29 +24,6 @@
 
 #include <linux/i2c/adp5588.h>
 
- /* Configuration Register1 */
-#define AUTO_INC        (1 << 7)
-#define GPIEM_CFG       (1 << 6)
-#define OVR_FLOW_M      (1 << 5)
-#define INT_CFG         (1 << 4)
-#define OVR_FLOW_IEN    (1 << 3)
-#define K_LCK_IM        (1 << 2)
-#define GPI_IEN         (1 << 1)
-#define KE_IEN          (1 << 0)
-
-/* Interrupt Status Register */
-#define CMP2_INT        (1 << 5)
-#define CMP1_INT        (1 << 4)
-#define OVR_FLOW_INT    (1 << 3)
-#define K_LCK_INT       (1 << 2)
-#define GPI_INT         (1 << 1)
-#define KE_INT          (1 << 0)
-
-/* Key Lock and Event Counter Register */
-#define K_LCK_EN        (1 << 6)
-#define LCK21           0x30
-#define KEC             0xF
-
 /* Key Event Register xy */
 #define KEY_EV_PRESSED          (1 << 7)
 #define KEY_EV_MASK             (0x7F)
@@ -55,10 +32,6 @@
 
 #define KEYP_MAX_EVENT          10
 
-#define MAXGPIO                 18
-#define ADP_BANK(offs)          ((offs) >> 3)
-#define ADP_BIT(offs)           (1u << ((offs) & 0x7))
-
 /*
  * Early pre 4.0 Silicon required to delay readout by at least 25ms,
  * since the Event Counter Register updated 25ms after the interrupt
@@ -75,7 +48,7 @@ struct adp5588_kpad {
         const struct adp5588_gpi_map *gpimap;
         unsigned short gpimapsize;
 #ifdef CONFIG_GPIOLIB
-        unsigned char gpiomap[MAXGPIO];
+        unsigned char gpiomap[ADP5588_MAXGPIO];
         bool export_gpio;
         struct gpio_chip gc;
         struct mutex gpio_lock; /* Protect cached dir, dat_out */
@@ -103,8 +76,8 @@ static int adp5588_write(struct i2c_client *client, u8 reg, u8 val)
 static int adp5588_gpio_get_value(struct gpio_chip *chip, unsigned off)
 {
         struct adp5588_kpad *kpad = container_of(chip, struct adp5588_kpad, gc);
-        unsigned int bank = ADP_BANK(kpad->gpiomap[off]);
-        unsigned int bit = ADP_BIT(kpad->gpiomap[off]);
+        unsigned int bank = ADP5588_BANK(kpad->gpiomap[off]);
+        unsigned int bit = ADP5588_BIT(kpad->gpiomap[off]);
 
         return !!(adp5588_read(kpad->client, GPIO_DAT_STAT1 + bank) & bit);
 }
@@ -113,8 +86,8 @@ static void adp5588_gpio_set_value(struct gpio_chip *chip,
                                    unsigned off, int val)
 {
         struct adp5588_kpad *kpad = container_of(chip, struct adp5588_kpad, gc);
-        unsigned int bank = ADP_BANK(kpad->gpiomap[off]);
-        unsigned int bit = ADP_BIT(kpad->gpiomap[off]);
+        unsigned int bank = ADP5588_BANK(kpad->gpiomap[off]);
+        unsigned int bit = ADP5588_BIT(kpad->gpiomap[off]);
 
         mutex_lock(&kpad->gpio_lock);
 
@@ -132,8 +105,8 @@ static void adp5588_gpio_set_value(struct gpio_chip *chip,
 static int adp5588_gpio_direction_input(struct gpio_chip *chip, unsigned off)
 {
         struct adp5588_kpad *kpad = container_of(chip, struct adp5588_kpad, gc);
-        unsigned int bank = ADP_BANK(kpad->gpiomap[off]);
-        unsigned int bit = ADP_BIT(kpad->gpiomap[off]);
+        unsigned int bank = ADP5588_BANK(kpad->gpiomap[off]);
+        unsigned int bit = ADP5588_BIT(kpad->gpiomap[off]);
         int ret;
 
         mutex_lock(&kpad->gpio_lock);
@@ -150,8 +123,8 @@ static int adp5588_gpio_direction_output(struct gpio_chip *chip,
                                          unsigned off, int val)
 {
         struct adp5588_kpad *kpad = container_of(chip, struct adp5588_kpad, gc);
-        unsigned int bank = ADP_BANK(kpad->gpiomap[off]);
-        unsigned int bit = ADP_BIT(kpad->gpiomap[off]);
+        unsigned int bank = ADP5588_BANK(kpad->gpiomap[off]);
+        unsigned int bit = ADP5588_BIT(kpad->gpiomap[off]);
         int ret;
 
         mutex_lock(&kpad->gpio_lock);
@@ -176,7 +149,7 @@ static int adp5588_gpio_direction_output(struct gpio_chip *chip,
 static int __devinit adp5588_build_gpiomap(struct adp5588_kpad *kpad,
                                 const struct adp5588_kpad_platform_data *pdata)
 {
-        bool pin_used[MAXGPIO];
+        bool pin_used[ADP5588_MAXGPIO];
         int n_unused = 0;
         int i;
 
@@ -191,7 +164,7 @@ static int __devinit adp5588_build_gpiomap(struct adp5588_kpad *kpad,
         for (i = 0; i < kpad->gpimapsize; i++)
                 pin_used[kpad->gpimap[i].pin - GPI_PIN_BASE] = true;
 
-        for (i = 0; i < MAXGPIO; i++)
+        for (i = 0; i < ADP5588_MAXGPIO; i++)
                 if (!pin_used[i])
                         kpad->gpiomap[n_unused++] = i;
 
@@ -234,7 +207,7 @@ static int __devinit adp5588_gpio_add(struct adp5588_kpad *kpad)
                 return error;
         }
 
-        for (i = 0; i <= ADP_BANK(MAXGPIO); i++) {
+        for (i = 0; i <= ADP5588_BANK(ADP5588_MAXGPIO); i++) {
                 kpad->dat_out[i] = adp5588_read(kpad->client,
                                                 GPIO_DAT_OUT1 + i);
                 kpad->dir[i] = adp5588_read(kpad->client, GPIO_DIR1 + i);
@@ -318,11 +291,11 @@ static void adp5588_work(struct work_struct *work)
 
         status = adp5588_read(client, INT_STAT);
 
-        if (status & OVR_FLOW_INT)      /* Unlikely and should never happen */
+        if (status & ADP5588_OVR_FLOW_INT)      /* Unlikely and should never happen */
                 dev_err(&client->dev, "Event Overflow Error\n");
 
-        if (status & KE_INT) {
-                ev_cnt = adp5588_read(client, KEY_LCK_EC_STAT) & KEC;
+        if (status & ADP5588_KE_INT) {
+                ev_cnt = adp5588_read(client, KEY_LCK_EC_STAT) & ADP5588_KEC;
                 if (ev_cnt) {
                         adp5588_report_events(kpad, ev_cnt);
                         input_sync(kpad->input);
@@ -360,7 +333,7 @@ static int __devinit adp5588_setup(struct i2c_client *client)
         if (pdata->en_keylock) {
                 ret |= adp5588_write(client, UNLOCK1, pdata->unlock_key1);
                 ret |= adp5588_write(client, UNLOCK2, pdata->unlock_key2);
-                ret |= adp5588_write(client, KEY_LCK_EC_STAT, K_LCK_EN);
+                ret |= adp5588_write(client, KEY_LCK_EC_STAT, ADP5588_K_LCK_EN);
         }
 
         for (i = 0; i < KEYP_MAX_EVENT; i++)
@@ -384,7 +357,7 @@ static int __devinit adp5588_setup(struct i2c_client *client)
         }
 
         if (gpio_data) {
-                for (i = 0; i <= ADP_BANK(MAXGPIO); i++) {
+                for (i = 0; i <= ADP5588_BANK(ADP5588_MAXGPIO); i++) {
                         int pull_mask = gpio_data->pullup_dis_mask;
 
                         ret |= adp5588_write(client, GPIO_PULL1 + i,
@@ -392,11 +365,14 @@ static int __devinit adp5588_setup(struct i2c_client *client)
                 }
         }
 
-        ret |= adp5588_write(client, INT_STAT, CMP2_INT | CMP1_INT |
-                                        OVR_FLOW_INT | K_LCK_INT |
-                                        GPI_INT | KE_INT); /* Status is W1C */
+        ret |= adp5588_write(client, INT_STAT,
+                                ADP5588_CMP2_INT | ADP5588_CMP1_INT |
+                                ADP5588_OVR_FLOW_INT | ADP5588_K_LCK_INT |
+                                ADP5588_GPI_INT | ADP5588_KE_INT); /* Status is W1C */
 
-        ret |= adp5588_write(client, CFG, INT_CFG | OVR_FLOW_IEN | KE_IEN);
+        ret |= adp5588_write(client, CFG, ADP5588_INT_CFG |
+                                          ADP5588_OVR_FLOW_IEN |
+                                          ADP5588_KE_IEN);
 
         if (ret < 0) {
                 dev_err(&client->dev, "Write Error\n");
@@ -660,7 +636,7 @@ static const struct dev_pm_ops adp5588_dev_pm_ops = {
 #endif
 
 static const struct i2c_device_id adp5588_id[] = {
-        { KBUILD_MODNAME, 0 },
+        { "adp5588-keys", 0 },
         { "adp5587-keys", 0 },
         { }
 };
diff --git a/drivers/input/keyboard/adp5589-keys.c b/drivers/input/keyboard/adp5589-keys.c
new file mode 100644
index 000000000000..631598663aab
--- /dev/null
+++ b/drivers/input/keyboard/adp5589-keys.c
@@ -0,0 +1,771 @@
+/*
+ * Description:  keypad driver for ADP5589
+ *               I2C QWERTY Keypad and IO Expander
+ * Bugs: Enter bugs at http://blackfin.uclinux.org/
+ *
+ * Copyright (C) 2010-2011 Analog Devices Inc.
+ * Licensed under the GPL-2.
+ */
+
+#include <linux/module.h>
+#include <linux/version.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/irq.h>
+#include <linux/workqueue.h>
+#include <linux/errno.h>
+#include <linux/pm.h>
+#include <linux/platform_device.h>
+#include <linux/input.h>
+#include <linux/i2c.h>
+#include <linux/gpio.h>
+#include <linux/slab.h>
+
+#include <linux/input/adp5589.h>
+
+/* GENERAL_CFG Register */
+#define OSC_EN          (1 << 7)
+#define CORE_CLK(x)     (((x) & 0x3) << 5)
+#define LCK_TRK_LOGIC   (1 << 4)
+#define LCK_TRK_GPI     (1 << 3)
+#define INT_CFG         (1 << 1)
+#define RST_CFG         (1 << 0)
+
+/* INT_EN Register */
+#define LOGIC2_IEN      (1 << 5)
+#define LOGIC1_IEN      (1 << 4)
+#define LOCK_IEN        (1 << 3)
+#define OVRFLOW_IEN     (1 << 2)
+#define GPI_IEN         (1 << 1)
+#define EVENT_IEN       (1 << 0)
+
+/* Interrupt Status Register */
+#define LOGIC2_INT      (1 << 5)
+#define LOGIC1_INT      (1 << 4)
+#define LOCK_INT        (1 << 3)
+#define OVRFLOW_INT     (1 << 2)
+#define GPI_INT         (1 << 1)
+#define EVENT_INT       (1 << 0)
+
+/* STATUS Register */
+
+#define LOGIC2_STAT     (1 << 7)
+#define LOGIC1_STAT     (1 << 6)
+#define LOCK_STAT       (1 << 5)
+#define KEC             0xF
+
+/* PIN_CONFIG_D Register */
+#define C4_EXTEND_CFG   (1 << 6)        /* RESET2 */
+#define R4_EXTEND_CFG   (1 << 5)        /* RESET1 */
+
+/* LOCK_CFG */
+#define LOCK_EN         (1 << 0)
+
+#define PTIME_MASK      0x3
+#define LTIME_MASK      0x3
+
+/* Key Event Register xy */
+#define KEY_EV_PRESSED          (1 << 7)
+#define KEY_EV_MASK             (0x7F)
+
+#define KEYP_MAX_EVENT          16
+
+#define MAXGPIO                 19
+#define ADP_BANK(offs)          ((offs) >> 3)
+#define ADP_BIT(offs)           (1u << ((offs) & 0x7))
+
+struct adp5589_kpad {
+        struct i2c_client *client;
+        struct input_dev *input;
+        unsigned short keycode[ADP5589_KEYMAPSIZE];
+        const struct adp5589_gpi_map *gpimap;
+        unsigned short gpimapsize;
+        unsigned extend_cfg;
+#ifdef CONFIG_GPIOLIB
+        unsigned char gpiomap[MAXGPIO];
+        bool export_gpio;
+        struct gpio_chip gc;
+        struct mutex gpio_lock; /* Protect cached dir, dat_out */
+        u8 dat_out[3];
+        u8 dir[3];
+#endif
+};
+
+static int adp5589_read(struct i2c_client *client, u8 reg)
+{
+        int ret = i2c_smbus_read_byte_data(client, reg);
+
+        if (ret < 0)
+                dev_err(&client->dev, "Read Error\n");
+
+        return ret;
+}
+
+static int adp5589_write(struct i2c_client *client, u8 reg, u8 val)
+{
+        return i2c_smbus_write_byte_data(client, reg, val);
+}
+
+#ifdef CONFIG_GPIOLIB
+static int adp5589_gpio_get_value(struct gpio_chip *chip, unsigned off)
+{
+        struct adp5589_kpad *kpad = container_of(chip, struct adp5589_kpad, gc);
+        unsigned int bank = ADP_BANK(kpad->gpiomap[off]);
+        unsigned int bit = ADP_BIT(kpad->gpiomap[off]);
+
+        return !!(adp5589_read(kpad->client, ADP5589_GPI_STATUS_A + bank) &
+                  bit);
+}
+
+static void adp5589_gpio_set_value(struct gpio_chip *chip,
+                                   unsigned off, int val)
+{
+        struct adp5589_kpad *kpad = container_of(chip, struct adp5589_kpad, gc);
+        unsigned int bank = ADP_BANK(kpad->gpiomap[off]);
+        unsigned int bit = ADP_BIT(kpad->gpiomap[off]);
+
+        mutex_lock(&kpad->gpio_lock);
+
+        if (val)
+                kpad->dat_out[bank] |= bit;
+        else
+                kpad->dat_out[bank] &= ~bit;
+
+        adp5589_write(kpad->client, ADP5589_GPO_DATA_OUT_A + bank,
+                      kpad->dat_out[bank]);
+
+        mutex_unlock(&kpad->gpio_lock);
+}
+
+static int adp5589_gpio_direction_input(struct gpio_chip *chip, unsigned off)
+{
+        struct adp5589_kpad *kpad = container_of(chip, struct adp5589_kpad, gc);
+        unsigned int bank = ADP_BANK(kpad->gpiomap[off]);
+        unsigned int bit = ADP_BIT(kpad->gpiomap[off]);
+        int ret;
+
+        mutex_lock(&kpad->gpio_lock);
+
+        kpad->dir[bank] &= ~bit;
+        ret = adp5589_write(kpad->client, ADP5589_GPIO_DIRECTION_A + bank,
+                            kpad->dir[bank]);
+
+        mutex_unlock(&kpad->gpio_lock);
+
+        return ret;
+}
+
+static int adp5589_gpio_direction_output(struct gpio_chip *chip,
+                                         unsigned off, int val)
+{
+        struct adp5589_kpad *kpad = container_of(chip, struct adp5589_kpad, gc);
+        unsigned int bank = ADP_BANK(kpad->gpiomap[off]);
+        unsigned int bit = ADP_BIT(kpad->gpiomap[off]);
+        int ret;
+
+        mutex_lock(&kpad->gpio_lock);
+
+        kpad->dir[bank] |= bit;
+
+        if (val)
+                kpad->dat_out[bank] |= bit;
+        else
+                kpad->dat_out[bank] &= ~bit;
+
+        ret = adp5589_write(kpad->client, ADP5589_GPO_DATA_OUT_A + bank,
+                            kpad->dat_out[bank]);
+        ret |= adp5589_write(kpad->client, ADP5589_GPIO_DIRECTION_A + bank,
+                             kpad->dir[bank]);
+
+        mutex_unlock(&kpad->gpio_lock);
+
+        return ret;
+}
+
+static int __devinit adp5589_build_gpiomap(struct adp5589_kpad *kpad,
+                                const struct adp5589_kpad_platform_data *pdata)
+{
+        bool pin_used[MAXGPIO];
+        int n_unused = 0;
+        int i;
+
+        memset(pin_used, false, sizeof(pin_used));
+
+        for (i = 0; i < MAXGPIO; i++)
+                if (pdata->keypad_en_mask & (1 << i))
+                        pin_used[i] = true;
+
+        for (i = 0; i < kpad->gpimapsize; i++)
+                pin_used[kpad->gpimap[i].pin - ADP5589_GPI_PIN_BASE] = true;
+
+        if (kpad->extend_cfg & R4_EXTEND_CFG)
+                pin_used[4] = true;
+
+        if (kpad->extend_cfg & C4_EXTEND_CFG)
+                pin_used[12] = true;
+
+        for (i = 0; i < MAXGPIO; i++)
+                if (!pin_used[i])
+                        kpad->gpiomap[n_unused++] = i;
+
+        return n_unused;
+}
+
+static int __devinit adp5589_gpio_add(struct adp5589_kpad *kpad)
+{
+        struct device *dev = &kpad->client->dev;
+        const struct adp5589_kpad_platform_data *pdata = dev->platform_data;
+        const struct adp5589_gpio_platform_data *gpio_data = pdata->gpio_data;
+        int i, error;
+
+        if (!gpio_data)
+                return 0;
+
+        kpad->gc.ngpio = adp5589_build_gpiomap(kpad, pdata);
+        if (kpad->gc.ngpio == 0) {
+                dev_info(dev, "No unused gpios left to export\n");
+                return 0;
+        }
+
+        kpad->export_gpio = true;
+
+        kpad->gc.direction_input = adp5589_gpio_direction_input;
+        kpad->gc.direction_output = adp5589_gpio_direction_output;
+        kpad->gc.get = adp5589_gpio_get_value;
+        kpad->gc.set = adp5589_gpio_set_value;
+        kpad->gc.can_sleep = 1;
+
+        kpad->gc.base = gpio_data->gpio_start;
+        kpad->gc.label = kpad->client->name;
+        kpad->gc.owner = THIS_MODULE;
+
+        mutex_init(&kpad->gpio_lock);
+
+        error = gpiochip_add(&kpad->gc);
+        if (error) {
+                dev_err(dev, "gpiochip_add failed, err: %d\n", error);
+                return error;
+        }
+
+        for (i = 0; i <= ADP_BANK(MAXGPIO); i++) {
+                kpad->dat_out[i] = adp5589_read(kpad->client,
+                                                ADP5589_GPO_DATA_OUT_A + i);
+                kpad->dir[i] = adp5589_read(kpad->client,
+                                            ADP5589_GPIO_DIRECTION_A + i);
+        }
+
+        if (gpio_data->setup) {
+                error = gpio_data->setup(kpad->client,
+                                         kpad->gc.base, kpad->gc.ngpio,
+                                         gpio_data->context);
+                if (error)
+                        dev_warn(dev, "setup failed, %d\n", error);
+        }
+
+        return 0;
+}
+
+static void __devexit adp5589_gpio_remove(struct adp5589_kpad *kpad)
+{
+        struct device *dev = &kpad->client->dev;
+        const struct adp5589_kpad_platform_data *pdata = dev->platform_data;
+        const struct adp5589_gpio_platform_data *gpio_data = pdata->gpio_data;
+        int error;
+
+        if (!kpad->export_gpio)
+                return;
+
+        if (gpio_data->teardown) {
+                error = gpio_data->teardown(kpad->client,
+                                            kpad->gc.base, kpad->gc.ngpio,
+                                            gpio_data->context);
+                if (error)
+                        dev_warn(dev, "teardown failed %d\n", error);
+        }
+
+        error = gpiochip_remove(&kpad->gc);
+        if (error)
+                dev_warn(dev, "gpiochip_remove failed %d\n", error);
+}
+#else
+static inline int adp5589_gpio_add(struct adp5589_kpad *kpad)
+{
+        return 0;
+}
+
+static inline void adp5589_gpio_remove(struct adp5589_kpad *kpad)
+{
+}
+#endif
+
+static void adp5589_report_switches(struct adp5589_kpad *kpad,
+                                    int key, int key_val)
+{
+        int i;
+
+        for (i = 0; i < kpad->gpimapsize; i++) {
+                if (key_val == kpad->gpimap[i].pin) {
+                        input_report_switch(kpad->input,
+                                            kpad->gpimap[i].sw_evt,
+                                            key & KEY_EV_PRESSED);
+                        break;
+                }
+        }
+}
+
+static void adp5589_report_events(struct adp5589_kpad *kpad, int ev_cnt)
+{
+        int i;
+
+        for (i = 0; i < ev_cnt; i++) {
+                int key = adp5589_read(kpad->client, ADP5589_FIFO_1 + i);
+                int key_val = key & KEY_EV_MASK;
+
+                if (key_val >= ADP5589_GPI_PIN_BASE &&
+                    key_val <= ADP5589_GPI_PIN_END) {
+                        adp5589_report_switches(kpad, key, key_val);
+                } else {
+                        input_report_key(kpad->input,
+                                         kpad->keycode[key_val - 1],
+                                         key & KEY_EV_PRESSED);
+                }
+        }
+}
+
+static irqreturn_t adp5589_irq(int irq, void *handle)
+{
+        struct adp5589_kpad *kpad = handle;
+        struct i2c_client *client = kpad->client;
+        int status, ev_cnt;
+
+        status = adp5589_read(client, ADP5589_INT_STATUS);
+
+        if (status & OVRFLOW_INT)       /* Unlikely and should never happen */
+                dev_err(&client->dev, "Event Overflow Error\n");
+
+        if (status & EVENT_INT) {
+                ev_cnt = adp5589_read(client, ADP5589_STATUS) & KEC;
+                if (ev_cnt) {
+                        adp5589_report_events(kpad, ev_cnt);
+                        input_sync(kpad->input);
+                }
+        }
+
+        adp5589_write(client, ADP5589_INT_STATUS, status);      /* Status is W1C */
+
+        return IRQ_HANDLED;
+}
+
+static int __devinit adp5589_get_evcode(struct adp5589_kpad *kpad, unsigned short key)
+{
+        int i;
+
+        for (i = 0; i < ADP5589_KEYMAPSIZE; i++)
+                if (key == kpad->keycode[i])
+                        return (i + 1) | KEY_EV_PRESSED;
+
+        dev_err(&kpad->client->dev, "RESET/UNLOCK key not in keycode map\n");
+
+        return -EINVAL;
+}
+
+static int __devinit adp5589_setup(struct adp5589_kpad *kpad)
+{
+        struct i2c_client *client = kpad->client;
+        const struct adp5589_kpad_platform_data *pdata =
+            client->dev.platform_data;
+        int i, ret;
+        unsigned char evt_mode1 = 0, evt_mode2 = 0, evt_mode3 = 0;
+        unsigned char pull_mask = 0;
+
+        ret = adp5589_write(client, ADP5589_PIN_CONFIG_A,
+                            pdata->keypad_en_mask & 0xFF);
+        ret |= adp5589_write(client, ADP5589_PIN_CONFIG_B,
+                             (pdata->keypad_en_mask >> 8) & 0xFF);
+        ret |= adp5589_write(client, ADP5589_PIN_CONFIG_C,
+                             (pdata->keypad_en_mask >> 16) & 0xFF);
+
+        if (pdata->en_keylock) {
+                ret |= adp5589_write(client, ADP5589_UNLOCK1,
+                                     pdata->unlock_key1);
+                ret |= adp5589_write(client, ADP5589_UNLOCK2,
+                                     pdata->unlock_key2);
+                ret |= adp5589_write(client, ADP5589_UNLOCK_TIMERS,
+                                     pdata->unlock_timer & LTIME_MASK);
+                ret |= adp5589_write(client, ADP5589_LOCK_CFG, LOCK_EN);
+        }
+
+        for (i = 0; i < KEYP_MAX_EVENT; i++)
+                ret |= adp5589_read(client, ADP5589_FIFO_1 + i);
+
+        for (i = 0; i < pdata->gpimapsize; i++) {
+                unsigned short pin = pdata->gpimap[i].pin;
+
+                if (pin <= ADP5589_GPI_PIN_ROW_END) {
+                        evt_mode1 |= (1 << (pin - ADP5589_GPI_PIN_ROW_BASE));
+                } else {
+                        evt_mode2 |=
+                            ((1 << (pin - ADP5589_GPI_PIN_COL_BASE)) & 0xFF);
+                        evt_mode3 |=
+                            ((1 << (pin - ADP5589_GPI_PIN_COL_BASE)) >> 8);
+                }
+        }
+
+        if (pdata->gpimapsize) {
+                ret |= adp5589_write(client, ADP5589_GPI_EVENT_EN_A, evt_mode1);
+                ret |= adp5589_write(client, ADP5589_GPI_EVENT_EN_B, evt_mode2);
+                ret |= adp5589_write(client, ADP5589_GPI_EVENT_EN_C, evt_mode3);
+        }
+
+        if (pdata->pull_dis_mask & pdata->pullup_en_100k &
+            pdata->pullup_en_300k & pdata->pulldown_en_300k)
+                dev_warn(&client->dev, "Conflicting pull resistor config\n");
+
+        for (i = 0; i < MAXGPIO; i++) {
+                unsigned val = 0;
+
+                if (pdata->pullup_en_300k & (1 << i))
+                        val = 0;
+                else if (pdata->pulldown_en_300k & (1 << i))
+                        val = 1;
+                else if (pdata->pullup_en_100k & (1 << i))
+                        val = 2;
+                else if (pdata->pull_dis_mask & (1 << i))
+                        val = 3;
+
+                pull_mask |= val << (2 * (i & 0x3));
+
+                if ((i & 0x3) == 0x3 || i == MAXGPIO - 1) {
+                        ret |= adp5589_write(client,
+                                             ADP5589_RPULL_CONFIG_A + (i >> 2),
+                                             pull_mask);
+                        pull_mask = 0;
+                }
+        }
+
+        if (pdata->reset1_key_1 && pdata->reset1_key_2 && pdata->reset1_key_3) {
+                ret |= adp5589_write(client, ADP5589_RESET1_EVENT_A,
+                                     adp5589_get_evcode(kpad,
+                                                        pdata->reset1_key_1));
+                ret |= adp5589_write(client, ADP5589_RESET1_EVENT_B,
+                                     adp5589_get_evcode(kpad,
+                                                        pdata->reset1_key_2));
+                ret |= adp5589_write(client, ADP5589_RESET1_EVENT_C,
+                                     adp5589_get_evcode(kpad,
+                                                        pdata->reset1_key_3));
+                kpad->extend_cfg |= R4_EXTEND_CFG;
+        }
+
+        if (pdata->reset2_key_1 && pdata->reset2_key_2) {
+                ret |= adp5589_write(client, ADP5589_RESET2_EVENT_A,
+                                     adp5589_get_evcode(kpad,
+                                                        pdata->reset2_key_1));
+                ret |= adp5589_write(client, ADP5589_RESET2_EVENT_B,
+                                     adp5589_get_evcode(kpad,
+                                                        pdata->reset2_key_2));
+                kpad->extend_cfg |= C4_EXTEND_CFG;
+        }
+
+        if (kpad->extend_cfg) {
+                ret |= adp5589_write(client, ADP5589_RESET_CFG,
+                                     pdata->reset_cfg);
+                ret |= adp5589_write(client, ADP5589_PIN_CONFIG_D,
+                                     kpad->extend_cfg);
+        }
+
+        for (i = 0; i <= ADP_BANK(MAXGPIO); i++)
+                ret |= adp5589_write(client, ADP5589_DEBOUNCE_DIS_A + i,
+                                     pdata->debounce_dis_mask >> (i * 8));
+
+        ret |= adp5589_write(client, ADP5589_POLL_PTIME_CFG,
+                             pdata->scan_cycle_time & PTIME_MASK);
+        ret |= adp5589_write(client, ADP5589_INT_STATUS, LOGIC2_INT |
+                             LOGIC1_INT | OVRFLOW_INT | LOCK_INT |
+                             GPI_INT | EVENT_INT);      /* Status is W1C */
+
+        ret |= adp5589_write(client, ADP5589_GENERAL_CFG,
+                             INT_CFG | OSC_EN | CORE_CLK(3));
+        ret |= adp5589_write(client, ADP5589_INT_EN,
+                             OVRFLOW_IEN | GPI_IEN | EVENT_IEN);
+
+        if (ret < 0) {
+                dev_err(&client->dev, "Write Error\n");
+                return ret;
+        }
+
+        return 0;
+}
+
+static void __devinit adp5589_report_switch_state(struct adp5589_kpad *kpad)
+{
+        int gpi_stat1 = adp5589_read(kpad->client, ADP5589_GPI_STATUS_A);
+        int gpi_stat2 = adp5589_read(kpad->client, ADP5589_GPI_STATUS_B);
+        int gpi_stat3 = adp5589_read(kpad->client, ADP5589_GPI_STATUS_C);
+        int gpi_stat_tmp, pin_loc;
+        int i;
+
+        for (i = 0; i < kpad->gpimapsize; i++) {
+                unsigned short pin = kpad->gpimap[i].pin;
+
+                if (pin <= ADP5589_GPI_PIN_ROW_END) {
+                        gpi_stat_tmp = gpi_stat1;
+                        pin_loc = pin - ADP5589_GPI_PIN_ROW_BASE;
+                } else if ((pin - ADP5589_GPI_PIN_COL_BASE) < 8) {
+                        gpi_stat_tmp = gpi_stat2;
+                        pin_loc = pin - ADP5589_GPI_PIN_COL_BASE;
+                } else {
+                        gpi_stat_tmp = gpi_stat3;
+                        pin_loc = pin - ADP5589_GPI_PIN_COL_BASE - 8;
+                }
+
+                if (gpi_stat_tmp < 0) {
+                        dev_err(&kpad->client->dev,
+                                "Can't read GPIO_DAT_STAT switch"
+                                " %d default to OFF\n", pin);
+                        gpi_stat_tmp = 0;
+                }
+
+                input_report_switch(kpad->input,
+                                    kpad->gpimap[i].sw_evt,
+                                    !(gpi_stat_tmp & (1 << pin_loc)));
+        }
+
+        input_sync(kpad->input);
+}
+
+static int __devinit adp5589_probe(struct i2c_client *client,
+                                   const struct i2c_device_id *id)
+{
+        struct adp5589_kpad *kpad;
+        const struct adp5589_kpad_platform_data *pdata;
+        struct input_dev *input;
+        unsigned int revid;
+        int ret, i;
+        int error;
+
+        if (!i2c_check_functionality(client->adapter,
+                                     I2C_FUNC_SMBUS_BYTE_DATA)) {
+                dev_err(&client->dev, "SMBUS Byte Data not Supported\n");
+                return -EIO;
+        }
+
+        pdata = client->dev.platform_data;
+        if (!pdata) {
+                dev_err(&client->dev, "no platform data?\n");
+                return -EINVAL;
+        }
+
+        if (!((pdata->keypad_en_mask & 0xFF) &&
+                        (pdata->keypad_en_mask >> 8)) || !pdata->keymap) {
+                dev_err(&client->dev, "no rows, cols or keymap from pdata\n");
+                return -EINVAL;
+        }
+
+        if (pdata->keymapsize != ADP5589_KEYMAPSIZE) {
+                dev_err(&client->dev, "invalid keymapsize\n");
+                return -EINVAL;
+        }
+
+        if (!pdata->gpimap && pdata->gpimapsize) {
+                dev_err(&client->dev, "invalid gpimap from pdata\n");
+                return -EINVAL;
+        }
+
+        if (pdata->gpimapsize > ADP5589_GPIMAPSIZE_MAX) {
+                dev_err(&client->dev, "invalid gpimapsize\n");
+                return -EINVAL;
+        }
+
+        for (i = 0; i < pdata->gpimapsize; i++) {
+                unsigned short pin = pdata->gpimap[i].pin;
+
+                if (pin < ADP5589_GPI_PIN_BASE || pin > ADP5589_GPI_PIN_END) {
+                        dev_err(&client->dev, "invalid gpi pin data\n");
+                        return -EINVAL;
+                }
+
+                if ((1 << (pin - ADP5589_GPI_PIN_ROW_BASE)) &
+                                pdata->keypad_en_mask) {
+                        dev_err(&client->dev, "invalid gpi row/col data\n");
+                        return -EINVAL;
+                }
+        }
+
+        if (!client->irq) {
+                dev_err(&client->dev, "no IRQ?\n");
+                return -EINVAL;
+        }
+
+        kpad = kzalloc(sizeof(*kpad), GFP_KERNEL);
+        input = input_allocate_device();
+        if (!kpad || !input) {
+                error = -ENOMEM;
+                goto err_free_mem;
+        }
+
+        kpad->client = client;
+        kpad->input = input;
+
+        ret = adp5589_read(client, ADP5589_ID);
+        if (ret < 0) {
+                error = ret;
+                goto err_free_mem;
+        }
+
+        revid = (u8) ret & ADP5589_DEVICE_ID_MASK;
+
+        input->name = client->name;
+        input->phys = "adp5589-keys/input0";
+        input->dev.parent = &client->dev;
+
+        input_set_drvdata(input, kpad);
+
+        input->id.bustype = BUS_I2C;
+        input->id.vendor = 0x0001;
+        input->id.product = 0x0001;
+        input->id.version = revid;
+
+        input->keycodesize = sizeof(kpad->keycode[0]);
+        input->keycodemax = pdata->keymapsize;
+        input->keycode = kpad->keycode;
+
+        memcpy(kpad->keycode, pdata->keymap,
+               pdata->keymapsize * input->keycodesize);
+
+        kpad->gpimap = pdata->gpimap;
+        kpad->gpimapsize = pdata->gpimapsize;
+
+        /* setup input device */
+        __set_bit(EV_KEY, input->evbit);
+
+        if (pdata->repeat)
+                __set_bit(EV_REP, input->evbit);
+
+        for (i = 0; i < input->keycodemax; i++)
+                __set_bit(kpad->keycode[i] & KEY_MAX, input->keybit);
+        __clear_bit(KEY_RESERVED, input->keybit);
+
+        if (kpad->gpimapsize)
+                __set_bit(EV_SW, input->evbit);
+        for (i = 0; i < kpad->gpimapsize; i++)
+                __set_bit(kpad->gpimap[i].sw_evt, input->swbit);
+
+        error = input_register_device(input);
+        if (error) {
+                dev_err(&client->dev, "unable to register input device\n");
+                goto err_free_mem;
+        }
+
+        error = request_threaded_irq(client->irq, NULL, adp5589_irq,
+                                     IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
+                                     client->dev.driver->name, kpad);
+        if (error) {
+                dev_err(&client->dev, "irq %d busy?\n", client->irq);
+                goto err_unreg_dev;
+        }
+
+        error = adp5589_setup(kpad);
+        if (error)
+                goto err_free_irq;
+
+        if (kpad->gpimapsize)
+                adp5589_report_switch_state(kpad);
+
+        error = adp5589_gpio_add(kpad);
+        if (error)
+                goto err_free_irq;
+
+        device_init_wakeup(&client->dev, 1);
+        i2c_set_clientdata(client, kpad);
+
+        dev_info(&client->dev, "Rev.%d keypad, irq %d\n", revid, client->irq);
+        return 0;
+
+err_free_irq:
+        free_irq(client->irq, kpad);
+err_unreg_dev:
+        input_unregister_device(input);
+        input = NULL;
+err_free_mem:
+        input_free_device(input);
+        kfree(kpad);
+
+        return error;
+}
+
+static int __devexit adp5589_remove(struct i2c_client *client)
+{
+        struct adp5589_kpad *kpad = i2c_get_clientdata(client);
+
+        adp5589_write(client, ADP5589_GENERAL_CFG, 0);
+        free_irq(client->irq, kpad);
+        input_unregister_device(kpad->input);
+        adp5589_gpio_remove(kpad);
+        kfree(kpad);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM_SLEEP
+static int adp5589_suspend(struct device *dev)
+{
+        struct adp5589_kpad *kpad = dev_get_drvdata(dev);
+        struct i2c_client *client = kpad->client;
+
+        disable_irq(client->irq);
+
+        if (device_may_wakeup(&client->dev))
+                enable_irq_wake(client->irq);
+
+        return 0;
+}
+
+static int adp5589_resume(struct device *dev)
+{
+        struct adp5589_kpad *kpad = dev_get_drvdata(dev);
+        struct i2c_client *client = kpad->client;
+
+        if (device_may_wakeup(&client->dev))
+                disable_irq_wake(client->irq);
+
+        enable_irq(client->irq);
+
+        return 0;
+}
+#endif
+
+static SIMPLE_DEV_PM_OPS(adp5589_dev_pm_ops, adp5589_suspend, adp5589_resume);
+
+static const struct i2c_device_id adp5589_id[] = {
+        {"adp5589-keys", 0},
+        {}
+};
+
+MODULE_DEVICE_TABLE(i2c, adp5589_id);
+
+static struct i2c_driver adp5589_driver = {
+        .driver = {
+                .name = KBUILD_MODNAME,
+                .owner = THIS_MODULE,
+                .pm = &adp5589_dev_pm_ops,
+        },
+        .probe = adp5589_probe,
+        .remove = __devexit_p(adp5589_remove),
+        .id_table = adp5589_id,
+};
+
+static int __init adp5589_init(void)
+{
+        return i2c_add_driver(&adp5589_driver);
+}
+module_init(adp5589_init);
+
+static void __exit adp5589_exit(void)
+{
+        i2c_del_driver(&adp5589_driver);
+}
+module_exit(adp5589_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
+MODULE_DESCRIPTION("ADP5589 Keypad driver");
diff --git a/drivers/input/keyboard/atakbd.c b/drivers/input/keyboard/atakbd.c
index 1839194ea987..10bcd4ae5402 100644
--- a/drivers/input/keyboard/atakbd.c
+++ b/drivers/input/keyboard/atakbd.c
@@ -223,8 +223,9 @@ static int __init atakbd_init(void)
                 return -ENODEV;
 
         // need to init core driver if not already done so
-        if (atari_keyb_init())
-                return -ENODEV;
+        error = atari_keyb_init();
+        if (error)
+                return error;
 
         atakbd_dev = input_allocate_device();
         if (!atakbd_dev)
diff --git a/drivers/input/keyboard/atkbd.c b/drivers/input/keyboard/atkbd.c
index d358ef8623f4..11478eb2c27d 100644
--- a/drivers/input/keyboard/atkbd.c
+++ b/drivers/input/keyboard/atkbd.c
@@ -63,6 +63,10 @@ static bool atkbd_extra;
 module_param_named(extra, atkbd_extra, bool, 0);
 MODULE_PARM_DESC(extra, "Enable extra LEDs and keys on IBM RapidAcces, EzKey and similar keyboards");
 
+static bool atkbd_terminal;
+module_param_named(terminal, atkbd_terminal, bool, 0);
+MODULE_PARM_DESC(terminal, "Enable break codes on an IBM Terminal keyboard connected via AT/PS2");
+
 /*
  * Scancode to keycode tables. These are just the default setting, and
  * are loadable via a userland utility.
@@ -136,7 +140,8 @@ static const unsigned short atkbd_unxlate_table[128] = {
 #define ATKBD_CMD_ENABLE        0x00f4
 #define ATKBD_CMD_RESET_DIS     0x00f5  /* Reset to defaults and disable */
 #define ATKBD_CMD_RESET_DEF     0x00f6  /* Reset to defaults */
-#define ATKBD_CMD_SETALL_MBR    0x00fa
+#define ATKBD_CMD_SETALL_MB     0x00f8  /* Set all keys to give break codes */
+#define ATKBD_CMD_SETALL_MBR    0x00fa  /* ... and repeat */
 #define ATKBD_CMD_RESET_BAT     0x02ff
 #define ATKBD_CMD_RESEND        0x00fe
 #define ATKBD_CMD_EX_ENABLE     0x10ea
@@ -764,6 +769,11 @@ static int atkbd_select_set(struct atkbd *atkbd, int target_set, int allow_extra
                 }
         }
 
+        if (atkbd_terminal) {
+                ps2_command(ps2dev, param, ATKBD_CMD_SETALL_MB);
+                return 3;
+        }
+
         if (target_set != 3)
                 return 2;
 
diff --git a/drivers/input/keyboard/davinci_keyscan.c b/drivers/input/keyboard/davinci_keyscan.c
index a91ee941b5c1..cd89d17162a3 100644
--- a/drivers/input/keyboard/davinci_keyscan.c
+++ b/drivers/input/keyboard/davinci_keyscan.c
@@ -5,7 +5,7 @@
  *
  * Author: Miguel Aguilar <miguel.aguilar@ridgerun.com>
  *
- * Intial Code: Sandeep Paulraj <s-paulraj@ti.com>
+ * Initial Code: Sandeep Paulraj <s-paulraj@ti.com>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
diff --git a/drivers/input/keyboard/gpio_keys.c b/drivers/input/keyboard/gpio_keys.c
index 6069abe31e42..6e6145b9a4c1 100644
--- a/drivers/input/keyboard/gpio_keys.c
+++ b/drivers/input/keyboard/gpio_keys.c
@@ -322,9 +322,14 @@ static void gpio_keys_report_event(struct gpio_button_data *bdata)
         struct gpio_keys_button *button = bdata->button;
         struct input_dev *input = bdata->input;
         unsigned int type = button->type ?: EV_KEY;
-        int state = (gpio_get_value(button->gpio) ? 1 : 0) ^ button->active_low;
+        int state = (gpio_get_value_cansleep(button->gpio) ? 1 : 0) ^ button->active_low;
 
-        input_event(input, type, button->code, !!state);
+        if (type == EV_ABS) {
+                if (state)
+                        input_event(input, type, button->code, button->value);
+        } else {
+                input_event(input, type, button->code, !!state);
+        }
         input_sync(input);
 }
 
@@ -363,7 +368,7 @@ static int __devinit gpio_keys_setup_key(struct platform_device *pdev,
                                          struct gpio_button_data *bdata,
                                          struct gpio_keys_button *button)
 {
-        char *desc = button->desc ? button->desc : "gpio_keys";
+        const char *desc = button->desc ? button->desc : "gpio_keys";
         struct device *dev = &pdev->dev;
         unsigned long irqflags;
         int irq, error;
@@ -410,8 +415,8 @@ static int __devinit gpio_keys_setup_key(struct platform_device *pdev,
         if (!button->can_disable)
                 irqflags |= IRQF_SHARED;
 
-        error = request_irq(irq, gpio_keys_isr, irqflags, desc, bdata);
-        if (error) {
+        error = request_any_context_irq(irq, gpio_keys_isr, irqflags, desc, bdata);
+        if (error < 0) {
                 dev_err(dev, "Unable to claim irq %d; error %d\n",
                         irq, error);
                 goto fail3;
@@ -468,7 +473,7 @@ static int __devinit gpio_keys_probe(struct platform_device *pdev)
         platform_set_drvdata(pdev, ddata);
         input_set_drvdata(input, ddata);
 
-        input->name = pdev->name;
+        input->name = pdata->name ? : pdev->name;
         input->phys = "gpio-keys/input0";
         input->dev.parent = &pdev->dev;
         input->open = gpio_keys_open;
diff --git a/drivers/input/keyboard/gpio_keys_polled.c b/drivers/input/keyboard/gpio_keys_polled.c
new file mode 100644
index 000000000000..4c17aff20657
--- /dev/null
+++ b/drivers/input/keyboard/gpio_keys_polled.c
@@ -0,0 +1,261 @@
+/*
+ *  Driver for buttons on GPIO lines not capable of generating interrupts
+ *
+ *  Copyright (C) 2007-2010 Gabor Juhos <juhosg@openwrt.org>
+ *  Copyright (C) 2010 Nuno Goncalves <nunojpg@gmail.com>
+ *
+ *  This file was based on: /drivers/input/misc/cobalt_btns.c
+ *      Copyright (C) 2007 Yoichi Yuasa <yoichi_yuasa@tripeaks.co.jp>
+ *
+ *  also was based on: /drivers/input/keyboard/gpio_keys.c
+ *      Copyright 2005 Phil Blundell
+ *
+ *  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/slab.h>
+#include <linux/input.h>
+#include <linux/input-polldev.h>
+#include <linux/ioport.h>
+#include <linux/platform_device.h>
+#include <linux/gpio.h>
+#include <linux/gpio_keys.h>
+
+#define DRV_NAME        "gpio-keys-polled"
+
+struct gpio_keys_button_data {
+        int last_state;
+        int count;
+        int threshold;
+        int can_sleep;
+};
+
+struct gpio_keys_polled_dev {
+        struct input_polled_dev *poll_dev;
+        struct device *dev;
+        struct gpio_keys_platform_data *pdata;
+        struct gpio_keys_button_data data[0];
+};
+
+static void gpio_keys_polled_check_state(struct input_dev *input,
+                                         struct gpio_keys_button *button,
+                                         struct gpio_keys_button_data *bdata)
+{
+        int state;
+
+        if (bdata->can_sleep)
+                state = !!gpio_get_value_cansleep(button->gpio);
+        else
+                state = !!gpio_get_value(button->gpio);
+
+        if (state != bdata->last_state) {
+                unsigned int type = button->type ?: EV_KEY;
+
+                input_event(input, type, button->code,
+                            !!(state ^ button->active_low));
+                input_sync(input);
+                bdata->count = 0;
+                bdata->last_state = state;
+        }
+}
+
+static void gpio_keys_polled_poll(struct input_polled_dev *dev)
+{
+        struct gpio_keys_polled_dev *bdev = dev->private;
+        struct gpio_keys_platform_data *pdata = bdev->pdata;
+        struct input_dev *input = dev->input;
+        int i;
+
+        for (i = 0; i < bdev->pdata->nbuttons; i++) {
+                struct gpio_keys_button_data *bdata = &bdev->data[i];
+
+                if (bdata->count < bdata->threshold)
+                        bdata->count++;
+                else
+                        gpio_keys_polled_check_state(input, &pdata->buttons[i],
+                                                     bdata);
+        }
+}
+
+static void gpio_keys_polled_open(struct input_polled_dev *dev)
+{
+        struct gpio_keys_polled_dev *bdev = dev->private;
+        struct gpio_keys_platform_data *pdata = bdev->pdata;
+
+        if (pdata->enable)
+                pdata->enable(bdev->dev);
+}
+
+static void gpio_keys_polled_close(struct input_polled_dev *dev)
+{
+        struct gpio_keys_polled_dev *bdev = dev->private;
+        struct gpio_keys_platform_data *pdata = bdev->pdata;
+
+        if (pdata->disable)
+                pdata->disable(bdev->dev);
+}
+
+static int __devinit gpio_keys_polled_probe(struct platform_device *pdev)
+{
+        struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
+        struct device *dev = &pdev->dev;
+        struct gpio_keys_polled_dev *bdev;
+        struct input_polled_dev *poll_dev;
+        struct input_dev *input;
+        int error;
+        int i;
+
+        if (!pdata || !pdata->poll_interval)
+                return -EINVAL;
+
+        bdev = kzalloc(sizeof(struct gpio_keys_polled_dev) +
+                       pdata->nbuttons * sizeof(struct gpio_keys_button_data),
+                       GFP_KERNEL);
+        if (!bdev) {
+                dev_err(dev, "no memory for private data\n");
+                return -ENOMEM;
+        }
+
+        poll_dev = input_allocate_polled_device();
+        if (!poll_dev) {
+                dev_err(dev, "no memory for polled device\n");
+                error = -ENOMEM;
+                goto err_free_bdev;
+        }
+
+        poll_dev->private = bdev;
+        poll_dev->poll = gpio_keys_polled_poll;
+        poll_dev->poll_interval = pdata->poll_interval;
+        poll_dev->open = gpio_keys_polled_open;
+        poll_dev->close = gpio_keys_polled_close;
+
+        input = poll_dev->input;
+
+        input->evbit[0] = BIT(EV_KEY);
+        input->name = pdev->name;
+        input->phys = DRV_NAME"/input0";
+        input->dev.parent = &pdev->dev;
+
+        input->id.bustype = BUS_HOST;
+        input->id.vendor = 0x0001;
+        input->id.product = 0x0001;
+        input->id.version = 0x0100;
+
+        for (i = 0; i < pdata->nbuttons; i++) {
+                struct gpio_keys_button *button = &pdata->buttons[i];
+                struct gpio_keys_button_data *bdata = &bdev->data[i];
+                unsigned int gpio = button->gpio;
+                unsigned int type = button->type ?: EV_KEY;
+
+                if (button->wakeup) {
+                        dev_err(dev, DRV_NAME " does not support wakeup\n");
+                        error = -EINVAL;
+                        goto err_free_gpio;
+                }
+
+                error = gpio_request(gpio,
+                                     button->desc ? button->desc : DRV_NAME);
+                if (error) {
+                        dev_err(dev, "unable to claim gpio %u, err=%d\n",
+                                gpio, error);
+                        goto err_free_gpio;
+                }
+
+                error = gpio_direction_input(gpio);
+                if (error) {
+                        dev_err(dev,
+                                "unable to set direction on gpio %u, err=%d\n",
+                                gpio, error);
+                        goto err_free_gpio;
+                }
+
+                bdata->can_sleep = gpio_cansleep(gpio);
+                bdata->last_state = -1;
+                bdata->threshold = DIV_ROUND_UP(button->debounce_interval,
+                                                pdata->poll_interval);
+
+                input_set_capability(input, type, button->code);
+        }
+
+        bdev->poll_dev = poll_dev;
+        bdev->dev = dev;
+        bdev->pdata = pdata;
+        platform_set_drvdata(pdev, bdev);
+
+        error = input_register_polled_device(poll_dev);
+        if (error) {
+                dev_err(dev, "unable to register polled device, err=%d\n",
+                        error);
+                goto err_free_gpio;
+        }
+
+        /* report initial state of the buttons */
+        for (i = 0; i < pdata->nbuttons; i++)
+                gpio_keys_polled_check_state(input, &pdata->buttons[i],
+                                         &bdev->data[i]);
+
+        return 0;
+
+err_free_gpio:
+        while (--i >= 0)
+                gpio_free(pdata->buttons[i].gpio);
+
+        input_free_polled_device(poll_dev);
+
+err_free_bdev:
+        kfree(bdev);
+
+        platform_set_drvdata(pdev, NULL);
+        return error;
+}
+
+static int __devexit gpio_keys_polled_remove(struct platform_device *pdev)
+{
+        struct gpio_keys_polled_dev *bdev = platform_get_drvdata(pdev);
+        struct gpio_keys_platform_data *pdata = bdev->pdata;
+        int i;
+
+        input_unregister_polled_device(bdev->poll_dev);
+
+        for (i = 0; i < pdata->nbuttons; i++)
+                gpio_free(pdata->buttons[i].gpio);
+
+        input_free_polled_device(bdev->poll_dev);
+
+        kfree(bdev);
+        platform_set_drvdata(pdev, NULL);
+
+        return 0;
+}
+
+static struct platform_driver gpio_keys_polled_driver = {
+        .probe  = gpio_keys_polled_probe,
+        .remove = __devexit_p(gpio_keys_polled_remove),
+        .driver = {
+                .name   = DRV_NAME,
+                .owner  = THIS_MODULE,
+        },
+};
+
+static int __init gpio_keys_polled_init(void)
+{
+        return platform_driver_register(&gpio_keys_polled_driver);
+}
+
+static void __exit gpio_keys_polled_exit(void)
+{
+        platform_driver_unregister(&gpio_keys_polled_driver);
+}
+
+module_init(gpio_keys_polled_init);
+module_exit(gpio_keys_polled_exit);
+
+MODULE_LICENSE("GPL v2");
+MODULE_AUTHOR("Gabor Juhos <juhosg@openwrt.org>");
+MODULE_DESCRIPTION("Polled GPIO Buttons driver");
+MODULE_ALIAS("platform:" DRV_NAME);
diff --git a/drivers/input/keyboard/hil_kbd.c b/drivers/input/keyboard/hil_kbd.c
index 19fa94af207a..fed31e0947a1 100644
--- a/drivers/input/keyboard/hil_kbd.c
+++ b/drivers/input/keyboard/hil_kbd.c
@@ -570,6 +570,8 @@ static struct serio_device_id hil_dev_ids[] = {
         { 0 }
 };
 
+MODULE_DEVICE_TABLE(serio, hil_dev_ids);
+
 static struct serio_driver hil_serio_drv = {
         .driver         = {
                 .name   = "hil_dev",
diff --git a/drivers/input/keyboard/jornada680_kbd.c b/drivers/input/keyboard/jornada680_kbd.c
index 5fc976dbce0b..7197c5698747 100644
--- a/drivers/input/keyboard/jornada680_kbd.c
+++ b/drivers/input/keyboard/jornada680_kbd.c
@@ -139,35 +139,35 @@ static void jornada_scan_keyb(unsigned char *s)
         }, *y = matrix_PDE;
 
         /* Save these control reg bits */
-        dc_static = (ctrl_inw(PDCR) & (~0xcc0c));
-        ec_static = (ctrl_inw(PECR) & (~0xf0cf));
+        dc_static = (__raw_readw(PDCR) & (~0xcc0c));
+        ec_static = (__raw_readw(PECR) & (~0xf0cf));
 
         for (i = 0; i < 8; i++) {
                 /* disable output for all but the one we want to scan */
-                ctrl_outw((dc_static | *y++), PDCR);
-                ctrl_outw((ec_static | *y++), PECR);
+                __raw_writew((dc_static | *y++), PDCR);
+                __raw_writew((ec_static | *y++), PECR);
                 udelay(5);
 
                 /* Get scanline row */
-                ctrl_outb(*t++, PDDR);
-                ctrl_outb(*t++, PEDR);
+                __raw_writeb(*t++, PDDR);
+                __raw_writeb(*t++, PEDR);
                 udelay(50);
 
                 /* Read data */
-                *s++ = ctrl_inb(PCDR);
-                *s++ = ctrl_inb(PFDR);
+                *s++ = __raw_readb(PCDR);
+                *s++ = __raw_readb(PFDR);
         }
         /* Scan no lines */
-        ctrl_outb(0xff, PDDR);
-        ctrl_outb(0xff, PEDR);
+        __raw_writeb(0xff, PDDR);
+        __raw_writeb(0xff, PEDR);
 
         /* Enable all scanlines */
-        ctrl_outw((dc_static | (0x5555 & 0xcc0c)),PDCR);
-        ctrl_outw((ec_static | (0x5555 & 0xf0cf)),PECR);
+        __raw_writew((dc_static | (0x5555 & 0xcc0c)),PDCR);
+        __raw_writew((ec_static | (0x5555 & 0xf0cf)),PECR);
 
         /* Ignore extra keys and events */
-        *s++ = ctrl_inb(PGDR);
-        *s++ = ctrl_inb(PHDR);
+        *s++ = __raw_readb(PGDR);
+        *s++ = __raw_readb(PHDR);
 }
 
 static void jornadakbd680_poll(struct input_polled_dev *dev)
diff --git a/drivers/input/keyboard/lm8323.c b/drivers/input/keyboard/lm8323.c
index f7c2a166576b..71f744a8e686 100644
--- a/drivers/input/keyboard/lm8323.c
+++ b/drivers/input/keyboard/lm8323.c
@@ -30,6 +30,7 @@
 #include <linux/delay.h>
 #include <linux/input.h>
 #include <linux/leds.h>
+#include <linux/pm.h>
 #include <linux/i2c/lm8323.h>
 #include <linux/slab.h>
 
@@ -802,12 +803,13 @@ static int __devexit lm8323_remove(struct i2c_client *client)
  * We don't need to explicitly suspend the chip, as it already switches off
  * when there's no activity.
  */
-static int lm8323_suspend(struct i2c_client *client, pm_message_t mesg)
+static int lm8323_suspend(struct device *dev)
 {
+        struct i2c_client *client = to_i2c_client(dev);
         struct lm8323_chip *lm = i2c_get_clientdata(client);
         int i;
 
-        set_irq_wake(client->irq, 0);
+        irq_set_irq_wake(client->irq, 0);
         disable_irq(client->irq);
 
         mutex_lock(&lm->lock);
@@ -821,8 +823,9 @@ static int lm8323_suspend(struct i2c_client *client, pm_message_t mesg)
         return 0;
 }
 
-static int lm8323_resume(struct i2c_client *client)
+static int lm8323_resume(struct device *dev)
 {
+        struct i2c_client *client = to_i2c_client(dev);
         struct lm8323_chip *lm = i2c_get_clientdata(client);
         int i;
 
@@ -835,15 +838,14 @@ static int lm8323_resume(struct i2c_client *client)
                         led_classdev_resume(&lm->pwm[i].cdev);
 
         enable_irq(client->irq);
-        set_irq_wake(client->irq, 1);
+        irq_set_irq_wake(client->irq, 1);
 
         return 0;
 }
-#else
-#define lm8323_suspend  NULL
-#define lm8323_resume   NULL
 #endif
 
+static SIMPLE_DEV_PM_OPS(lm8323_pm_ops, lm8323_suspend, lm8323_resume);
+
 static const struct i2c_device_id lm8323_id[] = {
         { "lm8323", 0 },
         { }
@@ -852,11 +854,10 @@ static const struct i2c_device_id lm8323_id[] = {
 static struct i2c_driver lm8323_i2c_driver = {
         .driver = {
                 .name   = "lm8323",
+                .pm     = &lm8323_pm_ops,
         },
         .probe          = lm8323_probe,
         .remove         = __devexit_p(lm8323_remove),
-        .suspend        = lm8323_suspend,
-        .resume         = lm8323_resume,
         .id_table       = lm8323_id,
 };
 MODULE_DEVICE_TABLE(i2c, lm8323_id);
diff --git a/drivers/input/keyboard/max7359_keypad.c b/drivers/input/keyboard/max7359_keypad.c
index 9091ff5ea808..5afe35ad24d3 100644
--- a/drivers/input/keyboard/max7359_keypad.c
+++ b/drivers/input/keyboard/max7359_keypad.c
@@ -17,6 +17,7 @@
 #include <linux/i2c.h>
 #include <linux/slab.h>
 #include <linux/interrupt.h>
+#include <linux/pm.h>
 #include <linux/input.h>
 #include <linux/input/matrix_keypad.h>
 
@@ -271,8 +272,10 @@ static int __devexit max7359_remove(struct i2c_client *client)
 }
 
 #ifdef CONFIG_PM
-static int max7359_suspend(struct i2c_client *client, pm_message_t mesg)
+static int max7359_suspend(struct device *dev)
 {
+        struct i2c_client *client = to_i2c_client(dev);
+
         max7359_fall_deepsleep(client);
 
         if (device_may_wakeup(&client->dev))
@@ -281,8 +284,10 @@ static int max7359_suspend(struct i2c_client *client, pm_message_t mesg)
         return 0;
 }
 
-static int max7359_resume(struct i2c_client *client)
+static int max7359_resume(struct device *dev)
 {
+        struct i2c_client *client = to_i2c_client(dev);
+
         if (device_may_wakeup(&client->dev))
                 disable_irq_wake(client->irq);
 
@@ -291,11 +296,10 @@ static int max7359_resume(struct i2c_client *client)
 
         return 0;
 }
-#else
-#define max7359_suspend NULL
-#define max7359_resume  NULL
 #endif
 
+static SIMPLE_DEV_PM_OPS(max7359_pm, max7359_suspend, max7359_resume);
+
 static const struct i2c_device_id max7359_ids[] = {
         { "max7359", 0 },
         { }
@@ -305,11 +309,10 @@ MODULE_DEVICE_TABLE(i2c, max7359_ids);
 static struct i2c_driver max7359_i2c_driver = {
         .driver = {
                 .name = "max7359",
+                .pm   = &max7359_pm,
         },
         .probe          = max7359_probe,
         .remove         = __devexit_p(max7359_remove),
-        .suspend        = max7359_suspend,
-        .resume         = max7359_resume,
         .id_table       = max7359_ids,
 };
 
diff --git a/drivers/input/keyboard/mcs_touchkey.c b/drivers/input/keyboard/mcs_touchkey.c
index 63b849d7e90b..af1aab324a4c 100644
--- a/drivers/input/keyboard/mcs_touchkey.c
+++ b/drivers/input/keyboard/mcs_touchkey.c
@@ -1,5 +1,5 @@
 /*
- * mcs_touchkey.c - Touchkey driver for MELFAS MCS5000/5080 controller
+ * Touchkey driver for MELFAS MCS5000/5080 controller
  *
  * Copyright (C) 2010 Samsung Electronics Co.Ltd
  * Author: HeungJun Kim <riverful.kim@samsung.com>
@@ -19,6 +19,7 @@
 #include <linux/input.h>
 #include <linux/irq.h>
 #include <linux/slab.h>
+#include <linux/pm.h>
 
 /* MCS5000 Touchkey */
 #define MCS5000_TOUCHKEY_STATUS         0x04
@@ -45,6 +46,8 @@ struct mcs_touchkey_chip {
 };
 
 struct mcs_touchkey_data {
+        void (*poweron)(bool);
+
         struct i2c_client *client;
         struct input_dev *input_dev;
         struct mcs_touchkey_chip chip;
@@ -169,6 +172,11 @@ static int __devinit mcs_touchkey_probe(struct i2c_client *client,
         if (pdata->cfg_pin)
                 pdata->cfg_pin();
 
+        if (pdata->poweron) {
+                data->poweron = pdata->poweron;
+                data->poweron(true);
+        }
+
         error = request_threaded_irq(client->irq, NULL, mcs_touchkey_interrupt,
                         IRQF_TRIGGER_FALLING, client->dev.driver->name, data);
         if (error) {
@@ -196,12 +204,57 @@ static int __devexit mcs_touchkey_remove(struct i2c_client *client)
         struct mcs_touchkey_data *data = i2c_get_clientdata(client);
 
         free_irq(client->irq, data);
+        if (data->poweron)
+                data->poweron(false);
         input_unregister_device(data->input_dev);
         kfree(data);
 
         return 0;
 }
 
+static void mcs_touchkey_shutdown(struct i2c_client *client)
+{
+        struct mcs_touchkey_data *data = i2c_get_clientdata(client);
+
+        if (data->poweron)
+                data->poweron(false);
+}
+
+#ifdef CONFIG_PM_SLEEP
+static int mcs_touchkey_suspend(struct device *dev)
+{
+        struct mcs_touchkey_data *data = dev_get_drvdata(dev);
+        struct i2c_client *client = data->client;
+
+        /* Disable the work */
+        disable_irq(client->irq);
+
+        /* Finally turn off the power */
+        if (data->poweron)
+                data->poweron(false);
+
+        return 0;
+}
+
+static int mcs_touchkey_resume(struct device *dev)
+{
+        struct mcs_touchkey_data *data = dev_get_drvdata(dev);
+        struct i2c_client *client = data->client;
+
+        /* Enable the device first */
+        if (data->poweron)
+                data->poweron(true);
+
+        /* Enable irq again */
+        enable_irq(client->irq);
+
+        return 0;
+}
+#endif
+
+static SIMPLE_DEV_PM_OPS(mcs_touchkey_pm_ops,
+                         mcs_touchkey_suspend, mcs_touchkey_resume);
+
 static const struct i2c_device_id mcs_touchkey_id[] = {
         { "mcs5000_touchkey", MCS5000_TOUCHKEY },
         { "mcs5080_touchkey", MCS5080_TOUCHKEY },
@@ -213,9 +266,11 @@ static struct i2c_driver mcs_touchkey_driver = {
         .driver = {
                 .name   = "mcs_touchkey",
                 .owner  = THIS_MODULE,
+                .pm     = &mcs_touchkey_pm_ops,
         },
         .probe          = mcs_touchkey_probe,
         .remove         = __devexit_p(mcs_touchkey_remove),
+        .shutdown       = mcs_touchkey_shutdown,
         .id_table       = mcs_touchkey_id,
 };
 
diff --git a/drivers/input/keyboard/mpr121_touchkey.c b/drivers/input/keyboard/mpr121_touchkey.c
new file mode 100644
index 000000000000..0a9e81194888
--- /dev/null
+++ b/drivers/input/keyboard/mpr121_touchkey.c
@@ -0,0 +1,339 @@
+/*
+ * Touchkey driver for Freescale MPR121 Controllor
+ *
+ * Copyright (C) 2011 Freescale Semiconductor, Inc.
+ * Author: Zhang Jiejing <jiejing.zhang@freescale.com>
+ *
+ * Based on mcs_touchkey.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/module.h>
+#include <linux/init.h>
+#include <linux/input.h>
+#include <linux/i2c.h>
+#include <linux/slab.h>
+#include <linux/delay.h>
+#include <linux/bitops.h>
+#include <linux/interrupt.h>
+#include <linux/i2c/mpr121_touchkey.h>
+
+/* Register definitions */
+#define ELE_TOUCH_STATUS_0_ADDR 0x0
+#define ELE_TOUCH_STATUS_1_ADDR 0X1
+#define MHD_RISING_ADDR         0x2b
+#define NHD_RISING_ADDR         0x2c
+#define NCL_RISING_ADDR         0x2d
+#define FDL_RISING_ADDR         0x2e
+#define MHD_FALLING_ADDR        0x2f
+#define NHD_FALLING_ADDR        0x30
+#define NCL_FALLING_ADDR        0x31
+#define FDL_FALLING_ADDR        0x32
+#define ELE0_TOUCH_THRESHOLD_ADDR       0x41
+#define ELE0_RELEASE_THRESHOLD_ADDR     0x42
+#define AFE_CONF_ADDR                   0x5c
+#define FILTER_CONF_ADDR                0x5d
+
+/*
+ * ELECTRODE_CONF_ADDR: This register configures the number of
+ * enabled capacitance sensing inputs and its run/suspend mode.
+ */
+#define ELECTRODE_CONF_ADDR             0x5e
+#define AUTO_CONFIG_CTRL_ADDR           0x7b
+#define AUTO_CONFIG_USL_ADDR            0x7d
+#define AUTO_CONFIG_LSL_ADDR            0x7e
+#define AUTO_CONFIG_TL_ADDR             0x7f
+
+/* Threshold of touch/release trigger */
+#define TOUCH_THRESHOLD                 0x0f
+#define RELEASE_THRESHOLD               0x0a
+/* Masks for touch and release triggers */
+#define TOUCH_STATUS_MASK               0xfff
+/* MPR121 has 12 keys */
+#define MPR121_MAX_KEY_COUNT            12
+
+struct mpr121_touchkey {
+        struct i2c_client       *client;
+        struct input_dev        *input_dev;
+        unsigned int            key_val;
+        unsigned int            statusbits;
+        unsigned int            keycount;
+        u16                     keycodes[MPR121_MAX_KEY_COUNT];
+};
+
+struct mpr121_init_register {
+        int addr;
+        u8 val;
+};
+
+static const struct mpr121_init_register init_reg_table[] __devinitconst = {
+        { MHD_RISING_ADDR,      0x1 },
+        { NHD_RISING_ADDR,      0x1 },
+        { MHD_FALLING_ADDR,     0x1 },
+        { NHD_FALLING_ADDR,     0x1 },
+        { NCL_FALLING_ADDR,     0xff },
+        { FDL_FALLING_ADDR,     0x02 },
+        { FILTER_CONF_ADDR,     0x04 },
+        { AFE_CONF_ADDR,        0x0b },
+        { AUTO_CONFIG_CTRL_ADDR, 0x0b },
+};
+
+static irqreturn_t mpr_touchkey_interrupt(int irq, void *dev_id)
+{
+        struct mpr121_touchkey *mpr121 = dev_id;
+        struct i2c_client *client = mpr121->client;
+        struct input_dev *input = mpr121->input_dev;
+        unsigned int key_num, key_val, pressed;
+        int reg;
+
+        reg = i2c_smbus_read_byte_data(client, ELE_TOUCH_STATUS_1_ADDR);
+        if (reg < 0) {
+                dev_err(&client->dev, "i2c read error [%d]\n", reg);
+                goto out;
+        }
+
+        reg <<= 8;
+        reg |= i2c_smbus_read_byte_data(client, ELE_TOUCH_STATUS_0_ADDR);
+        if (reg < 0) {
+                dev_err(&client->dev, "i2c read error [%d]\n", reg);
+                goto out;
+        }
+
+        reg &= TOUCH_STATUS_MASK;
+        /* use old press bit to figure out which bit changed */
+        key_num = ffs(reg ^ mpr121->statusbits) - 1;
+        pressed = reg & (1 << key_num);
+        mpr121->statusbits = reg;
+
+        key_val = mpr121->keycodes[key_num];
+
+        input_event(input, EV_MSC, MSC_SCAN, key_num);
+        input_report_key(input, key_val, pressed);
+        input_sync(input);
+
+        dev_dbg(&client->dev, "key %d %d %s\n", key_num, key_val,
+                pressed ? "pressed" : "released");
+
+out:
+        return IRQ_HANDLED;
+}
+
+static int __devinit mpr121_phys_init(const struct mpr121_platform_data *pdata,
+                                      struct mpr121_touchkey *mpr121,
+                                      struct i2c_client *client)
+{
+        const struct mpr121_init_register *reg;
+        unsigned char usl, lsl, tl;
+        int i, t, vdd, ret;
+
+        /* Set up touch/release threshold for ele0-ele11 */
+        for (i = 0; i <= MPR121_MAX_KEY_COUNT; i++) {
+                t = ELE0_TOUCH_THRESHOLD_ADDR + (i * 2);
+                ret = i2c_smbus_write_byte_data(client, t, TOUCH_THRESHOLD);
+                if (ret < 0)
+                        goto err_i2c_write;
+                ret = i2c_smbus_write_byte_data(client, t + 1,
+                                                RELEASE_THRESHOLD);
+                if (ret < 0)
+                        goto err_i2c_write;
+        }
+
+        /* Set up init register */
+        for (i = 0; i < ARRAY_SIZE(init_reg_table); i++) {
+                reg = &init_reg_table[i];
+                ret = i2c_smbus_write_byte_data(client, reg->addr, reg->val);
+                if (ret < 0)
+                        goto err_i2c_write;
+        }
+
+
+        /*
+         * Capacitance on sensing input varies and needs to be compensated.
+         * The internal MPR121-auto-configuration can do this if it's
+         * registers are set properly (based on pdata->vdd_uv).
+         */
+        vdd = pdata->vdd_uv / 1000;
+        usl = ((vdd - 700) * 256) / vdd;
+        lsl = (usl * 65) / 100;
+        tl = (usl * 90) / 100;
+        ret = i2c_smbus_write_byte_data(client, AUTO_CONFIG_USL_ADDR, usl);
+        ret |= i2c_smbus_write_byte_data(client, AUTO_CONFIG_LSL_ADDR, lsl);
+        ret |= i2c_smbus_write_byte_data(client, AUTO_CONFIG_TL_ADDR, tl);
+        ret |= i2c_smbus_write_byte_data(client, ELECTRODE_CONF_ADDR,
+                                         mpr121->keycount);
+        if (ret != 0)
+                goto err_i2c_write;
+
+        dev_dbg(&client->dev, "set up with %x keys.\n", mpr121->keycount);
+
+        return 0;
+
+err_i2c_write:
+        dev_err(&client->dev, "i2c write error: %d\n", ret);
+        return ret;
+}
+
+static int __devinit mpr_touchkey_probe(struct i2c_client *client,
+                                        const struct i2c_device_id *id)
+{
+        const struct mpr121_platform_data *pdata = client->dev.platform_data;
+        struct mpr121_touchkey *mpr121;
+        struct input_dev *input_dev;
+        int error;
+        int i;
+
+        if (!pdata) {
+                dev_err(&client->dev, "no platform data defined\n");
+                return -EINVAL;
+        }
+
+        if (!pdata->keymap || !pdata->keymap_size) {
+                dev_err(&client->dev, "missing keymap data\n");
+                return -EINVAL;
+        }
+
+        if (pdata->keymap_size > MPR121_MAX_KEY_COUNT) {
+                dev_err(&client->dev, "too many keys defined\n");
+                return -EINVAL;
+        }
+
+        if (!client->irq) {
+                dev_err(&client->dev, "irq number should not be zero\n");
+                return -EINVAL;
+        }
+
+        mpr121 = kzalloc(sizeof(struct mpr121_touchkey), GFP_KERNEL);
+        input_dev = input_allocate_device();
+        if (!mpr121 || !input_dev) {
+                dev_err(&client->dev, "Failed to allocate memory\n");
+                error = -ENOMEM;
+                goto err_free_mem;
+        }
+
+        mpr121->client = client;
+        mpr121->input_dev = input_dev;
+        mpr121->keycount = pdata->keymap_size;
+
+        input_dev->name = "Freescale MPR121 Touchkey";
+        input_dev->id.bustype = BUS_I2C;
+        input_dev->dev.parent = &client->dev;
+        input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP);
+
+        input_dev->keycode = mpr121->keycodes;
+        input_dev->keycodesize = sizeof(mpr121->keycodes[0]);
+        input_dev->keycodemax = mpr121->keycount;
+
+        for (i = 0; i < pdata->keymap_size; i++) {
+                input_set_capability(input_dev, EV_KEY, pdata->keymap[i]);
+                mpr121->keycodes[i] = pdata->keymap[i];
+        }
+
+        error = mpr121_phys_init(pdata, mpr121, client);
+        if (error) {
+                dev_err(&client->dev, "Failed to init register\n");
+                goto err_free_mem;
+        }
+
+        error = request_threaded_irq(client->irq, NULL,
+                                     mpr_touchkey_interrupt,
+                                     IRQF_TRIGGER_FALLING,
+                                     client->dev.driver->name, mpr121);
+        if (error) {
+                dev_err(&client->dev, "Failed to register interrupt\n");
+                goto err_free_mem;
+        }
+
+        error = input_register_device(input_dev);
+        if (error)
+                goto err_free_irq;
+
+        i2c_set_clientdata(client, mpr121);
+        device_init_wakeup(&client->dev, pdata->wakeup);
+
+        return 0;
+
+err_free_irq:
+        free_irq(client->irq, mpr121);
+err_free_mem:
+        input_free_device(input_dev);
+        kfree(mpr121);
+        return error;
+}
+
+static int __devexit mpr_touchkey_remove(struct i2c_client *client)
+{
+        struct mpr121_touchkey *mpr121 = i2c_get_clientdata(client);
+
+        free_irq(client->irq, mpr121);
+        input_unregister_device(mpr121->input_dev);
+        kfree(mpr121);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM_SLEEP
+static int mpr_suspend(struct device *dev)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+
+        if (device_may_wakeup(&client->dev))
+                enable_irq_wake(client->irq);
+
+        i2c_smbus_write_byte_data(client, ELECTRODE_CONF_ADDR, 0x00);
+
+        return 0;
+}
+
+static int mpr_resume(struct device *dev)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct mpr121_touchkey *mpr121 = i2c_get_clientdata(client);
+
+        if (device_may_wakeup(&client->dev))
+                disable_irq_wake(client->irq);
+
+        i2c_smbus_write_byte_data(client, ELECTRODE_CONF_ADDR,
+                                  mpr121->keycount);
+
+        return 0;
+}
+#endif
+
+static SIMPLE_DEV_PM_OPS(mpr121_touchkey_pm_ops, mpr_suspend, mpr_resume);
+
+static const struct i2c_device_id mpr121_id[] = {
+        { "mpr121_touchkey", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, mpr121_id);
+
+static struct i2c_driver mpr_touchkey_driver = {
+        .driver = {
+                .name   = "mpr121",
+                .owner  = THIS_MODULE,
+                .pm     = &mpr121_touchkey_pm_ops,
+        },
+        .id_table       = mpr121_id,
+        .probe          = mpr_touchkey_probe,
+        .remove         = __devexit_p(mpr_touchkey_remove),
+};
+
+static int __init mpr_touchkey_init(void)
+{
+        return i2c_add_driver(&mpr_touchkey_driver);
+}
+module_init(mpr_touchkey_init);
+
+static void __exit mpr_touchkey_exit(void)
+{
+        i2c_del_driver(&mpr_touchkey_driver);
+}
+module_exit(mpr_touchkey_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Zhang Jiejing <jiejing.zhang@freescale.com>");
+MODULE_DESCRIPTION("Touch Key driver for Freescale MPR121 Chip");
diff --git a/drivers/input/keyboard/nomadik-ske-keypad.c b/drivers/input/keyboard/nomadik-ske-keypad.c
new file mode 100644
index 000000000000..6e0f23091360
--- /dev/null
+++ b/drivers/input/keyboard/nomadik-ske-keypad.c
@@ -0,0 +1,408 @@
+/*
+ * Copyright (C) ST-Ericsson SA 2010
+ *
+ * Author: Naveen Kumar G <naveen.gaddipati@stericsson.com> for ST-Ericsson
+ * Author: Sundar Iyer <sundar.iyer@stericsson.com> for ST-Ericsson
+ *
+ * License terms:GNU General Public License (GPL) version 2
+ *
+ * Keypad controller driver for the SKE (Scroll Key Encoder) module used in
+ * the Nomadik 8815 and Ux500 platforms.
+ */
+
+#include <linux/platform_device.h>
+#include <linux/interrupt.h>
+#include <linux/spinlock.h>
+#include <linux/io.h>
+#include <linux/delay.h>
+#include <linux/input.h>
+#include <linux/slab.h>
+#include <linux/clk.h>
+
+#include <plat/ske.h>
+
+/* SKE_CR bits */
+#define SKE_KPMLT       (0x1 << 6)
+#define SKE_KPCN        (0x7 << 3)
+#define SKE_KPASEN      (0x1 << 2)
+#define SKE_KPASON      (0x1 << 7)
+
+/* SKE_IMSC bits */
+#define SKE_KPIMA       (0x1 << 2)
+
+/* SKE_ICR bits */
+#define SKE_KPICS       (0x1 << 3)
+#define SKE_KPICA       (0x1 << 2)
+
+/* SKE_RIS bits */
+#define SKE_KPRISA      (0x1 << 2)
+
+#define SKE_KEYPAD_ROW_SHIFT    3
+#define SKE_KPD_KEYMAP_SIZE     (8 * 8)
+
+/* keypad auto scan registers */
+#define SKE_ASR0        0x20
+#define SKE_ASR1        0x24
+#define SKE_ASR2        0x28
+#define SKE_ASR3        0x2C
+
+#define SKE_NUM_ASRX_REGISTERS  (4)
+
+/**
+ * struct ske_keypad  - data structure used by keypad driver
+ * @irq:        irq no
+ * @reg_base:   ske regsiters base address
+ * @input:      pointer to input device object
+ * @board:      keypad platform device
+ * @keymap:     matrix scan code table for keycodes
+ * @clk:        clock structure pointer
+ */
+struct ske_keypad {
+        int irq;
+        void __iomem *reg_base;
+        struct input_dev *input;
+        const struct ske_keypad_platform_data *board;
+        unsigned short keymap[SKE_KPD_KEYMAP_SIZE];
+        struct clk *clk;
+        spinlock_t ske_keypad_lock;
+};
+
+static void ske_keypad_set_bits(struct ske_keypad *keypad, u16 addr,
+                u8 mask, u8 data)
+{
+        u32 ret;
+
+        spin_lock(&keypad->ske_keypad_lock);
+
+        ret = readl(keypad->reg_base + addr);
+        ret &= ~mask;
+        ret |= data;
+        writel(ret, keypad->reg_base + addr);
+
+        spin_unlock(&keypad->ske_keypad_lock);
+}
+
+/*
+ * ske_keypad_chip_init: init keypad controller configuration
+ *
+ * Enable Multi key press detection, auto scan mode
+ */
+static int __devinit ske_keypad_chip_init(struct ske_keypad *keypad)
+{
+        u32 value;
+        int timeout = 50;
+
+        /* check SKE_RIS to be 0 */
+        while ((readl(keypad->reg_base + SKE_RIS) != 0x00000000) && timeout--)
+                cpu_relax();
+
+        if (!timeout)
+                return -EINVAL;
+
+        /*
+         * set debounce value
+         * keypad dbounce is configured in DBCR[15:8]
+         * dbounce value in steps of 32/32.768 ms
+         */
+        spin_lock(&keypad->ske_keypad_lock);
+        value = readl(keypad->reg_base + SKE_DBCR);
+        value = value & 0xff;
+        value |= ((keypad->board->debounce_ms * 32000)/32768) << 8;
+        writel(value, keypad->reg_base + SKE_DBCR);
+        spin_unlock(&keypad->ske_keypad_lock);
+
+        /* enable multi key detection */
+        ske_keypad_set_bits(keypad, SKE_CR, 0x0, SKE_KPMLT);
+
+        /*
+         * set up the number of columns
+         * KPCN[5:3] defines no. of keypad columns to be auto scanned
+         */
+        value = (keypad->board->kcol - 1) << 3;
+        ske_keypad_set_bits(keypad, SKE_CR, SKE_KPCN, value);
+
+        /* clear keypad interrupt for auto(and pending SW) scans */
+        ske_keypad_set_bits(keypad, SKE_ICR, 0x0, SKE_KPICA | SKE_KPICS);
+
+        /* un-mask keypad interrupts */
+        ske_keypad_set_bits(keypad, SKE_IMSC, 0x0, SKE_KPIMA);
+
+        /* enable automatic scan */
+        ske_keypad_set_bits(keypad, SKE_CR, 0x0, SKE_KPASEN);
+
+        return 0;
+}
+
+static void ske_keypad_read_data(struct ske_keypad *keypad)
+{
+        struct input_dev *input = keypad->input;
+        u16 status;
+        int col = 0, row = 0, code;
+        int ske_asr, ske_ris, key_pressed, i;
+
+        /*
+         * Read the auto scan registers
+         *
+         * Each SKE_ASRx (x=0 to x=3) contains two row values.
+         * lower byte contains row value for column 2*x,
+         * upper byte contains row value for column 2*x + 1
+         */
+        for (i = 0; i < SKE_NUM_ASRX_REGISTERS; i++) {
+                ske_asr = readl(keypad->reg_base + SKE_ASR0 + (4 * i));
+                if (!ske_asr)
+                        continue;
+
+                /* now that ASRx is zero, find out the column x and row y*/
+                if (ske_asr & 0xff) {
+                        col = i * 2;
+                        status = ske_asr & 0xff;
+                } else {
+                        col = (i * 2) + 1;
+                        status = (ske_asr & 0xff00) >> 8;
+                }
+
+                /* find out the row */
+                row = __ffs(status);
+
+                code = MATRIX_SCAN_CODE(row, col, SKE_KEYPAD_ROW_SHIFT);
+                ske_ris = readl(keypad->reg_base + SKE_RIS);
+                key_pressed = ske_ris & SKE_KPRISA;
+
+                input_event(input, EV_MSC, MSC_SCAN, code);
+                input_report_key(input, keypad->keymap[code], key_pressed);
+                input_sync(input);
+        }
+}
+
+static irqreturn_t ske_keypad_irq(int irq, void *dev_id)
+{
+        struct ske_keypad *keypad = dev_id;
+        int retries = 20;
+
+        /* disable auto scan interrupt; mask the interrupt generated */
+        ske_keypad_set_bits(keypad, SKE_IMSC, ~SKE_KPIMA, 0x0);
+        ske_keypad_set_bits(keypad, SKE_ICR, 0x0, SKE_KPICA);
+
+        while ((readl(keypad->reg_base + SKE_CR) & SKE_KPASON) && --retries)
+                msleep(5);
+
+        if (retries) {
+                /* SKEx registers are stable and can be read */
+                ske_keypad_read_data(keypad);
+        }
+
+        /* enable auto scan interrupts */
+        ske_keypad_set_bits(keypad, SKE_IMSC, 0x0, SKE_KPIMA);
+
+        return IRQ_HANDLED;
+}
+
+static int __devinit ske_keypad_probe(struct platform_device *pdev)
+{
+        const struct ske_keypad_platform_data *plat = pdev->dev.platform_data;
+        struct ske_keypad *keypad;
+        struct input_dev *input;
+        struct resource *res;
+        int irq;
+        int error;
+
+        if (!plat) {
+                dev_err(&pdev->dev, "invalid keypad platform data\n");
+                return -EINVAL;
+        }
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0) {
+                dev_err(&pdev->dev, "failed to get keypad irq\n");
+                return -EINVAL;
+        }
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(&pdev->dev, "missing platform resources\n");
+                return -EINVAL;
+        }
+
+        keypad = kzalloc(sizeof(struct ske_keypad), GFP_KERNEL);
+        input = input_allocate_device();
+        if (!keypad || !input) {
+                dev_err(&pdev->dev, "failed to allocate keypad memory\n");
+                error = -ENOMEM;
+                goto err_free_mem;
+        }
+
+        keypad->irq = irq;
+        keypad->board = plat;
+        keypad->input = input;
+        spin_lock_init(&keypad->ske_keypad_lock);
+
+        if (!request_mem_region(res->start, resource_size(res), pdev->name)) {
+                dev_err(&pdev->dev, "failed to request I/O memory\n");
+                error = -EBUSY;
+                goto err_free_mem;
+        }
+
+        keypad->reg_base = ioremap(res->start, resource_size(res));
+        if (!keypad->reg_base) {
+                dev_err(&pdev->dev, "failed to remap I/O memory\n");
+                error = -ENXIO;
+                goto err_free_mem_region;
+        }
+
+        keypad->clk = clk_get(&pdev->dev, NULL);
+        if (IS_ERR(keypad->clk)) {
+                dev_err(&pdev->dev, "failed to get clk\n");
+                error = PTR_ERR(keypad->clk);
+                goto err_iounmap;
+        }
+
+        input->id.bustype = BUS_HOST;
+        input->name = "ux500-ske-keypad";
+        input->dev.parent = &pdev->dev;
+
+        input->keycode = keypad->keymap;
+        input->keycodesize = sizeof(keypad->keymap[0]);
+        input->keycodemax = ARRAY_SIZE(keypad->keymap);
+
+        input_set_capability(input, EV_MSC, MSC_SCAN);
+
+        __set_bit(EV_KEY, input->evbit);
+        if (!plat->no_autorepeat)
+                __set_bit(EV_REP, input->evbit);
+
+        matrix_keypad_build_keymap(plat->keymap_data, SKE_KEYPAD_ROW_SHIFT,
+                        input->keycode, input->keybit);
+
+        clk_enable(keypad->clk);
+
+        /* go through board initialization helpers */
+        if (keypad->board->init)
+                keypad->board->init();
+
+        error = ske_keypad_chip_init(keypad);
+        if (error) {
+                dev_err(&pdev->dev, "unable to init keypad hardware\n");
+                goto err_clk_disable;
+        }
+
+        error = request_threaded_irq(keypad->irq, NULL, ske_keypad_irq,
+                                     IRQF_ONESHOT, "ske-keypad", keypad);
+        if (error) {
+                dev_err(&pdev->dev, "allocate irq %d failed\n", keypad->irq);
+                goto err_clk_disable;
+        }
+
+        error = input_register_device(input);
+        if (error) {
+                dev_err(&pdev->dev,
+                                "unable to register input device: %d\n", error);
+                goto err_free_irq;
+        }
+
+        if (plat->wakeup_enable)
+                device_init_wakeup(&pdev->dev, true);
+
+        platform_set_drvdata(pdev, keypad);
+
+        return 0;
+
+err_free_irq:
+        free_irq(keypad->irq, keypad);
+err_clk_disable:
+        clk_disable(keypad->clk);
+        clk_put(keypad->clk);
+err_iounmap:
+        iounmap(keypad->reg_base);
+err_free_mem_region:
+        release_mem_region(res->start, resource_size(res));
+err_free_mem:
+        input_free_device(input);
+        kfree(keypad);
+        return error;
+}
+
+static int __devexit ske_keypad_remove(struct platform_device *pdev)
+{
+        struct ske_keypad *keypad = platform_get_drvdata(pdev);
+        struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+
+        free_irq(keypad->irq, keypad);
+
+        input_unregister_device(keypad->input);
+
+        clk_disable(keypad->clk);
+        clk_put(keypad->clk);
+
+        if (keypad->board->exit)
+                keypad->board->exit();
+
+        iounmap(keypad->reg_base);
+        release_mem_region(res->start, resource_size(res));
+        kfree(keypad);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int ske_keypad_suspend(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct ske_keypad *keypad = platform_get_drvdata(pdev);
+        int irq = platform_get_irq(pdev, 0);
+
+        if (device_may_wakeup(dev))
+                enable_irq_wake(irq);
+        else
+                ske_keypad_set_bits(keypad, SKE_IMSC, ~SKE_KPIMA, 0x0);
+
+        return 0;
+}
+
+static int ske_keypad_resume(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct ske_keypad *keypad = platform_get_drvdata(pdev);
+        int irq = platform_get_irq(pdev, 0);
+
+        if (device_may_wakeup(dev))
+                disable_irq_wake(irq);
+        else
+                ske_keypad_set_bits(keypad, SKE_IMSC, 0x0, SKE_KPIMA);
+
+        return 0;
+}
+
+static const struct dev_pm_ops ske_keypad_dev_pm_ops = {
+        .suspend = ske_keypad_suspend,
+        .resume = ske_keypad_resume,
+};
+#endif
+
+struct platform_driver ske_keypad_driver = {
+        .driver = {
+                .name = "nmk-ske-keypad",
+                .owner  = THIS_MODULE,
+#ifdef CONFIG_PM
+                .pm = &ske_keypad_dev_pm_ops,
+#endif
+        },
+        .probe = ske_keypad_probe,
+        .remove = __devexit_p(ske_keypad_remove),
+};
+
+static int __init ske_keypad_init(void)
+{
+        return platform_driver_probe(&ske_keypad_driver, ske_keypad_probe);
+}
+module_init(ske_keypad_init);
+
+static void __exit ske_keypad_exit(void)
+{
+        platform_driver_unregister(&ske_keypad_driver);
+}
+module_exit(ske_keypad_exit);
+
+MODULE_LICENSE("GPL v2");
+MODULE_AUTHOR("Naveen Kumar <naveen.gaddipati@stericsson.com> / Sundar Iyer <sundar.iyer@stericsson.com>");
+MODULE_DESCRIPTION("Nomadik Scroll-Key-Encoder Keypad Driver");
+MODULE_ALIAS("platform:nomadik-ske-keypad");
diff --git a/drivers/input/keyboard/omap-keypad.c b/drivers/input/keyboard/omap-keypad.c
index a72e61ddca91..33d0bdc837c0 100644
--- a/drivers/input/keyboard/omap-keypad.c
+++ b/drivers/input/keyboard/omap-keypad.c
@@ -65,7 +65,6 @@ struct omap_kp {
 
 static DECLARE_TASKLET_DISABLED(kp_tasklet, omap_kp_tasklet, 0);
 
-static int *keymap;
 static unsigned int *row_gpios;
 static unsigned int *col_gpios;
 
@@ -162,20 +161,11 @@ static void omap_kp_scan_keypad(struct omap_kp *omap_kp, unsigned char *state)
         }
 }
 
-static inline int omap_kp_find_key(int col, int row)
-{
-        int i, key;
-
-        key = KEY(col, row, 0);
-        for (i = 0; keymap[i] != 0; i++)
-                if ((keymap[i] & 0xff000000) == key)
-                        return keymap[i] & 0x00ffffff;
-        return -1;
-}
-
 static void omap_kp_tasklet(unsigned long data)
 {
         struct omap_kp *omap_kp_data = (struct omap_kp *) data;
+        unsigned short *keycodes = omap_kp_data->input->keycode;
+        unsigned int row_shift = get_count_order(omap_kp_data->cols);
         unsigned char new_state[8], changed, key_down = 0;
         int col, row;
         int spurious = 0;
@@ -199,7 +189,7 @@ static void omap_kp_tasklet(unsigned long data)
                                row, (new_state[col] & (1 << row)) ?
                                "pressed" : "released");
 #else
-                        key = omap_kp_find_key(col, row);
+                        key = keycodes[MATRIX_SCAN_CODE(row, col, row_shift)];
                         if (key < 0) {
                                 printk(KERN_WARNING
                                       "omap-keypad: Spurious key event %d-%d\n",
@@ -219,6 +209,7 @@ static void omap_kp_tasklet(unsigned long data)
 #endif
                 }
         }
+        input_sync(omap_kp_data->input);
         memcpy(keypad_state, new_state, sizeof(keypad_state));
 
         if (key_down) {
@@ -298,13 +289,18 @@ static int __devinit omap_kp_probe(struct platform_device *pdev)
         struct input_dev *input_dev;
         struct omap_kp_platform_data *pdata =  pdev->dev.platform_data;
         int i, col_idx, row_idx, irq_idx, ret;
+        unsigned int row_shift, keycodemax;
 
-        if (!pdata->rows || !pdata->cols || !pdata->keymap) {
-                printk(KERN_ERR "No rows, cols or keymap from pdata\n");
+        if (!pdata->rows || !pdata->cols || !pdata->keymap_data) {
+                printk(KERN_ERR "No rows, cols or keymap_data from pdata\n");
                 return -EINVAL;
         }
 
-        omap_kp = kzalloc(sizeof(struct omap_kp), GFP_KERNEL);
+        row_shift = get_count_order(pdata->cols);
+        keycodemax = pdata->rows << row_shift;
+
+        omap_kp = kzalloc(sizeof(struct omap_kp) +
+                        keycodemax * sizeof(unsigned short), GFP_KERNEL);
         input_dev = input_allocate_device();
         if (!omap_kp || !input_dev) {
                 kfree(omap_kp);
@@ -320,7 +316,9 @@ static int __devinit omap_kp_probe(struct platform_device *pdev)
         if (!cpu_is_omap24xx())
                 omap_writew(1, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT);
 
-        keymap = pdata->keymap;
+        input_dev->keycode      = &omap_kp[1];
+        input_dev->keycodesize  = sizeof(unsigned short);
+        input_dev->keycodemax   = keycodemax;
 
         if (pdata->rep)
                 __set_bit(EV_REP, input_dev->evbit);
@@ -374,8 +372,8 @@ static int __devinit omap_kp_probe(struct platform_device *pdev)
 
         /* setup input device */
         __set_bit(EV_KEY, input_dev->evbit);
-        for (i = 0; keymap[i] != 0; i++)
-                __set_bit(keymap[i] & KEY_MAX, input_dev->keybit);
+        matrix_keypad_build_keymap(pdata->keymap_data, row_shift,
+                        input_dev->keycode, input_dev->keybit);
         input_dev->name = "omap-keypad";
         input_dev->phys = "omap-keypad/input0";
         input_dev->dev.parent = &pdev->dev;
@@ -416,7 +414,7 @@ static int __devinit omap_kp_probe(struct platform_device *pdev)
         return 0;
 err5:
         for (i = irq_idx - 1; i >=0; i--)
-                free_irq(row_gpios[i], 0);
+                free_irq(row_gpios[i], omap_kp);
 err4:
         input_unregister_device(omap_kp->input);
         input_dev = NULL;
@@ -447,11 +445,11 @@ static int __devexit omap_kp_remove(struct platform_device *pdev)
                         gpio_free(col_gpios[i]);
                 for (i = 0; i < omap_kp->rows; i++) {
                         gpio_free(row_gpios[i]);
-                        free_irq(gpio_to_irq(row_gpios[i]), 0);
+                        free_irq(gpio_to_irq(row_gpios[i]), omap_kp);
                 }
         } else {
                 omap_writew(1, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT);
-                free_irq(omap_kp->irq, 0);
+                free_irq(omap_kp->irq, omap_kp);
         }
 
         del_timer_sync(&omap_kp->timer);
diff --git a/drivers/input/keyboard/omap4-keypad.c b/drivers/input/keyboard/omap4-keypad.c
new file mode 100644
index 000000000000..c51a3c4a7feb
--- /dev/null
+++ b/drivers/input/keyboard/omap4-keypad.c
@@ -0,0 +1,354 @@
+/*
+ * OMAP4 Keypad Driver
+ *
+ * Copyright (C) 2010 Texas Instruments
+ *
+ * Author: Abraham Arce <x0066660@ti.com>
+ * Initial Code: Syed Rafiuddin <rafiuddin.syed@ti.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/platform_device.h>
+#include <linux/errno.h>
+#include <linux/io.h>
+#include <linux/input.h>
+#include <linux/slab.h>
+#include <linux/pm_runtime.h>
+
+#include <plat/omap4-keypad.h>
+
+/* OMAP4 registers */
+#define OMAP4_KBD_REVISION              0x00
+#define OMAP4_KBD_SYSCONFIG             0x10
+#define OMAP4_KBD_SYSSTATUS             0x14
+#define OMAP4_KBD_IRQSTATUS             0x18
+#define OMAP4_KBD_IRQENABLE             0x1C
+#define OMAP4_KBD_WAKEUPENABLE          0x20
+#define OMAP4_KBD_PENDING               0x24
+#define OMAP4_KBD_CTRL                  0x28
+#define OMAP4_KBD_DEBOUNCINGTIME        0x2C
+#define OMAP4_KBD_LONGKEYTIME           0x30
+#define OMAP4_KBD_TIMEOUT               0x34
+#define OMAP4_KBD_STATEMACHINE          0x38
+#define OMAP4_KBD_ROWINPUTS             0x3C
+#define OMAP4_KBD_COLUMNOUTPUTS         0x40
+#define OMAP4_KBD_FULLCODE31_0          0x44
+#define OMAP4_KBD_FULLCODE63_32         0x48
+
+/* OMAP4 bit definitions */
+#define OMAP4_DEF_IRQENABLE_EVENTEN     (1 << 0)
+#define OMAP4_DEF_IRQENABLE_LONGKEY     (1 << 1)
+#define OMAP4_DEF_IRQENABLE_TIMEOUTEN   (1 << 2)
+#define OMAP4_DEF_WUP_EVENT_ENA         (1 << 0)
+#define OMAP4_DEF_WUP_LONG_KEY_ENA      (1 << 1)
+#define OMAP4_DEF_CTRL_NOSOFTMODE       (1 << 1)
+#define OMAP4_DEF_CTRLPTVVALUE          (1 << 2)
+#define OMAP4_DEF_CTRLPTV               (1 << 1)
+
+/* OMAP4 values */
+#define OMAP4_VAL_IRQDISABLE            0x00
+#define OMAP4_VAL_DEBOUNCINGTIME        0x07
+#define OMAP4_VAL_FUNCTIONALCFG         0x1E
+
+#define OMAP4_MASK_IRQSTATUSDISABLE     0xFFFF
+
+struct omap4_keypad {
+        struct input_dev *input;
+
+        void __iomem *base;
+        int irq;
+
+        unsigned int rows;
+        unsigned int cols;
+        unsigned int row_shift;
+        unsigned char key_state[8];
+        unsigned short keymap[];
+};
+
+/* Interrupt handler */
+static irqreturn_t omap4_keypad_interrupt(int irq, void *dev_id)
+{
+        struct omap4_keypad *keypad_data = dev_id;
+        struct input_dev *input_dev = keypad_data->input;
+        unsigned char key_state[ARRAY_SIZE(keypad_data->key_state)];
+        unsigned int col, row, code, changed;
+        u32 *new_state = (u32 *) key_state;
+
+        /* Disable interrupts */
+        __raw_writel(OMAP4_VAL_IRQDISABLE,
+                     keypad_data->base + OMAP4_KBD_IRQENABLE);
+
+        *new_state = __raw_readl(keypad_data->base + OMAP4_KBD_FULLCODE31_0);
+        *(new_state + 1) = __raw_readl(keypad_data->base
+                                                + OMAP4_KBD_FULLCODE63_32);
+
+        for (row = 0; row < keypad_data->rows; row++) {
+                changed = key_state[row] ^ keypad_data->key_state[row];
+                if (!changed)
+                        continue;
+
+                for (col = 0; col < keypad_data->cols; col++) {
+                        if (changed & (1 << col)) {
+                                code = MATRIX_SCAN_CODE(row, col,
+                                                keypad_data->row_shift);
+                                input_event(input_dev, EV_MSC, MSC_SCAN, code);
+                                input_report_key(input_dev,
+                                                 keypad_data->keymap[code],
+                                                 key_state[row] & (1 << col));
+                        }
+                }
+        }
+
+        input_sync(input_dev);
+
+        memcpy(keypad_data->key_state, key_state,
+                sizeof(keypad_data->key_state));
+
+        /* clear pending interrupts */
+        __raw_writel(__raw_readl(keypad_data->base + OMAP4_KBD_IRQSTATUS),
+                        keypad_data->base + OMAP4_KBD_IRQSTATUS);
+
+        /* enable interrupts */
+        __raw_writel(OMAP4_DEF_IRQENABLE_EVENTEN | OMAP4_DEF_IRQENABLE_LONGKEY,
+                        keypad_data->base + OMAP4_KBD_IRQENABLE);
+
+        return IRQ_HANDLED;
+}
+
+static int omap4_keypad_open(struct input_dev *input)
+{
+        struct omap4_keypad *keypad_data = input_get_drvdata(input);
+
+        pm_runtime_get_sync(input->dev.parent);
+
+        disable_irq(keypad_data->irq);
+
+        __raw_writel(OMAP4_VAL_FUNCTIONALCFG,
+                        keypad_data->base + OMAP4_KBD_CTRL);
+        __raw_writel(OMAP4_VAL_DEBOUNCINGTIME,
+                        keypad_data->base + OMAP4_KBD_DEBOUNCINGTIME);
+        __raw_writel(OMAP4_VAL_IRQDISABLE,
+                        keypad_data->base + OMAP4_KBD_IRQSTATUS);
+        __raw_writel(OMAP4_DEF_IRQENABLE_EVENTEN | OMAP4_DEF_IRQENABLE_LONGKEY,
+                        keypad_data->base + OMAP4_KBD_IRQENABLE);
+        __raw_writel(OMAP4_DEF_WUP_EVENT_ENA | OMAP4_DEF_WUP_LONG_KEY_ENA,
+                        keypad_data->base + OMAP4_KBD_WAKEUPENABLE);
+
+        enable_irq(keypad_data->irq);
+
+        return 0;
+}
+
+static void omap4_keypad_close(struct input_dev *input)
+{
+        struct omap4_keypad *keypad_data = input_get_drvdata(input);
+
+        disable_irq(keypad_data->irq);
+
+        /* Disable interrupts */
+        __raw_writel(OMAP4_VAL_IRQDISABLE,
+                     keypad_data->base + OMAP4_KBD_IRQENABLE);
+
+        /* clear pending interrupts */
+        __raw_writel(__raw_readl(keypad_data->base + OMAP4_KBD_IRQSTATUS),
+                        keypad_data->base + OMAP4_KBD_IRQSTATUS);
+
+        enable_irq(keypad_data->irq);
+
+        pm_runtime_put_sync(input->dev.parent);
+}
+
+static int __devinit omap4_keypad_probe(struct platform_device *pdev)
+{
+        const struct omap4_keypad_platform_data *pdata;
+        struct omap4_keypad *keypad_data;
+        struct input_dev *input_dev;
+        struct resource *res;
+        resource_size_t size;
+        unsigned int row_shift, max_keys;
+        int irq;
+        int error;
+
+        /* platform data */
+        pdata = pdev->dev.platform_data;
+        if (!pdata) {
+                dev_err(&pdev->dev, "no platform data defined\n");
+                return -EINVAL;
+        }
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(&pdev->dev, "no base address specified\n");
+                return -EINVAL;
+        }
+
+        irq = platform_get_irq(pdev, 0);
+        if (!irq) {
+                dev_err(&pdev->dev, "no keyboard irq assigned\n");
+                return -EINVAL;
+        }
+
+        if (!pdata->keymap_data) {
+                dev_err(&pdev->dev, "no keymap data defined\n");
+                return -EINVAL;
+        }
+
+        row_shift = get_count_order(pdata->cols);
+        max_keys = pdata->rows << row_shift;
+
+        keypad_data = kzalloc(sizeof(struct omap4_keypad) +
+                                max_keys * sizeof(keypad_data->keymap[0]),
+                              GFP_KERNEL);
+        if (!keypad_data) {
+                dev_err(&pdev->dev, "keypad_data memory allocation failed\n");
+                return -ENOMEM;
+        }
+
+        size = resource_size(res);
+
+        res = request_mem_region(res->start, size, pdev->name);
+        if (!res) {
+                dev_err(&pdev->dev, "can't request mem region\n");
+                error = -EBUSY;
+                goto err_free_keypad;
+        }
+
+        keypad_data->base = ioremap(res->start, resource_size(res));
+        if (!keypad_data->base) {
+                dev_err(&pdev->dev, "can't ioremap mem resource\n");
+                error = -ENOMEM;
+                goto err_release_mem;
+        }
+
+        keypad_data->irq = irq;
+        keypad_data->row_shift = row_shift;
+        keypad_data->rows = pdata->rows;
+        keypad_data->cols = pdata->cols;
+
+        /* input device allocation */
+        keypad_data->input = input_dev = input_allocate_device();
+        if (!input_dev) {
+                error = -ENOMEM;
+                goto err_unmap;
+        }
+
+        input_dev->name = pdev->name;
+        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 = 0x0001;
+
+        input_dev->open = omap4_keypad_open;
+        input_dev->close = omap4_keypad_close;
+
+        input_dev->keycode      = keypad_data->keymap;
+        input_dev->keycodesize  = sizeof(keypad_data->keymap[0]);
+        input_dev->keycodemax   = max_keys;
+
+        __set_bit(EV_KEY, input_dev->evbit);
+        __set_bit(EV_REP, input_dev->evbit);
+
+        input_set_capability(input_dev, EV_MSC, MSC_SCAN);
+
+        input_set_drvdata(input_dev, keypad_data);
+
+        matrix_keypad_build_keymap(pdata->keymap_data, row_shift,
+                        input_dev->keycode, input_dev->keybit);
+
+        error = request_irq(keypad_data->irq, omap4_keypad_interrupt,
+                             IRQF_TRIGGER_RISING,
+                             "omap4-keypad", keypad_data);
+        if (error) {
+                dev_err(&pdev->dev, "failed to register interrupt\n");
+                goto err_free_input;
+        }
+
+        pm_runtime_enable(&pdev->dev);
+
+        error = input_register_device(keypad_data->input);
+        if (error < 0) {
+                dev_err(&pdev->dev, "failed to register input device\n");
+                goto err_pm_disable;
+        }
+
+        platform_set_drvdata(pdev, keypad_data);
+        return 0;
+
+err_pm_disable:
+        pm_runtime_disable(&pdev->dev);
+        free_irq(keypad_data->irq, keypad_data);
+err_free_input:
+        input_free_device(input_dev);
+err_unmap:
+        iounmap(keypad_data->base);
+err_release_mem:
+        release_mem_region(res->start, size);
+err_free_keypad:
+        kfree(keypad_data);
+        return error;
+}
+
+static int __devexit omap4_keypad_remove(struct platform_device *pdev)
+{
+        struct omap4_keypad *keypad_data = platform_get_drvdata(pdev);
+        struct resource *res;
+
+        free_irq(keypad_data->irq, keypad_data);
+
+        pm_runtime_disable(&pdev->dev);
+
+        input_unregister_device(keypad_data->input);
+
+        iounmap(keypad_data->base);
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        release_mem_region(res->start, resource_size(res));
+
+        kfree(keypad_data);
+        platform_set_drvdata(pdev, NULL);
+
+        return 0;
+}
+
+static struct platform_driver omap4_keypad_driver = {
+        .probe          = omap4_keypad_probe,
+        .remove         = __devexit_p(omap4_keypad_remove),
+        .driver         = {
+                .name   = "omap4-keypad",
+                .owner  = THIS_MODULE,
+        },
+};
+
+static int __init omap4_keypad_init(void)
+{
+        return platform_driver_register(&omap4_keypad_driver);
+}
+module_init(omap4_keypad_init);
+
+static void __exit omap4_keypad_exit(void)
+{
+        platform_driver_unregister(&omap4_keypad_driver);
+}
+module_exit(omap4_keypad_exit);
+
+MODULE_AUTHOR("Texas Instruments");
+MODULE_DESCRIPTION("OMAP4 Keypad Driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:omap4-keypad");
diff --git a/drivers/input/keyboard/pmic8xxx-keypad.c b/drivers/input/keyboard/pmic8xxx-keypad.c
new file mode 100644
index 000000000000..6229c3e8e78b
--- /dev/null
+++ b/drivers/input/keyboard/pmic8xxx-keypad.c
@@ -0,0 +1,800 @@
+/* Copyright (c) 2009-2011, Code Aurora Forum. 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 and
+ * only 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.
+ */
+
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/kernel.h>
+#include <linux/interrupt.h>
+#include <linux/slab.h>
+#include <linux/input.h>
+#include <linux/bitops.h>
+#include <linux/delay.h>
+#include <linux/mutex.h>
+
+#include <linux/mfd/pm8xxx/core.h>
+#include <linux/mfd/pm8xxx/gpio.h>
+#include <linux/input/pmic8xxx-keypad.h>
+
+#define PM8XXX_MAX_ROWS         18
+#define PM8XXX_MAX_COLS         8
+#define PM8XXX_ROW_SHIFT        3
+#define PM8XXX_MATRIX_MAX_SIZE  (PM8XXX_MAX_ROWS * PM8XXX_MAX_COLS)
+
+#define PM8XXX_MIN_ROWS         5
+#define PM8XXX_MIN_COLS         5
+
+#define MAX_SCAN_DELAY          128
+#define MIN_SCAN_DELAY          1
+
+/* in nanoseconds */
+#define MAX_ROW_HOLD_DELAY      122000
+#define MIN_ROW_HOLD_DELAY      30500
+
+#define MAX_DEBOUNCE_TIME       20
+#define MIN_DEBOUNCE_TIME       5
+
+#define KEYP_CTRL                       0x148
+
+#define KEYP_CTRL_EVNTS                 BIT(0)
+#define KEYP_CTRL_EVNTS_MASK            0x3
+
+#define KEYP_CTRL_SCAN_COLS_SHIFT       5
+#define KEYP_CTRL_SCAN_COLS_MIN         5
+#define KEYP_CTRL_SCAN_COLS_BITS        0x3
+
+#define KEYP_CTRL_SCAN_ROWS_SHIFT       2
+#define KEYP_CTRL_SCAN_ROWS_MIN         5
+#define KEYP_CTRL_SCAN_ROWS_BITS        0x7
+
+#define KEYP_CTRL_KEYP_EN               BIT(7)
+
+#define KEYP_SCAN                       0x149
+
+#define KEYP_SCAN_READ_STATE            BIT(0)
+#define KEYP_SCAN_DBOUNCE_SHIFT         1
+#define KEYP_SCAN_PAUSE_SHIFT           3
+#define KEYP_SCAN_ROW_HOLD_SHIFT        6
+
+#define KEYP_TEST                       0x14A
+
+#define KEYP_TEST_CLEAR_RECENT_SCAN     BIT(6)
+#define KEYP_TEST_CLEAR_OLD_SCAN        BIT(5)
+#define KEYP_TEST_READ_RESET            BIT(4)
+#define KEYP_TEST_DTEST_EN              BIT(3)
+#define KEYP_TEST_ABORT_READ            BIT(0)
+
+#define KEYP_TEST_DBG_SELECT_SHIFT      1
+
+/* bits of these registers represent
+ * '0' for key press
+ * '1' for key release
+ */
+#define KEYP_RECENT_DATA                0x14B
+#define KEYP_OLD_DATA                   0x14C
+
+#define KEYP_CLOCK_FREQ                 32768
+
+/**
+ * struct pmic8xxx_kp - internal keypad data structure
+ * @pdata - keypad platform data pointer
+ * @input - input device pointer for keypad
+ * @key_sense_irq - key press/release irq number
+ * @key_stuck_irq - key stuck notification irq number
+ * @keycodes - array to hold the key codes
+ * @dev - parent device pointer
+ * @keystate - present key press/release state
+ * @stuckstate - present state when key stuck irq
+ * @ctrl_reg - control register value
+ */
+struct pmic8xxx_kp {
+        const struct pm8xxx_keypad_platform_data *pdata;
+        struct input_dev *input;
+        int key_sense_irq;
+        int key_stuck_irq;
+
+        unsigned short keycodes[PM8XXX_MATRIX_MAX_SIZE];
+
+        struct device *dev;
+        u16 keystate[PM8XXX_MAX_ROWS];
+        u16 stuckstate[PM8XXX_MAX_ROWS];
+
+        u8 ctrl_reg;
+};
+
+static int pmic8xxx_kp_write_u8(struct pmic8xxx_kp *kp,
+                                 u8 data, u16 reg)
+{
+        int rc;
+
+        rc = pm8xxx_writeb(kp->dev->parent, reg, data);
+        return rc;
+}
+
+static int pmic8xxx_kp_read(struct pmic8xxx_kp *kp,
+                                 u8 *data, u16 reg, unsigned num_bytes)
+{
+        int rc;
+
+        rc = pm8xxx_read_buf(kp->dev->parent, reg, data, num_bytes);
+        return rc;
+}
+
+static int pmic8xxx_kp_read_u8(struct pmic8xxx_kp *kp,
+                                 u8 *data, u16 reg)
+{
+        int rc;
+
+        rc = pmic8xxx_kp_read(kp, data, reg, 1);
+        return rc;
+}
+
+static u8 pmic8xxx_col_state(struct pmic8xxx_kp *kp, u8 col)
+{
+        /* all keys pressed on that particular row? */
+        if (col == 0x00)
+                return 1 << kp->pdata->num_cols;
+        else
+                return col & ((1 << kp->pdata->num_cols) - 1);
+}
+
+/*
+ * Synchronous read protocol for RevB0 onwards:
+ *
+ * 1. Write '1' to ReadState bit in KEYP_SCAN register
+ * 2. Wait 2*32KHz clocks, so that HW can successfully enter read mode
+ *    synchronously
+ * 3. Read rows in old array first if events are more than one
+ * 4. Read rows in recent array
+ * 5. Wait 4*32KHz clocks
+ * 6. Write '0' to ReadState bit of KEYP_SCAN register so that hw can
+ *    synchronously exit read mode.
+ */
+static int pmic8xxx_chk_sync_read(struct pmic8xxx_kp *kp)
+{
+        int rc;
+        u8 scan_val;
+
+        rc = pmic8xxx_kp_read_u8(kp, &scan_val, KEYP_SCAN);
+        if (rc < 0) {
+                dev_err(kp->dev, "Error reading KEYP_SCAN reg, rc=%d\n", rc);
+                return rc;
+        }
+
+        scan_val |= 0x1;
+
+        rc = pmic8xxx_kp_write_u8(kp, scan_val, KEYP_SCAN);
+        if (rc < 0) {
+                dev_err(kp->dev, "Error writing KEYP_SCAN reg, rc=%d\n", rc);
+                return rc;
+        }
+
+        /* 2 * 32KHz clocks */
+        udelay((2 * DIV_ROUND_UP(USEC_PER_SEC, KEYP_CLOCK_FREQ)) + 1);
+
+        return rc;
+}
+
+static int pmic8xxx_kp_read_data(struct pmic8xxx_kp *kp, u16 *state,
+                                        u16 data_reg, int read_rows)
+{
+        int rc, row;
+        u8 new_data[PM8XXX_MAX_ROWS];
+
+        rc = pmic8xxx_kp_read(kp, new_data, data_reg, read_rows);
+        if (rc)
+                return rc;
+
+        for (row = 0; row < kp->pdata->num_rows; row++) {
+                dev_dbg(kp->dev, "new_data[%d] = %d\n", row,
+                                        new_data[row]);
+                state[row] = pmic8xxx_col_state(kp, new_data[row]);
+        }
+
+        return rc;
+}
+
+static int pmic8xxx_kp_read_matrix(struct pmic8xxx_kp *kp, u16 *new_state,
+                                         u16 *old_state)
+{
+        int rc, read_rows;
+        u8 scan_val;
+
+        if (kp->pdata->num_rows < PM8XXX_MIN_ROWS)
+                read_rows = PM8XXX_MIN_ROWS;
+        else
+                read_rows = kp->pdata->num_rows;
+
+        pmic8xxx_chk_sync_read(kp);
+
+        if (old_state) {
+                rc = pmic8xxx_kp_read_data(kp, old_state, KEYP_OLD_DATA,
+                                                read_rows);
+                if (rc < 0) {
+                        dev_err(kp->dev,
+                                "Error reading KEYP_OLD_DATA, rc=%d\n", rc);
+                        return rc;
+                }
+        }
+
+        rc = pmic8xxx_kp_read_data(kp, new_state, KEYP_RECENT_DATA,
+                                         read_rows);
+        if (rc < 0) {
+                dev_err(kp->dev,
+                        "Error reading KEYP_RECENT_DATA, rc=%d\n", rc);
+                return rc;
+        }
+
+        /* 4 * 32KHz clocks */
+        udelay((4 * DIV_ROUND_UP(USEC_PER_SEC, KEYP_CLOCK_FREQ)) + 1);
+
+        rc = pmic8xxx_kp_read_u8(kp, &scan_val, KEYP_SCAN);
+        if (rc < 0) {
+                dev_err(kp->dev, "Error reading KEYP_SCAN reg, rc=%d\n", rc);
+                return rc;
+        }
+
+        scan_val &= 0xFE;
+        rc = pmic8xxx_kp_write_u8(kp, scan_val, KEYP_SCAN);
+        if (rc < 0)
+                dev_err(kp->dev, "Error writing KEYP_SCAN reg, rc=%d\n", rc);
+
+        return rc;
+}
+
+static void __pmic8xxx_kp_scan_matrix(struct pmic8xxx_kp *kp, u16 *new_state,
+                                         u16 *old_state)
+{
+        int row, col, code;
+
+        for (row = 0; row < kp->pdata->num_rows; row++) {
+                int bits_changed = new_state[row] ^ old_state[row];
+
+                if (!bits_changed)
+                        continue;
+
+                for (col = 0; col < kp->pdata->num_cols; col++) {
+                        if (!(bits_changed & (1 << col)))
+                                continue;
+
+                        dev_dbg(kp->dev, "key [%d:%d] %s\n", row, col,
+                                        !(new_state[row] & (1 << col)) ?
+                                        "pressed" : "released");
+
+                        code = MATRIX_SCAN_CODE(row, col, PM8XXX_ROW_SHIFT);
+
+                        input_event(kp->input, EV_MSC, MSC_SCAN, code);
+                        input_report_key(kp->input,
+                                        kp->keycodes[code],
+                                        !(new_state[row] & (1 << col)));
+
+                        input_sync(kp->input);
+                }
+        }
+}
+
+static bool pmic8xxx_detect_ghost_keys(struct pmic8xxx_kp *kp, u16 *new_state)
+{
+        int row, found_first = -1;
+        u16 check, row_state;
+
+        check = 0;
+        for (row = 0; row < kp->pdata->num_rows; row++) {
+                row_state = (~new_state[row]) &
+                                 ((1 << kp->pdata->num_cols) - 1);
+
+                if (hweight16(row_state) > 1) {
+                        if (found_first == -1)
+                                found_first = row;
+                        if (check & row_state) {
+                                dev_dbg(kp->dev, "detected ghost key on row[%d]"
+                                         " and row[%d]\n", found_first, row);
+                                return true;
+                        }
+                }
+                check |= row_state;
+        }
+        return false;
+}
+
+static int pmic8xxx_kp_scan_matrix(struct pmic8xxx_kp *kp, unsigned int events)
+{
+        u16 new_state[PM8XXX_MAX_ROWS];
+        u16 old_state[PM8XXX_MAX_ROWS];
+        int rc;
+
+        switch (events) {
+        case 0x1:
+                rc = pmic8xxx_kp_read_matrix(kp, new_state, NULL);
+                if (rc < 0)
+                        return rc;
+
+                /* detecting ghost key is not an error */
+                if (pmic8xxx_detect_ghost_keys(kp, new_state))
+                        return 0;
+                __pmic8xxx_kp_scan_matrix(kp, new_state, kp->keystate);
+                memcpy(kp->keystate, new_state, sizeof(new_state));
+        break;
+        case 0x3: /* two events - eventcounter is gray-coded */
+                rc = pmic8xxx_kp_read_matrix(kp, new_state, old_state);
+                if (rc < 0)
+                        return rc;
+
+                __pmic8xxx_kp_scan_matrix(kp, old_state, kp->keystate);
+                __pmic8xxx_kp_scan_matrix(kp, new_state, old_state);
+                memcpy(kp->keystate, new_state, sizeof(new_state));
+        break;
+        case 0x2:
+                dev_dbg(kp->dev, "Some key events were lost\n");
+                rc = pmic8xxx_kp_read_matrix(kp, new_state, old_state);
+                if (rc < 0)
+                        return rc;
+                __pmic8xxx_kp_scan_matrix(kp, old_state, kp->keystate);
+                __pmic8xxx_kp_scan_matrix(kp, new_state, old_state);
+                memcpy(kp->keystate, new_state, sizeof(new_state));
+        break;
+        default:
+                rc = -EINVAL;
+        }
+        return rc;
+}
+
+/*
+ * NOTE: We are reading recent and old data registers blindly
+ * whenever key-stuck interrupt happens, because events counter doesn't
+ * get updated when this interrupt happens due to key stuck doesn't get
+ * considered as key state change.
+ *
+ * We are not using old data register contents after they are being read
+ * because it might report the key which was pressed before the key being stuck
+ * as stuck key because it's pressed status is stored in the old data
+ * register.
+ */
+static irqreturn_t pmic8xxx_kp_stuck_irq(int irq, void *data)
+{
+        u16 new_state[PM8XXX_MAX_ROWS];
+        u16 old_state[PM8XXX_MAX_ROWS];
+        int rc;
+        struct pmic8xxx_kp *kp = data;
+
+        rc = pmic8xxx_kp_read_matrix(kp, new_state, old_state);
+        if (rc < 0) {
+                dev_err(kp->dev, "failed to read keypad matrix\n");
+                return IRQ_HANDLED;
+        }
+
+        __pmic8xxx_kp_scan_matrix(kp, new_state, kp->stuckstate);
+
+        return IRQ_HANDLED;
+}
+
+static irqreturn_t pmic8xxx_kp_irq(int irq, void *data)
+{
+        struct pmic8xxx_kp *kp = data;
+        u8 ctrl_val, events;
+        int rc;
+
+        rc = pmic8xxx_kp_read(kp, &ctrl_val, KEYP_CTRL, 1);
+        if (rc < 0) {
+                dev_err(kp->dev, "failed to read keyp_ctrl register\n");
+                return IRQ_HANDLED;
+        }
+
+        events = ctrl_val & KEYP_CTRL_EVNTS_MASK;
+
+        rc = pmic8xxx_kp_scan_matrix(kp, events);
+        if (rc < 0)
+                dev_err(kp->dev, "failed to scan matrix\n");
+
+        return IRQ_HANDLED;
+}
+
+static int __devinit pmic8xxx_kpd_init(struct pmic8xxx_kp *kp)
+{
+        int bits, rc, cycles;
+        u8 scan_val = 0, ctrl_val = 0;
+        static const u8 row_bits[] = {
+                0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 6, 7, 7, 7,
+        };
+
+        /* Find column bits */
+        if (kp->pdata->num_cols < KEYP_CTRL_SCAN_COLS_MIN)
+                bits = 0;
+        else
+                bits = kp->pdata->num_cols - KEYP_CTRL_SCAN_COLS_MIN;
+        ctrl_val = (bits & KEYP_CTRL_SCAN_COLS_BITS) <<
+                KEYP_CTRL_SCAN_COLS_SHIFT;
+
+        /* Find row bits */
+        if (kp->pdata->num_rows < KEYP_CTRL_SCAN_ROWS_MIN)
+                bits = 0;
+        else
+                bits = row_bits[kp->pdata->num_rows - KEYP_CTRL_SCAN_ROWS_MIN];
+
+        ctrl_val |= (bits << KEYP_CTRL_SCAN_ROWS_SHIFT);
+
+        rc = pmic8xxx_kp_write_u8(kp, ctrl_val, KEYP_CTRL);
+        if (rc < 0) {
+                dev_err(kp->dev, "Error writing KEYP_CTRL reg, rc=%d\n", rc);
+                return rc;
+        }
+
+        bits = (kp->pdata->debounce_ms / 5) - 1;
+
+        scan_val |= (bits << KEYP_SCAN_DBOUNCE_SHIFT);
+
+        bits = fls(kp->pdata->scan_delay_ms) - 1;
+        scan_val |= (bits << KEYP_SCAN_PAUSE_SHIFT);
+
+        /* Row hold time is a multiple of 32KHz cycles. */
+        cycles = (kp->pdata->row_hold_ns * KEYP_CLOCK_FREQ) / NSEC_PER_SEC;
+
+        scan_val |= (cycles << KEYP_SCAN_ROW_HOLD_SHIFT);
+
+        rc = pmic8xxx_kp_write_u8(kp, scan_val, KEYP_SCAN);
+        if (rc)
+                dev_err(kp->dev, "Error writing KEYP_SCAN reg, rc=%d\n", rc);
+
+        return rc;
+
+}
+
+static int  __devinit pmic8xxx_kp_config_gpio(int gpio_start, int num_gpios,
+                        struct pmic8xxx_kp *kp, struct pm_gpio *gpio_config)
+{
+        int     rc, i;
+
+        if (gpio_start < 0 || num_gpios < 0)
+                return -EINVAL;
+
+        for (i = 0; i < num_gpios; i++) {
+                rc = pm8xxx_gpio_config(gpio_start + i, gpio_config);
+                if (rc) {
+                        dev_err(kp->dev, "%s: FAIL pm8xxx_gpio_config():"
+                                        "for PM GPIO [%d] rc=%d.\n",
+                                        __func__, gpio_start + i, rc);
+                        return rc;
+                }
+         }
+
+        return 0;
+}
+
+static int pmic8xxx_kp_enable(struct pmic8xxx_kp *kp)
+{
+        int rc;
+
+        kp->ctrl_reg |= KEYP_CTRL_KEYP_EN;
+
+        rc = pmic8xxx_kp_write_u8(kp, kp->ctrl_reg, KEYP_CTRL);
+        if (rc < 0)
+                dev_err(kp->dev, "Error writing KEYP_CTRL reg, rc=%d\n", rc);
+
+        return rc;
+}
+
+static int pmic8xxx_kp_disable(struct pmic8xxx_kp *kp)
+{
+        int rc;
+
+        kp->ctrl_reg &= ~KEYP_CTRL_KEYP_EN;
+
+        rc = pmic8xxx_kp_write_u8(kp, kp->ctrl_reg, KEYP_CTRL);
+        if (rc < 0)
+                return rc;
+
+        return rc;
+}
+
+static int pmic8xxx_kp_open(struct input_dev *dev)
+{
+        struct pmic8xxx_kp *kp = input_get_drvdata(dev);
+
+        return pmic8xxx_kp_enable(kp);
+}
+
+static void pmic8xxx_kp_close(struct input_dev *dev)
+{
+        struct pmic8xxx_kp *kp = input_get_drvdata(dev);
+
+        pmic8xxx_kp_disable(kp);
+}
+
+/*
+ * keypad controller should be initialized in the following sequence
+ * only, otherwise it might get into FSM stuck state.
+ *
+ * - Initialize keypad control parameters, like no. of rows, columns,
+ *   timing values etc.,
+ * - configure rows and column gpios pull up/down.
+ * - set irq edge type.
+ * - enable the keypad controller.
+ */
+static int __devinit pmic8xxx_kp_probe(struct platform_device *pdev)
+{
+        const struct pm8xxx_keypad_platform_data *pdata =
+                                        dev_get_platdata(&pdev->dev);
+        const struct matrix_keymap_data *keymap_data;
+        struct pmic8xxx_kp *kp;
+        int rc;
+        u8 ctrl_val;
+
+        struct pm_gpio kypd_drv = {
+                .direction      = PM_GPIO_DIR_OUT,
+                .output_buffer  = PM_GPIO_OUT_BUF_OPEN_DRAIN,
+                .output_value   = 0,
+                .pull           = PM_GPIO_PULL_NO,
+                .vin_sel        = PM_GPIO_VIN_S3,
+                .out_strength   = PM_GPIO_STRENGTH_LOW,
+                .function       = PM_GPIO_FUNC_1,
+                .inv_int_pol    = 1,
+        };
+
+        struct pm_gpio kypd_sns = {
+                .direction      = PM_GPIO_DIR_IN,
+                .pull           = PM_GPIO_PULL_UP_31P5,
+                .vin_sel        = PM_GPIO_VIN_S3,
+                .out_strength   = PM_GPIO_STRENGTH_NO,
+                .function       = PM_GPIO_FUNC_NORMAL,
+                .inv_int_pol    = 1,
+        };
+
+
+        if (!pdata || !pdata->num_cols || !pdata->num_rows ||
+                pdata->num_cols > PM8XXX_MAX_COLS ||
+                pdata->num_rows > PM8XXX_MAX_ROWS ||
+                pdata->num_cols < PM8XXX_MIN_COLS) {
+                dev_err(&pdev->dev, "invalid platform data\n");
+                return -EINVAL;
+        }
+
+        if (!pdata->scan_delay_ms ||
+                pdata->scan_delay_ms > MAX_SCAN_DELAY ||
+                pdata->scan_delay_ms < MIN_SCAN_DELAY ||
+                !is_power_of_2(pdata->scan_delay_ms)) {
+                dev_err(&pdev->dev, "invalid keypad scan time supplied\n");
+                return -EINVAL;
+        }
+
+        if (!pdata->row_hold_ns ||
+                pdata->row_hold_ns > MAX_ROW_HOLD_DELAY ||
+                pdata->row_hold_ns < MIN_ROW_HOLD_DELAY ||
+                ((pdata->row_hold_ns % MIN_ROW_HOLD_DELAY) != 0)) {
+                dev_err(&pdev->dev, "invalid keypad row hold time supplied\n");
+                return -EINVAL;
+        }
+
+        if (!pdata->debounce_ms ||
+                ((pdata->debounce_ms % 5) != 0) ||
+                pdata->debounce_ms > MAX_DEBOUNCE_TIME ||
+                pdata->debounce_ms < MIN_DEBOUNCE_TIME) {
+                dev_err(&pdev->dev, "invalid debounce time supplied\n");
+                return -EINVAL;
+        }
+
+        keymap_data = pdata->keymap_data;
+        if (!keymap_data) {
+                dev_err(&pdev->dev, "no keymap data supplied\n");
+                return -EINVAL;
+        }
+
+        kp = kzalloc(sizeof(*kp), GFP_KERNEL);
+        if (!kp)
+                return -ENOMEM;
+
+        platform_set_drvdata(pdev, kp);
+
+        kp->pdata       = pdata;
+        kp->dev         = &pdev->dev;
+
+        kp->input = input_allocate_device();
+        if (!kp->input) {
+                dev_err(&pdev->dev, "unable to allocate input device\n");
+                rc = -ENOMEM;
+                goto err_alloc_device;
+        }
+
+        kp->key_sense_irq = platform_get_irq(pdev, 0);
+        if (kp->key_sense_irq < 0) {
+                dev_err(&pdev->dev, "unable to get keypad sense irq\n");
+                rc = -ENXIO;
+                goto err_get_irq;
+        }
+
+        kp->key_stuck_irq = platform_get_irq(pdev, 1);
+        if (kp->key_stuck_irq < 0) {
+                dev_err(&pdev->dev, "unable to get keypad stuck irq\n");
+                rc = -ENXIO;
+                goto err_get_irq;
+        }
+
+        kp->input->name = pdata->input_name ? : "PMIC8XXX keypad";
+        kp->input->phys = pdata->input_phys_device ? : "pmic8xxx_keypad/input0";
+
+        kp->input->dev.parent   = &pdev->dev;
+
+        kp->input->id.bustype   = BUS_I2C;
+        kp->input->id.version   = 0x0001;
+        kp->input->id.product   = 0x0001;
+        kp->input->id.vendor    = 0x0001;
+
+        kp->input->evbit[0]     = BIT_MASK(EV_KEY);
+
+        if (pdata->rep)
+                __set_bit(EV_REP, kp->input->evbit);
+
+        kp->input->keycode      = kp->keycodes;
+        kp->input->keycodemax   = PM8XXX_MATRIX_MAX_SIZE;
+        kp->input->keycodesize  = sizeof(kp->keycodes);
+        kp->input->open         = pmic8xxx_kp_open;
+        kp->input->close        = pmic8xxx_kp_close;
+
+        matrix_keypad_build_keymap(keymap_data, PM8XXX_ROW_SHIFT,
+                                        kp->input->keycode, kp->input->keybit);
+
+        input_set_capability(kp->input, EV_MSC, MSC_SCAN);
+        input_set_drvdata(kp->input, kp);
+
+        /* initialize keypad state */
+        memset(kp->keystate, 0xff, sizeof(kp->keystate));
+        memset(kp->stuckstate, 0xff, sizeof(kp->stuckstate));
+
+        rc = pmic8xxx_kpd_init(kp);
+        if (rc < 0) {
+                dev_err(&pdev->dev, "unable to initialize keypad controller\n");
+                goto err_get_irq;
+        }
+
+        rc = pmic8xxx_kp_config_gpio(pdata->cols_gpio_start,
+                                        pdata->num_cols, kp, &kypd_sns);
+        if (rc < 0) {
+                dev_err(&pdev->dev, "unable to configure keypad sense lines\n");
+                goto err_gpio_config;
+        }
+
+        rc = pmic8xxx_kp_config_gpio(pdata->rows_gpio_start,
+                                        pdata->num_rows, kp, &kypd_drv);
+        if (rc < 0) {
+                dev_err(&pdev->dev, "unable to configure keypad drive lines\n");
+                goto err_gpio_config;
+        }
+
+        rc = request_any_context_irq(kp->key_sense_irq, pmic8xxx_kp_irq,
+                                 IRQF_TRIGGER_RISING, "pmic-keypad", kp);
+        if (rc < 0) {
+                dev_err(&pdev->dev, "failed to request keypad sense irq\n");
+                goto err_get_irq;
+        }
+
+        rc = request_any_context_irq(kp->key_stuck_irq, pmic8xxx_kp_stuck_irq,
+                                 IRQF_TRIGGER_RISING, "pmic-keypad-stuck", kp);
+        if (rc < 0) {
+                dev_err(&pdev->dev, "failed to request keypad stuck irq\n");
+                goto err_req_stuck_irq;
+        }
+
+        rc = pmic8xxx_kp_read_u8(kp, &ctrl_val, KEYP_CTRL);
+        if (rc < 0) {
+                dev_err(&pdev->dev, "failed to read KEYP_CTRL register\n");
+                goto err_pmic_reg_read;
+        }
+
+        kp->ctrl_reg = ctrl_val;
+
+        rc = input_register_device(kp->input);
+        if (rc < 0) {
+                dev_err(&pdev->dev, "unable to register keypad input device\n");
+                goto err_pmic_reg_read;
+        }
+
+        device_init_wakeup(&pdev->dev, pdata->wakeup);
+
+        return 0;
+
+err_pmic_reg_read:
+        free_irq(kp->key_stuck_irq, NULL);
+err_req_stuck_irq:
+        free_irq(kp->key_sense_irq, NULL);
+err_gpio_config:
+err_get_irq:
+        input_free_device(kp->input);
+err_alloc_device:
+        platform_set_drvdata(pdev, NULL);
+        kfree(kp);
+        return rc;
+}
+
+static int __devexit pmic8xxx_kp_remove(struct platform_device *pdev)
+{
+        struct pmic8xxx_kp *kp = platform_get_drvdata(pdev);
+
+        device_init_wakeup(&pdev->dev, 0);
+        free_irq(kp->key_stuck_irq, NULL);
+        free_irq(kp->key_sense_irq, NULL);
+        input_unregister_device(kp->input);
+        kfree(kp);
+
+        platform_set_drvdata(pdev, NULL);
+        return 0;
+}
+
+#ifdef CONFIG_PM_SLEEP
+static int pmic8xxx_kp_suspend(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct pmic8xxx_kp *kp = platform_get_drvdata(pdev);
+        struct input_dev *input_dev = kp->input;
+
+        if (device_may_wakeup(dev)) {
+                enable_irq_wake(kp->key_sense_irq);
+        } else {
+                mutex_lock(&input_dev->mutex);
+
+                if (input_dev->users)
+                        pmic8xxx_kp_disable(kp);
+
+                mutex_unlock(&input_dev->mutex);
+        }
+
+        return 0;
+}
+
+static int pmic8xxx_kp_resume(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct pmic8xxx_kp *kp = platform_get_drvdata(pdev);
+        struct input_dev *input_dev = kp->input;
+
+        if (device_may_wakeup(dev)) {
+                disable_irq_wake(kp->key_sense_irq);
+        } else {
+                mutex_lock(&input_dev->mutex);
+
+                if (input_dev->users)
+                        pmic8xxx_kp_enable(kp);
+
+                mutex_unlock(&input_dev->mutex);
+        }
+
+        return 0;
+}
+#endif
+
+static SIMPLE_DEV_PM_OPS(pm8xxx_kp_pm_ops,
+                         pmic8xxx_kp_suspend, pmic8xxx_kp_resume);
+
+static struct platform_driver pmic8xxx_kp_driver = {
+        .probe          = pmic8xxx_kp_probe,
+        .remove         = __devexit_p(pmic8xxx_kp_remove),
+        .driver         = {
+                .name = PM8XXX_KEYPAD_DEV_NAME,
+                .owner = THIS_MODULE,
+                .pm = &pm8xxx_kp_pm_ops,
+        },
+};
+
+static int __init pmic8xxx_kp_init(void)
+{
+        return platform_driver_register(&pmic8xxx_kp_driver);
+}
+module_init(pmic8xxx_kp_init);
+
+static void __exit pmic8xxx_kp_exit(void)
+{
+        platform_driver_unregister(&pmic8xxx_kp_driver);
+}
+module_exit(pmic8xxx_kp_exit);
+
+MODULE_LICENSE("GPL v2");
+MODULE_DESCRIPTION("PMIC8XXX keypad driver");
+MODULE_VERSION("1.0");
+MODULE_ALIAS("platform:pmic8xxx_keypad");
+MODULE_AUTHOR("Trilok Soni <tsoni@codeaurora.org>");
diff --git a/drivers/input/keyboard/pxa27x_keypad.c b/drivers/input/keyboard/pxa27x_keypad.c
index f32404f99189..4b0ec35259a1 100644
--- a/drivers/input/keyboard/pxa27x_keypad.c
+++ b/drivers/input/keyboard/pxa27x_keypad.c
@@ -32,7 +32,7 @@
 #include <asm/mach/map.h>
 
 #include <mach/hardware.h>
-#include <mach/pxa27x_keypad.h>
+#include <plat/pxa27x_keypad.h>
 /*
  * Keypad Controller registers
  */
@@ -330,11 +330,21 @@ static void pxa27x_keypad_scan_direct(struct pxa27x_keypad *keypad)
         keypad->direct_key_state = new_state;
 }
 
+static void clear_wakeup_event(struct pxa27x_keypad *keypad)
+{
+        struct pxa27x_keypad_platform_data *pdata = keypad->pdata;
+
+        if (pdata->clear_wakeup_event)
+                (pdata->clear_wakeup_event)();
+}
+
 static irqreturn_t pxa27x_keypad_irq_handler(int irq, void *dev_id)
 {
         struct pxa27x_keypad *keypad = dev_id;
         unsigned long kpc = keypad_readl(KPC);
 
+        clear_wakeup_event(keypad);
+
         if (kpc & KPC_DI)
                 pxa27x_keypad_scan_direct(keypad);
 
diff --git a/drivers/input/keyboard/qt1070.c b/drivers/input/keyboard/qt1070.c
new file mode 100644
index 000000000000..ca7b89196ab7
--- /dev/null
+++ b/drivers/input/keyboard/qt1070.c
@@ -0,0 +1,277 @@
+/*
+ *  Atmel AT42QT1070 QTouch Sensor Controller
+ *
+ *  Copyright (C) 2011 Atmel
+ *
+ *  Authors: Bo Shen <voice.shen@atmel.com>
+ *
+ *  Base on AT42QT2160 driver by:
+ *  Raphael Derosso Pereira <raphaelpereira@gmail.com>
+ *  Copyright (C) 2009
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/i2c.h>
+#include <linux/input.h>
+#include <linux/slab.h>
+#include <linux/irq.h>
+#include <linux/interrupt.h>
+#include <linux/jiffies.h>
+#include <linux/delay.h>
+
+/* Address for each register */
+#define CHIP_ID            0x00
+#define QT1070_CHIP_ID     0x2E
+
+#define FW_VERSION         0x01
+#define QT1070_FW_VERSION  0x15
+
+#define DET_STATUS         0x02
+
+#define KEY_STATUS         0x03
+
+/* Calibrate */
+#define CALIBRATE_CMD      0x38
+#define QT1070_CAL_TIME    200
+
+/* Reset */
+#define RESET              0x39
+#define QT1070_RESET_TIME  255
+
+/* AT42QT1070 support up to 7 keys */
+static const unsigned short qt1070_key2code[] = {
+        KEY_0, KEY_1, KEY_2, KEY_3,
+        KEY_4, KEY_5, KEY_6,
+};
+
+struct qt1070_data {
+        struct i2c_client *client;
+        struct input_dev *input;
+        unsigned int irq;
+        unsigned short keycodes[ARRAY_SIZE(qt1070_key2code)];
+        u8 last_keys;
+};
+
+static int qt1070_read(struct i2c_client *client, u8 reg)
+{
+        int ret;
+
+        ret = i2c_smbus_read_byte_data(client, reg);
+        if (ret < 0)
+                dev_err(&client->dev,
+                        "can not read register, returned %d\n", ret);
+
+        return ret;
+}
+
+static int qt1070_write(struct i2c_client *client, u8 reg, u8 data)
+{
+        int ret;
+
+        ret = i2c_smbus_write_byte_data(client, reg, data);
+        if (ret < 0)
+                dev_err(&client->dev,
+                        "can not write register, returned %d\n", ret);
+
+        return ret;
+}
+
+static bool __devinit qt1070_identify(struct i2c_client *client)
+{
+        int id, ver;
+
+        /* Read Chip ID */
+        id = qt1070_read(client, CHIP_ID);
+        if (id != QT1070_CHIP_ID) {
+                dev_err(&client->dev, "ID %d not supported\n", id);
+                return false;
+        }
+
+        /* Read firmware version */
+        ver = qt1070_read(client, FW_VERSION);
+        if (ver < 0) {
+                dev_err(&client->dev, "could not read the firmware version\n");
+                return false;
+        }
+
+        dev_info(&client->dev, "AT42QT1070 firmware version %x\n", ver);
+
+        return true;
+}
+
+static irqreturn_t qt1070_interrupt(int irq, void *dev_id)
+{
+        struct qt1070_data *data = dev_id;
+        struct i2c_client *client = data->client;
+        struct input_dev *input = data->input;
+        int i;
+        u8 new_keys, keyval, mask = 0x01;
+
+        /* Read the detected status register, thus clearing interrupt */
+        qt1070_read(client, DET_STATUS);
+
+        /* Read which key changed */
+        new_keys = qt1070_read(client, KEY_STATUS);
+
+        for (i = 0; i < ARRAY_SIZE(qt1070_key2code); i++) {
+                keyval = new_keys & mask;
+                if ((data->last_keys & mask) != keyval)
+                        input_report_key(input, data->keycodes[i], keyval);
+                mask <<= 1;
+        }
+        input_sync(input);
+
+        data->last_keys = new_keys;
+        return IRQ_HANDLED;
+}
+
+static int __devinit qt1070_probe(struct i2c_client *client,
+                                const struct i2c_device_id *id)
+{
+        struct qt1070_data *data;
+        struct input_dev *input;
+        int i;
+        int err;
+
+        err = i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE);
+        if (!err) {
+                dev_err(&client->dev, "%s adapter not supported\n",
+                        dev_driver_string(&client->adapter->dev));
+                return -ENODEV;
+        }
+
+        if (!client->irq) {
+                dev_err(&client->dev, "please assign the irq to this device\n");
+                return -EINVAL;
+        }
+
+        /* Identify the qt1070 chip */
+        if (!qt1070_identify(client))
+                return -ENODEV;
+
+        data = kzalloc(sizeof(struct qt1070_data), GFP_KERNEL);
+        input = input_allocate_device();
+        if (!data || !input) {
+                dev_err(&client->dev, "insufficient memory\n");
+                err = -ENOMEM;
+                goto err_free_mem;
+        }
+
+        data->client = client;
+        data->input = input;
+        data->irq = client->irq;
+
+        input->name = "AT42QT1070 QTouch Sensor";
+        input->dev.parent = &client->dev;
+        input->id.bustype = BUS_I2C;
+
+        /* Add the keycode */
+        input->keycode = data->keycodes;
+        input->keycodesize = sizeof(data->keycodes[0]);
+        input->keycodemax = ARRAY_SIZE(qt1070_key2code);
+
+        __set_bit(EV_KEY, input->evbit);
+
+        for (i = 0; i < ARRAY_SIZE(qt1070_key2code); i++) {
+                data->keycodes[i] = qt1070_key2code[i];
+                __set_bit(qt1070_key2code[i], input->keybit);
+        }
+
+        /* Calibrate device */
+        qt1070_write(client, CALIBRATE_CMD, 1);
+        msleep(QT1070_CAL_TIME);
+
+        /* Soft reset */
+        qt1070_write(client, RESET, 1);
+        msleep(QT1070_RESET_TIME);
+
+        err = request_threaded_irq(client->irq, NULL, qt1070_interrupt,
+                IRQF_TRIGGER_NONE, client->dev.driver->name, data);
+        if (err) {
+                dev_err(&client->dev, "fail to request irq\n");
+                goto err_free_mem;
+        }
+
+        /* Register the input device */
+        err = input_register_device(data->input);
+        if (err) {
+                dev_err(&client->dev, "Failed to register input device\n");
+                goto err_free_irq;
+        }
+
+        i2c_set_clientdata(client, data);
+
+        /* Read to clear the chang line */
+        qt1070_read(client, DET_STATUS);
+
+        return 0;
+
+err_free_irq:
+        free_irq(client->irq, data);
+err_free_mem:
+        input_free_device(input);
+        kfree(data);
+        return err;
+}
+
+static int __devexit qt1070_remove(struct i2c_client *client)
+{
+        struct qt1070_data *data = i2c_get_clientdata(client);
+
+        /* Release IRQ */
+        free_irq(client->irq, data);
+
+        input_unregister_device(data->input);
+        kfree(data);
+
+        i2c_set_clientdata(client, NULL);
+
+        return 0;
+}
+
+static const struct i2c_device_id qt1070_id[] = {
+        { "qt1070", 0 },
+        { },
+};
+MODULE_DEVICE_TABLE(i2c, qt1070_id);
+
+static struct i2c_driver qt1070_driver = {
+        .driver = {
+                .name   = "qt1070",
+                .owner  = THIS_MODULE,
+        },
+        .id_table       = qt1070_id,
+        .probe          = qt1070_probe,
+        .remove         = __devexit_p(qt1070_remove),
+};
+
+static int __init qt1070_init(void)
+{
+        return i2c_add_driver(&qt1070_driver);
+}
+module_init(qt1070_init);
+
+static void __exit qt1070_exit(void)
+{
+        i2c_del_driver(&qt1070_driver);
+}
+module_exit(qt1070_exit);
+
+MODULE_AUTHOR("Bo Shen <voice.shen@atmel.com>");
+MODULE_DESCRIPTION("Driver for AT42QT1070 QTouch sensor");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/keyboard/sh_keysc.c b/drivers/input/keyboard/sh_keysc.c
index d7dafd9425b6..6876700a4469 100644
--- a/drivers/input/keyboard/sh_keysc.c
+++ b/drivers/input/keyboard/sh_keysc.c
@@ -20,7 +20,7 @@
 #include <linux/input.h>
 #include <linux/input/sh_keysc.h>
 #include <linux/bitmap.h>
-#include <linux/clk.h>
+#include <linux/pm_runtime.h>
 #include <linux/io.h>
 #include <linux/slab.h>
 
@@ -32,12 +32,11 @@ static const struct {
         [SH_KEYSC_MODE_3] = { 2, 4, 7 },
         [SH_KEYSC_MODE_4] = { 3, 6, 6 },
         [SH_KEYSC_MODE_5] = { 4, 6, 7 },
-        [SH_KEYSC_MODE_6] = { 5, 7, 7 },
+        [SH_KEYSC_MODE_6] = { 5, 8, 8 },
 };
 
 struct sh_keysc_priv {
         void __iomem *iomem_base;
-        struct clk *clk;
         DECLARE_BITMAP(last_keys, SH_KEYSC_MAXKEYS);
         struct input_dev *input;
         struct sh_keysc_info pdata;
@@ -169,7 +168,6 @@ static int __devinit sh_keysc_probe(struct platform_device *pdev)
         struct sh_keysc_info *pdata;
         struct resource *res;
         struct input_dev *input;
-        char clk_name[8];
         int i;
         int irq, error;
 
@@ -210,19 +208,11 @@ static int __devinit sh_keysc_probe(struct platform_device *pdev)
                 goto err1;
         }
 
-        snprintf(clk_name, sizeof(clk_name), "keysc%d", pdev->id);
-        priv->clk = clk_get(&pdev->dev, clk_name);
-        if (IS_ERR(priv->clk)) {
-                dev_err(&pdev->dev, "cannot get clock \"%s\"\n", clk_name);
-                error = PTR_ERR(priv->clk);
-                goto err2;
-        }
-
         priv->input = input_allocate_device();
         if (!priv->input) {
                 dev_err(&pdev->dev, "failed to allocate input device\n");
                 error = -ENOMEM;
-                goto err3;
+                goto err2;
         }
 
         input = priv->input;
@@ -241,10 +231,11 @@ static int __devinit sh_keysc_probe(struct platform_device *pdev)
         input->keycodesize = sizeof(pdata->keycodes[0]);
         input->keycodemax = ARRAY_SIZE(pdata->keycodes);
 
-        error = request_irq(irq, sh_keysc_isr, 0, pdev->name, pdev);
+        error = request_threaded_irq(irq, NULL, sh_keysc_isr, IRQF_ONESHOT,
+                                     dev_name(&pdev->dev), pdev);
         if (error) {
                 dev_err(&pdev->dev, "failed to request IRQ\n");
-                goto err4;
+                goto err3;
         }
 
         for (i = 0; i < SH_KEYSC_MAXKEYS; i++)
@@ -254,10 +245,11 @@ static int __devinit sh_keysc_probe(struct platform_device *pdev)
         error = input_register_device(input);
         if (error) {
                 dev_err(&pdev->dev, "failed to register input device\n");
-                goto err5;
+                goto err4;
         }
 
-        clk_enable(priv->clk);
+        pm_runtime_enable(&pdev->dev);
+        pm_runtime_get_sync(&pdev->dev);
 
         sh_keysc_write(priv, KYCR1, (sh_keysc_mode[pdata->mode].kymd << 8) |
                        pdata->scan_timing);
@@ -267,12 +259,10 @@ static int __devinit sh_keysc_probe(struct platform_device *pdev)
 
         return 0;
 
- err5:
-        free_irq(irq, pdev);
  err4:
-        input_free_device(input);
+        free_irq(irq, pdev);
  err3:
-        clk_put(priv->clk);
+        input_free_device(input);
  err2:
         iounmap(priv->iomem_base);
  err1:
@@ -292,8 +282,8 @@ static int __devexit sh_keysc_remove(struct platform_device *pdev)
         free_irq(platform_get_irq(pdev, 0), pdev);
         iounmap(priv->iomem_base);
 
-        clk_disable(priv->clk);
-        clk_put(priv->clk);
+        pm_runtime_put_sync(&pdev->dev);
+        pm_runtime_disable(&pdev->dev);
 
         platform_set_drvdata(pdev, NULL);
         kfree(priv);
@@ -301,6 +291,7 @@ static int __devexit sh_keysc_remove(struct platform_device *pdev)
         return 0;
 }
 
+#if CONFIG_PM_SLEEP
 static int sh_keysc_suspend(struct device *dev)
 {
         struct platform_device *pdev = to_platform_device(dev);
@@ -311,14 +302,13 @@ static int sh_keysc_suspend(struct device *dev)
         value = sh_keysc_read(priv, KYCR1);
 
         if (device_may_wakeup(dev)) {
-                value |= 0x80;
+                sh_keysc_write(priv, KYCR1, value | 0x80);
                 enable_irq_wake(irq);
         } else {
-                value &= ~0x80;
+                sh_keysc_write(priv, KYCR1, value & ~0x80);
+                pm_runtime_put_sync(dev);
         }
 
-        sh_keysc_write(priv, KYCR1, value);
-
         return 0;
 }
 
@@ -329,16 +319,17 @@ static int sh_keysc_resume(struct device *dev)
 
         if (device_may_wakeup(dev))
                 disable_irq_wake(irq);
+        else
+                pm_runtime_get_sync(dev);
 
         return 0;
 }
+#endif
 
-static const struct dev_pm_ops sh_keysc_dev_pm_ops = {
-        .suspend = sh_keysc_suspend,
-        .resume = sh_keysc_resume,
-};
+static SIMPLE_DEV_PM_OPS(sh_keysc_dev_pm_ops,
+                         sh_keysc_suspend, sh_keysc_resume);
 
-struct platform_driver sh_keysc_device_driver = {
+static struct platform_driver sh_keysc_device_driver = {
         .probe          = sh_keysc_probe,
         .remove         = __devexit_p(sh_keysc_remove),
         .driver         = {
diff --git a/drivers/input/keyboard/spear-keyboard.c b/drivers/input/keyboard/spear-keyboard.c
new file mode 100644
index 000000000000..d712dffd2157
--- /dev/null
+++ b/drivers/input/keyboard/spear-keyboard.c
@@ -0,0 +1,344 @@
+/*
+ * SPEAr Keyboard Driver
+ * Based on omap-keypad driver
+ *
+ * Copyright (C) 2010 ST Microelectronics
+ * Rajeev Kumar<rajeev-dlh.kumar@st.com>
+ *
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed "as is" without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include <linux/clk.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/input.h>
+#include <linux/io.h>
+#include <linux/irq.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/pm_wakeup.h>
+#include <linux/slab.h>
+#include <linux/types.h>
+#include <plat/keyboard.h>
+
+/* Keyboard Registers */
+#define MODE_REG        0x00    /* 16 bit reg */
+#define STATUS_REG      0x0C    /* 2 bit reg */
+#define DATA_REG        0x10    /* 8 bit reg */
+#define INTR_MASK       0x54
+
+/* Register Values */
+/*
+ * pclk freq mask = (APB FEQ -1)= 82 MHZ.Programme bit 15-9 in mode
+ * control register as 1010010(82MHZ)
+ */
+#define PCLK_FREQ_MSK   0xA400  /* 82 MHz */
+#define START_SCAN      0x0100
+#define SCAN_RATE_10    0x0000
+#define SCAN_RATE_20    0x0004
+#define SCAN_RATE_40    0x0008
+#define SCAN_RATE_80    0x000C
+#define MODE_KEYBOARD   0x0002
+#define DATA_AVAIL      0x2
+
+#define KEY_MASK        0xFF000000
+#define KEY_VALUE       0x00FFFFFF
+#define ROW_MASK        0xF0
+#define COLUMN_MASK     0x0F
+#define ROW_SHIFT       4
+
+struct spear_kbd {
+        struct input_dev *input;
+        struct resource *res;
+        void __iomem *io_base;
+        struct clk *clk;
+        unsigned int irq;
+        unsigned short last_key;
+        unsigned short keycodes[256];
+};
+
+static irqreturn_t spear_kbd_interrupt(int irq, void *dev_id)
+{
+        struct spear_kbd *kbd = dev_id;
+        struct input_dev *input = kbd->input;
+        unsigned int key;
+        u8 sts, val;
+
+        sts = readb(kbd->io_base + STATUS_REG);
+        if (!(sts & DATA_AVAIL))
+                return IRQ_NONE;
+
+        if (kbd->last_key != KEY_RESERVED) {
+                input_report_key(input, kbd->last_key, 0);
+                kbd->last_key = KEY_RESERVED;
+        }
+
+        /* following reads active (row, col) pair */
+        val = readb(kbd->io_base + DATA_REG);
+        key = kbd->keycodes[val];
+
+        input_event(input, EV_MSC, MSC_SCAN, val);
+        input_report_key(input, key, 1);
+        input_sync(input);
+
+        kbd->last_key = key;
+
+        /* clear interrupt */
+        writeb(0, kbd->io_base + STATUS_REG);
+
+        return IRQ_HANDLED;
+}
+
+static int spear_kbd_open(struct input_dev *dev)
+{
+        struct spear_kbd *kbd = input_get_drvdata(dev);
+        int error;
+        u16 val;
+
+        kbd->last_key = KEY_RESERVED;
+
+        error = clk_enable(kbd->clk);
+        if (error)
+                return error;
+
+        /* program keyboard */
+        val = SCAN_RATE_80 | MODE_KEYBOARD | PCLK_FREQ_MSK;
+        writew(val, kbd->io_base + MODE_REG);
+        writeb(1, kbd->io_base + STATUS_REG);
+
+        /* start key scan */
+        val = readw(kbd->io_base + MODE_REG);
+        val |= START_SCAN;
+        writew(val, kbd->io_base + MODE_REG);
+
+        return 0;
+}
+
+static void spear_kbd_close(struct input_dev *dev)
+{
+        struct spear_kbd *kbd = input_get_drvdata(dev);
+        u16 val;
+
+        /* stop key scan */
+        val = readw(kbd->io_base + MODE_REG);
+        val &= ~START_SCAN;
+        writew(val, kbd->io_base + MODE_REG);
+
+        clk_disable(kbd->clk);
+
+        kbd->last_key = KEY_RESERVED;
+}
+
+static int __devinit spear_kbd_probe(struct platform_device *pdev)
+{
+        const struct kbd_platform_data *pdata = pdev->dev.platform_data;
+        const struct matrix_keymap_data *keymap;
+        struct spear_kbd *kbd;
+        struct input_dev *input_dev;
+        struct resource *res;
+        int irq;
+        int error;
+
+        if (!pdata) {
+                dev_err(&pdev->dev, "Invalid platform data\n");
+                return -EINVAL;
+        }
+
+        keymap = pdata->keymap;
+        if (!keymap) {
+                dev_err(&pdev->dev, "no keymap defined\n");
+                return -EINVAL;
+        }
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(&pdev->dev, "no keyboard resource defined\n");
+                return -EBUSY;
+        }
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0) {
+                dev_err(&pdev->dev, "not able to get irq for the device\n");
+                return irq;
+        }
+
+        kbd = kzalloc(sizeof(*kbd), GFP_KERNEL);
+        input_dev = input_allocate_device();
+        if (!kbd || !input_dev) {
+                dev_err(&pdev->dev, "out of memory\n");
+                error = -ENOMEM;
+                goto err_free_mem;
+        }
+
+        kbd->input = input_dev;
+        kbd->irq = irq;
+        kbd->res = request_mem_region(res->start, resource_size(res),
+                                      pdev->name);
+        if (!kbd->res) {
+                dev_err(&pdev->dev, "keyboard region already claimed\n");
+                error = -EBUSY;
+                goto err_free_mem;
+        }
+
+        kbd->io_base = ioremap(res->start, resource_size(res));
+        if (!kbd->io_base) {
+                dev_err(&pdev->dev, "ioremap failed for kbd_region\n");
+                error = -ENOMEM;
+                goto err_release_mem_region;
+        }
+
+        kbd->clk = clk_get(&pdev->dev, NULL);
+        if (IS_ERR(kbd->clk)) {
+                error = PTR_ERR(kbd->clk);
+                goto err_iounmap;
+        }
+
+        input_dev->name = "Spear Keyboard";
+        input_dev->phys = "keyboard/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->open = spear_kbd_open;
+        input_dev->close = spear_kbd_close;
+
+        __set_bit(EV_KEY, input_dev->evbit);
+        if (pdata->rep)
+                __set_bit(EV_REP, input_dev->evbit);
+        input_set_capability(input_dev, EV_MSC, MSC_SCAN);
+
+        input_dev->keycode = kbd->keycodes;
+        input_dev->keycodesize = sizeof(kbd->keycodes[0]);
+        input_dev->keycodemax = ARRAY_SIZE(kbd->keycodes);
+
+        matrix_keypad_build_keymap(keymap, ROW_SHIFT,
+                        input_dev->keycode, input_dev->keybit);
+
+        input_set_drvdata(input_dev, kbd);
+
+        error = request_irq(irq, spear_kbd_interrupt, 0, "keyboard", kbd);
+        if (error) {
+                dev_err(&pdev->dev, "request_irq fail\n");
+                goto err_put_clk;
+        }
+
+        error = input_register_device(input_dev);
+        if (error) {
+                dev_err(&pdev->dev, "Unable to register keyboard device\n");
+                goto err_free_irq;
+        }
+
+        device_init_wakeup(&pdev->dev, 1);
+        platform_set_drvdata(pdev, kbd);
+
+        return 0;
+
+err_free_irq:
+        free_irq(kbd->irq, kbd);
+err_put_clk:
+        clk_put(kbd->clk);
+err_iounmap:
+        iounmap(kbd->io_base);
+err_release_mem_region:
+        release_mem_region(res->start, resource_size(res));
+err_free_mem:
+        input_free_device(input_dev);
+        kfree(kbd);
+
+        return error;
+}
+
+static int __devexit spear_kbd_remove(struct platform_device *pdev)
+{
+        struct spear_kbd *kbd = platform_get_drvdata(pdev);
+
+        free_irq(kbd->irq, kbd);
+        input_unregister_device(kbd->input);
+        clk_put(kbd->clk);
+        iounmap(kbd->io_base);
+        release_mem_region(kbd->res->start, resource_size(kbd->res));
+        kfree(kbd);
+
+        device_init_wakeup(&pdev->dev, 1);
+        platform_set_drvdata(pdev, NULL);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int spear_kbd_suspend(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct spear_kbd *kbd = platform_get_drvdata(pdev);
+        struct input_dev *input_dev = kbd->input;
+
+        mutex_lock(&input_dev->mutex);
+
+        if (input_dev->users)
+                clk_enable(kbd->clk);
+
+        if (device_may_wakeup(&pdev->dev))
+                enable_irq_wake(kbd->irq);
+
+        mutex_unlock(&input_dev->mutex);
+
+        return 0;
+}
+
+static int spear_kbd_resume(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct spear_kbd *kbd = platform_get_drvdata(pdev);
+        struct input_dev *input_dev = kbd->input;
+
+        mutex_lock(&input_dev->mutex);
+
+        if (device_may_wakeup(&pdev->dev))
+                disable_irq_wake(kbd->irq);
+
+        if (input_dev->users)
+                clk_enable(kbd->clk);
+
+        mutex_unlock(&input_dev->mutex);
+
+        return 0;
+}
+
+static const struct dev_pm_ops spear_kbd_pm_ops = {
+        .suspend        = spear_kbd_suspend,
+        .resume         = spear_kbd_resume,
+};
+#endif
+
+static struct platform_driver spear_kbd_driver = {
+        .probe          = spear_kbd_probe,
+        .remove         = __devexit_p(spear_kbd_remove),
+        .driver         = {
+                .name   = "keyboard",
+                .owner  = THIS_MODULE,
+#ifdef CONFIG_PM
+                .pm     = &spear_kbd_pm_ops,
+#endif
+        },
+};
+
+static int __init spear_kbd_init(void)
+{
+        return platform_driver_register(&spear_kbd_driver);
+}
+module_init(spear_kbd_init);
+
+static void __exit spear_kbd_exit(void)
+{
+        platform_driver_unregister(&spear_kbd_driver);
+}
+module_exit(spear_kbd_exit);
+
+MODULE_AUTHOR("Rajeev Kumar");
+MODULE_DESCRIPTION("SPEAr Keyboard Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/keyboard/tc3589x-keypad.c b/drivers/input/keyboard/tc3589x-keypad.c
new file mode 100644
index 000000000000..99122f59e988
--- /dev/null
+++ b/drivers/input/keyboard/tc3589x-keypad.c
@@ -0,0 +1,472 @@
+/*
+ * Copyright (C) ST-Ericsson SA 2010
+ *
+ * Author: Jayeeta Banerjee <jayeeta.banerjee@stericsson.com>
+ * Author: Sundar Iyer <sundar.iyer@stericsson.com>
+ *
+ * License Terms: GNU General Public License, version 2
+ *
+ * TC35893 MFD Keypad Controller driver
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/input.h>
+#include <linux/platform_device.h>
+#include <linux/input/matrix_keypad.h>
+#include <linux/i2c.h>
+#include <linux/slab.h>
+#include <linux/mfd/tc3589x.h>
+
+/* Maximum supported keypad matrix row/columns size */
+#define TC3589x_MAX_KPROW               8
+#define TC3589x_MAX_KPCOL               12
+
+/* keypad related Constants */
+#define TC3589x_MAX_DEBOUNCE_SETTLE     0xFF
+#define DEDICATED_KEY_VAL               0xFF
+
+/* Pull up/down masks */
+#define TC3589x_NO_PULL_MASK            0x0
+#define TC3589x_PULL_DOWN_MASK          0x1
+#define TC3589x_PULL_UP_MASK            0x2
+#define TC3589x_PULLUP_ALL_MASK         0xAA
+#define TC3589x_IO_PULL_VAL(index, mask)        ((mask)<<((index)%4)*2))
+
+/* Bit masks for IOCFG register */
+#define IOCFG_BALLCFG           0x01
+#define IOCFG_IG                0x08
+
+#define KP_EVCODE_COL_MASK      0x0F
+#define KP_EVCODE_ROW_MASK      0x70
+#define KP_RELEASE_EVT_MASK     0x80
+
+#define KP_ROW_SHIFT            4
+
+#define KP_NO_VALID_KEY_MASK    0x7F
+
+/* bit masks for RESTCTRL register */
+#define TC3589x_KBDRST          0x2
+#define TC3589x_IRQRST          0x10
+#define TC3589x_RESET_ALL       0x1B
+
+/* KBDMFS register bit mask */
+#define TC3589x_KBDMFS_EN       0x1
+
+/* CLKEN register bitmask */
+#define KPD_CLK_EN              0x1
+
+/* RSTINTCLR register bit mask */
+#define IRQ_CLEAR               0x1
+
+/* bit masks for keyboard interrupts*/
+#define TC3589x_EVT_LOSS_INT    0x8
+#define TC3589x_EVT_INT         0x4
+#define TC3589x_KBD_LOSS_INT    0x2
+#define TC3589x_KBD_INT         0x1
+
+/* bit masks for keyboard interrupt clear*/
+#define TC3589x_EVT_INT_CLR     0x2
+#define TC3589x_KBD_INT_CLR     0x1
+
+#define TC3589x_KBD_KEYMAP_SIZE     64
+
+/**
+ * struct tc_keypad - data structure used by keypad driver
+ * @input:      pointer to input device object
+ * @board:      keypad platform device
+ * @krow:       number of rows
+ * @kcol:       number of coloumns
+ * @keymap:     matrix scan code table for keycodes
+ */
+struct tc_keypad {
+        struct tc3589x *tc3589x;
+        struct input_dev *input;
+        const struct tc3589x_keypad_platform_data *board;
+        unsigned int krow;
+        unsigned int kcol;
+        unsigned short keymap[TC3589x_KBD_KEYMAP_SIZE];
+        bool keypad_stopped;
+};
+
+static int __devinit tc3589x_keypad_init_key_hardware(struct tc_keypad *keypad)
+{
+        int ret;
+        struct tc3589x *tc3589x = keypad->tc3589x;
+        u8 settle_time = keypad->board->settle_time;
+        u8 dbounce_period = keypad->board->debounce_period;
+        u8 rows = keypad->board->krow & 0xf;    /* mask out the nibble */
+        u8 column = keypad->board->kcol & 0xf;  /* mask out the nibble */
+
+        /* validate platform configurations */
+        if (keypad->board->kcol > TC3589x_MAX_KPCOL ||
+            keypad->board->krow > TC3589x_MAX_KPROW ||
+            keypad->board->debounce_period > TC3589x_MAX_DEBOUNCE_SETTLE ||
+            keypad->board->settle_time > TC3589x_MAX_DEBOUNCE_SETTLE)
+                return -EINVAL;
+
+        /* configure KBDSIZE 4 LSbits for cols and 4 MSbits for rows */
+        ret = tc3589x_reg_write(tc3589x, TC3589x_KBDSIZE,
+                        (rows << KP_ROW_SHIFT) | column);
+        if (ret < 0)
+                return ret;
+
+        /* configure dedicated key config, no dedicated key selected */
+        ret = tc3589x_reg_write(tc3589x, TC3589x_KBCFG_LSB, DEDICATED_KEY_VAL);
+        if (ret < 0)
+                return ret;
+
+        ret = tc3589x_reg_write(tc3589x, TC3589x_KBCFG_MSB, DEDICATED_KEY_VAL);
+        if (ret < 0)
+                return ret;
+
+        /* Configure settle time */
+        ret = tc3589x_reg_write(tc3589x, TC3589x_KBDSETTLE_REG, settle_time);
+        if (ret < 0)
+                return ret;
+
+        /* Configure debounce time */
+        ret = tc3589x_reg_write(tc3589x, TC3589x_KBDBOUNCE, dbounce_period);
+        if (ret < 0)
+                return ret;
+
+        /* Start of initialise keypad GPIOs */
+        ret = tc3589x_set_bits(tc3589x, TC3589x_IOCFG, 0x0, IOCFG_IG);
+        if (ret < 0)
+                return ret;
+
+        /* Configure pull-up resistors for all row GPIOs */
+        ret = tc3589x_reg_write(tc3589x, TC3589x_IOPULLCFG0_LSB,
+                                        TC3589x_PULLUP_ALL_MASK);
+        if (ret < 0)
+                return ret;
+
+        ret = tc3589x_reg_write(tc3589x, TC3589x_IOPULLCFG0_MSB,
+                                        TC3589x_PULLUP_ALL_MASK);
+        if (ret < 0)
+                return ret;
+
+        /* Configure pull-up resistors for all column GPIOs */
+        ret = tc3589x_reg_write(tc3589x, TC3589x_IOPULLCFG1_LSB,
+                        TC3589x_PULLUP_ALL_MASK);
+        if (ret < 0)
+                return ret;
+
+        ret = tc3589x_reg_write(tc3589x, TC3589x_IOPULLCFG1_MSB,
+                        TC3589x_PULLUP_ALL_MASK);
+        if (ret < 0)
+                return ret;
+
+        ret = tc3589x_reg_write(tc3589x, TC3589x_IOPULLCFG2_LSB,
+                        TC3589x_PULLUP_ALL_MASK);
+
+        return ret;
+}
+
+#define TC35893_DATA_REGS               4
+#define TC35893_KEYCODE_FIFO_EMPTY      0x7f
+#define TC35893_KEYCODE_FIFO_CLEAR      0xff
+#define TC35893_KEYPAD_ROW_SHIFT        0x3
+
+static irqreturn_t tc3589x_keypad_irq(int irq, void *dev)
+{
+        struct tc_keypad *keypad = dev;
+        struct tc3589x *tc3589x = keypad->tc3589x;
+        u8 i, row_index, col_index, kbd_code, up;
+        u8 code;
+
+        for (i = 0; i < TC35893_DATA_REGS * 2; i++) {
+                kbd_code = tc3589x_reg_read(tc3589x, TC3589x_EVTCODE_FIFO);
+
+                /* loop till fifo is empty and no more keys are pressed */
+                if (kbd_code == TC35893_KEYCODE_FIFO_EMPTY ||
+                                kbd_code == TC35893_KEYCODE_FIFO_CLEAR)
+                        continue;
+
+                /* valid key is found */
+                col_index = kbd_code & KP_EVCODE_COL_MASK;
+                row_index = (kbd_code & KP_EVCODE_ROW_MASK) >> KP_ROW_SHIFT;
+                code = MATRIX_SCAN_CODE(row_index, col_index,
+                                                TC35893_KEYPAD_ROW_SHIFT);
+                up = kbd_code & KP_RELEASE_EVT_MASK;
+
+                input_event(keypad->input, EV_MSC, MSC_SCAN, code);
+                input_report_key(keypad->input, keypad->keymap[code], !up);
+                input_sync(keypad->input);
+        }
+
+        /* clear IRQ */
+        tc3589x_set_bits(tc3589x, TC3589x_KBDIC,
+                        0x0, TC3589x_EVT_INT_CLR | TC3589x_KBD_INT_CLR);
+        /* enable IRQ */
+        tc3589x_set_bits(tc3589x, TC3589x_KBDMSK,
+                        0x0, TC3589x_EVT_LOSS_INT | TC3589x_EVT_INT);
+
+        return IRQ_HANDLED;
+}
+
+static int tc3589x_keypad_enable(struct tc_keypad *keypad)
+{
+        struct tc3589x *tc3589x = keypad->tc3589x;
+        int ret;
+
+        /* pull the keypad module out of reset */
+        ret = tc3589x_set_bits(tc3589x, TC3589x_RSTCTRL, TC3589x_KBDRST, 0x0);
+        if (ret < 0)
+                return ret;
+
+        /* configure KBDMFS */
+        ret = tc3589x_set_bits(tc3589x, TC3589x_KBDMFS, 0x0, TC3589x_KBDMFS_EN);
+        if (ret < 0)
+                return ret;
+
+        /* enable the keypad clock */
+        ret = tc3589x_set_bits(tc3589x, TC3589x_CLKEN, 0x0, KPD_CLK_EN);
+        if (ret < 0)
+                return ret;
+
+        /* clear pending IRQs */
+        ret =  tc3589x_set_bits(tc3589x, TC3589x_RSTINTCLR, 0x0, 0x1);
+        if (ret < 0)
+                return ret;
+
+        /* enable the IRQs */
+        ret = tc3589x_set_bits(tc3589x, TC3589x_KBDMSK, 0x0,
+                                        TC3589x_EVT_LOSS_INT | TC3589x_EVT_INT);
+        if (ret < 0)
+                return ret;
+
+        keypad->keypad_stopped = false;
+
+        return ret;
+}
+
+static int tc3589x_keypad_disable(struct tc_keypad *keypad)
+{
+        struct tc3589x *tc3589x = keypad->tc3589x;
+        int ret;
+
+        /* clear IRQ */
+        ret = tc3589x_set_bits(tc3589x, TC3589x_KBDIC,
+                        0x0, TC3589x_EVT_INT_CLR | TC3589x_KBD_INT_CLR);
+        if (ret < 0)
+                return ret;
+
+        /* disable all interrupts */
+        ret = tc3589x_set_bits(tc3589x, TC3589x_KBDMSK,
+                        ~(TC3589x_EVT_LOSS_INT | TC3589x_EVT_INT), 0x0);
+        if (ret < 0)
+                return ret;
+
+        /* disable the keypad module */
+        ret = tc3589x_set_bits(tc3589x, TC3589x_CLKEN, 0x1, 0x0);
+        if (ret < 0)
+                return ret;
+
+        /* put the keypad module into reset */
+        ret = tc3589x_set_bits(tc3589x, TC3589x_RSTCTRL, TC3589x_KBDRST, 0x1);
+
+        keypad->keypad_stopped = true;
+
+        return ret;
+}
+
+static int tc3589x_keypad_open(struct input_dev *input)
+{
+        int error;
+        struct tc_keypad *keypad = input_get_drvdata(input);
+
+        /* enable the keypad module */
+        error = tc3589x_keypad_enable(keypad);
+        if (error < 0) {
+                dev_err(&input->dev, "failed to enable keypad module\n");
+                return error;
+        }
+
+        error = tc3589x_keypad_init_key_hardware(keypad);
+        if (error < 0) {
+                dev_err(&input->dev, "failed to configure keypad module\n");
+                return error;
+        }
+
+        return 0;
+}
+
+static void tc3589x_keypad_close(struct input_dev *input)
+{
+        struct tc_keypad *keypad = input_get_drvdata(input);
+
+        /* disable the keypad module */
+        tc3589x_keypad_disable(keypad);
+}
+
+static int __devinit tc3589x_keypad_probe(struct platform_device *pdev)
+{
+        struct tc3589x *tc3589x = dev_get_drvdata(pdev->dev.parent);
+        struct tc_keypad *keypad;
+        struct input_dev *input;
+        const struct tc3589x_keypad_platform_data *plat;
+        int error, irq;
+
+        plat = tc3589x->pdata->keypad;
+        if (!plat) {
+                dev_err(&pdev->dev, "invalid keypad platform data\n");
+                return -EINVAL;
+        }
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0)
+                return irq;
+
+        keypad = kzalloc(sizeof(struct tc_keypad), GFP_KERNEL);
+        input = input_allocate_device();
+        if (!keypad || !input) {
+                dev_err(&pdev->dev, "failed to allocate keypad memory\n");
+                error = -ENOMEM;
+                goto err_free_mem;
+        }
+
+        keypad->board = plat;
+        keypad->input = input;
+        keypad->tc3589x = tc3589x;
+
+        input->id.bustype = BUS_I2C;
+        input->name = pdev->name;
+        input->dev.parent = &pdev->dev;
+
+        input->keycode = keypad->keymap;
+        input->keycodesize = sizeof(keypad->keymap[0]);
+        input->keycodemax = ARRAY_SIZE(keypad->keymap);
+
+        input->open = tc3589x_keypad_open;
+        input->close = tc3589x_keypad_close;
+
+        input_set_drvdata(input, keypad);
+
+        input_set_capability(input, EV_MSC, MSC_SCAN);
+
+        __set_bit(EV_KEY, input->evbit);
+        if (!plat->no_autorepeat)
+                __set_bit(EV_REP, input->evbit);
+
+        matrix_keypad_build_keymap(plat->keymap_data, 0x3,
+                        input->keycode, input->keybit);
+
+        error = request_threaded_irq(irq, NULL,
+                        tc3589x_keypad_irq, plat->irqtype,
+                        "tc3589x-keypad", keypad);
+        if (error < 0) {
+                dev_err(&pdev->dev,
+                                "Could not allocate irq %d,error %d\n",
+                                irq, error);
+                goto err_free_mem;
+        }
+
+        error = input_register_device(input);
+        if (error) {
+                dev_err(&pdev->dev, "Could not register input device\n");
+                goto err_free_irq;
+        }
+
+        /* let platform decide if keypad is a wakeup source or not */
+        device_init_wakeup(&pdev->dev, plat->enable_wakeup);
+        device_set_wakeup_capable(&pdev->dev, plat->enable_wakeup);
+
+        platform_set_drvdata(pdev, keypad);
+
+        return 0;
+
+err_free_irq:
+        free_irq(irq, keypad);
+err_free_mem:
+        input_free_device(input);
+        kfree(keypad);
+        return error;
+}
+
+static int __devexit tc3589x_keypad_remove(struct platform_device *pdev)
+{
+        struct tc_keypad *keypad = platform_get_drvdata(pdev);
+        int irq = platform_get_irq(pdev, 0);
+
+        if (!keypad->keypad_stopped)
+                tc3589x_keypad_disable(keypad);
+
+        free_irq(irq, keypad);
+
+        input_unregister_device(keypad->input);
+
+        kfree(keypad);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM_SLEEP
+static int tc3589x_keypad_suspend(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct tc_keypad *keypad = platform_get_drvdata(pdev);
+        int irq = platform_get_irq(pdev, 0);
+
+        /* keypad is already off; we do nothing */
+        if (keypad->keypad_stopped)
+                return 0;
+
+        /* if device is not a wakeup source, disable it for powersave */
+        if (!device_may_wakeup(&pdev->dev))
+                tc3589x_keypad_disable(keypad);
+        else
+                enable_irq_wake(irq);
+
+        return 0;
+}
+
+static int tc3589x_keypad_resume(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct tc_keypad *keypad = platform_get_drvdata(pdev);
+        int irq = platform_get_irq(pdev, 0);
+
+        if (!keypad->keypad_stopped)
+                return 0;
+
+        /* enable the device to resume normal operations */
+        if (!device_may_wakeup(&pdev->dev))
+                tc3589x_keypad_enable(keypad);
+        else
+                disable_irq_wake(irq);
+
+        return 0;
+}
+#endif
+
+static SIMPLE_DEV_PM_OPS(tc3589x_keypad_dev_pm_ops,
+                         tc3589x_keypad_suspend, tc3589x_keypad_resume);
+
+static struct platform_driver tc3589x_keypad_driver = {
+        .driver = {
+                .name   = "tc3589x-keypad",
+                .owner  = THIS_MODULE,
+                .pm     = &tc3589x_keypad_dev_pm_ops,
+        },
+        .probe  = tc3589x_keypad_probe,
+        .remove = __devexit_p(tc3589x_keypad_remove),
+};
+
+static int __init tc3589x_keypad_init(void)
+{
+        return platform_driver_register(&tc3589x_keypad_driver);
+}
+module_init(tc3589x_keypad_init);
+
+static void __exit tc3589x_keypad_exit(void)
+{
+        return platform_driver_unregister(&tc3589x_keypad_driver);
+}
+module_exit(tc3589x_keypad_exit);
+
+MODULE_LICENSE("GPL v2");
+MODULE_AUTHOR("Jayeeta Banerjee/Sundar Iyer");
+MODULE_DESCRIPTION("TC35893 Keypad Driver");
+MODULE_ALIAS("platform:tc3589x-keypad");
diff --git a/drivers/input/keyboard/tca6416-keypad.c b/drivers/input/keyboard/tca6416-keypad.c
index 00137bebcf97..3afea3f89718 100644
--- a/drivers/input/keyboard/tca6416-keypad.c
+++ b/drivers/input/keyboard/tca6416-keypad.c
@@ -29,6 +29,7 @@
 
 static const struct i2c_device_id tca6416_id[] = {
         { "tca6416-keys", 16, },
+        { "tca6408-keys", 8, },
         { }
 };
 MODULE_DEVICE_TABLE(i2c, tca6416_id);
@@ -46,8 +47,9 @@ struct tca6416_keypad_chip {
         struct i2c_client *client;
         struct input_dev *input;
         struct delayed_work dwork;
-        u16 pinmask;
+        int io_size;
         int irqnum;
+        u16 pinmask;
         bool use_polling;
         struct tca6416_button buttons[0];
 };
@@ -56,7 +58,9 @@ static int tca6416_write_reg(struct tca6416_keypad_chip *chip, int reg, u16 val)
 {
         int error;
 
-        error = i2c_smbus_write_word_data(chip->client, reg << 1, val);
+        error = chip->io_size > 8 ?
+                i2c_smbus_write_word_data(chip->client, reg << 1, val) :
+                i2c_smbus_write_byte_data(chip->client, reg, val);
         if (error < 0) {
                 dev_err(&chip->client->dev,
                         "%s failed, reg: %d, val: %d, error: %d\n",
@@ -71,7 +75,9 @@ static int tca6416_read_reg(struct tca6416_keypad_chip *chip, int reg, u16 *val)
 {
         int retval;
 
-        retval = i2c_smbus_read_word_data(chip->client, reg << 1);
+        retval = chip->io_size > 8 ?
+                 i2c_smbus_read_word_data(chip->client, reg << 1) :
+                 i2c_smbus_read_byte_data(chip->client, reg);
         if (retval < 0) {
                 dev_err(&chip->client->dev, "%s failed, reg: %d, error: %d\n",
                         __func__, reg, retval);
@@ -224,6 +230,7 @@ static int __devinit tca6416_keypad_probe(struct i2c_client *client,
 
         chip->client = client;
         chip->input = input;
+        chip->io_size = id->driver_data;
         chip->pinmask = pdata->pinmask;
         chip->use_polling = pdata->use_polling;
 
@@ -290,6 +297,7 @@ static int __devinit tca6416_keypad_probe(struct i2c_client *client,
         }
 
         i2c_set_clientdata(client, chip);
+        device_init_wakeup(&client->dev, 1);
 
         return 0;
 
@@ -319,10 +327,37 @@ static int __devexit tca6416_keypad_remove(struct i2c_client *client)
         return 0;
 }
 
+#ifdef CONFIG_PM_SLEEP
+static int tca6416_keypad_suspend(struct device *dev)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct tca6416_keypad_chip *chip = i2c_get_clientdata(client);
+
+        if (device_may_wakeup(dev))
+                enable_irq_wake(chip->irqnum);
+
+        return 0;
+}
+
+static int tca6416_keypad_resume(struct device *dev)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct tca6416_keypad_chip *chip = i2c_get_clientdata(client);
+
+        if (device_may_wakeup(dev))
+                disable_irq_wake(chip->irqnum);
+
+        return 0;
+}
+#endif
+
+static SIMPLE_DEV_PM_OPS(tca6416_keypad_dev_pm_ops,
+                         tca6416_keypad_suspend, tca6416_keypad_resume);
 
 static struct i2c_driver tca6416_keypad_driver = {
         .driver = {
                 .name   = "tca6416-keypad",
+                .pm     = &tca6416_keypad_dev_pm_ops,
         },
         .probe          = tca6416_keypad_probe,
         .remove         = __devexit_p(tca6416_keypad_remove),
diff --git a/drivers/input/keyboard/tegra-kbc.c b/drivers/input/keyboard/tegra-kbc.c
new file mode 100644
index 000000000000..2b3b73ec6689
--- /dev/null
+++ b/drivers/input/keyboard/tegra-kbc.c
@@ -0,0 +1,799 @@
+/*
+ * Keyboard class input driver for the NVIDIA Tegra SoC internal matrix
+ * keyboard controller
+ *
+ * Copyright (c) 2009-2011, NVIDIA Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+#include <linux/module.h>
+#include <linux/input.h>
+#include <linux/platform_device.h>
+#include <linux/delay.h>
+#include <linux/io.h>
+#include <linux/interrupt.h>
+#include <linux/clk.h>
+#include <linux/slab.h>
+#include <mach/clk.h>
+#include <mach/kbc.h>
+
+#define KBC_MAX_DEBOUNCE_CNT    0x3ffu
+
+/* KBC row scan time and delay for beginning the row scan. */
+#define KBC_ROW_SCAN_TIME       16
+#define KBC_ROW_SCAN_DLY        5
+
+/* KBC uses a 32KHz clock so a cycle = 1/32Khz */
+#define KBC_CYCLE_USEC  32
+
+/* KBC Registers */
+
+/* KBC Control Register */
+#define KBC_CONTROL_0   0x0
+#define KBC_FIFO_TH_CNT_SHIFT(cnt)      (cnt << 14)
+#define KBC_DEBOUNCE_CNT_SHIFT(cnt)     (cnt << 4)
+#define KBC_CONTROL_FIFO_CNT_INT_EN     (1 << 3)
+#define KBC_CONTROL_KBC_EN              (1 << 0)
+
+/* KBC Interrupt Register */
+#define KBC_INT_0       0x4
+#define KBC_INT_FIFO_CNT_INT_STATUS     (1 << 2)
+
+#define KBC_ROW_CFG0_0  0x8
+#define KBC_COL_CFG0_0  0x18
+#define KBC_INIT_DLY_0  0x28
+#define KBC_RPT_DLY_0   0x2c
+#define KBC_KP_ENT0_0   0x30
+#define KBC_KP_ENT1_0   0x34
+#define KBC_ROW0_MASK_0 0x38
+
+#define KBC_ROW_SHIFT   3
+
+struct tegra_kbc {
+        void __iomem *mmio;
+        struct input_dev *idev;
+        unsigned int irq;
+        spinlock_t lock;
+        unsigned int repoll_dly;
+        unsigned long cp_dly_jiffies;
+        bool use_fn_map;
+        bool use_ghost_filter;
+        const struct tegra_kbc_platform_data *pdata;
+        unsigned short keycode[KBC_MAX_KEY * 2];
+        unsigned short current_keys[KBC_MAX_KPENT];
+        unsigned int num_pressed_keys;
+        struct timer_list timer;
+        struct clk *clk;
+};
+
+static const u32 tegra_kbc_default_keymap[] = {
+        KEY(0, 2, KEY_W),
+        KEY(0, 3, KEY_S),
+        KEY(0, 4, KEY_A),
+        KEY(0, 5, KEY_Z),
+        KEY(0, 7, KEY_FN),
+
+        KEY(1, 7, KEY_LEFTMETA),
+
+        KEY(2, 6, KEY_RIGHTALT),
+        KEY(2, 7, KEY_LEFTALT),
+
+        KEY(3, 0, KEY_5),
+        KEY(3, 1, KEY_4),
+        KEY(3, 2, KEY_R),
+        KEY(3, 3, KEY_E),
+        KEY(3, 4, KEY_F),
+        KEY(3, 5, KEY_D),
+        KEY(3, 6, KEY_X),
+
+        KEY(4, 0, KEY_7),
+        KEY(4, 1, KEY_6),
+        KEY(4, 2, KEY_T),
+        KEY(4, 3, KEY_H),
+        KEY(4, 4, KEY_G),
+        KEY(4, 5, KEY_V),
+        KEY(4, 6, KEY_C),
+        KEY(4, 7, KEY_SPACE),
+
+        KEY(5, 0, KEY_9),
+        KEY(5, 1, KEY_8),
+        KEY(5, 2, KEY_U),
+        KEY(5, 3, KEY_Y),
+        KEY(5, 4, KEY_J),
+        KEY(5, 5, KEY_N),
+        KEY(5, 6, KEY_B),
+        KEY(5, 7, KEY_BACKSLASH),
+
+        KEY(6, 0, KEY_MINUS),
+        KEY(6, 1, KEY_0),
+        KEY(6, 2, KEY_O),
+        KEY(6, 3, KEY_I),
+        KEY(6, 4, KEY_L),
+        KEY(6, 5, KEY_K),
+        KEY(6, 6, KEY_COMMA),
+        KEY(6, 7, KEY_M),
+
+        KEY(7, 1, KEY_EQUAL),
+        KEY(7, 2, KEY_RIGHTBRACE),
+        KEY(7, 3, KEY_ENTER),
+        KEY(7, 7, KEY_MENU),
+
+        KEY(8, 4, KEY_RIGHTSHIFT),
+        KEY(8, 5, KEY_LEFTSHIFT),
+
+        KEY(9, 5, KEY_RIGHTCTRL),
+        KEY(9, 7, KEY_LEFTCTRL),
+
+        KEY(11, 0, KEY_LEFTBRACE),
+        KEY(11, 1, KEY_P),
+        KEY(11, 2, KEY_APOSTROPHE),
+        KEY(11, 3, KEY_SEMICOLON),
+        KEY(11, 4, KEY_SLASH),
+        KEY(11, 5, KEY_DOT),
+
+        KEY(12, 0, KEY_F10),
+        KEY(12, 1, KEY_F9),
+        KEY(12, 2, KEY_BACKSPACE),
+        KEY(12, 3, KEY_3),
+        KEY(12, 4, KEY_2),
+        KEY(12, 5, KEY_UP),
+        KEY(12, 6, KEY_PRINT),
+        KEY(12, 7, KEY_PAUSE),
+
+        KEY(13, 0, KEY_INSERT),
+        KEY(13, 1, KEY_DELETE),
+        KEY(13, 3, KEY_PAGEUP),
+        KEY(13, 4, KEY_PAGEDOWN),
+        KEY(13, 5, KEY_RIGHT),
+        KEY(13, 6, KEY_DOWN),
+        KEY(13, 7, KEY_LEFT),
+
+        KEY(14, 0, KEY_F11),
+        KEY(14, 1, KEY_F12),
+        KEY(14, 2, KEY_F8),
+        KEY(14, 3, KEY_Q),
+        KEY(14, 4, KEY_F4),
+        KEY(14, 5, KEY_F3),
+        KEY(14, 6, KEY_1),
+        KEY(14, 7, KEY_F7),
+
+        KEY(15, 0, KEY_ESC),
+        KEY(15, 1, KEY_GRAVE),
+        KEY(15, 2, KEY_F5),
+        KEY(15, 3, KEY_TAB),
+        KEY(15, 4, KEY_F1),
+        KEY(15, 5, KEY_F2),
+        KEY(15, 6, KEY_CAPSLOCK),
+        KEY(15, 7, KEY_F6),
+
+        /* Software Handled Function Keys */
+        KEY(20, 0, KEY_KP7),
+
+        KEY(21, 0, KEY_KP9),
+        KEY(21, 1, KEY_KP8),
+        KEY(21, 2, KEY_KP4),
+        KEY(21, 4, KEY_KP1),
+
+        KEY(22, 1, KEY_KPSLASH),
+        KEY(22, 2, KEY_KP6),
+        KEY(22, 3, KEY_KP5),
+        KEY(22, 4, KEY_KP3),
+        KEY(22, 5, KEY_KP2),
+        KEY(22, 7, KEY_KP0),
+
+        KEY(27, 1, KEY_KPASTERISK),
+        KEY(27, 3, KEY_KPMINUS),
+        KEY(27, 4, KEY_KPPLUS),
+        KEY(27, 5, KEY_KPDOT),
+
+        KEY(28, 5, KEY_VOLUMEUP),
+
+        KEY(29, 3, KEY_HOME),
+        KEY(29, 4, KEY_END),
+        KEY(29, 5, KEY_BRIGHTNESSDOWN),
+        KEY(29, 6, KEY_VOLUMEDOWN),
+        KEY(29, 7, KEY_BRIGHTNESSUP),
+
+        KEY(30, 0, KEY_NUMLOCK),
+        KEY(30, 1, KEY_SCROLLLOCK),
+        KEY(30, 2, KEY_MUTE),
+
+        KEY(31, 4, KEY_HELP),
+};
+
+static const struct matrix_keymap_data tegra_kbc_default_keymap_data = {
+        .keymap         = tegra_kbc_default_keymap,
+        .keymap_size    = ARRAY_SIZE(tegra_kbc_default_keymap),
+};
+
+static void tegra_kbc_report_released_keys(struct input_dev *input,
+                                           unsigned short old_keycodes[],
+                                           unsigned int old_num_keys,
+                                           unsigned short new_keycodes[],
+                                           unsigned int new_num_keys)
+{
+        unsigned int i, j;
+
+        for (i = 0; i < old_num_keys; i++) {
+                for (j = 0; j < new_num_keys; j++)
+                        if (old_keycodes[i] == new_keycodes[j])
+                                break;
+
+                if (j == new_num_keys)
+                        input_report_key(input, old_keycodes[i], 0);
+        }
+}
+
+static void tegra_kbc_report_pressed_keys(struct input_dev *input,
+                                          unsigned char scancodes[],
+                                          unsigned short keycodes[],
+                                          unsigned int num_pressed_keys)
+{
+        unsigned int i;
+
+        for (i = 0; i < num_pressed_keys; i++) {
+                input_event(input, EV_MSC, MSC_SCAN, scancodes[i]);
+                input_report_key(input, keycodes[i], 1);
+        }
+}
+
+static void tegra_kbc_report_keys(struct tegra_kbc *kbc)
+{
+        unsigned char scancodes[KBC_MAX_KPENT];
+        unsigned short keycodes[KBC_MAX_KPENT];
+        u32 val = 0;
+        unsigned int i;
+        unsigned int num_down = 0;
+        unsigned long flags;
+        bool fn_keypress = false;
+        bool key_in_same_row = false;
+        bool key_in_same_col = false;
+
+        spin_lock_irqsave(&kbc->lock, flags);
+        for (i = 0; i < KBC_MAX_KPENT; i++) {
+                if ((i % 4) == 0)
+                        val = readl(kbc->mmio + KBC_KP_ENT0_0 + i);
+
+                if (val & 0x80) {
+                        unsigned int col = val & 0x07;
+                        unsigned int row = (val >> 3) & 0x0f;
+                        unsigned char scancode =
+                                MATRIX_SCAN_CODE(row, col, KBC_ROW_SHIFT);
+
+                        scancodes[num_down] = scancode;
+                        keycodes[num_down] = kbc->keycode[scancode];
+                        /* If driver uses Fn map, do not report the Fn key. */
+                        if ((keycodes[num_down] == KEY_FN) && kbc->use_fn_map)
+                                fn_keypress = true;
+                        else
+                                num_down++;
+                }
+
+                val >>= 8;
+        }
+
+        /*
+         * Matrix keyboard designs are prone to keyboard ghosting.
+         * Ghosting occurs if there are 3 keys such that -
+         * any 2 of the 3 keys share a row, and any 2 of them share a column.
+         * If so ignore the key presses for this iteration.
+         */
+        if ((kbc->use_ghost_filter) && (num_down >= 3)) {
+                for (i = 0; i < num_down; i++) {
+                        unsigned int j;
+                        u8 curr_col = scancodes[i] & 0x07;
+                        u8 curr_row = scancodes[i] >> KBC_ROW_SHIFT;
+
+                        /*
+                         * Find 2 keys such that one key is in the same row
+                         * and the other is in the same column as the i-th key.
+                         */
+                        for (j = i + 1; j < num_down; j++) {
+                                u8 col = scancodes[j] & 0x07;
+                                u8 row = scancodes[j] >> KBC_ROW_SHIFT;
+
+                                if (col == curr_col)
+                                        key_in_same_col = true;
+                                if (row == curr_row)
+                                        key_in_same_row = true;
+                        }
+                }
+        }
+
+        /*
+         * If the platform uses Fn keymaps, translate keys on a Fn keypress.
+         * Function keycodes are KBC_MAX_KEY apart from the plain keycodes.
+         */
+        if (fn_keypress) {
+                for (i = 0; i < num_down; i++) {
+                        scancodes[i] += KBC_MAX_KEY;
+                        keycodes[i] = kbc->keycode[scancodes[i]];
+                }
+        }
+
+        spin_unlock_irqrestore(&kbc->lock, flags);
+
+        /* Ignore the key presses for this iteration? */
+        if (key_in_same_col && key_in_same_row)
+                return;
+
+        tegra_kbc_report_released_keys(kbc->idev,
+                                       kbc->current_keys, kbc->num_pressed_keys,
+                                       keycodes, num_down);
+        tegra_kbc_report_pressed_keys(kbc->idev, scancodes, keycodes, num_down);
+        input_sync(kbc->idev);
+
+        memcpy(kbc->current_keys, keycodes, sizeof(kbc->current_keys));
+        kbc->num_pressed_keys = num_down;
+}
+
+static void tegra_kbc_keypress_timer(unsigned long data)
+{
+        struct tegra_kbc *kbc = (struct tegra_kbc *)data;
+        unsigned long flags;
+        u32 val;
+        unsigned int i;
+
+        val = (readl(kbc->mmio + KBC_INT_0) >> 4) & 0xf;
+        if (val) {
+                unsigned long dly;
+
+                tegra_kbc_report_keys(kbc);
+
+                /*
+                 * If more than one keys are pressed we need not wait
+                 * for the repoll delay.
+                 */
+                dly = (val == 1) ? kbc->repoll_dly : 1;
+                mod_timer(&kbc->timer, jiffies + msecs_to_jiffies(dly));
+        } else {
+                /* Release any pressed keys and exit the polling loop */
+                for (i = 0; i < kbc->num_pressed_keys; i++)
+                        input_report_key(kbc->idev, kbc->current_keys[i], 0);
+                input_sync(kbc->idev);
+
+                kbc->num_pressed_keys = 0;
+
+                /* All keys are released so enable the keypress interrupt */
+                spin_lock_irqsave(&kbc->lock, flags);
+                val = readl(kbc->mmio + KBC_CONTROL_0);
+                val |= KBC_CONTROL_FIFO_CNT_INT_EN;
+                writel(val, kbc->mmio + KBC_CONTROL_0);
+                spin_unlock_irqrestore(&kbc->lock, flags);
+        }
+}
+
+static irqreturn_t tegra_kbc_isr(int irq, void *args)
+{
+        struct tegra_kbc *kbc = args;
+        u32 val, ctl;
+
+        /*
+         * Until all keys are released, defer further processing to
+         * the polling loop in tegra_kbc_keypress_timer
+         */
+        ctl = readl(kbc->mmio + KBC_CONTROL_0);
+        ctl &= ~KBC_CONTROL_FIFO_CNT_INT_EN;
+        writel(ctl, kbc->mmio + KBC_CONTROL_0);
+
+        /*
+         * Quickly bail out & reenable interrupts if the fifo threshold
+         * count interrupt wasn't the interrupt source
+         */
+        val = readl(kbc->mmio + KBC_INT_0);
+        writel(val, kbc->mmio + KBC_INT_0);
+
+        if (val & KBC_INT_FIFO_CNT_INT_STATUS) {
+                /*
+                 * Schedule timer to run when hardware is in continuous
+                 * polling mode.
+                 */
+                mod_timer(&kbc->timer, jiffies + kbc->cp_dly_jiffies);
+        } else {
+                ctl |= KBC_CONTROL_FIFO_CNT_INT_EN;
+                writel(ctl, kbc->mmio + KBC_CONTROL_0);
+        }
+
+        return IRQ_HANDLED;
+}
+
+static void tegra_kbc_setup_wakekeys(struct tegra_kbc *kbc, bool filter)
+{
+        const struct tegra_kbc_platform_data *pdata = kbc->pdata;
+        int i;
+        unsigned int rst_val;
+
+        /* Either mask all keys or none. */
+        rst_val = (filter && !pdata->wakeup) ? ~0 : 0;
+
+        for (i = 0; i < KBC_MAX_ROW; i++)
+                writel(rst_val, kbc->mmio + KBC_ROW0_MASK_0 + i * 4);
+}
+
+static void tegra_kbc_config_pins(struct tegra_kbc *kbc)
+{
+        const struct tegra_kbc_platform_data *pdata = kbc->pdata;
+        int i;
+
+        for (i = 0; i < KBC_MAX_GPIO; i++) {
+                u32 r_shft = 5 * (i % 6);
+                u32 c_shft = 4 * (i % 8);
+                u32 r_mask = 0x1f << r_shft;
+                u32 c_mask = 0x0f << c_shft;
+                u32 r_offs = (i / 6) * 4 + KBC_ROW_CFG0_0;
+                u32 c_offs = (i / 8) * 4 + KBC_COL_CFG0_0;
+                u32 row_cfg = readl(kbc->mmio + r_offs);
+                u32 col_cfg = readl(kbc->mmio + c_offs);
+
+                row_cfg &= ~r_mask;
+                col_cfg &= ~c_mask;
+
+                if (pdata->pin_cfg[i].is_row)
+                        row_cfg |= ((pdata->pin_cfg[i].num << 1) | 1) << r_shft;
+                else
+                        col_cfg |= ((pdata->pin_cfg[i].num << 1) | 1) << c_shft;
+
+                writel(row_cfg, kbc->mmio + r_offs);
+                writel(col_cfg, kbc->mmio + c_offs);
+        }
+}
+
+static int tegra_kbc_start(struct tegra_kbc *kbc)
+{
+        const struct tegra_kbc_platform_data *pdata = kbc->pdata;
+        unsigned long flags;
+        unsigned int debounce_cnt;
+        u32 val = 0;
+
+        clk_enable(kbc->clk);
+
+        /* Reset the KBC controller to clear all previous status.*/
+        tegra_periph_reset_assert(kbc->clk);
+        udelay(100);
+        tegra_periph_reset_deassert(kbc->clk);
+        udelay(100);
+
+        tegra_kbc_config_pins(kbc);
+        tegra_kbc_setup_wakekeys(kbc, false);
+
+        writel(pdata->repeat_cnt, kbc->mmio + KBC_RPT_DLY_0);
+
+        /* Keyboard debounce count is maximum of 12 bits. */
+        debounce_cnt = min(pdata->debounce_cnt, KBC_MAX_DEBOUNCE_CNT);
+        val = KBC_DEBOUNCE_CNT_SHIFT(debounce_cnt);
+        val |= KBC_FIFO_TH_CNT_SHIFT(1); /* set fifo interrupt threshold to 1 */
+        val |= KBC_CONTROL_FIFO_CNT_INT_EN;  /* interrupt on FIFO threshold */
+        val |= KBC_CONTROL_KBC_EN;     /* enable */
+        writel(val, kbc->mmio + KBC_CONTROL_0);
+
+        /*
+         * Compute the delay(ns) from interrupt mode to continuous polling
+         * mode so the timer routine is scheduled appropriately.
+         */
+        val = readl(kbc->mmio + KBC_INIT_DLY_0);
+        kbc->cp_dly_jiffies = usecs_to_jiffies((val & 0xfffff) * 32);
+
+        kbc->num_pressed_keys = 0;
+
+        /*
+         * Atomically clear out any remaining entries in the key FIFO
+         * and enable keyboard interrupts.
+         */
+        spin_lock_irqsave(&kbc->lock, flags);
+        while (1) {
+                val = readl(kbc->mmio + KBC_INT_0);
+                val >>= 4;
+                if (!val)
+                        break;
+
+                val = readl(kbc->mmio + KBC_KP_ENT0_0);
+                val = readl(kbc->mmio + KBC_KP_ENT1_0);
+        }
+        writel(0x7, kbc->mmio + KBC_INT_0);
+        spin_unlock_irqrestore(&kbc->lock, flags);
+
+        enable_irq(kbc->irq);
+
+        return 0;
+}
+
+static void tegra_kbc_stop(struct tegra_kbc *kbc)
+{
+        unsigned long flags;
+        u32 val;
+
+        spin_lock_irqsave(&kbc->lock, flags);
+        val = readl(kbc->mmio + KBC_CONTROL_0);
+        val &= ~1;
+        writel(val, kbc->mmio + KBC_CONTROL_0);
+        spin_unlock_irqrestore(&kbc->lock, flags);
+
+        disable_irq(kbc->irq);
+        del_timer_sync(&kbc->timer);
+
+        clk_disable(kbc->clk);
+}
+
+static int tegra_kbc_open(struct input_dev *dev)
+{
+        struct tegra_kbc *kbc = input_get_drvdata(dev);
+
+        return tegra_kbc_start(kbc);
+}
+
+static void tegra_kbc_close(struct input_dev *dev)
+{
+        struct tegra_kbc *kbc = input_get_drvdata(dev);
+
+        return tegra_kbc_stop(kbc);
+}
+
+static bool __devinit
+tegra_kbc_check_pin_cfg(const struct tegra_kbc_platform_data *pdata,
+                        struct device *dev, unsigned int *num_rows)
+{
+        int i;
+
+        *num_rows = 0;
+
+        for (i = 0; i < KBC_MAX_GPIO; i++) {
+                const struct tegra_kbc_pin_cfg *pin_cfg = &pdata->pin_cfg[i];
+
+                if (pin_cfg->is_row) {
+                        if (pin_cfg->num >= KBC_MAX_ROW) {
+                                dev_err(dev,
+                                        "pin_cfg[%d]: invalid row number %d\n",
+                                        i, pin_cfg->num);
+                                return false;
+                        }
+                        (*num_rows)++;
+                } else {
+                        if (pin_cfg->num >= KBC_MAX_COL) {
+                                dev_err(dev,
+                                        "pin_cfg[%d]: invalid column number %d\n",
+                                        i, pin_cfg->num);
+                                return false;
+                        }
+                }
+        }
+
+        return true;
+}
+
+static int __devinit tegra_kbc_probe(struct platform_device *pdev)
+{
+        const struct tegra_kbc_platform_data *pdata = pdev->dev.platform_data;
+        const struct matrix_keymap_data *keymap_data;
+        struct tegra_kbc *kbc;
+        struct input_dev *input_dev;
+        struct resource *res;
+        int irq;
+        int err;
+        int num_rows = 0;
+        unsigned int debounce_cnt;
+        unsigned int scan_time_rows;
+
+        if (!pdata)
+                return -EINVAL;
+
+        if (!tegra_kbc_check_pin_cfg(pdata, &pdev->dev, &num_rows))
+                return -EINVAL;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(&pdev->dev, "failed to get I/O memory\n");
+                return -ENXIO;
+        }
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0) {
+                dev_err(&pdev->dev, "failed to get keyboard IRQ\n");
+                return -ENXIO;
+        }
+
+        kbc = kzalloc(sizeof(*kbc), GFP_KERNEL);
+        input_dev = input_allocate_device();
+        if (!kbc || !input_dev) {
+                err = -ENOMEM;
+                goto err_free_mem;
+        }
+
+        kbc->pdata = pdata;
+        kbc->idev = input_dev;
+        kbc->irq = irq;
+        spin_lock_init(&kbc->lock);
+        setup_timer(&kbc->timer, tegra_kbc_keypress_timer, (unsigned long)kbc);
+
+        res = request_mem_region(res->start, resource_size(res), pdev->name);
+        if (!res) {
+                dev_err(&pdev->dev, "failed to request I/O memory\n");
+                err = -EBUSY;
+                goto err_free_mem;
+        }
+
+        kbc->mmio = ioremap(res->start, resource_size(res));
+        if (!kbc->mmio) {
+                dev_err(&pdev->dev, "failed to remap I/O memory\n");
+                err = -ENXIO;
+                goto err_free_mem_region;
+        }
+
+        kbc->clk = clk_get(&pdev->dev, NULL);
+        if (IS_ERR(kbc->clk)) {
+                dev_err(&pdev->dev, "failed to get keyboard clock\n");
+                err = PTR_ERR(kbc->clk);
+                goto err_iounmap;
+        }
+
+        /*
+         * The time delay between two consecutive reads of the FIFO is
+         * the sum of the repeat time and the time taken for scanning
+         * the rows. There is an additional delay before the row scanning
+         * starts. The repoll delay is computed in milliseconds.
+         */
+        debounce_cnt = min(pdata->debounce_cnt, KBC_MAX_DEBOUNCE_CNT);
+        scan_time_rows = (KBC_ROW_SCAN_TIME + debounce_cnt) * num_rows;
+        kbc->repoll_dly = KBC_ROW_SCAN_DLY + scan_time_rows + pdata->repeat_cnt;
+        kbc->repoll_dly = ((kbc->repoll_dly * KBC_CYCLE_USEC) + 999) / 1000;
+
+        input_dev->name = pdev->name;
+        input_dev->id.bustype = BUS_HOST;
+        input_dev->dev.parent = &pdev->dev;
+        input_dev->open = tegra_kbc_open;
+        input_dev->close = tegra_kbc_close;
+
+        input_set_drvdata(input_dev, kbc);
+
+        input_dev->evbit[0] = BIT_MASK(EV_KEY);
+        input_set_capability(input_dev, EV_MSC, MSC_SCAN);
+
+        input_dev->keycode = kbc->keycode;
+        input_dev->keycodesize = sizeof(kbc->keycode[0]);
+        input_dev->keycodemax = KBC_MAX_KEY;
+        if (pdata->use_fn_map)
+                input_dev->keycodemax *= 2;
+
+        kbc->use_fn_map = pdata->use_fn_map;
+        kbc->use_ghost_filter = pdata->use_ghost_filter;
+        keymap_data = pdata->keymap_data ?: &tegra_kbc_default_keymap_data;
+        matrix_keypad_build_keymap(keymap_data, KBC_ROW_SHIFT,
+                                   input_dev->keycode, input_dev->keybit);
+
+        err = request_irq(kbc->irq, tegra_kbc_isr, IRQF_TRIGGER_HIGH,
+                          pdev->name, kbc);
+        if (err) {
+                dev_err(&pdev->dev, "failed to request keyboard IRQ\n");
+                goto err_put_clk;
+        }
+
+        disable_irq(kbc->irq);
+
+        err = input_register_device(kbc->idev);
+        if (err) {
+                dev_err(&pdev->dev, "failed to register input device\n");
+                goto err_free_irq;
+        }
+
+        platform_set_drvdata(pdev, kbc);
+        device_init_wakeup(&pdev->dev, pdata->wakeup);
+
+        return 0;
+
+err_free_irq:
+        free_irq(kbc->irq, pdev);
+err_put_clk:
+        clk_put(kbc->clk);
+err_iounmap:
+        iounmap(kbc->mmio);
+err_free_mem_region:
+        release_mem_region(res->start, resource_size(res));
+err_free_mem:
+        input_free_device(kbc->idev);
+        kfree(kbc);
+
+        return err;
+}
+
+static int __devexit tegra_kbc_remove(struct platform_device *pdev)
+{
+        struct tegra_kbc *kbc = platform_get_drvdata(pdev);
+        struct resource *res;
+
+        free_irq(kbc->irq, pdev);
+        clk_put(kbc->clk);
+
+        input_unregister_device(kbc->idev);
+        iounmap(kbc->mmio);
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        release_mem_region(res->start, resource_size(res));
+
+        kfree(kbc);
+
+        platform_set_drvdata(pdev, NULL);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM_SLEEP
+static int tegra_kbc_suspend(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct tegra_kbc *kbc = platform_get_drvdata(pdev);
+
+        if (device_may_wakeup(&pdev->dev)) {
+                tegra_kbc_setup_wakekeys(kbc, true);
+                enable_irq_wake(kbc->irq);
+                /* Forcefully clear the interrupt status */
+                writel(0x7, kbc->mmio + KBC_INT_0);
+                msleep(30);
+        } else {
+                mutex_lock(&kbc->idev->mutex);
+                if (kbc->idev->users)
+                        tegra_kbc_stop(kbc);
+                mutex_unlock(&kbc->idev->mutex);
+        }
+
+        return 0;
+}
+
+static int tegra_kbc_resume(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct tegra_kbc *kbc = platform_get_drvdata(pdev);
+        int err = 0;
+
+        if (device_may_wakeup(&pdev->dev)) {
+                disable_irq_wake(kbc->irq);
+                tegra_kbc_setup_wakekeys(kbc, false);
+        } else {
+                mutex_lock(&kbc->idev->mutex);
+                if (kbc->idev->users)
+                        err = tegra_kbc_start(kbc);
+                mutex_unlock(&kbc->idev->mutex);
+        }
+
+        return err;
+}
+#endif
+
+static SIMPLE_DEV_PM_OPS(tegra_kbc_pm_ops, tegra_kbc_suspend, tegra_kbc_resume);
+
+static struct platform_driver tegra_kbc_driver = {
+        .probe          = tegra_kbc_probe,
+        .remove         = __devexit_p(tegra_kbc_remove),
+        .driver = {
+                .name   = "tegra-kbc",
+                .owner  = THIS_MODULE,
+                .pm     = &tegra_kbc_pm_ops,
+        },
+};
+
+static void __exit tegra_kbc_exit(void)
+{
+        platform_driver_unregister(&tegra_kbc_driver);
+}
+module_exit(tegra_kbc_exit);
+
+static int __init tegra_kbc_init(void)
+{
+        return platform_driver_register(&tegra_kbc_driver);
+}
+module_init(tegra_kbc_init);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Rakesh Iyer <riyer@nvidia.com>");
+MODULE_DESCRIPTION("Tegra matrix keyboard controller driver");
+MODULE_ALIAS("platform:tegra-kbc");
diff --git a/drivers/input/keyboard/tnetv107x-keypad.c b/drivers/input/keyboard/tnetv107x-keypad.c
new file mode 100644
index 000000000000..c8f097a15d89
--- /dev/null
+++ b/drivers/input/keyboard/tnetv107x-keypad.c
@@ -0,0 +1,341 @@
+/*
+ * Texas Instruments TNETV107X Keypad Driver
+ *
+ * Copyright (C) 2010 Texas Instruments
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation version 2.
+ *
+ * This program is distributed "as is" WITHOUT ANY WARRANTY of any
+ * kind, whether express or implied; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/kernel.h>
+#include <linux/err.h>
+#include <linux/errno.h>
+#include <linux/input.h>
+#include <linux/platform_device.h>
+#include <linux/interrupt.h>
+#include <linux/slab.h>
+#include <linux/delay.h>
+#include <linux/io.h>
+#include <linux/clk.h>
+#include <linux/input/matrix_keypad.h>
+
+#define BITS(x)                 (BIT(x) - 1)
+
+#define KEYPAD_ROWS             9
+#define KEYPAD_COLS             9
+
+#define DEBOUNCE_MIN            0x400ul
+#define DEBOUNCE_MAX            0x3ffffffful
+
+struct keypad_regs {
+        u32     rev;
+        u32     mode;
+        u32     mask;
+        u32     pol;
+        u32     dclock;
+        u32     rclock;
+        u32     stable_cnt;
+        u32     in_en;
+        u32     out;
+        u32     out_en;
+        u32     in;
+        u32     lock;
+        u32     pres[3];
+};
+
+#define keypad_read(kp, reg)            __raw_readl(&(kp)->regs->reg)
+#define keypad_write(kp, reg, val)      __raw_writel(val, &(kp)->regs->reg)
+
+struct keypad_data {
+        struct input_dev                *input_dev;
+        struct resource                 *res;
+        struct keypad_regs __iomem      *regs;
+        struct clk                      *clk;
+        struct device                   *dev;
+        spinlock_t                      lock;
+        u32                             irq_press;
+        u32                             irq_release;
+        int                             rows, cols, row_shift;
+        int                             debounce_ms, active_low;
+        u32                             prev_keys[3];
+        unsigned short                  keycodes[];
+};
+
+static irqreturn_t keypad_irq(int irq, void *data)
+{
+        struct keypad_data *kp = data;
+        int i, bit, val, row, col, code;
+        unsigned long flags;
+        u32 curr_keys[3];
+        u32 change;
+
+        spin_lock_irqsave(&kp->lock, flags);
+
+        memset(curr_keys, 0, sizeof(curr_keys));
+        if (irq == kp->irq_press)
+                for (i = 0; i < 3; i++)
+                        curr_keys[i] = keypad_read(kp, pres[i]);
+
+        for (i = 0; i < 3; i++) {
+                change = curr_keys[i] ^ kp->prev_keys[i];
+
+                while (change) {
+                        bit     = fls(change) - 1;
+                        change ^= BIT(bit);
+                        val     = curr_keys[i] & BIT(bit);
+                        bit    += i * 32;
+                        row     = bit / KEYPAD_COLS;
+                        col     = bit % KEYPAD_COLS;
+
+                        code = MATRIX_SCAN_CODE(row, col, kp->row_shift);
+                        input_event(kp->input_dev, EV_MSC, MSC_SCAN, code);
+                        input_report_key(kp->input_dev, kp->keycodes[code],
+                                         val);
+                }
+        }
+        input_sync(kp->input_dev);
+        memcpy(kp->prev_keys, curr_keys, sizeof(curr_keys));
+
+        if (irq == kp->irq_press)
+                keypad_write(kp, lock, 0); /* Allow hardware updates */
+
+        spin_unlock_irqrestore(&kp->lock, flags);
+
+        return IRQ_HANDLED;
+}
+
+static int keypad_start(struct input_dev *dev)
+{
+        struct keypad_data *kp = input_get_drvdata(dev);
+        unsigned long mask, debounce, clk_rate_khz;
+        unsigned long flags;
+
+        clk_enable(kp->clk);
+        clk_rate_khz = clk_get_rate(kp->clk) / 1000;
+
+        spin_lock_irqsave(&kp->lock, flags);
+
+        /* Initialize device registers */
+        keypad_write(kp, mode, 0);
+
+        mask  = BITS(kp->rows) << KEYPAD_COLS;
+        mask |= BITS(kp->cols);
+        keypad_write(kp, mask, ~mask);
+
+        keypad_write(kp, pol, kp->active_low ? 0 : 0x3ffff);
+        keypad_write(kp, stable_cnt, 3);
+
+        debounce = kp->debounce_ms * clk_rate_khz;
+        debounce = clamp(debounce, DEBOUNCE_MIN, DEBOUNCE_MAX);
+        keypad_write(kp, dclock, debounce);
+        keypad_write(kp, rclock, 4 * debounce);
+
+        keypad_write(kp, in_en, 1);
+
+        spin_unlock_irqrestore(&kp->lock, flags);
+
+        return 0;
+}
+
+static void keypad_stop(struct input_dev *dev)
+{
+        struct keypad_data *kp = input_get_drvdata(dev);
+
+        synchronize_irq(kp->irq_press);
+        synchronize_irq(kp->irq_release);
+        clk_disable(kp->clk);
+}
+
+static int __devinit keypad_probe(struct platform_device *pdev)
+{
+        const struct matrix_keypad_platform_data *pdata;
+        const struct matrix_keymap_data *keymap_data;
+        struct device *dev = &pdev->dev;
+        struct keypad_data *kp;
+        int error = 0, sz, row_shift;
+        u32 rev = 0;
+
+        pdata = pdev->dev.platform_data;
+        if (!pdata) {
+                dev_err(dev, "cannot find device data\n");
+                return -EINVAL;
+        }
+
+        keymap_data = pdata->keymap_data;
+        if (!keymap_data) {
+                dev_err(dev, "cannot find keymap data\n");
+                return -EINVAL;
+        }
+
+        row_shift = get_count_order(pdata->num_col_gpios);
+        sz  = offsetof(struct keypad_data, keycodes);
+        sz += (pdata->num_row_gpios << row_shift) * sizeof(kp->keycodes[0]);
+        kp = kzalloc(sz, GFP_KERNEL);
+        if (!kp) {
+                dev_err(dev, "cannot allocate device info\n");
+                return -ENOMEM;
+        }
+
+        kp->dev  = dev;
+        kp->rows = pdata->num_row_gpios;
+        kp->cols = pdata->num_col_gpios;
+        kp->row_shift = row_shift;
+        platform_set_drvdata(pdev, kp);
+        spin_lock_init(&kp->lock);
+
+        kp->irq_press   = platform_get_irq_byname(pdev, "press");
+        kp->irq_release = platform_get_irq_byname(pdev, "release");
+        if (kp->irq_press < 0 || kp->irq_release < 0) {
+                dev_err(dev, "cannot determine device interrupts\n");
+                error = -ENODEV;
+                goto error_res;
+        }
+
+        kp->res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!kp->res) {
+                dev_err(dev, "cannot determine register area\n");
+                error = -ENODEV;
+                goto error_res;
+        }
+
+        if (!request_mem_region(kp->res->start, resource_size(kp->res),
+                                pdev->name)) {
+                dev_err(dev, "cannot claim register memory\n");
+                kp->res = NULL;
+                error = -EINVAL;
+                goto error_res;
+        }
+
+        kp->regs = ioremap(kp->res->start, resource_size(kp->res));
+        if (!kp->regs) {
+                dev_err(dev, "cannot map register memory\n");
+                error = -ENOMEM;
+                goto error_map;
+        }
+
+        kp->clk = clk_get(dev, NULL);
+        if (IS_ERR(kp->clk)) {
+                dev_err(dev, "cannot claim device clock\n");
+                error = PTR_ERR(kp->clk);
+                goto error_clk;
+        }
+
+        error = request_threaded_irq(kp->irq_press, NULL, keypad_irq, 0,
+                                     dev_name(dev), kp);
+        if (error < 0) {
+                dev_err(kp->dev, "Could not allocate keypad press key irq\n");
+                goto error_irq_press;
+        }
+
+        error = request_threaded_irq(kp->irq_release, NULL, keypad_irq, 0,
+                                     dev_name(dev), kp);
+        if (error < 0) {
+                dev_err(kp->dev, "Could not allocate keypad release key irq\n");
+                goto error_irq_release;
+        }
+
+        kp->input_dev = input_allocate_device();
+        if (!kp->input_dev) {
+                dev_err(dev, "cannot allocate input device\n");
+                error = -ENOMEM;
+                goto error_input;
+        }
+        input_set_drvdata(kp->input_dev, kp);
+
+        kp->input_dev->name       = pdev->name;
+        kp->input_dev->dev.parent = &pdev->dev;
+        kp->input_dev->open       = keypad_start;
+        kp->input_dev->close      = keypad_stop;
+        kp->input_dev->evbit[0]   = BIT_MASK(EV_KEY);
+        if (!pdata->no_autorepeat)
+                kp->input_dev->evbit[0] |= BIT_MASK(EV_REP);
+
+        clk_enable(kp->clk);
+        rev = keypad_read(kp, rev);
+        kp->input_dev->id.bustype = BUS_HOST;
+        kp->input_dev->id.product = ((rev >>  8) & 0x07);
+        kp->input_dev->id.version = ((rev >> 16) & 0xfff);
+        clk_disable(kp->clk);
+
+        kp->input_dev->keycode     = kp->keycodes;
+        kp->input_dev->keycodesize = sizeof(kp->keycodes[0]);
+        kp->input_dev->keycodemax  = kp->rows << kp->row_shift;
+
+        matrix_keypad_build_keymap(keymap_data, kp->row_shift, kp->keycodes,
+                                   kp->input_dev->keybit);
+
+        input_set_capability(kp->input_dev, EV_MSC, MSC_SCAN);
+
+        error = input_register_device(kp->input_dev);
+        if (error < 0) {
+                dev_err(dev, "Could not register input device\n");
+                goto error_reg;
+        }
+
+        return 0;
+
+
+error_reg:
+        input_free_device(kp->input_dev);
+error_input:
+        free_irq(kp->irq_release, kp);
+error_irq_release:
+        free_irq(kp->irq_press, kp);
+error_irq_press:
+        clk_put(kp->clk);
+error_clk:
+        iounmap(kp->regs);
+error_map:
+        release_mem_region(kp->res->start, resource_size(kp->res));
+error_res:
+        platform_set_drvdata(pdev, NULL);
+        kfree(kp);
+        return error;
+}
+
+static int __devexit keypad_remove(struct platform_device *pdev)
+{
+        struct keypad_data *kp = platform_get_drvdata(pdev);
+
+        free_irq(kp->irq_press, kp);
+        free_irq(kp->irq_release, kp);
+        input_unregister_device(kp->input_dev);
+        clk_put(kp->clk);
+        iounmap(kp->regs);
+        release_mem_region(kp->res->start, resource_size(kp->res));
+        platform_set_drvdata(pdev, NULL);
+        kfree(kp);
+
+        return 0;
+}
+
+static struct platform_driver keypad_driver = {
+        .probe          = keypad_probe,
+        .remove         = __devexit_p(keypad_remove),
+        .driver.name    = "tnetv107x-keypad",
+        .driver.owner   = THIS_MODULE,
+};
+
+static int __init keypad_init(void)
+{
+        return platform_driver_register(&keypad_driver);
+}
+
+static void __exit keypad_exit(void)
+{
+        platform_driver_unregister(&keypad_driver);
+}
+
+module_init(keypad_init);
+module_exit(keypad_exit);
+
+MODULE_AUTHOR("Cyril Chemparathy");
+MODULE_DESCRIPTION("TNETV107X Keypad Driver");
+MODULE_ALIAS("platform: tnetv107x-keypad");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/keyboard/twl4030_keypad.c b/drivers/input/keyboard/twl4030_keypad.c
index fb16b5e5ea13..a26922cf0e84 100644
--- a/drivers/input/keyboard/twl4030_keypad.c
+++ b/drivers/input/keyboard/twl4030_keypad.c
@@ -332,18 +332,20 @@ static int __devinit twl4030_kp_program(struct twl4030_keypad *kp)
 static int __devinit twl4030_kp_probe(struct platform_device *pdev)
 {
         struct twl4030_keypad_data *pdata = pdev->dev.platform_data;
-        const struct matrix_keymap_data *keymap_data = pdata->keymap_data;
+        const struct matrix_keymap_data *keymap_data;
         struct twl4030_keypad *kp;
         struct input_dev *input;
         u8 reg;
         int error;
 
-        if (!pdata || !pdata->rows || !pdata->cols ||
+        if (!pdata || !pdata->rows || !pdata->cols || !pdata->keymap_data ||
             pdata->rows > TWL4030_MAX_ROWS || pdata->cols > TWL4030_MAX_COLS) {
                 dev_err(&pdev->dev, "Invalid platform_data\n");
                 return -EINVAL;
         }
 
+        keymap_data = pdata->keymap_data;
+
         kp = kzalloc(sizeof(*kp), GFP_KERNEL);
         input = input_allocate_device();
         if (!kp || !input) {
@@ -406,23 +408,22 @@ static int __devinit twl4030_kp_probe(struct platform_device *pdev)
         if (error) {
                 dev_info(kp->dbg_dev, "request_irq failed for irq no=%d\n",
                         kp->irq);
-                goto err3;
+                goto err2;
         }
 
         /* Enable KP and TO interrupts now. */
         reg = (u8) ~(KEYP_IMR1_KP | KEYP_IMR1_TO);
         if (twl4030_kpwrite_u8(kp, reg, KEYP_IMR1)) {
                 error = -EIO;
-                goto err4;
+                goto err3;
         }
 
         platform_set_drvdata(pdev, kp);
         return 0;
 
-err4:
+err3:
         /* mask all events - we don't care about the result */
         (void) twl4030_kpwrite_u8(kp, 0xff, KEYP_IMR1);
-err3:
         free_irq(kp->irq, NULL);
 err2:
         input_unregister_device(input);
diff --git a/drivers/input/misc/88pm860x_onkey.c b/drivers/input/misc/88pm860x_onkey.c
index 4cc82826ea6b..3dca3c14510e 100644
--- a/drivers/input/misc/88pm860x_onkey.c
+++ b/drivers/input/misc/88pm860x_onkey.c
@@ -74,7 +74,7 @@ static int __devinit pm860x_onkey_probe(struct platform_device *pdev)
         info->chip = chip;
         info->i2c = (chip->id == CHIP_PM8607) ? chip->client : chip->companion;
         info->dev = &pdev->dev;
-        info->irq = irq + chip->irq_base;
+        info->irq = irq;
 
         info->idev = input_allocate_device();
         if (!info->idev) {
diff --git a/drivers/input/misc/Kconfig b/drivers/input/misc/Kconfig
index b49e23379723..45dc6aa62ba4 100644
--- a/drivers/input/misc/Kconfig
+++ b/drivers/input/misc/Kconfig
@@ -22,6 +22,16 @@ config INPUT_88PM860X_ONKEY
           To compile this driver as a module, choose M here: the module
           will be called 88pm860x_onkey.
 
+config INPUT_AB8500_PONKEY
+        tristate "AB8500 Pon (PowerOn) Key"
+        depends on AB8500_CORE
+        help
+          Say Y here to use the PowerOn Key for ST-Ericsson's AB8500
+          Mix-Sig PMIC.
+
+          To compile this driver as a module, choose M here: the module
+          will be called ab8500-ponkey.
+
 config INPUT_AD714X
         tristate "Analog Devices AD714x Capacitance Touch Sensor"
         help
@@ -284,24 +294,6 @@ config INPUT_SGI_BTNS
           To compile this driver as a module, choose M here: the
           module will be called sgi_btns.
 
-config INPUT_WINBOND_CIR
-        tristate "Winbond IR remote control"
-        depends on X86 && PNP
-        select NEW_LEDS
-        select LEDS_CLASS
-        select LEDS_TRIGGERS
-        select BITREVERSE
-        help
-          Say Y here if you want to use the IR remote functionality found
-          in some Winbond SuperI/O chips. Currently only the WPCD376I
-          chip is supported (included in some Intel Media series motherboards).
-
-          IR Receive and wake-on-IR from suspend and power-off is currently
-          supported.
-
-          To compile this driver as a module, choose M here: the module will be
-          called winbond_cir.
-
 config HP_SDC_RTC
         tristate "HP SDC Real Time Clock"
         depends on (GSC || HP300) && SERIO
@@ -338,6 +330,17 @@ config INPUT_PWM_BEEPER
           To compile this driver as a module, choose M here: the module will be
           called pwm-beeper.
 
+config INPUT_PMIC8XXX_PWRKEY
+        tristate "PMIC8XXX power key support"
+        depends on MFD_PM8XXX
+        help
+          Say Y here if you want support for the PMIC8XXX power key.
+
+          If unsure, say N.
+
+          To compile this driver as a module, choose M here: the
+          module will be called pmic8xxx-pwrkey.
+
 config INPUT_GPIO_ROTARY_ENCODER
         tristate "Rotary encoders connected to GPIO pins"
         depends on GPIOLIB && GENERIC_GPIO
@@ -438,4 +441,41 @@ config INPUT_ADXL34X_SPI
           To compile this driver as a module, choose M here: the
           module will be called adxl34x-spi.
 
+config INPUT_CMA3000
+        tristate "VTI CMA3000 Tri-axis accelerometer"
+        help
+          Say Y here if you want to use VTI CMA3000_D0x Accelerometer
+          driver
+
+          This driver currently only supports I2C interface to the
+          controller. Also select the I2C method.
+
+          If unsure, say N
+
+          To compile this driver as a module, choose M here: the
+          module will be called cma3000_d0x.
+
+config INPUT_CMA3000_I2C
+        tristate "Support I2C bus connection"
+        depends on INPUT_CMA3000 && I2C
+        help
+          Say Y here if you want to use VTI CMA3000_D0x Accelerometer
+          through I2C interface.
+
+          To compile this driver as a module, choose M here: the
+          module will be called cma3000_d0x_i2c.
+
+config INPUT_XEN_KBDDEV_FRONTEND
+        tristate "Xen virtual keyboard and mouse support"
+        depends on XEN_FBDEV_FRONTEND
+        default y
+        select XEN_XENBUS_FRONTEND
+        help
+          This driver implements the front-end of the Xen virtual
+          keyboard and mouse device driver.  It communicates with a back-end
+          in another domain.
+
+          To compile this driver as a module, choose M here: the
+          module will be called xen-kbdfront.
+
 endif
diff --git a/drivers/input/misc/Makefile b/drivers/input/misc/Makefile
index 19ccca78fa76..38efb2cb182b 100644
--- a/drivers/input/misc/Makefile
+++ b/drivers/input/misc/Makefile
@@ -5,6 +5,7 @@
 # Each configuration option enables a list of files.
 
 obj-$(CONFIG_INPUT_88PM860X_ONKEY)      += 88pm860x_onkey.o
+obj-$(CONFIG_INPUT_AB8500_PONKEY)       += ab8500-ponkey.o
 obj-$(CONFIG_INPUT_AD714X)              += ad714x.o
 obj-$(CONFIG_INPUT_AD714X_I2C)          += ad714x-i2c.o
 obj-$(CONFIG_INPUT_AD714X_SPI)          += ad714x-spi.o
@@ -17,6 +18,8 @@ obj-$(CONFIG_INPUT_ATI_REMOTE2)		+= ati_remote2.o
 obj-$(CONFIG_INPUT_ATLAS_BTNS)          += atlas_btns.o
 obj-$(CONFIG_INPUT_BFIN_ROTARY)         += bfin_rotary.o
 obj-$(CONFIG_INPUT_CM109)               += cm109.o
+obj-$(CONFIG_INPUT_CMA3000)             += cma3000_d0x.o
+obj-$(CONFIG_INPUT_CMA3000_I2C)         += cma3000_d0x_i2c.o
 obj-$(CONFIG_INPUT_COBALT_BTNS)         += cobalt_btns.o
 obj-$(CONFIG_INPUT_DM355EVM)            += dm355evm_keys.o
 obj-$(CONFIG_HP_SDC_RTC)                += hp_sdc_rtc.o
@@ -30,6 +33,7 @@ obj-$(CONFIG_INPUT_PCF8574)		+= pcf8574_keypad.o
 obj-$(CONFIG_INPUT_PCSPKR)              += pcspkr.o
 obj-$(CONFIG_INPUT_POWERMATE)           += powermate.o
 obj-$(CONFIG_INPUT_PWM_BEEPER)          += pwm-beeper.o
+obj-$(CONFIG_INPUT_PMIC8XXX_PWRKEY)     += pmic8xxx-pwrkey.o
 obj-$(CONFIG_INPUT_RB532_BUTTON)        += rb532_button.o
 obj-$(CONFIG_INPUT_GPIO_ROTARY_ENCODER) += rotary_encoder.o
 obj-$(CONFIG_INPUT_SGI_BTNS)            += sgi_btns.o
@@ -37,8 +41,8 @@ obj-$(CONFIG_INPUT_SPARCSPKR)		+= sparcspkr.o
 obj-$(CONFIG_INPUT_TWL4030_PWRBUTTON)   += twl4030-pwrbutton.o
 obj-$(CONFIG_INPUT_TWL4030_VIBRA)       += twl4030-vibra.o
 obj-$(CONFIG_INPUT_UINPUT)              += uinput.o
-obj-$(CONFIG_INPUT_WINBOND_CIR)         += winbond-cir.o
 obj-$(CONFIG_INPUT_WISTRON_BTNS)        += wistron_btns.o
 obj-$(CONFIG_INPUT_WM831X_ON)           += wm831x-on.o
+obj-$(CONFIG_INPUT_XEN_KBDDEV_FRONTEND) += xen-kbdfront.o
 obj-$(CONFIG_INPUT_YEALINK)             += yealink.o
 
diff --git a/drivers/input/misc/ab8500-ponkey.c b/drivers/input/misc/ab8500-ponkey.c
new file mode 100644
index 000000000000..3d3288a78fdc
--- /dev/null
+++ b/drivers/input/misc/ab8500-ponkey.c
@@ -0,0 +1,157 @@
+/*
+ * Copyright (C) ST-Ericsson SA 2010
+ *
+ * License Terms: GNU General Public License v2
+ * Author: Sundar Iyer <sundar.iyer@stericsson.com> for ST-Ericsson
+ *
+ * AB8500 Power-On Key handler
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/input.h>
+#include <linux/interrupt.h>
+#include <linux/mfd/ab8500.h>
+#include <linux/slab.h>
+
+/**
+ * struct ab8500_ponkey - ab8500 ponkey information
+ * @input_dev: pointer to input device
+ * @ab8500: ab8500 parent
+ * @irq_dbf: irq number for falling transition
+ * @irq_dbr: irq number for rising transition
+ */
+struct ab8500_ponkey {
+        struct input_dev        *idev;
+        struct ab8500           *ab8500;
+        int                     irq_dbf;
+        int                     irq_dbr;
+};
+
+/* AB8500 gives us an interrupt when ONKEY is held */
+static irqreturn_t ab8500_ponkey_handler(int irq, void *data)
+{
+        struct ab8500_ponkey *ponkey = data;
+
+        if (irq == ponkey->irq_dbf)
+                input_report_key(ponkey->idev, KEY_POWER, true);
+        else if (irq == ponkey->irq_dbr)
+                input_report_key(ponkey->idev, KEY_POWER, false);
+
+        input_sync(ponkey->idev);
+
+        return IRQ_HANDLED;
+}
+
+static int __devinit ab8500_ponkey_probe(struct platform_device *pdev)
+{
+        struct ab8500 *ab8500 = dev_get_drvdata(pdev->dev.parent);
+        struct ab8500_ponkey *ponkey;
+        struct input_dev *input;
+        int irq_dbf, irq_dbr;
+        int error;
+
+        irq_dbf = platform_get_irq_byname(pdev, "ONKEY_DBF");
+        if (irq_dbf < 0) {
+                dev_err(&pdev->dev, "No IRQ for ONKEY_DBF, error=%d\n", irq_dbf);
+                return irq_dbf;
+        }
+
+        irq_dbr = platform_get_irq_byname(pdev, "ONKEY_DBR");
+        if (irq_dbr < 0) {
+                dev_err(&pdev->dev, "No IRQ for ONKEY_DBR, error=%d\n", irq_dbr);
+                return irq_dbr;
+        }
+
+        ponkey = kzalloc(sizeof(struct ab8500_ponkey), GFP_KERNEL);
+        input = input_allocate_device();
+        if (!ponkey || !input) {
+                error = -ENOMEM;
+                goto err_free_mem;
+        }
+
+        ponkey->idev = input;
+        ponkey->ab8500 = ab8500;
+        ponkey->irq_dbf = irq_dbf;
+        ponkey->irq_dbr = irq_dbr;
+
+        input->name = "AB8500 POn(PowerOn) Key";
+        input->dev.parent = &pdev->dev;
+
+        input_set_capability(input, EV_KEY, KEY_POWER);
+
+        error = request_any_context_irq(ponkey->irq_dbf, ab8500_ponkey_handler,
+                                        0, "ab8500-ponkey-dbf", ponkey);
+        if (error < 0) {
+                dev_err(ab8500->dev, "Failed to request dbf IRQ#%d: %d\n",
+                        ponkey->irq_dbf, error);
+                goto err_free_mem;
+        }
+
+        error = request_any_context_irq(ponkey->irq_dbr, ab8500_ponkey_handler,
+                                        0, "ab8500-ponkey-dbr", ponkey);
+        if (error < 0) {
+                dev_err(ab8500->dev, "Failed to request dbr IRQ#%d: %d\n",
+                        ponkey->irq_dbr, error);
+                goto err_free_dbf_irq;
+        }
+
+        error = input_register_device(ponkey->idev);
+        if (error) {
+                dev_err(ab8500->dev, "Can't register input device: %d\n", error);
+                goto err_free_dbr_irq;
+        }
+
+        platform_set_drvdata(pdev, ponkey);
+        return 0;
+
+err_free_dbr_irq:
+        free_irq(ponkey->irq_dbr, ponkey);
+err_free_dbf_irq:
+        free_irq(ponkey->irq_dbf, ponkey);
+err_free_mem:
+        input_free_device(input);
+        kfree(ponkey);
+
+        return error;
+}
+
+static int __devexit ab8500_ponkey_remove(struct platform_device *pdev)
+{
+        struct ab8500_ponkey *ponkey = platform_get_drvdata(pdev);
+
+        free_irq(ponkey->irq_dbf, ponkey);
+        free_irq(ponkey->irq_dbr, ponkey);
+        input_unregister_device(ponkey->idev);
+        kfree(ponkey);
+
+        platform_set_drvdata(pdev, NULL);
+
+        return 0;
+}
+
+static struct platform_driver ab8500_ponkey_driver = {
+        .driver         = {
+                .name   = "ab8500-poweron-key",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = ab8500_ponkey_probe,
+        .remove         = __devexit_p(ab8500_ponkey_remove),
+};
+
+static int __init ab8500_ponkey_init(void)
+{
+        return platform_driver_register(&ab8500_ponkey_driver);
+}
+module_init(ab8500_ponkey_init);
+
+static void __exit ab8500_ponkey_exit(void)
+{
+        platform_driver_unregister(&ab8500_ponkey_driver);
+}
+module_exit(ab8500_ponkey_exit);
+
+MODULE_LICENSE("GPL v2");
+MODULE_AUTHOR("Sundar Iyer <sundar.iyer@stericsson.com>");
+MODULE_DESCRIPTION("ST-Ericsson AB8500 Power-ON(Pon) Key driver");
diff --git a/drivers/input/misc/ad714x-i2c.c b/drivers/input/misc/ad714x-i2c.c
index 2bef8fa56c94..e21deb1baa8a 100644
--- a/drivers/input/misc/ad714x-i2c.c
+++ b/drivers/input/misc/ad714x-i2c.c
@@ -10,23 +10,23 @@
 #include <linux/i2c.h>
 #include <linux/module.h>
 #include <linux/types.h>
+#include <linux/pm.h>
 #include "ad714x.h"
 
 #ifdef CONFIG_PM
-static int ad714x_i2c_suspend(struct i2c_client *client, pm_message_t message)
+static int ad714x_i2c_suspend(struct device *dev)
 {
-        return ad714x_disable(i2c_get_clientdata(client));
+        return ad714x_disable(i2c_get_clientdata(to_i2c_client(dev)));
 }
 
-static int ad714x_i2c_resume(struct i2c_client *client)
+static int ad714x_i2c_resume(struct device *dev)
 {
-        return ad714x_enable(i2c_get_clientdata(client));
+        return ad714x_enable(i2c_get_clientdata(to_i2c_client(dev)));
 }
-#else
-# define ad714x_i2c_suspend NULL
-# define ad714x_i2c_resume  NULL
 #endif
 
+static SIMPLE_DEV_PM_OPS(ad714x_i2c_pm, ad714x_i2c_suspend, ad714x_i2c_resume);
+
 static int ad714x_i2c_write(struct device *dev, unsigned short reg,
                                 unsigned short data)
 {
@@ -114,11 +114,10 @@ MODULE_DEVICE_TABLE(i2c, ad714x_id);
 static struct i2c_driver ad714x_i2c_driver = {
         .driver = {
                 .name = "ad714x_captouch",
+                .pm   = &ad714x_i2c_pm,
         },
         .probe    = ad714x_i2c_probe,
         .remove   = __devexit_p(ad714x_i2c_remove),
-        .suspend  = ad714x_i2c_suspend,
-        .resume   = ad714x_i2c_resume,
         .id_table = ad714x_id,
 };
 
diff --git a/drivers/input/misc/ad714x-spi.c b/drivers/input/misc/ad714x-spi.c
index 7f8dedfd1bfe..4120dd549305 100644
--- a/drivers/input/misc/ad714x-spi.c
+++ b/drivers/input/misc/ad714x-spi.c
@@ -9,6 +9,7 @@
 #include <linux/input.h>        /* BUS_I2C */
 #include <linux/module.h>
 #include <linux/spi/spi.h>
+#include <linux/pm.h>
 #include <linux/types.h>
 #include "ad714x.h"
 
@@ -16,20 +17,19 @@
 #define AD714x_SPI_READ            BIT(10)
 
 #ifdef CONFIG_PM
-static int ad714x_spi_suspend(struct spi_device *spi, pm_message_t message)
+static int ad714x_spi_suspend(struct device *dev)
 {
-        return ad714x_disable(spi_get_drvdata(spi));
+        return ad714x_disable(spi_get_drvdata(to_spi_device(dev)));
 }
 
-static int ad714x_spi_resume(struct spi_device *spi)
+static int ad714x_spi_resume(struct device *dev)
 {
-        return ad714x_enable(spi_get_drvdata(spi));
+        return ad714x_enable(spi_get_drvdata(to_spi_device(dev)));
 }
-#else
-# define ad714x_spi_suspend NULL
-# define ad714x_spi_resume  NULL
 #endif
 
+static SIMPLE_DEV_PM_OPS(ad714x_spi_pm, ad714x_spi_suspend, ad714x_spi_resume);
+
 static int ad714x_spi_read(struct device *dev, unsigned short reg,
                 unsigned short *data)
 {
@@ -79,11 +79,10 @@ static struct spi_driver ad714x_spi_driver = {
         .driver = {
                 .name   = "ad714x_captouch",
                 .owner  = THIS_MODULE,
+                .pm     = &ad714x_spi_pm,
         },
         .probe          = ad714x_spi_probe,
         .remove         = __devexit_p(ad714x_spi_remove),
-        .suspend        = ad714x_spi_suspend,
-        .resume         = ad714x_spi_resume,
 };
 
 static __init int ad714x_spi_init(void)
diff --git a/drivers/input/misc/ad714x.c b/drivers/input/misc/ad714x.c
index c431d09e401a..c3a62c42cd28 100644
--- a/drivers/input/misc/ad714x.c
+++ b/drivers/input/misc/ad714x.c
@@ -79,13 +79,7 @@ struct ad714x_slider_drv {
 struct ad714x_wheel_drv {
         int abs_pos;
         int flt_pos;
-        int pre_mean_value;
         int pre_highest_stage;
-        int pre_mean_value_no_offset;
-        int mean_value;
-        int mean_value_no_offset;
-        int pos_offset;
-        int pos_ratio;
         int highest_stage;
         enum ad714x_device_state state;
         struct input_dev *input;
@@ -158,10 +152,10 @@ static void ad714x_use_com_int(struct ad714x_chip *ad714x,
         unsigned short data;
         unsigned short mask;
 
-        mask = ((1 << (end_stage + 1)) - 1) - (1 << start_stage);
+        mask = ((1 << (end_stage + 1)) - 1) - ((1 << start_stage) - 1);
 
         ad714x->read(ad714x->dev, STG_COM_INT_EN_REG, &data);
-        data |= 1 << start_stage;
+        data |= 1 << end_stage;
         ad714x->write(ad714x->dev, STG_COM_INT_EN_REG, data);
 
         ad714x->read(ad714x->dev, STG_HIGH_INT_EN_REG, &data);
@@ -175,10 +169,10 @@ static void ad714x_use_thr_int(struct ad714x_chip *ad714x,
         unsigned short data;
         unsigned short mask;
 
-        mask = ((1 << (end_stage + 1)) - 1) - (1 << start_stage);
+        mask = ((1 << (end_stage + 1)) - 1) - ((1 << start_stage) - 1);
 
         ad714x->read(ad714x->dev, STG_COM_INT_EN_REG, &data);
-        data &= ~(1 << start_stage);
+        data &= ~(1 << end_stage);
         ad714x->write(ad714x->dev, STG_COM_INT_EN_REG, data);
 
         ad714x->read(ad714x->dev, STG_HIGH_INT_EN_REG, &data);
@@ -404,7 +398,6 @@ static void ad714x_slider_state_machine(struct ad714x_chip *ad714x, int idx)
                                 ad714x_slider_cal_highest_stage(ad714x, idx);
                                 ad714x_slider_cal_abs_pos(ad714x, idx);
                                 ad714x_slider_cal_flt_pos(ad714x, idx);
-
                                 input_report_abs(sw->input, ABS_X, sw->flt_pos);
                                 input_report_key(sw->input, BTN_TOUCH, 1);
                         } else {
@@ -468,104 +461,41 @@ static void ad714x_wheel_cal_sensor_val(struct ad714x_chip *ad714x, int idx)
 /*
  * When the scroll wheel is activated, we compute the absolute position based
  * on the sensor values. To calculate the position, we first determine the
- * sensor that has the greatest response among the 8 sensors that constitutes
- * the scrollwheel. Then we determined the 2 sensors on either sides of the
+ * sensor that has the greatest response among the sensors that constitutes
+ * the scrollwheel. Then we determined the sensors on either sides of the
  * sensor with the highest response and we apply weights to these sensors. The
- * result of this computation gives us the mean value which defined by the
- * following formula:
- * For i= second_before_highest_stage to i= second_after_highest_stage
- *         v += Sensor response(i)*WEIGHT*(i+3)
- *         w += Sensor response(i)
- * Mean_Value=v/w
- * pos_on_scrollwheel = (Mean_Value - position_offset) / position_ratio
+ * result of this computation gives us the mean value.
  */
 
-#define WEIGHT_FACTOR 30
-/* This constant prevents the "PositionOffset" from reaching a big value */
-#define OFFSET_POSITION_CLAMP   120
 static void ad714x_wheel_cal_abs_pos(struct ad714x_chip *ad714x, int idx)
 {
         struct ad714x_wheel_plat *hw = &ad714x->hw->wheel[idx];
         struct ad714x_wheel_drv *sw = &ad714x->sw->wheel[idx];
         int stage_num = hw->end_stage - hw->start_stage + 1;
-        int second_before, first_before, highest, first_after, second_after;
+        int first_before, highest, first_after;
         int a_param, b_param;
 
-        /* Calculate Mean value */
-
-        second_before = (sw->highest_stage + stage_num - 2) % stage_num;
         first_before = (sw->highest_stage + stage_num - 1) % stage_num;
         highest = sw->highest_stage;
         first_after = (sw->highest_stage + stage_num + 1) % stage_num;
-        second_after = (sw->highest_stage + stage_num + 2) % stage_num;
-
-        if (((sw->highest_stage - hw->start_stage) > 1) &&
-            ((hw->end_stage - sw->highest_stage) > 1)) {
-                a_param = ad714x->sensor_val[second_before] *
-                        (second_before - hw->start_stage + 3) +
-                        ad714x->sensor_val[first_before] *
-                        (second_before - hw->start_stage + 3) +
-                        ad714x->sensor_val[highest] *
-                        (second_before - hw->start_stage + 3) +
-                        ad714x->sensor_val[first_after] *
-                        (first_after - hw->start_stage + 3) +
-                        ad714x->sensor_val[second_after] *
-                        (second_after - hw->start_stage + 3);
-        } else {
-                a_param = ad714x->sensor_val[second_before] *
-                        (second_before - hw->start_stage + 1) +
-                        ad714x->sensor_val[first_before] *
-                        (second_before - hw->start_stage + 2) +
-                        ad714x->sensor_val[highest] *
-                        (second_before - hw->start_stage + 3) +
-                        ad714x->sensor_val[first_after] *
-                        (first_after - hw->start_stage + 4) +
-                        ad714x->sensor_val[second_after] *
-                        (second_after - hw->start_stage + 5);
-        }
-        a_param *= WEIGHT_FACTOR;
 
-        b_param = ad714x->sensor_val[second_before] +
+        a_param = ad714x->sensor_val[highest] *
+                (highest - hw->start_stage) +
+                ad714x->sensor_val[first_before] *
+                (highest - hw->start_stage - 1) +
+                ad714x->sensor_val[first_after] *
+                (highest - hw->start_stage + 1);
+        b_param = ad714x->sensor_val[highest] +
                 ad714x->sensor_val[first_before] +
-                ad714x->sensor_val[highest] +
-                ad714x->sensor_val[first_after] +
-                ad714x->sensor_val[second_after];
-
-        sw->pre_mean_value = sw->mean_value;
-        sw->mean_value = a_param / b_param;
-
-        /* Calculate the offset */
-
-        if ((sw->pre_highest_stage == hw->end_stage) &&
-                        (sw->highest_stage == hw->start_stage))
-                sw->pos_offset = sw->mean_value;
-        else if ((sw->pre_highest_stage == hw->start_stage) &&
-                        (sw->highest_stage == hw->end_stage))
-                sw->pos_offset = sw->pre_mean_value;
-
-        if (sw->pos_offset > OFFSET_POSITION_CLAMP)
-                sw->pos_offset = OFFSET_POSITION_CLAMP;
-
-        /* Calculate the mean value without the offset */
-
-        sw->pre_mean_value_no_offset = sw->mean_value_no_offset;
-        sw->mean_value_no_offset = sw->mean_value - sw->pos_offset;
-        if (sw->mean_value_no_offset < 0)
-                sw->mean_value_no_offset = 0;
-
-        /* Calculate ratio to scale down to NUMBER_OF_WANTED_POSITIONS */
-
-        if ((sw->pre_highest_stage == hw->end_stage) &&
-                        (sw->highest_stage == hw->start_stage))
-                sw->pos_ratio = (sw->pre_mean_value_no_offset * 100) /
-                        hw->max_coord;
-        else if ((sw->pre_highest_stage == hw->start_stage) &&
-                        (sw->highest_stage == hw->end_stage))
-                sw->pos_ratio = (sw->mean_value_no_offset * 100) /
-                        hw->max_coord;
-        sw->abs_pos = (sw->mean_value_no_offset * 100) / sw->pos_ratio;
+                ad714x->sensor_val[first_after];
+
+        sw->abs_pos = ((hw->max_coord / (hw->end_stage - hw->start_stage)) *
+                        a_param) / b_param;
+
         if (sw->abs_pos > hw->max_coord)
                 sw->abs_pos = hw->max_coord;
+        else if (sw->abs_pos < 0)
+                sw->abs_pos = 0;
 }
 
 static void ad714x_wheel_cal_flt_pos(struct ad714x_chip *ad714x, int idx)
@@ -639,9 +569,8 @@ static void ad714x_wheel_state_machine(struct ad714x_chip *ad714x, int idx)
                                 ad714x_wheel_cal_highest_stage(ad714x, idx);
                                 ad714x_wheel_cal_abs_pos(ad714x, idx);
                                 ad714x_wheel_cal_flt_pos(ad714x, idx);
-
                                 input_report_abs(sw->input, ABS_WHEEL,
-                                        sw->abs_pos);
+                                        sw->flt_pos);
                                 input_report_key(sw->input, BTN_TOUCH, 1);
                         } else {
                                 /* When the user lifts off the sensor, configure
@@ -1149,6 +1078,8 @@ struct ad714x_chip *ad714x_probe(struct device *dev, u16 bus_type, int irq,
                         input[alloc_idx]->id.bustype = bus_type;
                         input[alloc_idx]->id.product = ad714x->product;
                         input[alloc_idx]->id.version = ad714x->version;
+                        input[alloc_idx]->name = "ad714x_captouch_slider";
+                        input[alloc_idx]->dev.parent = dev;
 
                         error = input_register_device(input[alloc_idx]);
                         if (error)
@@ -1179,6 +1110,8 @@ struct ad714x_chip *ad714x_probe(struct device *dev, u16 bus_type, int irq,
                         input[alloc_idx]->id.bustype = bus_type;
                         input[alloc_idx]->id.product = ad714x->product;
                         input[alloc_idx]->id.version = ad714x->version;
+                        input[alloc_idx]->name = "ad714x_captouch_wheel";
+                        input[alloc_idx]->dev.parent = dev;
 
                         error = input_register_device(input[alloc_idx]);
                         if (error)
@@ -1212,6 +1145,8 @@ struct ad714x_chip *ad714x_probe(struct device *dev, u16 bus_type, int irq,
                         input[alloc_idx]->id.bustype = bus_type;
                         input[alloc_idx]->id.product = ad714x->product;
                         input[alloc_idx]->id.version = ad714x->version;
+                        input[alloc_idx]->name = "ad714x_captouch_pad";
+                        input[alloc_idx]->dev.parent = dev;
 
                         error = input_register_device(input[alloc_idx]);
                         if (error)
@@ -1240,6 +1175,8 @@ struct ad714x_chip *ad714x_probe(struct device *dev, u16 bus_type, int irq,
                 input[alloc_idx]->id.bustype = bus_type;
                 input[alloc_idx]->id.product = ad714x->product;
                 input[alloc_idx]->id.version = ad714x->version;
+                input[alloc_idx]->name = "ad714x_captouch_button";
+                input[alloc_idx]->dev.parent = dev;
 
                 error = input_register_device(input[alloc_idx]);
                 if (error)
@@ -1249,7 +1186,9 @@ struct ad714x_chip *ad714x_probe(struct device *dev, u16 bus_type, int irq,
         }
 
         error = request_threaded_irq(ad714x->irq, NULL, ad714x_interrupt_thread,
-                        IRQF_TRIGGER_FALLING, "ad714x_captouch", ad714x);
+                                plat_data->irqflags ?
+                                        plat_data->irqflags : IRQF_TRIGGER_FALLING,
+                                "ad714x_captouch", ad714x);
         if (error) {
                 dev_err(dev, "can't allocate irq %d\n", ad714x->irq);
                 goto err_unreg_dev;
diff --git a/drivers/input/misc/adxl34x-i2c.c b/drivers/input/misc/adxl34x-i2c.c
index 0779724af7e7..ccacf2bb06a4 100644
--- a/drivers/input/misc/adxl34x-i2c.c
+++ b/drivers/input/misc/adxl34x-i2c.c
@@ -11,6 +11,7 @@
 #include <linux/i2c.h>
 #include <linux/module.h>
 #include <linux/types.h>
+#include <linux/pm.h>
 #include "adxl34x.h"
 
 static int adxl34x_smbus_read(struct device *dev, unsigned char reg)
@@ -105,8 +106,9 @@ static int __devexit adxl34x_i2c_remove(struct i2c_client *client)
 }
 
 #ifdef CONFIG_PM
-static int adxl34x_i2c_suspend(struct i2c_client *client, pm_message_t message)
+static int adxl34x_i2c_suspend(struct device *dev)
 {
+        struct i2c_client *client = to_i2c_client(dev);
         struct adxl34x *ac = i2c_get_clientdata(client);
 
         adxl34x_suspend(ac);
@@ -114,19 +116,20 @@ static int adxl34x_i2c_suspend(struct i2c_client *client, pm_message_t message)
         return 0;
 }
 
-static int adxl34x_i2c_resume(struct i2c_client *client)
+static int adxl34x_i2c_resume(struct device *dev)
 {
+        struct i2c_client *client = to_i2c_client(dev);
         struct adxl34x *ac = i2c_get_clientdata(client);
 
         adxl34x_resume(ac);
 
         return 0;
 }
-#else
-# define adxl34x_i2c_suspend NULL
-# define adxl34x_i2c_resume  NULL
 #endif
 
+static SIMPLE_DEV_PM_OPS(adxl34x_i2c_pm, adxl34x_i2c_suspend,
+                         adxl34x_i2c_resume);
+
 static const struct i2c_device_id adxl34x_id[] = {
         { "adxl34x", 0 },
         { }
@@ -138,11 +141,10 @@ static struct i2c_driver adxl34x_driver = {
         .driver = {
                 .name = "adxl34x",
                 .owner = THIS_MODULE,
+                .pm = &adxl34x_i2c_pm,
         },
         .probe    = adxl34x_i2c_probe,
         .remove   = __devexit_p(adxl34x_i2c_remove),
-        .suspend  = adxl34x_i2c_suspend,
-        .resume   = adxl34x_i2c_resume,
         .id_table = adxl34x_id,
 };
 
diff --git a/drivers/input/misc/adxl34x-spi.c b/drivers/input/misc/adxl34x-spi.c
index 782de9e89828..f29de22fdda0 100644
--- a/drivers/input/misc/adxl34x-spi.c
+++ b/drivers/input/misc/adxl34x-spi.c
@@ -10,6 +10,7 @@
 #include <linux/input.h>        /* BUS_SPI */
 #include <linux/module.h>
 #include <linux/spi/spi.h>
+#include <linux/pm.h>
 #include <linux/types.h>
 #include "adxl34x.h"
 
@@ -57,7 +58,7 @@ static int adxl34x_spi_read_block(struct device *dev,
         return (status < 0) ? status : 0;
 }
 
-static const struct adxl34x_bus_ops adx134x_spi_bops = {
+static const struct adxl34x_bus_ops adxl34x_spi_bops = {
         .bustype        = BUS_SPI,
         .write          = adxl34x_spi_write,
         .read           = adxl34x_spi_read,
@@ -76,7 +77,7 @@ static int __devinit adxl34x_spi_probe(struct spi_device *spi)
 
         ac = adxl34x_probe(&spi->dev, spi->irq,
                            spi->max_speed_hz > MAX_FREQ_NO_FIFODELAY,
-                           &adx134x_spi_bops);
+                           &adxl34x_spi_bops);
 
         if (IS_ERR(ac))
                 return PTR_ERR(ac);
@@ -94,8 +95,9 @@ static int __devexit adxl34x_spi_remove(struct spi_device *spi)
 }
 
 #ifdef CONFIG_PM
-static int adxl34x_spi_suspend(struct spi_device *spi, pm_message_t message)
+static int adxl34x_spi_suspend(struct device *dev)
 {
+        struct spi_device *spi = to_spi_device(dev);
         struct adxl34x *ac = dev_get_drvdata(&spi->dev);
 
         adxl34x_suspend(ac);
@@ -103,29 +105,29 @@ static int adxl34x_spi_suspend(struct spi_device *spi, pm_message_t message)
         return 0;
 }
 
-static int adxl34x_spi_resume(struct spi_device *spi)
+static int adxl34x_spi_resume(struct device *dev)
 {
+        struct spi_device *spi = to_spi_device(dev);
         struct adxl34x *ac = dev_get_drvdata(&spi->dev);
 
         adxl34x_resume(ac);
 
         return 0;
 }
-#else
-# define adxl34x_spi_suspend NULL
-# define adxl34x_spi_resume  NULL
 #endif
 
+static SIMPLE_DEV_PM_OPS(adxl34x_spi_pm, adxl34x_spi_suspend,
+                         adxl34x_spi_resume);
+
 static struct spi_driver adxl34x_driver = {
         .driver = {
                 .name = "adxl34x",
                 .bus = &spi_bus_type,
                 .owner = THIS_MODULE,
+                .pm = &adxl34x_spi_pm,
         },
         .probe   = adxl34x_spi_probe,
         .remove  = __devexit_p(adxl34x_spi_remove),
-        .suspend = adxl34x_spi_suspend,
-        .resume  = adxl34x_spi_resume,
 };
 
 static int __init adxl34x_spi_init(void)
diff --git a/drivers/input/misc/adxl34x.c b/drivers/input/misc/adxl34x.c
index de5900d50788..144ddbdeb9b3 100644
--- a/drivers/input/misc/adxl34x.c
+++ b/drivers/input/misc/adxl34x.c
@@ -716,7 +716,7 @@ struct adxl34x *adxl34x_probe(struct device *dev, int irq,
         pdata = dev->platform_data;
         if (!pdata) {
                 dev_dbg(dev,
-                        "No platfrom data: Using default initialization\n");
+                        "No platform data: Using default initialization\n");
                 pdata = &adxl34x_default_init;
         }
 
diff --git a/drivers/input/misc/ati_remote2.c b/drivers/input/misc/ati_remote2.c
index 23257652b8e8..1de58e8a1b71 100644
--- a/drivers/input/misc/ati_remote2.c
+++ b/drivers/input/misc/ati_remote2.c
@@ -483,51 +483,88 @@ static void ati_remote2_complete_key(struct urb *urb)
 }
 
 static int ati_remote2_getkeycode(struct input_dev *idev,
-                                  unsigned int scancode, unsigned int *keycode)
+                                  struct input_keymap_entry *ke)
 {
         struct ati_remote2 *ar2 = input_get_drvdata(idev);
         unsigned int mode;
-        int index;
-
-        mode = scancode >> 8;
-        if (mode > ATI_REMOTE2_PC || !((1 << mode) & ar2->mode_mask))
-                return -EINVAL;
+        int offset;
+        unsigned int index;
+        unsigned int scancode;
+
+        if (ke->flags & INPUT_KEYMAP_BY_INDEX) {
+                index = ke->index;
+                if (index >= ATI_REMOTE2_MODES *
+                                ARRAY_SIZE(ati_remote2_key_table))
+                        return -EINVAL;
+
+                mode = ke->index / ARRAY_SIZE(ati_remote2_key_table);
+                offset = ke->index % ARRAY_SIZE(ati_remote2_key_table);
+                scancode = (mode << 8) + ati_remote2_key_table[offset].hw_code;
+        } else {
+                if (input_scancode_to_scalar(ke, &scancode))
+                        return -EINVAL;
+
+                mode = scancode >> 8;
+                if (mode > ATI_REMOTE2_PC)
+                        return -EINVAL;
+
+                offset = ati_remote2_lookup(scancode & 0xff);
+                if (offset < 0)
+                        return -EINVAL;
+
+                index = mode * ARRAY_SIZE(ati_remote2_key_table) + offset;
+        }
 
-        index = ati_remote2_lookup(scancode & 0xFF);
-        if (index < 0)
-                return -EINVAL;
+        ke->keycode = ar2->keycode[mode][offset];
+        ke->len = sizeof(scancode);
+        memcpy(&ke->scancode, &scancode, sizeof(scancode));
+        ke->index = index;
 
-        *keycode = ar2->keycode[mode][index];
         return 0;
 }
 
 static int ati_remote2_setkeycode(struct input_dev *idev,
-                                  unsigned int scancode, unsigned int keycode)
+                                  const struct input_keymap_entry *ke,
+                                  unsigned int *old_keycode)
 {
         struct ati_remote2 *ar2 = input_get_drvdata(idev);
-        unsigned int mode, old_keycode;
-        int index;
-
-        mode = scancode >> 8;
-        if (mode > ATI_REMOTE2_PC || !((1 << mode) & ar2->mode_mask))
-                return -EINVAL;
-
-        index = ati_remote2_lookup(scancode & 0xFF);
-        if (index < 0)
-                return -EINVAL;
+        unsigned int mode;
+        int offset;
+        unsigned int index;
+        unsigned int scancode;
+
+        if (ke->flags & INPUT_KEYMAP_BY_INDEX) {
+                if (ke->index >= ATI_REMOTE2_MODES *
+                                ARRAY_SIZE(ati_remote2_key_table))
+                        return -EINVAL;
+
+                mode = ke->index / ARRAY_SIZE(ati_remote2_key_table);
+                offset = ke->index % ARRAY_SIZE(ati_remote2_key_table);
+        } else {
+                if (input_scancode_to_scalar(ke, &scancode))
+                        return -EINVAL;
+
+                mode = scancode >> 8;
+                if (mode > ATI_REMOTE2_PC)
+                        return -EINVAL;
+
+                offset = ati_remote2_lookup(scancode & 0xff);
+                if (offset < 0)
+                        return -EINVAL;
+        }
 
-        old_keycode = ar2->keycode[mode][index];
-        ar2->keycode[mode][index] = keycode;
-        __set_bit(keycode, idev->keybit);
+        *old_keycode = ar2->keycode[mode][offset];
+        ar2->keycode[mode][offset] = ke->keycode;
+        __set_bit(ke->keycode, idev->keybit);
 
         for (mode = 0; mode < ATI_REMOTE2_MODES; mode++) {
                 for (index = 0; index < ARRAY_SIZE(ati_remote2_key_table); index++) {
-                        if (ar2->keycode[mode][index] == old_keycode)
+                        if (ar2->keycode[mode][index] == *old_keycode)
                                 return 0;
                 }
         }
 
-        __clear_bit(old_keycode, idev->keybit);
+        __clear_bit(*old_keycode, idev->keybit);
 
         return 0;
 }
@@ -700,14 +737,17 @@ static ssize_t ati_remote2_store_channel_mask(struct device *dev,
 
         mutex_lock(&ati_remote2_mutex);
 
-        if (mask != ar2->channel_mask && !ati_remote2_setup(ar2, mask))
-                ar2->channel_mask = mask;
+        if (mask != ar2->channel_mask) {
+                r = ati_remote2_setup(ar2, mask);
+                if (!r)
+                        ar2->channel_mask = mask;
+        }
 
         mutex_unlock(&ati_remote2_mutex);
 
         usb_autopm_put_interface(ar2->intf[0]);
 
-        return count;
+        return r ? r : count;
 }
 
 static ssize_t ati_remote2_show_mode_mask(struct device *dev,
diff --git a/drivers/input/misc/cm109.c b/drivers/input/misc/cm109.c
index 2b0eba6619bd..b09c7d127219 100644
--- a/drivers/input/misc/cm109.c
+++ b/drivers/input/misc/cm109.c
@@ -259,7 +259,7 @@ static unsigned short keymap_usbph01(int scancode)
 
 /*
  * Keymap for ATCom AU-100
- * http://www.atcom.cn/En_products_AU100.html
+ * http://www.atcom.cn/products.html 
  * http://www.packetizer.com/products/au100/
  * http://www.voip-info.org/wiki/view/AU-100
  *
diff --git a/drivers/input/misc/cma3000_d0x.c b/drivers/input/misc/cma3000_d0x.c
new file mode 100644
index 000000000000..1633b6342267
--- /dev/null
+++ b/drivers/input/misc/cma3000_d0x.c
@@ -0,0 +1,398 @@
+/*
+ * VTI CMA3000_D0x Accelerometer driver
+ *
+ * Copyright (C) 2010 Texas Instruments
+ * Author: Hemanth V <hemanthv@ti.com>
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <linux/types.h>
+#include <linux/interrupt.h>
+#include <linux/delay.h>
+#include <linux/slab.h>
+#include <linux/input.h>
+#include <linux/input/cma3000.h>
+
+#include "cma3000_d0x.h"
+
+#define CMA3000_WHOAMI      0x00
+#define CMA3000_REVID       0x01
+#define CMA3000_CTRL        0x02
+#define CMA3000_STATUS      0x03
+#define CMA3000_RSTR        0x04
+#define CMA3000_INTSTATUS   0x05
+#define CMA3000_DOUTX       0x06
+#define CMA3000_DOUTY       0x07
+#define CMA3000_DOUTZ       0x08
+#define CMA3000_MDTHR       0x09
+#define CMA3000_MDFFTMR     0x0A
+#define CMA3000_FFTHR       0x0B
+
+#define CMA3000_RANGE2G    (1 << 7)
+#define CMA3000_RANGE8G    (0 << 7)
+#define CMA3000_BUSI2C     (0 << 4)
+#define CMA3000_MODEMASK   (7 << 1)
+#define CMA3000_GRANGEMASK (1 << 7)
+
+#define CMA3000_STATUS_PERR    1
+#define CMA3000_INTSTATUS_FFDET (1 << 2)
+
+/* Settling time delay in ms */
+#define CMA3000_SETDELAY    30
+
+/* Delay for clearing interrupt in us */
+#define CMA3000_INTDELAY    44
+
+
+/*
+ * Bit weights in mg for bit 0, other bits need
+ * multipy factor 2^n. Eight bit is the sign bit.
+ */
+#define BIT_TO_2G  18
+#define BIT_TO_8G  71
+
+struct cma3000_accl_data {
+        const struct cma3000_bus_ops *bus_ops;
+        const struct cma3000_platform_data *pdata;
+
+        struct device *dev;
+        struct input_dev *input_dev;
+
+        int bit_to_mg;
+        int irq;
+
+        int g_range;
+        u8 mode;
+
+        struct mutex mutex;
+        bool opened;
+        bool suspended;
+};
+
+#define CMA3000_READ(data, reg, msg) \
+        (data->bus_ops->read(data->dev, reg, msg))
+#define CMA3000_SET(data, reg, val, msg) \
+        ((data)->bus_ops->write(data->dev, reg, val, msg))
+
+/*
+ * Conversion for each of the eight modes to g, depending
+ * on G range i.e 2G or 8G. Some modes always operate in
+ * 8G.
+ */
+
+static int mode_to_mg[8][2] = {
+        { 0, 0 },
+        { BIT_TO_8G, BIT_TO_2G },
+        { BIT_TO_8G, BIT_TO_2G },
+        { BIT_TO_8G, BIT_TO_8G },
+        { BIT_TO_8G, BIT_TO_8G },
+        { BIT_TO_8G, BIT_TO_2G },
+        { BIT_TO_8G, BIT_TO_2G },
+        { 0, 0},
+};
+
+static void decode_mg(struct cma3000_accl_data *data, int *datax,
+                                int *datay, int *dataz)
+{
+        /* Data in 2's complement, convert to mg */
+        *datax = ((s8)*datax) * data->bit_to_mg;
+        *datay = ((s8)*datay) * data->bit_to_mg;
+        *dataz = ((s8)*dataz) * data->bit_to_mg;
+}
+
+static irqreturn_t cma3000_thread_irq(int irq, void *dev_id)
+{
+        struct cma3000_accl_data *data = dev_id;
+        int datax, datay, dataz;
+        u8 ctrl, mode, range, intr_status;
+
+        intr_status = CMA3000_READ(data, CMA3000_INTSTATUS, "interrupt status");
+        if (intr_status < 0)
+                return IRQ_NONE;
+
+        /* Check if free fall is detected, report immediately */
+        if (intr_status & CMA3000_INTSTATUS_FFDET) {
+                input_report_abs(data->input_dev, ABS_MISC, 1);
+                input_sync(data->input_dev);
+        } else {
+                input_report_abs(data->input_dev, ABS_MISC, 0);
+        }
+
+        datax = CMA3000_READ(data, CMA3000_DOUTX, "X");
+        datay = CMA3000_READ(data, CMA3000_DOUTY, "Y");
+        dataz = CMA3000_READ(data, CMA3000_DOUTZ, "Z");
+
+        ctrl = CMA3000_READ(data, CMA3000_CTRL, "ctrl");
+        mode = (ctrl & CMA3000_MODEMASK) >> 1;
+        range = (ctrl & CMA3000_GRANGEMASK) >> 7;
+
+        data->bit_to_mg = mode_to_mg[mode][range];
+
+        /* Interrupt not for this device */
+        if (data->bit_to_mg == 0)
+                return IRQ_NONE;
+
+        /* Decode register values to milli g */
+        decode_mg(data, &datax, &datay, &dataz);
+
+        input_report_abs(data->input_dev, ABS_X, datax);
+        input_report_abs(data->input_dev, ABS_Y, datay);
+        input_report_abs(data->input_dev, ABS_Z, dataz);
+        input_sync(data->input_dev);
+
+        return IRQ_HANDLED;
+}
+
+static int cma3000_reset(struct cma3000_accl_data *data)
+{
+        int val;
+
+        /* Reset sequence */
+        CMA3000_SET(data, CMA3000_RSTR, 0x02, "Reset");
+        CMA3000_SET(data, CMA3000_RSTR, 0x0A, "Reset");
+        CMA3000_SET(data, CMA3000_RSTR, 0x04, "Reset");
+
+        /* Settling time delay */
+        mdelay(10);
+
+        val = CMA3000_READ(data, CMA3000_STATUS, "Status");
+        if (val < 0) {
+                dev_err(data->dev, "Reset failed\n");
+                return val;
+        }
+
+        if (val & CMA3000_STATUS_PERR) {
+                dev_err(data->dev, "Parity Error\n");
+                return -EIO;
+        }
+
+        return 0;
+}
+
+static int cma3000_poweron(struct cma3000_accl_data *data)
+{
+        const struct cma3000_platform_data *pdata = data->pdata;
+        u8 ctrl = 0;
+        int ret;
+
+        if (data->g_range == CMARANGE_2G) {
+                ctrl = (data->mode << 1) | CMA3000_RANGE2G;
+        } else if (data->g_range == CMARANGE_8G) {
+                ctrl = (data->mode << 1) | CMA3000_RANGE8G;
+        } else {
+                dev_info(data->dev,
+                         "Invalid G range specified, assuming 8G\n");
+                ctrl = (data->mode << 1) | CMA3000_RANGE8G;
+        }
+
+        ctrl |= data->bus_ops->ctrl_mod;
+
+        CMA3000_SET(data, CMA3000_MDTHR, pdata->mdthr,
+                    "Motion Detect Threshold");
+        CMA3000_SET(data, CMA3000_MDFFTMR, pdata->mdfftmr,
+                    "Time register");
+        CMA3000_SET(data, CMA3000_FFTHR, pdata->ffthr,
+                    "Free fall threshold");
+        ret = CMA3000_SET(data, CMA3000_CTRL, ctrl, "Mode setting");
+        if (ret < 0)
+                return -EIO;
+
+        msleep(CMA3000_SETDELAY);
+
+        return 0;
+}
+
+static int cma3000_poweroff(struct cma3000_accl_data *data)
+{
+        int ret;
+
+        ret = CMA3000_SET(data, CMA3000_CTRL, CMAMODE_POFF, "Mode setting");
+        msleep(CMA3000_SETDELAY);
+
+        return ret;
+}
+
+static int cma3000_open(struct input_dev *input_dev)
+{
+        struct cma3000_accl_data *data = input_get_drvdata(input_dev);
+
+        mutex_lock(&data->mutex);
+
+        if (!data->suspended)
+                cma3000_poweron(data);
+
+        data->opened = true;
+
+        mutex_unlock(&data->mutex);
+
+        return 0;
+}
+
+static void cma3000_close(struct input_dev *input_dev)
+{
+        struct cma3000_accl_data *data = input_get_drvdata(input_dev);
+
+        mutex_lock(&data->mutex);
+
+        if (!data->suspended)
+                cma3000_poweroff(data);
+
+        data->opened = false;
+
+        mutex_unlock(&data->mutex);
+}
+
+void cma3000_suspend(struct cma3000_accl_data *data)
+{
+        mutex_lock(&data->mutex);
+
+        if (!data->suspended && data->opened)
+                cma3000_poweroff(data);
+
+        data->suspended = true;
+
+        mutex_unlock(&data->mutex);
+}
+EXPORT_SYMBOL(cma3000_suspend);
+
+
+void cma3000_resume(struct cma3000_accl_data *data)
+{
+        mutex_lock(&data->mutex);
+
+        if (data->suspended && data->opened)
+                cma3000_poweron(data);
+
+        data->suspended = false;
+
+        mutex_unlock(&data->mutex);
+}
+EXPORT_SYMBOL(cma3000_resume);
+
+struct cma3000_accl_data *cma3000_init(struct device *dev, int irq,
+                                       const struct cma3000_bus_ops *bops)
+{
+        const struct cma3000_platform_data *pdata = dev->platform_data;
+        struct cma3000_accl_data *data;
+        struct input_dev *input_dev;
+        int rev;
+        int error;
+
+        if (!pdata) {
+                dev_err(dev, "platform data not found\n");
+                error = -EINVAL;
+                goto err_out;
+        }
+
+
+        /* if no IRQ return error */
+        if (irq == 0) {
+                error = -EINVAL;
+                goto err_out;
+        }
+
+        data = kzalloc(sizeof(struct cma3000_accl_data), GFP_KERNEL);
+        input_dev = input_allocate_device();
+        if (!data || !input_dev) {
+                error = -ENOMEM;
+                goto err_free_mem;
+        }
+
+        data->dev = dev;
+        data->input_dev = input_dev;
+        data->bus_ops = bops;
+        data->pdata = pdata;
+        data->irq = irq;
+        mutex_init(&data->mutex);
+
+        data->mode = pdata->mode;
+        if (data->mode < CMAMODE_DEFAULT || data->mode > CMAMODE_POFF) {
+                data->mode = CMAMODE_MOTDET;
+                dev_warn(dev,
+                         "Invalid mode specified, assuming Motion Detect\n");
+        }
+
+        data->g_range = pdata->g_range;
+        if (data->g_range != CMARANGE_2G && data->g_range != CMARANGE_8G) {
+                dev_info(dev,
+                         "Invalid G range specified, assuming 8G\n");
+                data->g_range = CMARANGE_8G;
+        }
+
+        input_dev->name = "cma3000-accelerometer";
+        input_dev->id.bustype = bops->bustype;
+        input_dev->open = cma3000_open;
+        input_dev->close = cma3000_close;
+
+         __set_bit(EV_ABS, input_dev->evbit);
+
+        input_set_abs_params(input_dev, ABS_X,
+                        -data->g_range, data->g_range, pdata->fuzz_x, 0);
+        input_set_abs_params(input_dev, ABS_Y,
+                        -data->g_range, data->g_range, pdata->fuzz_y, 0);
+        input_set_abs_params(input_dev, ABS_Z,
+                        -data->g_range, data->g_range, pdata->fuzz_z, 0);
+        input_set_abs_params(input_dev, ABS_MISC, 0, 1, 0, 0);
+
+        input_set_drvdata(input_dev, data);
+
+        error = cma3000_reset(data);
+        if (error)
+                goto err_free_mem;
+
+        rev = CMA3000_READ(data, CMA3000_REVID, "Revid");
+        if (rev < 0) {
+                error = rev;
+                goto err_free_mem;
+        }
+
+        pr_info("CMA3000 Accelerometer: Revision %x\n", rev);
+
+        error = request_threaded_irq(irq, NULL, cma3000_thread_irq,
+                                     pdata->irqflags | IRQF_ONESHOT,
+                                     "cma3000_d0x", data);
+        if (error) {
+                dev_err(dev, "request_threaded_irq failed\n");
+                goto err_free_mem;
+        }
+
+        error = input_register_device(data->input_dev);
+        if (error) {
+                dev_err(dev, "Unable to register input device\n");
+                goto err_free_irq;
+        }
+
+        return data;
+
+err_free_irq:
+        free_irq(irq, data);
+err_free_mem:
+        input_free_device(input_dev);
+        kfree(data);
+err_out:
+        return ERR_PTR(error);
+}
+EXPORT_SYMBOL(cma3000_init);
+
+void cma3000_exit(struct cma3000_accl_data *data)
+{
+        free_irq(data->irq, data);
+        input_unregister_device(data->input_dev);
+        kfree(data);
+}
+EXPORT_SYMBOL(cma3000_exit);
+
+MODULE_DESCRIPTION("CMA3000-D0x Accelerometer Driver");
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Hemanth V <hemanthv@ti.com>");
diff --git a/drivers/input/misc/cma3000_d0x.h b/drivers/input/misc/cma3000_d0x.h
new file mode 100644
index 000000000000..2304ce306e1c
--- /dev/null
+++ b/drivers/input/misc/cma3000_d0x.h
@@ -0,0 +1,42 @@
+/*
+ * VTI CMA3000_D0x Accelerometer driver
+ *
+ * Copyright (C) 2010 Texas Instruments
+ * Author: Hemanth V <hemanthv@ti.com>
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _INPUT_CMA3000_H
+#define _INPUT_CMA3000_H
+
+#include <linux/types.h>
+#include <linux/input.h>
+
+struct device;
+struct cma3000_accl_data;
+
+struct cma3000_bus_ops {
+        u16 bustype;
+        u8 ctrl_mod;
+        int (*read)(struct device *, u8, char *);
+        int (*write)(struct device *, u8, u8, char *);
+};
+
+struct cma3000_accl_data *cma3000_init(struct device *dev, int irq,
+                                        const struct cma3000_bus_ops *bops);
+void cma3000_exit(struct cma3000_accl_data *);
+void cma3000_suspend(struct cma3000_accl_data *);
+void cma3000_resume(struct cma3000_accl_data *);
+
+#endif
diff --git a/drivers/input/misc/cma3000_d0x_i2c.c b/drivers/input/misc/cma3000_d0x_i2c.c
new file mode 100644
index 000000000000..d100cc5c5783
--- /dev/null
+++ b/drivers/input/misc/cma3000_d0x_i2c.c
@@ -0,0 +1,143 @@
+/*
+ * Implements I2C interface for VTI CMA300_D0x Accelerometer driver
+ *
+ * Copyright (C) 2010 Texas Instruments
+ * Author: Hemanth V <hemanthv@ti.com>
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <linux/module.h>
+#include <linux/i2c.h>
+#include <linux/input/cma3000.h>
+#include "cma3000_d0x.h"
+
+static int cma3000_i2c_set(struct device *dev,
+                           u8 reg, u8 val, char *msg)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        int ret;
+
+        ret = i2c_smbus_write_byte_data(client, reg, val);
+        if (ret < 0)
+                dev_err(&client->dev,
+                        "%s failed (%s, %d)\n", __func__, msg, ret);
+        return ret;
+}
+
+static int cma3000_i2c_read(struct device *dev, u8 reg, char *msg)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        int ret;
+
+        ret = i2c_smbus_read_byte_data(client, reg);
+        if (ret < 0)
+                dev_err(&client->dev,
+                        "%s failed (%s, %d)\n", __func__, msg, ret);
+        return ret;
+}
+
+static const struct cma3000_bus_ops cma3000_i2c_bops = {
+        .bustype        = BUS_I2C,
+#define CMA3000_BUSI2C     (0 << 4)
+        .ctrl_mod       = CMA3000_BUSI2C,
+        .read           = cma3000_i2c_read,
+        .write          = cma3000_i2c_set,
+};
+
+static int __devinit cma3000_i2c_probe(struct i2c_client *client,
+                                        const struct i2c_device_id *id)
+{
+        struct cma3000_accl_data *data;
+
+        data = cma3000_init(&client->dev, client->irq, &cma3000_i2c_bops);
+        if (IS_ERR(data))
+                return PTR_ERR(data);
+
+        i2c_set_clientdata(client, data);
+
+        return 0;
+}
+
+static int __devexit cma3000_i2c_remove(struct i2c_client *client)
+{
+        struct cma3000_accl_data *data = i2c_get_clientdata(client);
+
+        cma3000_exit(data);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int cma3000_i2c_suspend(struct device *dev)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct cma3000_accl_data *data = i2c_get_clientdata(client);
+
+        cma3000_suspend(data);
+
+        return 0;
+}
+
+static int cma3000_i2c_resume(struct device *dev)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct cma3000_accl_data *data = i2c_get_clientdata(client);
+
+        cma3000_resume(data);
+
+        return 0;
+}
+
+static const struct dev_pm_ops cma3000_i2c_pm_ops = {
+        .suspend        = cma3000_i2c_suspend,
+        .resume         = cma3000_i2c_resume,
+};
+#endif
+
+static const struct i2c_device_id cma3000_i2c_id[] = {
+        { "cma3000_d01", 0 },
+        { },
+};
+
+MODULE_DEVICE_TABLE(i2c, cma3000_i2c_id);
+
+static struct i2c_driver cma3000_i2c_driver = {
+        .probe          = cma3000_i2c_probe,
+        .remove         = __devexit_p(cma3000_i2c_remove),
+        .id_table       = cma3000_i2c_id,
+        .driver = {
+                .name   = "cma3000_i2c_accl",
+                .owner  = THIS_MODULE,
+#ifdef CONFIG_PM
+                .pm     = &cma3000_i2c_pm_ops,
+#endif
+        },
+};
+
+static int __init cma3000_i2c_init(void)
+{
+        return i2c_add_driver(&cma3000_i2c_driver);
+}
+
+static void __exit cma3000_i2c_exit(void)
+{
+        i2c_del_driver(&cma3000_i2c_driver);
+}
+
+module_init(cma3000_i2c_init);
+module_exit(cma3000_i2c_exit);
+
+MODULE_DESCRIPTION("CMA3000-D0x Accelerometer I2C Driver");
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Hemanth V <hemanthv@ti.com>");
diff --git a/drivers/input/misc/hp_sdc_rtc.c b/drivers/input/misc/hp_sdc_rtc.c
index c19066479057..0b4f54265f62 100644
--- a/drivers/input/misc/hp_sdc_rtc.c
+++ b/drivers/input/misc/hp_sdc_rtc.c
@@ -43,7 +43,7 @@
 #include <linux/proc_fs.h>
 #include <linux/poll.h>
 #include <linux/rtc.h>
-#include <linux/smp_lock.h>
+#include <linux/mutex.h>
 #include <linux/semaphore.h>
 
 MODULE_AUTHOR("Brian S. Julin <bri@calyx.com>");
@@ -52,6 +52,7 @@ MODULE_LICENSE("Dual BSD/GPL");
 
 #define RTC_VERSION "1.10d"
 
+static DEFINE_MUTEX(hp_sdc_rtc_mutex);
 static unsigned long epoch = 2000;
 
 static struct semaphore i8042tregs;
@@ -104,7 +105,7 @@ static int hp_sdc_rtc_do_read_bbrtc (struct rtc_time *rtctm)
         t.endidx =              91;
         t.seq =                 tseq;
         t.act.semaphore =       &tsem;
-        init_MUTEX_LOCKED(&tsem);
+        sema_init(&tsem, 0);
         
         if (hp_sdc_enqueue_transaction(&t)) return -1;
         
@@ -665,9 +666,9 @@ static long hp_sdc_rtc_unlocked_ioctl(struct file *file,
 {
         int ret;
 
-        lock_kernel();
+        mutex_lock(&hp_sdc_rtc_mutex);
         ret = hp_sdc_rtc_ioctl(file, cmd, arg);
-        unlock_kernel();
+        mutex_unlock(&hp_sdc_rtc_mutex);
 
         return ret;
 }
@@ -698,7 +699,7 @@ static int __init hp_sdc_rtc_init(void)
                 return -ENODEV;
 #endif
 
-        init_MUTEX(&i8042tregs);
+        sema_init(&i8042tregs, 1);
 
         if ((ret = hp_sdc_request_timer_irq(&hp_sdc_rtc_isr)))
                 return ret;
diff --git a/drivers/input/misc/ixp4xx-beeper.c b/drivers/input/misc/ixp4xx-beeper.c
index 9dfd6e5f786f..1f38302a5951 100644
--- a/drivers/input/misc/ixp4xx-beeper.c
+++ b/drivers/input/misc/ixp4xx-beeper.c
@@ -69,11 +69,7 @@ static int ixp4xx_spkr_event(struct input_dev *dev, unsigned int type, unsigned
         }
 
         if (value > 20 && value < 32767)
-#ifndef FREQ
-                count = (ixp4xx_get_board_tick_rate() / (value * 4)) - 1;
-#else
-                count = (FREQ / (value * 4)) - 1;
-#endif
+                count = (IXP4XX_TIMER_FREQ / (value * 4)) - 1;
 
         ixp4xx_spkr_control(pin, count);
 
diff --git a/drivers/input/misc/keyspan_remote.c b/drivers/input/misc/keyspan_remote.c
index a93c525475c6..fc62256c963f 100644
--- a/drivers/input/misc/keyspan_remote.c
+++ b/drivers/input/misc/keyspan_remote.c
@@ -312,7 +312,7 @@ static void keyspan_check_data(struct usb_keyspan *remote)
                         remote->data.tester = remote->data.tester >> 5;
                         remote->data.bits_left -= 5;
                 } else {
-                        err("Bad message recieved, no stop bit found.\n");
+                        err("Bad message received, no stop bit found.\n");
                 }
 
                 dev_dbg(&remote->udev->dev,
diff --git a/drivers/input/misc/max8925_onkey.c b/drivers/input/misc/max8925_onkey.c
index 80af44608018..7de0ded4ccc3 100644
--- a/drivers/input/misc/max8925_onkey.c
+++ b/drivers/input/misc/max8925_onkey.c
@@ -27,27 +27,37 @@
 #include <linux/mfd/max8925.h>
 #include <linux/slab.h>
 
+#define SW_INPUT                (1 << 7)        /* 0/1 -- up/down */
 #define HARDRESET_EN            (1 << 7)
 #define PWREN_EN                (1 << 7)
 
 struct max8925_onkey_info {
         struct input_dev        *idev;
         struct i2c_client       *i2c;
-        int                     irq;
+        struct device           *dev;
+        int                     irq[2];
 };
 
 /*
- * MAX8925 gives us an interrupt when ONKEY is held for 3 seconds.
+ * MAX8925 gives us an interrupt when ONKEY is pressed or released.
  * max8925_set_bits() operates I2C bus and may sleep. So implement
  * it in thread IRQ handler.
  */
 static irqreturn_t max8925_onkey_handler(int irq, void *data)
 {
         struct max8925_onkey_info *info = data;
-
-        input_report_key(info->idev, KEY_POWER, 1);
+        int ret, event;
+
+        ret = max8925_reg_read(info->i2c, MAX8925_ON_OFF_STATUS);
+        if (ret & SW_INPUT)
+                event = 1;
+        else
+                event = 0;
+        input_report_key(info->idev, KEY_POWER, event);
         input_sync(info->idev);
 
+        dev_dbg(info->dev, "onkey event:%d\n", event);
+
         /* Enable hardreset to halt if system isn't shutdown on time */
         max8925_set_bits(info->i2c, MAX8925_SYSENSEL,
                          HARDRESET_EN, HARDRESET_EN);
@@ -59,14 +69,42 @@ static int __devinit max8925_onkey_probe(struct platform_device *pdev)
 {
         struct max8925_chip *chip = dev_get_drvdata(pdev->dev.parent);
         struct max8925_onkey_info *info;
-        int error;
+        int irq[2], error;
+
+        irq[0] = platform_get_irq(pdev, 0);
+        if (irq[0] < 0) {
+                dev_err(&pdev->dev, "No IRQ resource!\n");
+                return -EINVAL;
+        }
+        irq[1] = platform_get_irq(pdev, 1);
+        if (irq[1] < 0) {
+                dev_err(&pdev->dev, "No IRQ resource!\n");
+                return -EINVAL;
+        }
 
         info = kzalloc(sizeof(struct max8925_onkey_info), GFP_KERNEL);
         if (!info)
                 return -ENOMEM;
 
         info->i2c = chip->i2c;
-        info->irq = chip->irq_base + MAX8925_IRQ_GPM_SW_3SEC;
+        info->dev = &pdev->dev;
+        irq[0] += chip->irq_base;
+        irq[1] += chip->irq_base;
+
+        error = request_threaded_irq(irq[0], NULL, max8925_onkey_handler,
+                                     IRQF_ONESHOT, "onkey-down", info);
+        if (error < 0) {
+                dev_err(chip->dev, "Failed to request IRQ: #%d: %d\n",
+                        irq[0], error);
+                goto out;
+        }
+        error = request_threaded_irq(irq[1], NULL, max8925_onkey_handler,
+                                     IRQF_ONESHOT, "onkey-up", info);
+        if (error < 0) {
+                dev_err(chip->dev, "Failed to request IRQ: #%d: %d\n",
+                        irq[1], error);
+                goto out_irq;
+        }
 
         info->idev = input_allocate_device();
         if (!info->idev) {
@@ -79,32 +117,29 @@ static int __devinit max8925_onkey_probe(struct platform_device *pdev)
         info->idev->phys = "max8925_on/input0";
         info->idev->id.bustype = BUS_I2C;
         info->idev->dev.parent = &pdev->dev;
+        info->irq[0] = irq[0];
+        info->irq[1] = irq[1];
         info->idev->evbit[0] = BIT_MASK(EV_KEY);
         info->idev->keybit[BIT_WORD(KEY_POWER)] = BIT_MASK(KEY_POWER);
 
-        error = request_threaded_irq(info->irq, NULL, max8925_onkey_handler,
-                                     IRQF_ONESHOT, "onkey", info);
-        if (error < 0) {
-                dev_err(chip->dev, "Failed to request IRQ: #%d: %d\n",
-                        info->irq, error);
-                goto out_irq;
-        }
 
         error = input_register_device(info->idev);
         if (error) {
                 dev_err(chip->dev, "Can't register input device: %d\n", error);
-                goto out;
+                goto out_reg;
         }
 
         platform_set_drvdata(pdev, info);
 
         return 0;
 
-out:
-        free_irq(info->irq, info);
-out_irq:
+out_reg:
         input_free_device(info->idev);
 out_input:
+        free_irq(info->irq[1], info);
+out_irq:
+        free_irq(info->irq[0], info);
+out:
         kfree(info);
         return error;
 }
@@ -113,7 +148,8 @@ static int __devexit max8925_onkey_remove(struct platform_device *pdev)
 {
         struct max8925_onkey_info *info = platform_get_drvdata(pdev);
 
-        free_irq(info->irq, info);
+        free_irq(info->irq[0], info);
+        free_irq(info->irq[1], info);
         input_unregister_device(info->idev);
         kfree(info);
 
diff --git a/drivers/input/misc/pcf8574_keypad.c b/drivers/input/misc/pcf8574_keypad.c
index 4b42ffc0532a..08be1a355956 100644
--- a/drivers/input/misc/pcf8574_keypad.c
+++ b/drivers/input/misc/pcf8574_keypad.c
@@ -127,14 +127,6 @@ static int __devinit pcf8574_kp_probe(struct i2c_client *client, const struct i2
         idev->id.product = 0x0001;
         idev->id.version = 0x0100;
 
-        input_set_drvdata(idev, lp);
-
-        ret = input_register_device(idev);
-        if (ret) {
-                dev_err(&client->dev, "input_register_device() failed\n");
-                goto fail_register;
-        }
-
         lp->laststate = read_state(lp);
 
         ret = request_threaded_irq(client->irq, NULL, pcf8574_kp_irq_handler,
@@ -142,16 +134,21 @@ static int __devinit pcf8574_kp_probe(struct i2c_client *client, const struct i2
                                    DRV_NAME, lp);
         if (ret) {
                 dev_err(&client->dev, "IRQ %d is not free\n", client->irq);
-                goto fail_irq;
+                goto fail_free_device;
+        }
+
+        ret = input_register_device(idev);
+        if (ret) {
+                dev_err(&client->dev, "input_register_device() failed\n");
+                goto fail_free_irq;
         }
 
         i2c_set_clientdata(client, lp);
         return 0;
 
- fail_irq:
-        input_unregister_device(idev);
- fail_register:
-        input_set_drvdata(idev, NULL);
+ fail_free_irq:
+        free_irq(client->irq, lp);
+ fail_free_device:
         input_free_device(idev);
  fail_allocate:
         kfree(lp);
@@ -172,19 +169,29 @@ static int __devexit pcf8574_kp_remove(struct i2c_client *client)
 }
 
 #ifdef CONFIG_PM
-static int pcf8574_kp_resume(struct i2c_client *client)
+static int pcf8574_kp_resume(struct device *dev)
 {
+        struct i2c_client *client = to_i2c_client(dev);
+
         enable_irq(client->irq);
 
         return 0;
 }
 
-static int pcf8574_kp_suspend(struct i2c_client *client, pm_message_t mesg)
+static int pcf8574_kp_suspend(struct device *dev)
 {
+        struct i2c_client *client = to_i2c_client(dev);
+
         disable_irq(client->irq);
 
         return 0;
 }
+
+static const struct dev_pm_ops pcf8574_kp_pm_ops = {
+        .suspend        = pcf8574_kp_suspend,
+        .resume         = pcf8574_kp_resume,
+};
+
 #else
 # define pcf8574_kp_resume  NULL
 # define pcf8574_kp_suspend NULL
@@ -200,11 +207,12 @@ static struct i2c_driver pcf8574_kp_driver = {
         .driver = {
                 .name  = DRV_NAME,
                 .owner = THIS_MODULE,
+#ifdef CONFIG_PM
+                .pm = &pcf8574_kp_pm_ops,
+#endif
         },
         .probe    = pcf8574_kp_probe,
         .remove   = __devexit_p(pcf8574_kp_remove),
-        .suspend  = pcf8574_kp_suspend,
-        .resume   = pcf8574_kp_resume,
         .id_table = pcf8574_kp_id,
 };
 
diff --git a/drivers/input/misc/pmic8xxx-pwrkey.c b/drivers/input/misc/pmic8xxx-pwrkey.c
new file mode 100644
index 000000000000..b3cfb9c71e66
--- /dev/null
+++ b/drivers/input/misc/pmic8xxx-pwrkey.c
@@ -0,0 +1,232 @@
+/* Copyright (c) 2010-2011, Code Aurora Forum. 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 and
+ * only 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.
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/slab.h>
+#include <linux/input.h>
+#include <linux/interrupt.h>
+#include <linux/platform_device.h>
+#include <linux/log2.h>
+
+#include <linux/mfd/pm8xxx/core.h>
+#include <linux/input/pmic8xxx-pwrkey.h>
+
+#define PON_CNTL_1 0x1C
+#define PON_CNTL_PULL_UP BIT(7)
+#define PON_CNTL_TRIG_DELAY_MASK (0x7)
+
+/**
+ * struct pmic8xxx_pwrkey - pmic8xxx pwrkey information
+ * @key_press_irq: key press irq number
+ */
+struct pmic8xxx_pwrkey {
+        struct input_dev *pwr;
+        int key_press_irq;
+};
+
+static irqreturn_t pwrkey_press_irq(int irq, void *_pwrkey)
+{
+        struct pmic8xxx_pwrkey *pwrkey = _pwrkey;
+
+        input_report_key(pwrkey->pwr, KEY_POWER, 1);
+        input_sync(pwrkey->pwr);
+
+        return IRQ_HANDLED;
+}
+
+static irqreturn_t pwrkey_release_irq(int irq, void *_pwrkey)
+{
+        struct pmic8xxx_pwrkey *pwrkey = _pwrkey;
+
+        input_report_key(pwrkey->pwr, KEY_POWER, 0);
+        input_sync(pwrkey->pwr);
+
+        return IRQ_HANDLED;
+}
+
+#ifdef CONFIG_PM_SLEEP
+static int pmic8xxx_pwrkey_suspend(struct device *dev)
+{
+        struct pmic8xxx_pwrkey *pwrkey = dev_get_drvdata(dev);
+
+        if (device_may_wakeup(dev))
+                enable_irq_wake(pwrkey->key_press_irq);
+
+        return 0;
+}
+
+static int pmic8xxx_pwrkey_resume(struct device *dev)
+{
+        struct pmic8xxx_pwrkey *pwrkey = dev_get_drvdata(dev);
+
+        if (device_may_wakeup(dev))
+                disable_irq_wake(pwrkey->key_press_irq);
+
+        return 0;
+}
+#endif
+
+static SIMPLE_DEV_PM_OPS(pm8xxx_pwr_key_pm_ops,
+                pmic8xxx_pwrkey_suspend, pmic8xxx_pwrkey_resume);
+
+static int __devinit pmic8xxx_pwrkey_probe(struct platform_device *pdev)
+{
+        struct input_dev *pwr;
+        int key_release_irq = platform_get_irq(pdev, 0);
+        int key_press_irq = platform_get_irq(pdev, 1);
+        int err;
+        unsigned int delay;
+        u8 pon_cntl;
+        struct pmic8xxx_pwrkey *pwrkey;
+        const struct pm8xxx_pwrkey_platform_data *pdata =
+                                        dev_get_platdata(&pdev->dev);
+
+        if (!pdata) {
+                dev_err(&pdev->dev, "power key platform data not supplied\n");
+                return -EINVAL;
+        }
+
+        if (pdata->kpd_trigger_delay_us > 62500) {
+                dev_err(&pdev->dev, "invalid power key trigger delay\n");
+                return -EINVAL;
+        }
+
+        pwrkey = kzalloc(sizeof(*pwrkey), GFP_KERNEL);
+        if (!pwrkey)
+                return -ENOMEM;
+
+        pwr = input_allocate_device();
+        if (!pwr) {
+                dev_dbg(&pdev->dev, "Can't allocate power button\n");
+                err = -ENOMEM;
+                goto free_pwrkey;
+        }
+
+        input_set_capability(pwr, EV_KEY, KEY_POWER);
+
+        pwr->name = "pmic8xxx_pwrkey";
+        pwr->phys = "pmic8xxx_pwrkey/input0";
+        pwr->dev.parent = &pdev->dev;
+
+        delay = (pdata->kpd_trigger_delay_us << 10) / USEC_PER_SEC;
+        delay = 1 + ilog2(delay);
+
+        err = pm8xxx_readb(pdev->dev.parent, PON_CNTL_1, &pon_cntl);
+        if (err < 0) {
+                dev_err(&pdev->dev, "failed reading PON_CNTL_1 err=%d\n", err);
+                goto free_input_dev;
+        }
+
+        pon_cntl &= ~PON_CNTL_TRIG_DELAY_MASK;
+        pon_cntl |= (delay & PON_CNTL_TRIG_DELAY_MASK);
+        if (pdata->pull_up)
+                pon_cntl |= PON_CNTL_PULL_UP;
+        else
+                pon_cntl &= ~PON_CNTL_PULL_UP;
+
+        err = pm8xxx_writeb(pdev->dev.parent, PON_CNTL_1, pon_cntl);
+        if (err < 0) {
+                dev_err(&pdev->dev, "failed writing PON_CNTL_1 err=%d\n", err);
+                goto free_input_dev;
+        }
+
+        err = input_register_device(pwr);
+        if (err) {
+                dev_dbg(&pdev->dev, "Can't register power key: %d\n", err);
+                goto free_input_dev;
+        }
+
+        pwrkey->key_press_irq = key_press_irq;
+        pwrkey->pwr = pwr;
+
+        platform_set_drvdata(pdev, pwrkey);
+
+        err = request_irq(key_press_irq, pwrkey_press_irq,
+                IRQF_TRIGGER_RISING, "pmic8xxx_pwrkey_press", pwrkey);
+        if (err < 0) {
+                dev_dbg(&pdev->dev, "Can't get %d IRQ for pwrkey: %d\n",
+                                 key_press_irq, err);
+                goto unreg_input_dev;
+        }
+
+        err = request_irq(key_release_irq, pwrkey_release_irq,
+                 IRQF_TRIGGER_RISING, "pmic8xxx_pwrkey_release", pwrkey);
+        if (err < 0) {
+                dev_dbg(&pdev->dev, "Can't get %d IRQ for pwrkey: %d\n",
+                                 key_release_irq, err);
+
+                goto free_press_irq;
+        }
+
+        device_init_wakeup(&pdev->dev, pdata->wakeup);
+
+        return 0;
+
+free_press_irq:
+        free_irq(key_press_irq, NULL);
+unreg_input_dev:
+        platform_set_drvdata(pdev, NULL);
+        input_unregister_device(pwr);
+        pwr = NULL;
+free_input_dev:
+        input_free_device(pwr);
+free_pwrkey:
+        kfree(pwrkey);
+        return err;
+}
+
+static int __devexit pmic8xxx_pwrkey_remove(struct platform_device *pdev)
+{
+        struct pmic8xxx_pwrkey *pwrkey = platform_get_drvdata(pdev);
+        int key_release_irq = platform_get_irq(pdev, 0);
+        int key_press_irq = platform_get_irq(pdev, 1);
+
+        device_init_wakeup(&pdev->dev, 0);
+
+        free_irq(key_press_irq, pwrkey);
+        free_irq(key_release_irq, pwrkey);
+        input_unregister_device(pwrkey->pwr);
+        platform_set_drvdata(pdev, NULL);
+        kfree(pwrkey);
+
+        return 0;
+}
+
+static struct platform_driver pmic8xxx_pwrkey_driver = {
+        .probe          = pmic8xxx_pwrkey_probe,
+        .remove         = __devexit_p(pmic8xxx_pwrkey_remove),
+        .driver         = {
+                .name   = PM8XXX_PWRKEY_DEV_NAME,
+                .owner  = THIS_MODULE,
+                .pm     = &pm8xxx_pwr_key_pm_ops,
+        },
+};
+
+static int __init pmic8xxx_pwrkey_init(void)
+{
+        return platform_driver_register(&pmic8xxx_pwrkey_driver);
+}
+module_init(pmic8xxx_pwrkey_init);
+
+static void __exit pmic8xxx_pwrkey_exit(void)
+{
+        platform_driver_unregister(&pmic8xxx_pwrkey_driver);
+}
+module_exit(pmic8xxx_pwrkey_exit);
+
+MODULE_ALIAS("platform:pmic8xxx_pwrkey");
+MODULE_DESCRIPTION("PMIC8XXX Power Key driver");
+MODULE_LICENSE("GPL v2");
+MODULE_AUTHOR("Trilok Soni <tsoni@codeaurora.org>");
diff --git a/drivers/input/misc/powermate.c b/drivers/input/misc/powermate.c
index bf170f6b4422..f45947190e4f 100644
--- a/drivers/input/misc/powermate.c
+++ b/drivers/input/misc/powermate.c
@@ -280,7 +280,7 @@ static int powermate_alloc_buffers(struct usb_device *udev, struct powermate_dev
 
         pm->configcr = kmalloc(sizeof(*(pm->configcr)), GFP_KERNEL);
         if (!pm->configcr)
-                return -1;
+                return -ENOMEM;
 
         return 0;
 }
diff --git a/drivers/input/misc/rotary_encoder.c b/drivers/input/misc/rotary_encoder.c
index 1f8e0108962e..2c8b84dd9dac 100644
--- a/drivers/input/misc/rotary_encoder.c
+++ b/drivers/input/misc/rotary_encoder.c
@@ -2,6 +2,7 @@
  * rotary_encoder.c
  *
  * (c) 2009 Daniel Mack <daniel@caiaq.de>
+ * Copyright (C) 2011 Johan Hovold <jhovold@gmail.com>
  *
  * state machine code inspired by code from Tim Ruetz
  *
@@ -38,52 +39,66 @@ struct rotary_encoder {
 
         bool armed;
         unsigned char dir;      /* 0 - clockwise, 1 - CCW */
+
+        char last_stable;
 };
 
-static irqreturn_t rotary_encoder_irq(int irq, void *dev_id)
+static int rotary_encoder_get_state(struct rotary_encoder_platform_data *pdata)
 {
-        struct rotary_encoder *encoder = dev_id;
-        struct rotary_encoder_platform_data *pdata = encoder->pdata;
         int a = !!gpio_get_value(pdata->gpio_a);
         int b = !!gpio_get_value(pdata->gpio_b);
-        int state;
 
         a ^= pdata->inverted_a;
         b ^= pdata->inverted_b;
-        state = (a << 1) | b;
 
-        switch (state) {
+        return ((a << 1) | b);
+}
 
-        case 0x0:
-                if (!encoder->armed)
-                        break;
+static void rotary_encoder_report_event(struct rotary_encoder *encoder)
+{
+        struct rotary_encoder_platform_data *pdata = encoder->pdata;
 
-                if (pdata->relative_axis) {
-                        input_report_rel(encoder->input, pdata->axis,
-                                         encoder->dir ? -1 : 1);
-                } else {
-                        unsigned int pos = encoder->pos;
-
-                        if (encoder->dir) {
-                                /* turning counter-clockwise */
-                                if (pdata->rollover)
-                                        pos += pdata->steps;
-                                if (pos)
-                                        pos--;
-                        } else {
-                                /* turning clockwise */
-                                if (pdata->rollover || pos < pdata->steps)
-                                        pos++;
-                        }
+        if (pdata->relative_axis) {
+                input_report_rel(encoder->input,
+                                 pdata->axis, encoder->dir ? -1 : 1);
+        } else {
+                unsigned int pos = encoder->pos;
+
+                if (encoder->dir) {
+                        /* turning counter-clockwise */
                         if (pdata->rollover)
-                                pos %= pdata->steps;
-                        encoder->pos = pos;
-                        input_report_abs(encoder->input, pdata->axis,
-                                         encoder->pos);
+                                pos += pdata->steps;
+                        if (pos)
+                                pos--;
+                } else {
+                        /* turning clockwise */
+                        if (pdata->rollover || pos < pdata->steps)
+                                pos++;
                 }
-                input_sync(encoder->input);
 
-                encoder->armed = false;
+                if (pdata->rollover)
+                        pos %= pdata->steps;
+
+                encoder->pos = pos;
+                input_report_abs(encoder->input, pdata->axis, encoder->pos);
+        }
+
+        input_sync(encoder->input);
+}
+
+static irqreturn_t rotary_encoder_irq(int irq, void *dev_id)
+{
+        struct rotary_encoder *encoder = dev_id;
+        int state;
+
+        state = rotary_encoder_get_state(encoder->pdata);
+
+        switch (state) {
+        case 0x0:
+                if (encoder->armed) {
+                        rotary_encoder_report_event(encoder);
+                        encoder->armed = false;
+                }
                 break;
 
         case 0x1:
@@ -100,11 +115,37 @@ static irqreturn_t rotary_encoder_irq(int irq, void *dev_id)
         return IRQ_HANDLED;
 }
 
+static irqreturn_t rotary_encoder_half_period_irq(int irq, void *dev_id)
+{
+        struct rotary_encoder *encoder = dev_id;
+        int state;
+
+        state = rotary_encoder_get_state(encoder->pdata);
+
+        switch (state) {
+        case 0x00:
+        case 0x03:
+                if (state != encoder->last_stable) {
+                        rotary_encoder_report_event(encoder);
+                        encoder->last_stable = state;
+                }
+                break;
+
+        case 0x01:
+        case 0x02:
+                encoder->dir = (encoder->last_stable + state) & 0x01;
+                break;
+        }
+
+        return IRQ_HANDLED;
+}
+
 static int __devinit rotary_encoder_probe(struct platform_device *pdev)
 {
         struct rotary_encoder_platform_data *pdata = pdev->dev.platform_data;
         struct rotary_encoder *encoder;
         struct input_dev *input;
+        irq_handler_t handler;
         int err;
 
         if (!pdata) {
@@ -175,8 +216,15 @@ static int __devinit rotary_encoder_probe(struct platform_device *pdev)
         }
 
         /* request the IRQs */
-        err = request_irq(encoder->irq_a, &rotary_encoder_irq,
-                          IORESOURCE_IRQ_HIGHEDGE | IORESOURCE_IRQ_LOWEDGE,
+        if (pdata->half_period) {
+                handler = &rotary_encoder_half_period_irq;
+                encoder->last_stable = rotary_encoder_get_state(pdata);
+        } else {
+                handler = &rotary_encoder_irq;
+        }
+
+        err = request_irq(encoder->irq_a, handler,
+                          IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
                           DRV_NAME, encoder);
         if (err) {
                 dev_err(&pdev->dev, "unable to request IRQ %d\n",
@@ -184,8 +232,8 @@ static int __devinit rotary_encoder_probe(struct platform_device *pdev)
                 goto exit_free_gpio_b;
         }
 
-        err = request_irq(encoder->irq_b, &rotary_encoder_irq,
-                          IORESOURCE_IRQ_HIGHEDGE | IORESOURCE_IRQ_LOWEDGE,
+        err = request_irq(encoder->irq_b, handler,
+                          IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
                           DRV_NAME, encoder);
         if (err) {
                 dev_err(&pdev->dev, "unable to request IRQ %d\n",
@@ -252,6 +300,5 @@ module_exit(rotary_encoder_exit);
 
 MODULE_ALIAS("platform:" DRV_NAME);
 MODULE_DESCRIPTION("GPIO rotary encoder driver");
-MODULE_AUTHOR("Daniel Mack <daniel@caiaq.de>");
+MODULE_AUTHOR("Daniel Mack <daniel@caiaq.de>, Johan Hovold");
 MODULE_LICENSE("GPL v2");
-
diff --git a/drivers/input/misc/sparcspkr.c b/drivers/input/misc/sparcspkr.c
index 8e130bf7d32b..0122f5351577 100644
--- a/drivers/input/misc/sparcspkr.c
+++ b/drivers/input/misc/sparcspkr.c
@@ -173,18 +173,16 @@ static int __devinit sparcspkr_probe(struct device *dev)
         return 0;
 }
 
-static int sparcspkr_shutdown(struct platform_device *dev)
+static void sparcspkr_shutdown(struct platform_device *dev)
 {
         struct sparcspkr_state *state = dev_get_drvdata(&dev->dev);
         struct input_dev *input_dev = state->input_dev;
 
         /* turn off the speaker */
         state->event(input_dev, EV_SND, SND_BELL, 0);
-
-        return 0;
 }
 
-static int __devinit bbc_beep_probe(struct platform_device *op, const struct of_device_id *match)
+static int __devinit bbc_beep_probe(struct platform_device *op)
 {
         struct sparcspkr_state *state;
         struct bbc_beep_info *info;
@@ -258,7 +256,7 @@ static const struct of_device_id bbc_beep_match[] = {
         {},
 };
 
-static struct of_platform_driver bbc_beep_driver = {
+static struct platform_driver bbc_beep_driver = {
         .driver = {
                 .name = "bbcbeep",
                 .owner = THIS_MODULE,
@@ -269,7 +267,7 @@ static struct of_platform_driver bbc_beep_driver = {
         .shutdown       = sparcspkr_shutdown,
 };
 
-static int __devinit grover_beep_probe(struct platform_device *op, const struct of_device_id *match)
+static int __devinit grover_beep_probe(struct platform_device *op)
 {
         struct sparcspkr_state *state;
         struct grover_beep_info *info;
@@ -340,7 +338,7 @@ static const struct of_device_id grover_beep_match[] = {
         {},
 };
 
-static struct of_platform_driver grover_beep_driver = {
+static struct platform_driver grover_beep_driver = {
         .driver = {
                 .name = "groverbeep",
                 .owner = THIS_MODULE,
@@ -353,12 +351,12 @@ static struct of_platform_driver grover_beep_driver = {
 
 static int __init sparcspkr_init(void)
 {
-        int err = of_register_platform_driver(&bbc_beep_driver);
+        int err = platform_driver_register(&bbc_beep_driver);
 
         if (!err) {
-                err = of_register_platform_driver(&grover_beep_driver);
+                err = platform_driver_register(&grover_beep_driver);
                 if (err)
-                        of_unregister_platform_driver(&bbc_beep_driver);
+                        platform_driver_unregister(&bbc_beep_driver);
         }
 
         return err;
@@ -366,8 +364,8 @@ static int __init sparcspkr_init(void)
 
 static void __exit sparcspkr_exit(void)
 {
-        of_unregister_platform_driver(&bbc_beep_driver);
-        of_unregister_platform_driver(&grover_beep_driver);
+        platform_driver_unregister(&bbc_beep_driver);
+        platform_driver_unregister(&grover_beep_driver);
 }
 
 module_init(sparcspkr_init);
diff --git a/drivers/input/misc/twl4030-pwrbutton.c b/drivers/input/misc/twl4030-pwrbutton.c
index f16972bddca4..38e4b507b94c 100644
--- a/drivers/input/misc/twl4030-pwrbutton.c
+++ b/drivers/input/misc/twl4030-pwrbutton.c
@@ -89,7 +89,7 @@ static int __init twl4030_pwrbutton_probe(struct platform_device *pdev)
         return 0;
 
 free_irq:
-        free_irq(irq, NULL);
+        free_irq(irq, pwr);
 free_input_dev:
         input_free_device(pwr);
         return err;
diff --git a/drivers/input/misc/twl4030-vibra.c b/drivers/input/misc/twl4030-vibra.c
index 4f9b2afc24e8..014dd4ad0d4f 100644
--- a/drivers/input/misc/twl4030-vibra.c
+++ b/drivers/input/misc/twl4030-vibra.c
@@ -271,7 +271,7 @@ static struct platform_driver twl4030_vibra_driver = {
         .probe          = twl4030_vibra_probe,
         .remove         = __devexit_p(twl4030_vibra_remove),
         .driver         = {
-                .name   = "twl4030_codec_vibra",
+                .name   = "twl4030-vibra",
                 .owner  = THIS_MODULE,
 #ifdef CONFIG_PM
                 .pm     = &twl4030_vibra_pm_ops,
@@ -291,7 +291,7 @@ static void __exit twl4030_vibra_exit(void)
 }
 module_exit(twl4030_vibra_exit);
 
-MODULE_ALIAS("platform:twl4030_codec_vibra");
+MODULE_ALIAS("platform:twl4030-vibra");
 
 MODULE_DESCRIPTION("TWL4030 Vibra driver");
 MODULE_LICENSE("GPL");
diff --git a/drivers/input/misc/uinput.c b/drivers/input/misc/uinput.c
index 360698553eb5..736056897e50 100644
--- a/drivers/input/misc/uinput.c
+++ b/drivers/input/misc/uinput.c
@@ -37,6 +37,7 @@
 #include <linux/fs.h>
 #include <linux/miscdevice.h>
 #include <linux/uinput.h>
+#include <linux/input/mt.h>
 #include "../input-compat.h"
 
 static int uinput_dev_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
@@ -301,10 +302,14 @@ static int uinput_validate_absbits(struct input_dev *dev)
         int retval = 0;
 
         for (cnt = 0; cnt < ABS_CNT; cnt++) {
+                int min, max;
                 if (!test_bit(cnt, dev->absbit))
                         continue;
 
-                if (input_abs_get_max(dev, cnt) <= input_abs_get_min(dev, cnt)) {
+                min = input_abs_get_min(dev, cnt);
+                max = input_abs_get_max(dev, cnt);
+
+                if ((min != 0 || max != 0) && max <= min) {
                         printk(KERN_DEBUG
                                 "%s: invalid abs[%02x] min:%d max:%d\n",
                                 UINPUT_NAME, cnt,
@@ -346,8 +351,7 @@ static int uinput_setup_device(struct uinput_device *udev, const char __user *bu
 {
         struct uinput_user_dev  *user_dev;
         struct input_dev        *dev;
-        char                    *name;
-        int                     i, size;
+        int                     i;
         int                     retval;
 
         if (count != sizeof(struct uinput_user_dev))
@@ -361,30 +365,25 @@ static int uinput_setup_device(struct uinput_device *udev, const char __user *bu
 
         dev = udev->dev;
 
-        user_dev = kmalloc(sizeof(struct uinput_user_dev), GFP_KERNEL);
-        if (!user_dev)
-                return -ENOMEM;
-
-        if (copy_from_user(user_dev, buffer, sizeof(struct uinput_user_dev))) {
-                retval = -EFAULT;
-                goto exit;
-        }
+        user_dev = memdup_user(buffer, sizeof(struct uinput_user_dev));
+        if (IS_ERR(user_dev))
+                return PTR_ERR(user_dev);
 
         udev->ff_effects_max = user_dev->ff_effects_max;
 
-        size = strnlen(user_dev->name, UINPUT_MAX_NAME_SIZE) + 1;
-        if (!size) {
+        /* Ensure name is filled in */
+        if (!user_dev->name[0]) {
                 retval = -EINVAL;
                 goto exit;
         }
 
         kfree(dev->name);
-        dev->name = name = kmalloc(size, GFP_KERNEL);
-        if (!name) {
+        dev->name = kstrndup(user_dev->name, UINPUT_MAX_NAME_SIZE,
+                             GFP_KERNEL);
+        if (!dev->name) {
                 retval = -ENOMEM;
                 goto exit;
         }
-        strlcpy(name, user_dev->name, size);
 
         dev->id.bustype = user_dev->id.bustype;
         dev->id.vendor  = user_dev->id.vendor;
@@ -406,8 +405,7 @@ static int uinput_setup_device(struct uinput_device *udev, const char __user *bu
                         goto exit;
                 if (test_bit(ABS_MT_SLOT, dev->absbit)) {
                         int nslot = input_abs_get_max(dev, ABS_MT_SLOT) + 1;
-                        input_mt_create_slots(dev, nslot);
-                        input_set_events_per_packet(dev, 6 * nslot);
+                        input_mt_init_slots(dev, nslot);
                 } else if (test_bit(ABS_MT_POSITION_X, dev->absbit)) {
                         input_set_events_per_packet(dev, 60);
                 }
@@ -622,7 +620,6 @@ static long uinput_ioctl_handler(struct file *file, unsigned int cmd,
         struct uinput_ff_upload ff_up;
         struct uinput_ff_erase  ff_erase;
         struct uinput_request   *req;
-        int                     length;
         char                    *phys;
 
         retval = mutex_lock_interruptible(&udev->mutex);
@@ -680,29 +677,24 @@ static long uinput_ioctl_handler(struct file *file, unsigned int cmd,
                         retval = uinput_set_bit(arg, swbit, SW_MAX);
                         break;
 
+                case UI_SET_PROPBIT:
+                        retval = uinput_set_bit(arg, propbit, INPUT_PROP_MAX);
+                        break;
+
                 case UI_SET_PHYS:
                         if (udev->state == UIST_CREATED) {
                                 retval = -EINVAL;
                                 goto out;
                         }
-                        length = strnlen_user(p, 1024);
-                        if (length <= 0) {
-                                retval = -EFAULT;
-                                break;
+
+                        phys = strndup_user(p, 1024);
+                        if (IS_ERR(phys)) {
+                                retval = PTR_ERR(phys);
+                                goto out;
                         }
+
                         kfree(udev->dev->phys);
-                        udev->dev->phys = phys = kmalloc(length, GFP_KERNEL);
-                        if (!phys) {
-                                retval = -ENOMEM;
-                                break;
-                        }
-                        if (copy_from_user(phys, p, length)) {
-                                udev->dev->phys = NULL;
-                                kfree(phys);
-                                retval = -EFAULT;
-                                break;
-                        }
-                        phys[length - 1] = '\0';
+                        udev->dev->phys = phys;
                         break;
 
                 case UI_BEGIN_FF_UPLOAD:
@@ -811,6 +803,7 @@ static const struct file_operations uinput_fops = {
 #ifdef CONFIG_COMPAT
         .compat_ioctl   = uinput_compat_ioctl,
 #endif
+        .llseek         = no_llseek,
 };
 
 static struct miscdevice uinput_misc = {
diff --git a/drivers/input/misc/winbond-cir.c b/drivers/input/misc/winbond-cir.c
deleted file mode 100644
index 64f1de7960c6..000000000000
--- a/drivers/input/misc/winbond-cir.c
+++ /dev/null
@@ -1,1608 +0,0 @@
-/*
- *  winbond-cir.c - Driver for the Consumer IR functionality of Winbond
- *                  SuperI/O chips.
- *
- *  Currently supports the Winbond WPCD376i chip (PNP id WEC1022), but
- *  could probably support others (Winbond WEC102X, NatSemi, etc)
- *  with minor modifications.
- *
- *  Original Author: David Härdeman <david@hardeman.nu>
- *     Copyright (C) 2009 David Härdeman <david@hardeman.nu>
- *
- *  Dedicated to Matilda, my newborn daughter, without whose loving attention
- *  this driver would have been finished in half the time and with a fraction
- *  of the bugs.
- *
- *  Written using:
- *    o Winbond WPCD376I datasheet helpfully provided by Jesse Barnes at Intel
- *    o NatSemi PC87338/PC97338 datasheet (for the serial port stuff)
- *    o DSDT dumps
- *
- *  Supported features:
- *    o RC6
- *    o Wake-On-CIR functionality
- *
- *  To do:
- *    o Test NEC and RC5
- *
- *  Left as an exercise for the reader:
- *    o Learning (I have neither the hardware, nor the need)
- *    o IR Transmit (ibid)
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-#include <linux/module.h>
-#include <linux/pnp.h>
-#include <linux/interrupt.h>
-#include <linux/timer.h>
-#include <linux/input.h>
-#include <linux/leds.h>
-#include <linux/list.h>
-#include <linux/spinlock.h>
-#include <linux/pci_ids.h>
-#include <linux/io.h>
-#include <linux/bitrev.h>
-#include <linux/bitops.h>
-#include <linux/slab.h>
-
-#define DRVNAME "winbond-cir"
-
-/* CEIR Wake-Up Registers, relative to data->wbase                      */
-#define WBCIR_REG_WCEIR_CTL     0x03 /* CEIR Receiver Control           */
-#define WBCIR_REG_WCEIR_STS     0x04 /* CEIR Receiver Status            */
-#define WBCIR_REG_WCEIR_EV_EN   0x05 /* CEIR Receiver Event Enable      */
-#define WBCIR_REG_WCEIR_CNTL    0x06 /* CEIR Receiver Counter Low       */
-#define WBCIR_REG_WCEIR_CNTH    0x07 /* CEIR Receiver Counter High      */
-#define WBCIR_REG_WCEIR_INDEX   0x08 /* CEIR Receiver Index             */
-#define WBCIR_REG_WCEIR_DATA    0x09 /* CEIR Receiver Data              */
-#define WBCIR_REG_WCEIR_CSL     0x0A /* CEIR Re. Compare Strlen         */
-#define WBCIR_REG_WCEIR_CFG1    0x0B /* CEIR Re. Configuration 1        */
-#define WBCIR_REG_WCEIR_CFG2    0x0C /* CEIR Re. Configuration 2        */
-
-/* CEIR Enhanced Functionality Registers, relative to data->ebase       */
-#define WBCIR_REG_ECEIR_CTS     0x00 /* Enhanced IR Control Status      */
-#define WBCIR_REG_ECEIR_CCTL    0x01 /* Infrared Counter Control        */
-#define WBCIR_REG_ECEIR_CNT_LO  0x02 /* Infrared Counter LSB            */
-#define WBCIR_REG_ECEIR_CNT_HI  0x03 /* Infrared Counter MSB            */
-#define WBCIR_REG_ECEIR_IREM    0x04 /* Infrared Emitter Status         */
-
-/* SP3 Banked Registers, relative to data->sbase                        */
-#define WBCIR_REG_SP3_BSR       0x03 /* Bank Select, all banks          */
-                                      /* Bank 0                         */
-#define WBCIR_REG_SP3_RXDATA    0x00 /* FIFO RX data (r)                */
-#define WBCIR_REG_SP3_TXDATA    0x00 /* FIFO TX data (w)                */
-#define WBCIR_REG_SP3_IER       0x01 /* Interrupt Enable                */
-#define WBCIR_REG_SP3_EIR       0x02 /* Event Identification (r)        */
-#define WBCIR_REG_SP3_FCR       0x02 /* FIFO Control (w)                */
-#define WBCIR_REG_SP3_MCR       0x04 /* Mode Control                    */
-#define WBCIR_REG_SP3_LSR       0x05 /* Link Status                     */
-#define WBCIR_REG_SP3_MSR       0x06 /* Modem Status                    */
-#define WBCIR_REG_SP3_ASCR      0x07 /* Aux Status and Control          */
-                                      /* Bank 2                         */
-#define WBCIR_REG_SP3_BGDL      0x00 /* Baud Divisor LSB                */
-#define WBCIR_REG_SP3_BGDH      0x01 /* Baud Divisor MSB                */
-#define WBCIR_REG_SP3_EXCR1     0x02 /* Extended Control 1              */
-#define WBCIR_REG_SP3_EXCR2     0x04 /* Extended Control 2              */
-#define WBCIR_REG_SP3_TXFLV     0x06 /* TX FIFO Level                   */
-#define WBCIR_REG_SP3_RXFLV     0x07 /* RX FIFO Level                   */
-                                      /* Bank 3                         */
-#define WBCIR_REG_SP3_MRID      0x00 /* Module Identification           */
-#define WBCIR_REG_SP3_SH_LCR    0x01 /* LCR Shadow                      */
-#define WBCIR_REG_SP3_SH_FCR    0x02 /* FCR Shadow                      */
-                                      /* Bank 4                         */
-#define WBCIR_REG_SP3_IRCR1     0x02 /* Infrared Control 1              */
-                                      /* Bank 5                         */
-#define WBCIR_REG_SP3_IRCR2     0x04 /* Infrared Control 2              */
-                                      /* Bank 6                         */
-#define WBCIR_REG_SP3_IRCR3     0x00 /* Infrared Control 3              */
-#define WBCIR_REG_SP3_SIR_PW    0x02 /* SIR Pulse Width         */
-                                      /* Bank 7                         */
-#define WBCIR_REG_SP3_IRRXDC    0x00 /* IR RX Demod Control             */
-#define WBCIR_REG_SP3_IRTXMC    0x01 /* IR TX Mod Control               */
-#define WBCIR_REG_SP3_RCCFG     0x02 /* CEIR Config                     */
-#define WBCIR_REG_SP3_IRCFG1    0x04 /* Infrared Config 1               */
-#define WBCIR_REG_SP3_IRCFG4    0x07 /* Infrared Config 4               */
-
-/*
- * Magic values follow
- */
-
-/* No interrupts for WBCIR_REG_SP3_IER and WBCIR_REG_SP3_EIR */
-#define WBCIR_IRQ_NONE          0x00
-/* RX data bit for WBCIR_REG_SP3_IER and WBCIR_REG_SP3_EIR */
-#define WBCIR_IRQ_RX            0x01
-/* Over/Under-flow bit for WBCIR_REG_SP3_IER and WBCIR_REG_SP3_EIR */
-#define WBCIR_IRQ_ERR           0x04
-/* Led enable/disable bit for WBCIR_REG_ECEIR_CTS */
-#define WBCIR_LED_ENABLE        0x80
-/* RX data available bit for WBCIR_REG_SP3_LSR */
-#define WBCIR_RX_AVAIL          0x01
-/* RX disable bit for WBCIR_REG_SP3_ASCR */
-#define WBCIR_RX_DISABLE        0x20
-/* Extended mode enable bit for WBCIR_REG_SP3_EXCR1 */
-#define WBCIR_EXT_ENABLE        0x01
-/* Select compare register in WBCIR_REG_WCEIR_INDEX (bits 5 & 6) */
-#define WBCIR_REGSEL_COMPARE    0x10
-/* Select mask register in WBCIR_REG_WCEIR_INDEX (bits 5 & 6) */
-#define WBCIR_REGSEL_MASK       0x20
-/* Starting address of selected register in WBCIR_REG_WCEIR_INDEX */
-#define WBCIR_REG_ADDR0         0x00
-
-/* Valid banks for the SP3 UART */
-enum wbcir_bank {
-        WBCIR_BANK_0          = 0x00,
-        WBCIR_BANK_1          = 0x80,
-        WBCIR_BANK_2          = 0xE0,
-        WBCIR_BANK_3          = 0xE4,
-        WBCIR_BANK_4          = 0xE8,
-        WBCIR_BANK_5          = 0xEC,
-        WBCIR_BANK_6          = 0xF0,
-        WBCIR_BANK_7          = 0xF4,
-};
-
-/* Supported IR Protocols */
-enum wbcir_protocol {
-        IR_PROTOCOL_RC5          = 0x0,
-        IR_PROTOCOL_NEC          = 0x1,
-        IR_PROTOCOL_RC6          = 0x2,
-};
-
-/* Misc */
-#define WBCIR_NAME      "Winbond CIR"
-#define WBCIR_ID_FAMILY          0xF1 /* Family ID for the WPCD376I     */
-#define WBCIR_ID_CHIP            0x04 /* Chip ID for the WPCD376I       */
-#define IR_KEYPRESS_TIMEOUT       250 /* FIXME: should be per-protocol? */
-#define INVALID_SCANCODE   0x7FFFFFFF /* Invalid with all protos        */
-#define WAKEUP_IOMEM_LEN         0x10 /* Wake-Up I/O Reg Len            */
-#define EHFUNC_IOMEM_LEN         0x10 /* Enhanced Func I/O Reg Len      */
-#define SP_IOMEM_LEN             0x08 /* Serial Port 3 (IR) Reg Len     */
-#define WBCIR_MAX_IDLE_BYTES       10
-
-static DEFINE_SPINLOCK(wbcir_lock);
-static DEFINE_RWLOCK(keytable_lock);
-
-struct wbcir_key {
-        u32 scancode;
-        unsigned int keycode;
-};
-
-struct wbcir_keyentry {
-        struct wbcir_key key;
-        struct list_head list;
-};
-
-static struct wbcir_key rc6_def_keymap[] = {
-        { 0x800F0400, KEY_NUMERIC_0             },
-        { 0x800F0401, KEY_NUMERIC_1             },
-        { 0x800F0402, KEY_NUMERIC_2             },
-        { 0x800F0403, KEY_NUMERIC_3             },
-        { 0x800F0404, KEY_NUMERIC_4             },
-        { 0x800F0405, KEY_NUMERIC_5             },
-        { 0x800F0406, KEY_NUMERIC_6             },
-        { 0x800F0407, KEY_NUMERIC_7             },
-        { 0x800F0408, KEY_NUMERIC_8             },
-        { 0x800F0409, KEY_NUMERIC_9             },
-        { 0x800F041D, KEY_NUMERIC_STAR          },
-        { 0x800F041C, KEY_NUMERIC_POUND         },
-        { 0x800F0410, KEY_VOLUMEUP              },
-        { 0x800F0411, KEY_VOLUMEDOWN            },
-        { 0x800F0412, KEY_CHANNELUP             },
-        { 0x800F0413, KEY_CHANNELDOWN           },
-        { 0x800F040E, KEY_MUTE                  },
-        { 0x800F040D, KEY_VENDOR                }, /* Vista Logo Key */
-        { 0x800F041E, KEY_UP                    },
-        { 0x800F041F, KEY_DOWN                  },
-        { 0x800F0420, KEY_LEFT                  },
-        { 0x800F0421, KEY_RIGHT                 },
-        { 0x800F0422, KEY_OK                    },
-        { 0x800F0423, KEY_ESC                   },
-        { 0x800F040F, KEY_INFO                  },
-        { 0x800F040A, KEY_CLEAR                 },
-        { 0x800F040B, KEY_ENTER                 },
-        { 0x800F045B, KEY_RED                   },
-        { 0x800F045C, KEY_GREEN                 },
-        { 0x800F045D, KEY_YELLOW                },
-        { 0x800F045E, KEY_BLUE                  },
-        { 0x800F045A, KEY_TEXT                  },
-        { 0x800F0427, KEY_SWITCHVIDEOMODE       },
-        { 0x800F040C, KEY_POWER                 },
-        { 0x800F0450, KEY_RADIO                 },
-        { 0x800F0448, KEY_PVR                   },
-        { 0x800F0447, KEY_AUDIO                 },
-        { 0x800F0426, KEY_EPG                   },
-        { 0x800F0449, KEY_CAMERA                },
-        { 0x800F0425, KEY_TV                    },
-        { 0x800F044A, KEY_VIDEO                 },
-        { 0x800F0424, KEY_DVD                   },
-        { 0x800F0416, KEY_PLAY                  },
-        { 0x800F0418, KEY_PAUSE                 },
-        { 0x800F0419, KEY_STOP                  },
-        { 0x800F0414, KEY_FASTFORWARD           },
-        { 0x800F041A, KEY_NEXT                  },
-        { 0x800F041B, KEY_PREVIOUS              },
-        { 0x800F0415, KEY_REWIND                },
-        { 0x800F0417, KEY_RECORD                },
-};
-
-/* Registers and other state is protected by wbcir_lock */
-struct wbcir_data {
-        unsigned long wbase;        /* Wake-Up Baseaddr         */
-        unsigned long ebase;        /* Enhanced Func. Baseaddr  */
-        unsigned long sbase;        /* Serial Port Baseaddr     */
-        unsigned int  irq;          /* Serial Port IRQ          */
-
-        struct input_dev *input_dev;
-        struct timer_list timer_keyup;
-        struct led_trigger *rxtrigger;
-        struct led_trigger *txtrigger;
-        struct led_classdev led;
-
-        u32 last_scancode;
-        unsigned int last_keycode;
-        u8 last_toggle;
-        u8 keypressed;
-        unsigned long keyup_jiffies;
-        unsigned int idle_count;
-
-        /* RX irdata and parsing state */
-        unsigned long irdata[30];
-        unsigned int irdata_count;
-        unsigned int irdata_idle;
-        unsigned int irdata_off;
-        unsigned int irdata_error;
-
-        /* Protected by keytable_lock */
-        struct list_head keytable;
-};
-
-static enum wbcir_protocol protocol = IR_PROTOCOL_RC6;
-module_param(protocol, uint, 0444);
-MODULE_PARM_DESC(protocol, "IR protocol to use "
-                 "(0 = RC5, 1 = NEC, 2 = RC6A, default)");
-
-static int invert; /* default = 0 */
-module_param(invert, bool, 0444);
-MODULE_PARM_DESC(invert, "Invert the signal from the IR receiver");
-
-static unsigned int wake_sc = 0x800F040C;
-module_param(wake_sc, uint, 0644);
-MODULE_PARM_DESC(wake_sc, "Scancode of the power-on IR command");
-
-static unsigned int wake_rc6mode = 6;
-module_param(wake_rc6mode, uint, 0644);
-MODULE_PARM_DESC(wake_rc6mode, "RC6 mode for the power-on command "
-                 "(0 = 0, 6 = 6A, default)");
-
-
-
-/*****************************************************************************
- *
- * UTILITY FUNCTIONS
- *
- *****************************************************************************/
-
-/* Caller needs to hold wbcir_lock */
-static void
-wbcir_set_bits(unsigned long addr, u8 bits, u8 mask)
-{
-        u8 val;
-
-        val = inb(addr);
-        val = ((val & ~mask) | (bits & mask));
-        outb(val, addr);
-}
-
-/* Selects the register bank for the serial port */
-static inline void
-wbcir_select_bank(struct wbcir_data *data, enum wbcir_bank bank)
-{
-        outb(bank, data->sbase + WBCIR_REG_SP3_BSR);
-}
-
-static enum led_brightness
-wbcir_led_brightness_get(struct led_classdev *led_cdev)
-{
-        struct wbcir_data *data = container_of(led_cdev,
-                                               struct wbcir_data,
-                                               led);
-
-        if (inb(data->ebase + WBCIR_REG_ECEIR_CTS) & WBCIR_LED_ENABLE)
-                return LED_FULL;
-        else
-                return LED_OFF;
-}
-
-static void
-wbcir_led_brightness_set(struct led_classdev *led_cdev,
-                            enum led_brightness brightness)
-{
-        struct wbcir_data *data = container_of(led_cdev,
-                                               struct wbcir_data,
-                                               led);
-
-        wbcir_set_bits(data->ebase + WBCIR_REG_ECEIR_CTS,
-                       brightness == LED_OFF ? 0x00 : WBCIR_LED_ENABLE,
-                       WBCIR_LED_ENABLE);
-}
-
-/* Manchester encodes bits to RC6 message cells (see wbcir_parse_rc6) */
-static u8
-wbcir_to_rc6cells(u8 val)
-{
-        u8 coded = 0x00;
-        int i;
-
-        val &= 0x0F;
-        for (i = 0; i < 4; i++) {
-                if (val & 0x01)
-                        coded |= 0x02 << (i * 2);
-                else
-                        coded |= 0x01 << (i * 2);
-                val >>= 1;
-        }
-
-        return coded;
-}
-
-
-
-/*****************************************************************************
- *
- * INPUT FUNCTIONS
- *
- *****************************************************************************/
-
-static unsigned int
-wbcir_do_getkeycode(struct wbcir_data *data, u32 scancode)
-{
-        struct wbcir_keyentry *keyentry;
-        unsigned int keycode = KEY_RESERVED;
-        unsigned long flags;
-
-        read_lock_irqsave(&keytable_lock, flags);
-
-        list_for_each_entry(keyentry, &data->keytable, list) {
-                if (keyentry->key.scancode == scancode) {
-                        keycode = keyentry->key.keycode;
-                        break;
-                }
-        }
-
-        read_unlock_irqrestore(&keytable_lock, flags);
-        return keycode;
-}
-
-static int
-wbcir_getkeycode(struct input_dev *dev,
-                 unsigned int scancode, unsigned int *keycode)
-{
-        struct wbcir_data *data = input_get_drvdata(dev);
-
-        *keycode = wbcir_do_getkeycode(data, scancode);
-        return 0;
-}
-
-static int
-wbcir_setkeycode(struct input_dev *dev,
-                 unsigned int scancode, unsigned int keycode)
-{
-        struct wbcir_data *data = input_get_drvdata(dev);
-        struct wbcir_keyentry *keyentry;
-        struct wbcir_keyentry *new_keyentry;
-        unsigned long flags;
-        unsigned int old_keycode = KEY_RESERVED;
-
-        new_keyentry = kmalloc(sizeof(*new_keyentry), GFP_KERNEL);
-        if (!new_keyentry)
-                return -ENOMEM;
-
-        write_lock_irqsave(&keytable_lock, flags);
-
-        list_for_each_entry(keyentry, &data->keytable, list) {
-                if (keyentry->key.scancode != scancode)
-                        continue;
-
-                old_keycode = keyentry->key.keycode;
-                keyentry->key.keycode = keycode;
-
-                if (keyentry->key.keycode == KEY_RESERVED) {
-                        list_del(&keyentry->list);
-                        kfree(keyentry);
-                }
-
-                break;
-        }
-
-        set_bit(keycode, dev->keybit);
-
-        if (old_keycode == KEY_RESERVED) {
-                new_keyentry->key.scancode = scancode;
-                new_keyentry->key.keycode = keycode;
-                list_add(&new_keyentry->list, &data->keytable);
-        } else {
-                kfree(new_keyentry);
-                clear_bit(old_keycode, dev->keybit);
-                list_for_each_entry(keyentry, &data->keytable, list) {
-                        if (keyentry->key.keycode == old_keycode) {
-                                set_bit(old_keycode, dev->keybit);
-                                break;
-                        }
-                }
-        }
-
-        write_unlock_irqrestore(&keytable_lock, flags);
-        return 0;
-}
-
-/*
- * Timer function to report keyup event some time after keydown is
- * reported by the ISR.
- */
-static void
-wbcir_keyup(unsigned long cookie)
-{
-        struct wbcir_data *data = (struct wbcir_data *)cookie;
-        unsigned long flags;
-
-        /*
-         * data->keyup_jiffies is used to prevent a race condition if a
-         * hardware interrupt occurs at this point and the keyup timer
-         * event is moved further into the future as a result.
-         *
-         * The timer will then be reactivated and this function called
-         * again in the future. We need to exit gracefully in that case
-         * to allow the input subsystem to do its auto-repeat magic or
-         * a keyup event might follow immediately after the keydown.
-         */
-
-        spin_lock_irqsave(&wbcir_lock, flags);
-
-        if (time_is_after_eq_jiffies(data->keyup_jiffies) && data->keypressed) {
-                data->keypressed = 0;
-                led_trigger_event(data->rxtrigger, LED_OFF);
-                input_report_key(data->input_dev, data->last_keycode, 0);
-                input_sync(data->input_dev);
-        }
-
-        spin_unlock_irqrestore(&wbcir_lock, flags);
-}
-
-static void
-wbcir_keydown(struct wbcir_data *data, u32 scancode, u8 toggle)
-{
-        unsigned int keycode;
-
-        /* Repeat? */
-        if (data->last_scancode == scancode &&
-            data->last_toggle == toggle &&
-            data->keypressed)
-                goto set_timer;
-        data->last_scancode = scancode;
-
-        /* Do we need to release an old keypress? */
-        if (data->keypressed) {
-                input_report_key(data->input_dev, data->last_keycode, 0);
-                input_sync(data->input_dev);
-                data->keypressed = 0;
-        }
-
-        /* Report scancode */
-        input_event(data->input_dev, EV_MSC, MSC_SCAN, (int)scancode);
-
-        /* Do we know this scancode? */
-        keycode = wbcir_do_getkeycode(data, scancode);
-        if (keycode == KEY_RESERVED)
-                goto set_timer;
-
-        /* Register a keypress */
-        input_report_key(data->input_dev, keycode, 1);
-        data->keypressed = 1;
-        data->last_keycode = keycode;
-        data->last_toggle = toggle;
-
-set_timer:
-        input_sync(data->input_dev);
-        led_trigger_event(data->rxtrigger,
-                          data->keypressed ? LED_FULL : LED_OFF);
-        data->keyup_jiffies = jiffies + msecs_to_jiffies(IR_KEYPRESS_TIMEOUT);
-        mod_timer(&data->timer_keyup, data->keyup_jiffies);
-}
-
-
-
-/*****************************************************************************
- *
- * IR PARSING FUNCTIONS
- *
- *****************************************************************************/
-
-/* Resets all irdata */
-static void
-wbcir_reset_irdata(struct wbcir_data *data)
-{
-        memset(data->irdata, 0, sizeof(data->irdata));
-        data->irdata_count = 0;
-        data->irdata_off = 0;
-        data->irdata_error = 0;
-        data->idle_count = 0;
-}
-
-/* Adds one bit of irdata */
-static void
-add_irdata_bit(struct wbcir_data *data, int set)
-{
-        if (data->irdata_count >= sizeof(data->irdata) * 8) {
-                data->irdata_error = 1;
-                return;
-        }
-
-        if (set)
-                __set_bit(data->irdata_count, data->irdata);
-        data->irdata_count++;
-}
-
-/* Gets count bits of irdata */
-static u16
-get_bits(struct wbcir_data *data, int count)
-{
-        u16 val = 0x0;
-
-        if (data->irdata_count - data->irdata_off < count) {
-                data->irdata_error = 1;
-                return 0x0;
-        }
-
-        while (count > 0) {
-                val <<= 1;
-                if (test_bit(data->irdata_off, data->irdata))
-                        val |= 0x1;
-                count--;
-                data->irdata_off++;
-        }
-
-        return val;
-}
-
-/* Reads 16 cells and converts them to a byte */
-static u8
-wbcir_rc6cells_to_byte(struct wbcir_data *data)
-{
-        u16 raw = get_bits(data, 16);
-        u8 val = 0x00;
-        int bit;
-
-        for (bit = 0; bit < 8; bit++) {
-                switch (raw & 0x03) {
-                case 0x01:
-                        break;
-                case 0x02:
-                        val |= (0x01 << bit);
-                        break;
-                default:
-                        data->irdata_error = 1;
-                        break;
-                }
-                raw >>= 2;
-        }
-
-        return val;
-}
-
-/* Decodes a number of bits from raw RC5 data */
-static u8
-wbcir_get_rc5bits(struct wbcir_data *data, unsigned int count)
-{
-        u16 raw = get_bits(data, count * 2);
-        u8 val = 0x00;
-        int bit;
-
-        for (bit = 0; bit < count; bit++) {
-                switch (raw & 0x03) {
-                case 0x01:
-                        val |= (0x01 << bit);
-                        break;
-                case 0x02:
-                        break;
-                default:
-                        data->irdata_error = 1;
-                        break;
-                }
-                raw >>= 2;
-        }
-
-        return val;
-}
-
-static void
-wbcir_parse_rc6(struct device *dev, struct wbcir_data *data)
-{
-        /*
-         * Normal bits are manchester coded as follows:
-         * cell0 + cell1 = logic "0"
-         * cell1 + cell0 = logic "1"
-         *
-         * The IR pulse has the following components:
-         *
-         * Leader               - 6 * cell1 - discarded
-         * Gap                  - 2 * cell0 - discarded
-         * Start bit            - Normal Coding - always "1"
-         * Mode Bit 2 - 0       - Normal Coding
-         * Toggle bit           - Normal Coding with double bit time,
-         *                        e.g. cell0 + cell0 + cell1 + cell1
-         *                        means logic "0".
-         *
-         * The rest depends on the mode, the following modes are known:
-         *
-         * MODE 0:
-         *  Address Bit 7 - 0   - Normal Coding
-         *  Command Bit 7 - 0   - Normal Coding
-         *
-         * MODE 6:
-         *  The above Toggle Bit is used as a submode bit, 0 = A, 1 = B.
-         *  Submode B is for pointing devices, only remotes using submode A
-         *  are supported.
-         *
-         *  Customer range bit  - 0 => Customer = 7 bits, 0...127
-         *                        1 => Customer = 15 bits, 32768...65535
-         *  Customer Bits       - Normal Coding
-         *
-         *  Customer codes are allocated by Philips. The rest of the bits
-         *  are customer dependent. The following is commonly used (and the
-         *  only supported config):
-         *
-         *  Toggle Bit          - Normal Coding
-         *  Address Bit 6 - 0   - Normal Coding
-         *  Command Bit 7 - 0   - Normal Coding
-         *
-         * All modes are followed by at least 6 * cell0.
-         *
-         * MODE 0 msglen:
-         *  1 * 2 (start bit) + 3 * 2 (mode) + 2 * 2 (toggle) +
-         *  8 * 2 (address) + 8 * 2 (command) =
-         *  44 cells
-         *
-         * MODE 6A msglen:
-         *  1 * 2 (start bit) + 3 * 2 (mode) + 2 * 2 (submode) +
-         *  1 * 2 (customer range bit) + 7/15 * 2 (customer bits) +
-         *  1 * 2 (toggle bit) + 7 * 2 (address) + 8 * 2 (command) =
-         *  60 - 76 cells
-         */
-        u8 mode;
-        u8 toggle;
-        u16 customer = 0x0;
-        u8 address;
-        u8 command;
-        u32 scancode;
-
-        /* Leader mark */
-        while (get_bits(data, 1) && !data->irdata_error)
-                /* Do nothing */;
-
-        /* Leader space */
-        if (get_bits(data, 1)) {
-                dev_dbg(dev, "RC6 - Invalid leader space\n");
-                return;
-        }
-
-        /* Start bit */
-        if (get_bits(data, 2) != 0x02) {
-                dev_dbg(dev, "RC6 - Invalid start bit\n");
-                return;
-        }
-
-        /* Mode */
-        mode = get_bits(data, 6);
-        switch (mode) {
-        case 0x15: /* 010101 = b000 */
-                mode = 0;
-                break;
-        case 0x29: /* 101001 = b110 */
-                mode = 6;
-                break;
-        default:
-                dev_dbg(dev, "RC6 - Invalid mode\n");
-                return;
-        }
-
-        /* Toggle bit / Submode bit */
-        toggle = get_bits(data, 4);
-        switch (toggle) {
-        case 0x03:
-                toggle = 0;
-                break;
-        case 0x0C:
-                toggle = 1;
-                break;
-        default:
-                dev_dbg(dev, "RC6 - Toggle bit error\n");
-                break;
-        }
-
-        /* Customer */
-        if (mode == 6) {
-                if (toggle != 0) {
-                        dev_dbg(dev, "RC6B - Not Supported\n");
-                        return;
-                }
-
-                customer = wbcir_rc6cells_to_byte(data);
-
-                if (customer & 0x80) {
-                        /* 15 bit customer value */
-                        customer <<= 8;
-                        customer |= wbcir_rc6cells_to_byte(data);
-                }
-        }
-
-        /* Address */
-        address = wbcir_rc6cells_to_byte(data);
-        if (mode == 6) {
-                toggle = address >> 7;
-                address &= 0x7F;
-        }
-
-        /* Command */
-        command = wbcir_rc6cells_to_byte(data);
-
-        /* Create scancode */
-        scancode =  command;
-        scancode |= address << 8;
-        scancode |= customer << 16;
-
-        /* Last sanity check */
-        if (data->irdata_error) {
-                dev_dbg(dev, "RC6 - Cell error(s)\n");
-                return;
-        }
-
-        dev_dbg(dev, "IR-RC6 ad 0x%02X cm 0x%02X cu 0x%04X "
-                "toggle %u mode %u scan 0x%08X\n",
-                address,
-                command,
-                customer,
-                (unsigned int)toggle,
-                (unsigned int)mode,
-                scancode);
-
-        wbcir_keydown(data, scancode, toggle);
-}
-
-static void
-wbcir_parse_rc5(struct device *dev, struct wbcir_data *data)
-{
-        /*
-         * Bits are manchester coded as follows:
-         * cell1 + cell0 = logic "0"
-         * cell0 + cell1 = logic "1"
-         * (i.e. the reverse of RC6)
-         *
-         * Start bit 1          - "1" - discarded
-         * Start bit 2          - Must be inverted to get command bit 6
-         * Toggle bit
-         * Address Bit 4 - 0
-         * Command Bit 5 - 0
-         */
-        u8 toggle;
-        u8 address;
-        u8 command;
-        u32 scancode;
-
-        /* Start bit 1 */
-        if (!get_bits(data, 1)) {
-                dev_dbg(dev, "RC5 - Invalid start bit\n");
-                return;
-        }
-
-        /* Start bit 2 */
-        if (!wbcir_get_rc5bits(data, 1))
-                command = 0x40;
-        else
-                command = 0x00;
-
-        toggle   = wbcir_get_rc5bits(data, 1);
-        address  = wbcir_get_rc5bits(data, 5);
-        command |= wbcir_get_rc5bits(data, 6);
-        scancode = address << 7 | command;
-
-        /* Last sanity check */
-        if (data->irdata_error) {
-                dev_dbg(dev, "RC5 - Invalid message\n");
-                return;
-        }
-
-        dev_dbg(dev, "IR-RC5 ad %u cm %u t %u s %u\n",
-                (unsigned int)address,
-                (unsigned int)command,
-                (unsigned int)toggle,
-                (unsigned int)scancode);
-
-        wbcir_keydown(data, scancode, toggle);
-}
-
-static void
-wbcir_parse_nec(struct device *dev, struct wbcir_data *data)
-{
-        /*
-         * Each bit represents 560 us.
-         *
-         * Leader               - 9 ms burst
-         * Gap                  - 4.5 ms silence
-         * Address1 bit 0 - 7   - Address 1
-         * Address2 bit 0 - 7   - Address 2
-         * Command1 bit 0 - 7   - Command 1
-         * Command2 bit 0 - 7   - Command 2
-         *
-         * Note the bit order!
-         *
-         * With the old NEC protocol, Address2 was the inverse of Address1
-         * and Command2 was the inverse of Command1 and were used as
-         * an error check.
-         *
-         * With NEC extended, Address1 is the LSB of the Address and
-         * Address2 is the MSB, Command parsing remains unchanged.
-         *
-         * A repeat message is coded as:
-         * Leader               - 9 ms burst
-         * Gap                  - 2.25 ms silence
-         * Repeat               - 560 us active
-         */
-        u8 address1;
-        u8 address2;
-        u8 command1;
-        u8 command2;
-        u16 address;
-        u32 scancode;
-
-        /* Leader mark */
-        while (get_bits(data, 1) && !data->irdata_error)
-                /* Do nothing */;
-
-        /* Leader space */
-        if (get_bits(data, 4)) {
-                dev_dbg(dev, "NEC - Invalid leader space\n");
-                return;
-        }
-
-        /* Repeat? */
-        if (get_bits(data, 1)) {
-                if (!data->keypressed) {
-                        dev_dbg(dev, "NEC - Stray repeat message\n");
-                        return;
-                }
-
-                dev_dbg(dev, "IR-NEC repeat s %u\n",
-                        (unsigned int)data->last_scancode);
-
-                wbcir_keydown(data, data->last_scancode, data->last_toggle);
-                return;
-        }
-
-        /* Remaining leader space */
-        if (get_bits(data, 3)) {
-                dev_dbg(dev, "NEC - Invalid leader space\n");
-                return;
-        }
-
-        address1  = bitrev8(get_bits(data, 8));
-        address2  = bitrev8(get_bits(data, 8));
-        command1  = bitrev8(get_bits(data, 8));
-        command2  = bitrev8(get_bits(data, 8));
-
-        /* Sanity check */
-        if (data->irdata_error) {
-                dev_dbg(dev, "NEC - Invalid message\n");
-                return;
-        }
-
-        /* Check command validity */
-        if (command1 != ~command2) {
-                dev_dbg(dev, "NEC - Command bytes mismatch\n");
-                return;
-        }
-
-        /* Check for extended NEC protocol */
-        address = address1;
-        if (address1 != ~address2)
-                address |= address2 << 8;
-
-        scancode = address << 8 | command1;
-
-        dev_dbg(dev, "IR-NEC ad %u cm %u s %u\n",
-                (unsigned int)address,
-                (unsigned int)command1,
-                (unsigned int)scancode);
-
-        wbcir_keydown(data, scancode, !data->last_toggle);
-}
-
-
-
-/*****************************************************************************
- *
- * INTERRUPT FUNCTIONS
- *
- *****************************************************************************/
-
-static irqreturn_t
-wbcir_irq_handler(int irqno, void *cookie)
-{
-        struct pnp_dev *device = cookie;
-        struct wbcir_data *data = pnp_get_drvdata(device);
-        struct device *dev = &device->dev;
-        u8 status;
-        unsigned long flags;
-        u8 irdata[8];
-        int i;
-        unsigned int hw;
-
-        spin_lock_irqsave(&wbcir_lock, flags);
-
-        wbcir_select_bank(data, WBCIR_BANK_0);
-
-        status = inb(data->sbase + WBCIR_REG_SP3_EIR);
-
-        if (!(status & (WBCIR_IRQ_RX | WBCIR_IRQ_ERR))) {
-                spin_unlock_irqrestore(&wbcir_lock, flags);
-                return IRQ_NONE;
-        }
-
-        if (status & WBCIR_IRQ_ERR)
-                data->irdata_error = 1;
-
-        if (!(status & WBCIR_IRQ_RX))
-                goto out;
-
-        /* Since RXHDLEV is set, at least 8 bytes are in the FIFO */
-        insb(data->sbase + WBCIR_REG_SP3_RXDATA, &irdata[0], 8);
-
-        for (i = 0; i < sizeof(irdata); i++) {
-                hw = hweight8(irdata[i]);
-                if (hw > 4)
-                        add_irdata_bit(data, 0);
-                else
-                        add_irdata_bit(data, 1);
-
-                if (hw == 8)
-                        data->idle_count++;
-                else
-                        data->idle_count = 0;
-        }
-
-        if (data->idle_count > WBCIR_MAX_IDLE_BYTES) {
-                /* Set RXINACTIVE... */
-                outb(WBCIR_RX_DISABLE, data->sbase + WBCIR_REG_SP3_ASCR);
-
-                /* ...and drain the FIFO */
-                while (inb(data->sbase + WBCIR_REG_SP3_LSR) & WBCIR_RX_AVAIL)
-                        inb(data->sbase + WBCIR_REG_SP3_RXDATA);
-
-                dev_dbg(dev, "IRDATA:\n");
-                for (i = 0; i < data->irdata_count; i += BITS_PER_LONG)
-                        dev_dbg(dev, "0x%08lX\n", data->irdata[i/BITS_PER_LONG]);
-
-                switch (protocol) {
-                case IR_PROTOCOL_RC5:
-                        wbcir_parse_rc5(dev, data);
-                        break;
-                case IR_PROTOCOL_RC6:
-                        wbcir_parse_rc6(dev, data);
-                        break;
-                case IR_PROTOCOL_NEC:
-                        wbcir_parse_nec(dev, data);
-                        break;
-                }
-
-                wbcir_reset_irdata(data);
-        }
-
-out:
-        spin_unlock_irqrestore(&wbcir_lock, flags);
-        return IRQ_HANDLED;
-}
-
-
-
-/*****************************************************************************
- *
- * SETUP/INIT/SUSPEND/RESUME FUNCTIONS
- *
- *****************************************************************************/
-
-static void
-wbcir_shutdown(struct pnp_dev *device)
-{
-        struct device *dev = &device->dev;
-        struct wbcir_data *data = pnp_get_drvdata(device);
-        int do_wake = 1;
-        u8 match[11];
-        u8 mask[11];
-        u8 rc6_csl = 0;
-        int i;
-
-        memset(match, 0, sizeof(match));
-        memset(mask, 0, sizeof(mask));
-
-        if (wake_sc == INVALID_SCANCODE || !device_may_wakeup(dev)) {
-                do_wake = 0;
-                goto finish;
-        }
-
-        switch (protocol) {
-        case IR_PROTOCOL_RC5:
-                if (wake_sc > 0xFFF) {
-                        do_wake = 0;
-                        dev_err(dev, "RC5 - Invalid wake scancode\n");
-                        break;
-                }
-
-                /* Mask = 13 bits, ex toggle */
-                mask[0] = 0xFF;
-                mask[1] = 0x17;
-
-                match[0]  = (wake_sc & 0x003F);      /* 6 command bits */
-                match[0] |= (wake_sc & 0x0180) >> 1; /* 2 address bits */
-                match[1]  = (wake_sc & 0x0E00) >> 9; /* 3 address bits */
-                if (!(wake_sc & 0x0040))             /* 2nd start bit  */
-                        match[1] |= 0x10;
-
-                break;
-
-        case IR_PROTOCOL_NEC:
-                if (wake_sc > 0xFFFFFF) {
-                        do_wake = 0;
-                        dev_err(dev, "NEC - Invalid wake scancode\n");
-                        break;
-                }
-
-                mask[0] = mask[1] = mask[2] = mask[3] = 0xFF;
-
-                match[1] = bitrev8((wake_sc & 0xFF));
-                match[0] = ~match[1];
-
-                match[3] = bitrev8((wake_sc & 0xFF00) >> 8);
-                if (wake_sc > 0xFFFF)
-                        match[2] = bitrev8((wake_sc & 0xFF0000) >> 16);
-                else
-                        match[2] = ~match[3];
-
-                break;
-
-        case IR_PROTOCOL_RC6:
-
-                if (wake_rc6mode == 0) {
-                        if (wake_sc > 0xFFFF) {
-                                do_wake = 0;
-                                dev_err(dev, "RC6 - Invalid wake scancode\n");
-                                break;
-                        }
-
-                        /* Command */
-                        match[0] = wbcir_to_rc6cells(wake_sc >>  0);
-                        mask[0]  = 0xFF;
-                        match[1] = wbcir_to_rc6cells(wake_sc >>  4);
-                        mask[1]  = 0xFF;
-
-                        /* Address */
-                        match[2] = wbcir_to_rc6cells(wake_sc >>  8);
-                        mask[2]  = 0xFF;
-                        match[3] = wbcir_to_rc6cells(wake_sc >> 12);
-                        mask[3]  = 0xFF;
-
-                        /* Header */
-                        match[4] = 0x50; /* mode1 = mode0 = 0, ignore toggle */
-                        mask[4]  = 0xF0;
-                        match[5] = 0x09; /* start bit = 1, mode2 = 0 */
-                        mask[5]  = 0x0F;
-
-                        rc6_csl = 44;
-
-                } else if (wake_rc6mode == 6) {
-                        i = 0;
-
-                        /* Command */
-                        match[i]  = wbcir_to_rc6cells(wake_sc >>  0);
-                        mask[i++] = 0xFF;
-                        match[i]  = wbcir_to_rc6cells(wake_sc >>  4);
-                        mask[i++] = 0xFF;
-
-                        /* Address + Toggle */
-                        match[i]  = wbcir_to_rc6cells(wake_sc >>  8);
-                        mask[i++] = 0xFF;
-                        match[i]  = wbcir_to_rc6cells(wake_sc >> 12);
-                        mask[i++] = 0x3F;
-
-                        /* Customer bits 7 - 0 */
-                        match[i]  = wbcir_to_rc6cells(wake_sc >> 16);
-                        mask[i++] = 0xFF;
-                        match[i]  = wbcir_to_rc6cells(wake_sc >> 20);
-                        mask[i++] = 0xFF;
-
-                        if (wake_sc & 0x80000000) {
-                                /* Customer range bit and bits 15 - 8 */
-                                match[i]  = wbcir_to_rc6cells(wake_sc >> 24);
-                                mask[i++] = 0xFF;
-                                match[i]  = wbcir_to_rc6cells(wake_sc >> 28);
-                                mask[i++] = 0xFF;
-                                rc6_csl = 76;
-                        } else if (wake_sc <= 0x007FFFFF) {
-                                rc6_csl = 60;
-                        } else {
-                                do_wake = 0;
-                                dev_err(dev, "RC6 - Invalid wake scancode\n");
-                                break;
-                        }
-
-                        /* Header */
-                        match[i]  = 0x93; /* mode1 = mode0 = 1, submode = 0 */
-                        mask[i++] = 0xFF;
-                        match[i]  = 0x0A; /* start bit = 1, mode2 = 1 */
-                        mask[i++] = 0x0F;
-
-                } else {
-                        do_wake = 0;
-                        dev_err(dev, "RC6 - Invalid wake mode\n");
-                }
-
-                break;
-
-        default:
-                do_wake = 0;
-                break;
-        }
-
-finish:
-        if (do_wake) {
-                /* Set compare and compare mask */
-                wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_INDEX,
-                               WBCIR_REGSEL_COMPARE | WBCIR_REG_ADDR0,
-                               0x3F);
-                outsb(data->wbase + WBCIR_REG_WCEIR_DATA, match, 11);
-                wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_INDEX,
-                               WBCIR_REGSEL_MASK | WBCIR_REG_ADDR0,
-                               0x3F);
-                outsb(data->wbase + WBCIR_REG_WCEIR_DATA, mask, 11);
-
-                /* RC6 Compare String Len */
-                outb(rc6_csl, data->wbase + WBCIR_REG_WCEIR_CSL);
-
-                /* Clear status bits NEC_REP, BUFF, MSG_END, MATCH */
-                wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_STS, 0x17, 0x17);
-
-                /* Clear BUFF_EN, Clear END_EN, Set MATCH_EN */
-                wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_EV_EN, 0x01, 0x07);
-
-                /* Set CEIR_EN */
-                wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_CTL, 0x01, 0x01);
-
-        } else {
-                /* Clear BUFF_EN, Clear END_EN, Clear MATCH_EN */
-                wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_EV_EN, 0x00, 0x07);
-
-                /* Clear CEIR_EN */
-                wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_CTL, 0x00, 0x01);
-        }
-
-        /* Disable interrupts */
-        wbcir_select_bank(data, WBCIR_BANK_0);
-        outb(WBCIR_IRQ_NONE, data->sbase + WBCIR_REG_SP3_IER);
-
-        /*
-         * ACPI will set the HW disable bit for SP3 which means that the
-         * output signals are left in an undefined state which may cause
-         * spurious interrupts which we need to ignore until the hardware
-         * is reinitialized.
-         */
-        disable_irq(data->irq);
-}
-
-static int
-wbcir_suspend(struct pnp_dev *device, pm_message_t state)
-{
-        wbcir_shutdown(device);
-        return 0;
-}
-
-static void
-wbcir_init_hw(struct wbcir_data *data)
-{
-        u8 tmp;
-
-        /* Disable interrupts */
-        wbcir_select_bank(data, WBCIR_BANK_0);
-        outb(WBCIR_IRQ_NONE, data->sbase + WBCIR_REG_SP3_IER);
-
-        /* Set PROT_SEL, RX_INV, Clear CEIR_EN (needed for the led) */
-        tmp = protocol << 4;
-        if (invert)
-                tmp |= 0x08;
-        outb(tmp, data->wbase + WBCIR_REG_WCEIR_CTL);
-
-        /* Clear status bits NEC_REP, BUFF, MSG_END, MATCH */
-        wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_STS, 0x17, 0x17);
-
-        /* Clear BUFF_EN, Clear END_EN, Clear MATCH_EN */
-        wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_EV_EN, 0x00, 0x07);
-
-        /* Set RC5 cell time to correspond to 36 kHz */
-        wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_CFG1, 0x4A, 0x7F);
-
-        /* Set IRTX_INV */
-        if (invert)
-                outb(0x04, data->ebase + WBCIR_REG_ECEIR_CCTL);
-        else
-                outb(0x00, data->ebase + WBCIR_REG_ECEIR_CCTL);
-
-        /*
-         * Clear IR LED, set SP3 clock to 24Mhz
-         * set SP3_IRRX_SW to binary 01, helpfully not documented
-         */
-        outb(0x10, data->ebase + WBCIR_REG_ECEIR_CTS);
-
-        /* Enable extended mode */
-        wbcir_select_bank(data, WBCIR_BANK_2);
-        outb(WBCIR_EXT_ENABLE, data->sbase + WBCIR_REG_SP3_EXCR1);
-
-        /*
-         * Configure baud generator, IR data will be sampled at
-         * a bitrate of: (24Mhz * prescaler) / (divisor * 16).
-         *
-         * The ECIR registers include a flag to change the
-         * 24Mhz clock freq to 48Mhz.
-         *
-         * It's not documented in the specs, but fifo levels
-         * other than 16 seems to be unsupported.
-         */
-
-        /* prescaler 1.0, tx/rx fifo lvl 16 */
-        outb(0x30, data->sbase + WBCIR_REG_SP3_EXCR2);
-
-        /* Set baud divisor to generate one byte per bit/cell */
-        switch (protocol) {
-        case IR_PROTOCOL_RC5:
-                outb(0xA7, data->sbase + WBCIR_REG_SP3_BGDL);
-                break;
-        case IR_PROTOCOL_RC6:
-                outb(0x53, data->sbase + WBCIR_REG_SP3_BGDL);
-                break;
-        case IR_PROTOCOL_NEC:
-                outb(0x69, data->sbase + WBCIR_REG_SP3_BGDL);
-                break;
-        }
-        outb(0x00, data->sbase + WBCIR_REG_SP3_BGDH);
-
-        /* Set CEIR mode */
-        wbcir_select_bank(data, WBCIR_BANK_0);
-        outb(0xC0, data->sbase + WBCIR_REG_SP3_MCR);
-        inb(data->sbase + WBCIR_REG_SP3_LSR); /* Clear LSR */
-        inb(data->sbase + WBCIR_REG_SP3_MSR); /* Clear MSR */
-
-        /* Disable RX demod, run-length encoding/decoding, set freq span */
-        wbcir_select_bank(data, WBCIR_BANK_7);
-        outb(0x10, data->sbase + WBCIR_REG_SP3_RCCFG);
-
-        /* Disable timer */
-        wbcir_select_bank(data, WBCIR_BANK_4);
-        outb(0x00, data->sbase + WBCIR_REG_SP3_IRCR1);
-
-        /* Enable MSR interrupt, Clear AUX_IRX */
-        wbcir_select_bank(data, WBCIR_BANK_5);
-        outb(0x00, data->sbase + WBCIR_REG_SP3_IRCR2);
-
-        /* Disable CRC */
-        wbcir_select_bank(data, WBCIR_BANK_6);
-        outb(0x20, data->sbase + WBCIR_REG_SP3_IRCR3);
-
-        /* Set RX/TX (de)modulation freq, not really used */
-        wbcir_select_bank(data, WBCIR_BANK_7);
-        outb(0xF2, data->sbase + WBCIR_REG_SP3_IRRXDC);
-        outb(0x69, data->sbase + WBCIR_REG_SP3_IRTXMC);
-
-        /* Set invert and pin direction */
-        if (invert)
-                outb(0x10, data->sbase + WBCIR_REG_SP3_IRCFG4);
-        else
-                outb(0x00, data->sbase + WBCIR_REG_SP3_IRCFG4);
-
-        /* Set FIFO thresholds (RX = 8, TX = 3), reset RX/TX */
-        wbcir_select_bank(data, WBCIR_BANK_0);
-        outb(0x97, data->sbase + WBCIR_REG_SP3_FCR);
-
-        /* Clear AUX status bits */
-        outb(0xE0, data->sbase + WBCIR_REG_SP3_ASCR);
-
-        /* Enable interrupts */
-        wbcir_reset_irdata(data);
-        outb(WBCIR_IRQ_RX | WBCIR_IRQ_ERR, data->sbase + WBCIR_REG_SP3_IER);
-}
-
-static int
-wbcir_resume(struct pnp_dev *device)
-{
-        struct wbcir_data *data = pnp_get_drvdata(device);
-
-        wbcir_init_hw(data);
-        enable_irq(data->irq);
-
-        return 0;
-}
-
-static int __devinit
-wbcir_probe(struct pnp_dev *device, const struct pnp_device_id *dev_id)
-{
-        struct device *dev = &device->dev;
-        struct wbcir_data *data;
-        int err;
-
-        if (!(pnp_port_len(device, 0) == EHFUNC_IOMEM_LEN &&
-              pnp_port_len(device, 1) == WAKEUP_IOMEM_LEN &&
-              pnp_port_len(device, 2) == SP_IOMEM_LEN)) {
-                dev_err(dev, "Invalid resources\n");
-                return -ENODEV;
-        }
-
-        data = kzalloc(sizeof(*data), GFP_KERNEL);
-        if (!data) {
-                err = -ENOMEM;
-                goto exit;
-        }
-
-        pnp_set_drvdata(device, data);
-
-        data->ebase = pnp_port_start(device, 0);
-        data->wbase = pnp_port_start(device, 1);
-        data->sbase = pnp_port_start(device, 2);
-        data->irq = pnp_irq(device, 0);
-
-        if (data->wbase == 0 || data->ebase == 0 ||
-            data->sbase == 0 || data->irq == 0) {
-                err = -ENODEV;
-                dev_err(dev, "Invalid resources\n");
-                goto exit_free_data;
-        }
-
-        dev_dbg(&device->dev, "Found device "
-                "(w: 0x%lX, e: 0x%lX, s: 0x%lX, i: %u)\n",
-                data->wbase, data->ebase, data->sbase, data->irq);
-
-        if (!request_region(data->wbase, WAKEUP_IOMEM_LEN, DRVNAME)) {
-                dev_err(dev, "Region 0x%lx-0x%lx already in use!\n",
-                        data->wbase, data->wbase + WAKEUP_IOMEM_LEN - 1);
-                err = -EBUSY;
-                goto exit_free_data;
-        }
-
-        if (!request_region(data->ebase, EHFUNC_IOMEM_LEN, DRVNAME)) {
-                dev_err(dev, "Region 0x%lx-0x%lx already in use!\n",
-                        data->ebase, data->ebase + EHFUNC_IOMEM_LEN - 1);
-                err = -EBUSY;
-                goto exit_release_wbase;
-        }
-
-        if (!request_region(data->sbase, SP_IOMEM_LEN, DRVNAME)) {
-                dev_err(dev, "Region 0x%lx-0x%lx already in use!\n",
-                        data->sbase, data->sbase + SP_IOMEM_LEN - 1);
-                err = -EBUSY;
-                goto exit_release_ebase;
-        }
-
-        err = request_irq(data->irq, wbcir_irq_handler,
-                          IRQF_DISABLED, DRVNAME, device);
-        if (err) {
-                dev_err(dev, "Failed to claim IRQ %u\n", data->irq);
-                err = -EBUSY;
-                goto exit_release_sbase;
-        }
-
-        led_trigger_register_simple("cir-tx", &data->txtrigger);
-        if (!data->txtrigger) {
-                err = -ENOMEM;
-                goto exit_free_irq;
-        }
-
-        led_trigger_register_simple("cir-rx", &data->rxtrigger);
-        if (!data->rxtrigger) {
-                err = -ENOMEM;
-                goto exit_unregister_txtrigger;
-        }
-
-        data->led.name = "cir::activity";
-        data->led.default_trigger = "cir-rx";
-        data->led.brightness_set = wbcir_led_brightness_set;
-        data->led.brightness_get = wbcir_led_brightness_get;
-        err = led_classdev_register(&device->dev, &data->led);
-        if (err)
-                goto exit_unregister_rxtrigger;
-
-        data->input_dev = input_allocate_device();
-        if (!data->input_dev) {
-                err = -ENOMEM;
-                goto exit_unregister_led;
-        }
-
-        data->input_dev->evbit[0] = BIT(EV_KEY);
-        data->input_dev->name = WBCIR_NAME;
-        data->input_dev->phys = "wbcir/cir0";
-        data->input_dev->id.bustype = BUS_HOST;
-        data->input_dev->id.vendor  = PCI_VENDOR_ID_WINBOND;
-        data->input_dev->id.product = WBCIR_ID_FAMILY;
-        data->input_dev->id.version = WBCIR_ID_CHIP;
-        data->input_dev->getkeycode = wbcir_getkeycode;
-        data->input_dev->setkeycode = wbcir_setkeycode;
-        input_set_capability(data->input_dev, EV_MSC, MSC_SCAN);
-        input_set_drvdata(data->input_dev, data);
-
-        err = input_register_device(data->input_dev);
-        if (err)
-                goto exit_free_input;
-
-        data->last_scancode = INVALID_SCANCODE;
-        INIT_LIST_HEAD(&data->keytable);
-        setup_timer(&data->timer_keyup, wbcir_keyup, (unsigned long)data);
-
-        /* Load default keymaps */
-        if (protocol == IR_PROTOCOL_RC6) {
-                int i;
-                for (i = 0; i < ARRAY_SIZE(rc6_def_keymap); i++) {
-                        err = wbcir_setkeycode(data->input_dev,
-                                               (int)rc6_def_keymap[i].scancode,
-                                               (int)rc6_def_keymap[i].keycode);
-                        if (err)
-                                goto exit_unregister_keys;
-                }
-        }
-
-        device_init_wakeup(&device->dev, 1);
-
-        wbcir_init_hw(data);
-
-        return 0;
-
-exit_unregister_keys:
-        if (!list_empty(&data->keytable)) {
-                struct wbcir_keyentry *key;
-                struct wbcir_keyentry *keytmp;
-
-                list_for_each_entry_safe(key, keytmp, &data->keytable, list) {
-                        list_del(&key->list);
-                        kfree(key);
-                }
-        }
-        input_unregister_device(data->input_dev);
-        /* Can't call input_free_device on an unregistered device */
-        data->input_dev = NULL;
-exit_free_input:
-        input_free_device(data->input_dev);
-exit_unregister_led:
-        led_classdev_unregister(&data->led);
-exit_unregister_rxtrigger:
-        led_trigger_unregister_simple(data->rxtrigger);
-exit_unregister_txtrigger:
-        led_trigger_unregister_simple(data->txtrigger);
-exit_free_irq:
-        free_irq(data->irq, device);
-exit_release_sbase:
-        release_region(data->sbase, SP_IOMEM_LEN);
-exit_release_ebase:
-        release_region(data->ebase, EHFUNC_IOMEM_LEN);
-exit_release_wbase:
-        release_region(data->wbase, WAKEUP_IOMEM_LEN);
-exit_free_data:
-        kfree(data);
-        pnp_set_drvdata(device, NULL);
-exit:
-        return err;
-}
-
-static void __devexit
-wbcir_remove(struct pnp_dev *device)
-{
-        struct wbcir_data *data = pnp_get_drvdata(device);
-        struct wbcir_keyentry *key;
-        struct wbcir_keyentry *keytmp;
-
-        /* Disable interrupts */
-        wbcir_select_bank(data, WBCIR_BANK_0);
-        outb(WBCIR_IRQ_NONE, data->sbase + WBCIR_REG_SP3_IER);
-
-        del_timer_sync(&data->timer_keyup);
-
-        free_irq(data->irq, device);
-
-        /* Clear status bits NEC_REP, BUFF, MSG_END, MATCH */
-        wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_STS, 0x17, 0x17);
-
-        /* Clear CEIR_EN */
-        wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_CTL, 0x00, 0x01);
-
-        /* Clear BUFF_EN, END_EN, MATCH_EN */
-        wbcir_set_bits(data->wbase + WBCIR_REG_WCEIR_EV_EN, 0x00, 0x07);
-
-        /* This will generate a keyup event if necessary */
-        input_unregister_device(data->input_dev);
-
-        led_trigger_unregister_simple(data->rxtrigger);
-        led_trigger_unregister_simple(data->txtrigger);
-        led_classdev_unregister(&data->led);
-
-        /* This is ok since &data->led isn't actually used */
-        wbcir_led_brightness_set(&data->led, LED_OFF);
-
-        release_region(data->wbase, WAKEUP_IOMEM_LEN);
-        release_region(data->ebase, EHFUNC_IOMEM_LEN);
-        release_region(data->sbase, SP_IOMEM_LEN);
-
-        list_for_each_entry_safe(key, keytmp, &data->keytable, list) {
-                list_del(&key->list);
-                kfree(key);
-        }
-
-        kfree(data);
-
-        pnp_set_drvdata(device, NULL);
-}
-
-static const struct pnp_device_id wbcir_ids[] = {
-        { "WEC1022", 0 },
-        { "", 0 }
-};
-MODULE_DEVICE_TABLE(pnp, wbcir_ids);
-
-static struct pnp_driver wbcir_driver = {
-        .name     = WBCIR_NAME,
-        .id_table = wbcir_ids,
-        .probe    = wbcir_probe,
-        .remove   = __devexit_p(wbcir_remove),
-        .suspend  = wbcir_suspend,
-        .resume   = wbcir_resume,
-        .shutdown = wbcir_shutdown
-};
-
-static int __init
-wbcir_init(void)
-{
-        int ret;
-
-        switch (protocol) {
-        case IR_PROTOCOL_RC5:
-        case IR_PROTOCOL_NEC:
-        case IR_PROTOCOL_RC6:
-                break;
-        default:
-                printk(KERN_ERR DRVNAME ": Invalid protocol argument\n");
-                return -EINVAL;
-        }
-
-        ret = pnp_register_driver(&wbcir_driver);
-        if (ret)
-                printk(KERN_ERR DRVNAME ": Unable to register driver\n");
-
-        return ret;
-}
-
-static void __exit
-wbcir_exit(void)
-{
-        pnp_unregister_driver(&wbcir_driver);
-}
-
-MODULE_AUTHOR("David Härdeman <david@hardeman.nu>");
-MODULE_DESCRIPTION("Winbond SuperI/O Consumer IR Driver");
-MODULE_LICENSE("GPL");
-
-module_init(wbcir_init);
-module_exit(wbcir_exit);
-
-
diff --git a/drivers/input/misc/wistron_btns.c b/drivers/input/misc/wistron_btns.c
index 12501de0c5cd..52b419348983 100644
--- a/drivers/input/misc/wistron_btns.c
+++ b/drivers/input/misc/wistron_btns.c
@@ -274,7 +274,7 @@ static struct key_entry keymap_fs_amilo_pro_v3505[] __initdata = {
         { KE_BLUETOOTH, 0x30 },                      /* Fn+F10 */
         { KE_KEY,       0x31, {KEY_MAIL} },          /* mail button */
         { KE_KEY,       0x36, {KEY_WWW} },           /* www button */
-        { KE_WIFI,      0x78 },                      /* satelite dish button */
+        { KE_WIFI,      0x78 },                      /* satellite dish button */
         { KE_END,       0 }
 };
 
diff --git a/drivers/input/xen-kbdfront.c b/drivers/input/misc/xen-kbdfront.c
index ebb11907d402..62bae99424e6 100644
--- a/drivers/input/xen-kbdfront.c
+++ b/drivers/input/misc/xen-kbdfront.c
@@ -11,11 +11,7 @@
  *  more details.
  */
 
-/*
- * TODO:
- *
- * Switch to grant tables together with xen-fbfront.c.
- */
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 
 #include <linux/kernel.h>
 #include <linux/errno.h>
@@ -28,6 +24,8 @@
 #include <xen/xen.h>
 #include <xen/events.h>
 #include <xen/page.h>
+#include <xen/grant_table.h>
+#include <xen/interface/grant_table.h>
 #include <xen/interface/io/fbif.h>
 #include <xen/interface/io/kbdif.h>
 #include <xen/xenbus.h>
@@ -36,6 +34,7 @@ struct xenkbd_info {
         struct input_dev *kbd;
         struct input_dev *ptr;
         struct xenkbd_page *page;
+        int gref;
         int irq;
         struct xenbus_device *xbdev;
         char phys[32];
@@ -84,9 +83,8 @@ static irqreturn_t input_handler(int rq, void *dev_id)
                                 input_report_key(dev, event->key.keycode,
                                                  event->key.pressed);
                         else
-                                printk(KERN_WARNING
-                                       "xenkbd: unhandled keycode 0x%x\n",
-                                       event->key.keycode);
+                                pr_warning("unhandled keycode 0x%x\n",
+                                           event->key.keycode);
                         break;
                 case XENKBD_TYPE_POS:
                         input_report_abs(dev, ABS_X, event->pos.abs_x);
@@ -109,7 +107,7 @@ static irqreturn_t input_handler(int rq, void *dev_id)
 static int __devinit xenkbd_probe(struct xenbus_device *dev,
                                   const struct xenbus_device_id *id)
 {
-        int ret, i;
+        int ret, i, abs;
         struct xenkbd_info *info;
         struct input_dev *kbd, *ptr;
 
@@ -121,12 +119,18 @@ static int __devinit xenkbd_probe(struct xenbus_device *dev,
         dev_set_drvdata(&dev->dev, info);
         info->xbdev = dev;
         info->irq = -1;
+        info->gref = -1;
         snprintf(info->phys, sizeof(info->phys), "xenbus/%s", dev->nodename);
 
         info->page = (void *)__get_free_page(GFP_KERNEL | __GFP_ZERO);
         if (!info->page)
                 goto error_nomem;
 
+        if (xenbus_scanf(XBT_NIL, dev->otherend, "feature-abs-pointer", "%d", &abs) < 0)
+                abs = 0;
+        if (abs)
+                xenbus_printf(XBT_NIL, dev->nodename, "request-abs-pointer", "1");
+
         /* keyboard */
         kbd = input_allocate_device();
         if (!kbd)
@@ -136,11 +140,12 @@ static int __devinit xenkbd_probe(struct xenbus_device *dev,
         kbd->id.bustype = BUS_PCI;
         kbd->id.vendor = 0x5853;
         kbd->id.product = 0xffff;
-        kbd->evbit[0] = BIT(EV_KEY);
+
+        __set_bit(EV_KEY, kbd->evbit);
         for (i = KEY_ESC; i < KEY_UNKNOWN; i++)
-                set_bit(i, kbd->keybit);
+                __set_bit(i, kbd->keybit);
         for (i = KEY_OK; i < KEY_MAX; i++)
-                set_bit(i, kbd->keybit);
+                __set_bit(i, kbd->keybit);
 
         ret = input_register_device(kbd);
         if (ret) {
@@ -159,12 +164,20 @@ static int __devinit xenkbd_probe(struct xenbus_device *dev,
         ptr->id.bustype = BUS_PCI;
         ptr->id.vendor = 0x5853;
         ptr->id.product = 0xfffe;
-        ptr->evbit[0] = BIT(EV_KEY) | BIT(EV_REL) | BIT(EV_ABS);
+
+        if (abs) {
+                __set_bit(EV_ABS, ptr->evbit);
+                input_set_abs_params(ptr, ABS_X, 0, XENFB_WIDTH, 0, 0);
+                input_set_abs_params(ptr, ABS_Y, 0, XENFB_HEIGHT, 0, 0);
+        } else {
+                input_set_capability(ptr, EV_REL, REL_X);
+                input_set_capability(ptr, EV_REL, REL_Y);
+        }
+        input_set_capability(ptr, EV_REL, REL_WHEEL);
+
+        __set_bit(EV_KEY, ptr->evbit);
         for (i = BTN_LEFT; i <= BTN_TASK; i++)
-                set_bit(i, ptr->keybit);
-        ptr->relbit[0] = BIT(REL_X) | BIT(REL_Y) | BIT(REL_WHEEL);
-        input_set_abs_params(ptr, ABS_X, 0, XENFB_WIDTH, 0, 0);
-        input_set_abs_params(ptr, ABS_Y, 0, XENFB_HEIGHT, 0, 0);
+                __set_bit(i, ptr->keybit);
 
         ret = input_register_device(ptr);
         if (ret) {
@@ -217,15 +230,20 @@ static int xenkbd_connect_backend(struct xenbus_device *dev,
         int ret, evtchn;
         struct xenbus_transaction xbt;
 
+        ret = gnttab_grant_foreign_access(dev->otherend_id,
+                                          virt_to_mfn(info->page), 0);
+        if (ret < 0)
+                return ret;
+        info->gref = ret;
+
         ret = xenbus_alloc_evtchn(dev, &evtchn);
         if (ret)
-                return ret;
+                goto error_grant;
         ret = bind_evtchn_to_irqhandler(evtchn, input_handler,
                                         0, dev->devicetype, info);
         if (ret < 0) {
-                xenbus_free_evtchn(dev, evtchn);
                 xenbus_dev_fatal(dev, ret, "bind_evtchn_to_irqhandler");
-                return ret;
+                goto error_evtchan;
         }
         info->irq = ret;
 
@@ -233,12 +251,15 @@ static int xenkbd_connect_backend(struct xenbus_device *dev,
         ret = xenbus_transaction_start(&xbt);
         if (ret) {
                 xenbus_dev_fatal(dev, ret, "starting transaction");
-                return ret;
+                goto error_irqh;
         }
         ret = xenbus_printf(xbt, dev->nodename, "page-ref", "%lu",
                             virt_to_mfn(info->page));
         if (ret)
                 goto error_xenbus;
+        ret = xenbus_printf(xbt, dev->nodename, "page-gref", "%u", info->gref);
+        if (ret)
+                goto error_xenbus;
         ret = xenbus_printf(xbt, dev->nodename, "event-channel", "%u",
                             evtchn);
         if (ret)
@@ -248,7 +269,7 @@ static int xenkbd_connect_backend(struct xenbus_device *dev,
                 if (ret == -EAGAIN)
                         goto again;
                 xenbus_dev_fatal(dev, ret, "completing transaction");
-                return ret;
+                goto error_irqh;
         }
 
         xenbus_switch_state(dev, XenbusStateInitialised);
@@ -257,6 +278,14 @@ static int xenkbd_connect_backend(struct xenbus_device *dev,
  error_xenbus:
         xenbus_transaction_end(xbt, 1);
         xenbus_dev_fatal(dev, ret, "writing xenstore");
+ error_irqh:
+        unbind_from_irqhandler(info->irq, info);
+        info->irq = -1;
+ error_evtchan:
+        xenbus_free_evtchn(dev, evtchn);
+ error_grant:
+        gnttab_end_foreign_access_ref(info->gref, 0);
+        info->gref = -1;
         return ret;
 }
 
@@ -265,6 +294,9 @@ static void xenkbd_disconnect_backend(struct xenkbd_info *info)
         if (info->irq >= 0)
                 unbind_from_irqhandler(info->irq, info);
         info->irq = -1;
+        if (info->gref >= 0)
+                gnttab_end_foreign_access_ref(info->gref, 0);
+        info->gref = -1;
 }
 
 static void xenkbd_backend_changed(struct xenbus_device *dev,
@@ -276,6 +308,8 @@ static void xenkbd_backend_changed(struct xenbus_device *dev,
         switch (backend_state) {
         case XenbusStateInitialising:
         case XenbusStateInitialised:
+        case XenbusStateReconfiguring:
+        case XenbusStateReconfigured:
         case XenbusStateUnknown:
         case XenbusStateClosed:
                 break;
@@ -290,9 +324,9 @@ InitWait:
                         ret = xenbus_printf(XBT_NIL, info->xbdev->nodename,
                                             "request-abs-pointer", "1");
                         if (ret)
-                                printk(KERN_WARNING
-                                       "xenkbd: can't request abs-pointer");
+                                pr_warning("xenkbd: can't request abs-pointer");
                 }
+
                 xenbus_switch_state(dev, XenbusStateConnected);
                 break;
 
diff --git a/drivers/input/mouse/Kconfig b/drivers/input/mouse/Kconfig
index c714ca2407f8..9c1e6ee83531 100644
--- a/drivers/input/mouse/Kconfig
+++ b/drivers/input/mouse/Kconfig
@@ -30,6 +30,7 @@ config MOUSE_PS2
                 <http://w1.894.telia.com/~u89404340/touchpad/index.html>
           and a new version of GPM at:
                 <http://www.geocities.com/dt_or/gpm/gpm.html>
+                <http://xorg.freedesktop.org/archive/individual/driver/>
           to take advantage of the advanced features of the touchpad.
 
           If unsure, say Y.
@@ -38,7 +39,7 @@ config MOUSE_PS2
           module will be called psmouse.
 
 config MOUSE_PS2_ALPS
-        bool "ALPS PS/2 mouse protocol extension" if EMBEDDED
+        bool "ALPS PS/2 mouse protocol extension" if EXPERT
         default y
         depends on MOUSE_PS2
         help
@@ -48,7 +49,7 @@ config MOUSE_PS2_ALPS
           If unsure, say Y.
 
 config MOUSE_PS2_LOGIPS2PP
-        bool "Logitech PS/2++ mouse protocol extension" if EMBEDDED
+        bool "Logitech PS/2++ mouse protocol extension" if EXPERT
         default y
         depends on MOUSE_PS2
         help
@@ -58,7 +59,7 @@ config MOUSE_PS2_LOGIPS2PP
           If unsure, say Y.
 
 config MOUSE_PS2_SYNAPTICS
-        bool "Synaptics PS/2 mouse protocol extension" if EMBEDDED
+        bool "Synaptics PS/2 mouse protocol extension" if EXPERT
         default y
         depends on MOUSE_PS2
         help
@@ -68,7 +69,7 @@ config MOUSE_PS2_SYNAPTICS
           If unsure, say Y.
 
 config MOUSE_PS2_LIFEBOOK
-        bool "Fujitsu Lifebook PS/2 mouse protocol extension" if EMBEDDED
+        bool "Fujitsu Lifebook PS/2 mouse protocol extension" if EXPERT
         default y
         depends on MOUSE_PS2 && X86 && DMI
         help
@@ -78,7 +79,7 @@ config MOUSE_PS2_LIFEBOOK
           If unsure, say Y.
 
 config MOUSE_PS2_TRACKPOINT
-        bool "IBM Trackpoint PS/2 mouse protocol extension" if EMBEDDED
+        bool "IBM Trackpoint PS/2 mouse protocol extension" if EXPERT
         default y
         depends on MOUSE_PS2
         help
diff --git a/drivers/input/mouse/appletouch.c b/drivers/input/mouse/appletouch.c
index a9cf76831634..b77f9991278e 100644
--- a/drivers/input/mouse/appletouch.c
+++ b/drivers/input/mouse/appletouch.c
@@ -630,7 +630,7 @@ static void atp_complete_geyser_3_4(struct urb *urb)
         /* Just update the base values (i.e. touchpad in untouched state) */
         if (dev->data[dev->info->datalen - 1] & ATP_STATUS_BASE_UPDATE) {
 
-                dprintk(KERN_DEBUG "appletouch: updated base values\n");
+                dprintk("appletouch: updated base values\n");
 
                 memcpy(dev->xy_old, dev->xy_cur, sizeof(dev->xy_old));
                 goto exit;
diff --git a/drivers/input/mouse/atarimouse.c b/drivers/input/mouse/atarimouse.c
index adf45b3040e9..5c4a692bf73a 100644
--- a/drivers/input/mouse/atarimouse.c
+++ b/drivers/input/mouse/atarimouse.c
@@ -77,15 +77,15 @@ static void atamouse_interrupt(char *buf)
 #endif
 
         /* only relative events get here */
-        dx =  buf[1];
-        dy = -buf[2];
+        dx = buf[1];
+        dy = buf[2];
 
         input_report_rel(atamouse_dev, REL_X, dx);
         input_report_rel(atamouse_dev, REL_Y, dy);
 
-        input_report_key(atamouse_dev, BTN_LEFT,   buttons & 0x1);
+        input_report_key(atamouse_dev, BTN_LEFT,   buttons & 0x4);
         input_report_key(atamouse_dev, BTN_MIDDLE, buttons & 0x2);
-        input_report_key(atamouse_dev, BTN_RIGHT,  buttons & 0x4);
+        input_report_key(atamouse_dev, BTN_RIGHT,  buttons & 0x1);
 
         input_sync(atamouse_dev);
 
@@ -108,7 +108,7 @@ static int atamouse_open(struct input_dev *dev)
 static void atamouse_close(struct input_dev *dev)
 {
         ikbd_mouse_disable();
-        atari_mouse_interrupt_hook = NULL;
+        atari_input_mouse_interrupt_hook = NULL;
 }
 
 static int __init atamouse_init(void)
@@ -118,8 +118,9 @@ static int __init atamouse_init(void)
         if (!MACH_IS_ATARI || !ATARIHW_PRESENT(ST_MFP))
                 return -ENODEV;
 
-        if (!atari_keyb_init())
-                return -ENODEV;
+        error = atari_keyb_init();
+        if (error)
+                return error;
 
         atamouse_dev = input_allocate_device();
         if (!atamouse_dev)
diff --git a/drivers/input/mouse/bcm5974.c b/drivers/input/mouse/bcm5974.c
index b95231763911..3126983c004a 100644
--- a/drivers/input/mouse/bcm5974.c
+++ b/drivers/input/mouse/bcm5974.c
@@ -55,6 +55,18 @@
 #define USB_DEVICE_ID_APPLE_WELLSPRING3_ANSI    0x0236
 #define USB_DEVICE_ID_APPLE_WELLSPRING3_ISO     0x0237
 #define USB_DEVICE_ID_APPLE_WELLSPRING3_JIS     0x0238
+/* MacbookAir3,2 (unibody), aka wellspring5 */
+#define USB_DEVICE_ID_APPLE_WELLSPRING4_ANSI    0x023f
+#define USB_DEVICE_ID_APPLE_WELLSPRING4_ISO     0x0240
+#define USB_DEVICE_ID_APPLE_WELLSPRING4_JIS     0x0241
+/* MacbookAir3,1 (unibody), aka wellspring4 */
+#define USB_DEVICE_ID_APPLE_WELLSPRING4A_ANSI   0x0242
+#define USB_DEVICE_ID_APPLE_WELLSPRING4A_ISO    0x0243
+#define USB_DEVICE_ID_APPLE_WELLSPRING4A_JIS    0x0244
+/* Macbook8 (unibody, March 2011) */
+#define USB_DEVICE_ID_APPLE_WELLSPRING5_ANSI    0x0245
+#define USB_DEVICE_ID_APPLE_WELLSPRING5_ISO     0x0246
+#define USB_DEVICE_ID_APPLE_WELLSPRING5_JIS     0x0247
 
 #define BCM5974_DEVICE(prod) {                                  \
         .match_flags = (USB_DEVICE_ID_MATCH_DEVICE |            \
@@ -80,6 +92,18 @@ static const struct usb_device_id bcm5974_table[] = {
         BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING3_ANSI),
         BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING3_ISO),
         BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING3_JIS),
+        /* MacbookAir3,2 */
+        BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING4_ANSI),
+        BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING4_ISO),
+        BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING4_JIS),
+        /* MacbookAir3,1 */
+        BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING4A_ANSI),
+        BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING4A_ISO),
+        BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING4A_JIS),
+        /* MacbookPro8 */
+        BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING5_ANSI),
+        BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING5_ISO),
+        BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING5_JIS),
         /* Terminating entry */
         {}
 };
@@ -234,6 +258,42 @@ static const struct bcm5974_config bcm5974_config_table[] = {
                 { DIM_X, DIM_X / SN_COORD, -4460, 5166 },
                 { DIM_Y, DIM_Y / SN_COORD, -75, 6700 }
         },
+        {
+                USB_DEVICE_ID_APPLE_WELLSPRING4_ANSI,
+                USB_DEVICE_ID_APPLE_WELLSPRING4_ISO,
+                USB_DEVICE_ID_APPLE_WELLSPRING4_JIS,
+                HAS_INTEGRATED_BUTTON,
+                0x84, sizeof(struct bt_data),
+                0x81, TYPE2, FINGER_TYPE2, FINGER_TYPE2 + SIZEOF_ALL_FINGERS,
+                { DIM_PRESSURE, DIM_PRESSURE / SN_PRESSURE, 0, 300 },
+                { DIM_WIDTH, DIM_WIDTH / SN_WIDTH, 0, 2048 },
+                { DIM_X, DIM_X / SN_COORD, -4620, 5140 },
+                { DIM_Y, DIM_Y / SN_COORD, -150, 6600 }
+        },
+        {
+                USB_DEVICE_ID_APPLE_WELLSPRING4A_ANSI,
+                USB_DEVICE_ID_APPLE_WELLSPRING4A_ISO,
+                USB_DEVICE_ID_APPLE_WELLSPRING4A_JIS,
+                HAS_INTEGRATED_BUTTON,
+                0x84, sizeof(struct bt_data),
+                0x81, TYPE2, FINGER_TYPE2, FINGER_TYPE2 + SIZEOF_ALL_FINGERS,
+                { DIM_PRESSURE, DIM_PRESSURE / SN_PRESSURE, 0, 300 },
+                { DIM_WIDTH, DIM_WIDTH / SN_WIDTH, 0, 2048 },
+                { DIM_X, DIM_X / SN_COORD, -4616, 5112 },
+                { DIM_Y, DIM_Y / SN_COORD, -142, 5234 }
+        },
+        {
+                USB_DEVICE_ID_APPLE_WELLSPRING5_ANSI,
+                USB_DEVICE_ID_APPLE_WELLSPRING5_ISO,
+                USB_DEVICE_ID_APPLE_WELLSPRING5_JIS,
+                HAS_INTEGRATED_BUTTON,
+                0x84, sizeof(struct bt_data),
+                0x81, TYPE2, FINGER_TYPE2, FINGER_TYPE2 + SIZEOF_ALL_FINGERS,
+                { DIM_PRESSURE, DIM_PRESSURE / SN_PRESSURE, 0, 300 },
+                { DIM_WIDTH, DIM_WIDTH / SN_WIDTH, 0, 2048 },
+                { DIM_X, DIM_X / SN_COORD, -4415, 5050 },
+                { DIM_Y, DIM_Y / SN_COORD, -55, 6680 }
+        },
         {}
 };
 
@@ -390,10 +450,6 @@ static int report_tp_state(struct bcm5974 *dev, int size)
                 ptest = int2bound(&c->p, raw_p);
                 origin = raw2int(f->origin);
 
-                /* set the integrated button if applicable */
-                if (c->tp_type == TYPE2)
-                        ibt = raw2int(dev->tp_data[BUTTON_TYPE2]);
-
                 /* while tracking finger still valid, count all fingers */
                 if (ptest > PRESSURE_LOW && origin) {
                         abs_p = ptest;
@@ -412,6 +468,10 @@ static int report_tp_state(struct bcm5974 *dev, int size)
                 }
         }
 
+        /* set the integrated button if applicable */
+        if (c->tp_type == TYPE2)
+                ibt = raw2int(dev->tp_data[BUTTON_TYPE2]);
+
         if (dev->fingers < nmin)
                 dev->fingers = nmin;
         if (dev->fingers > nmax)
@@ -579,7 +639,7 @@ exit:
  * device, resulting in trackpad malfunction under certain
  * circumstances. To get around this problem, there is at least one
  * example that utilizes the USB_QUIRK_RESET_RESUME quirk in order to
- * recieve a reset_resume request rather than the normal resume.
+ * receive a reset_resume request rather than the normal resume.
  * Since the implementation of reset_resume is equal to mode switch
  * plus start_traffic, it seems easier to always do the switch when
  * starting traffic on the device.
diff --git a/drivers/input/mouse/elantech.c b/drivers/input/mouse/elantech.c
index 48311204ba51..32503565faf9 100644
--- a/drivers/input/mouse/elantech.c
+++ b/drivers/input/mouse/elantech.c
@@ -16,6 +16,7 @@
 #include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/input.h>
+#include <linux/input/mt.h>
 #include <linux/serio.h>
 #include <linux/libps2.h>
 #include "psmouse.h"
@@ -242,15 +243,37 @@ static void elantech_report_absolute_v1(struct psmouse *psmouse)
         input_sync(dev);
 }
 
+static void elantech_set_slot(struct input_dev *dev, int slot, bool active,
+                              unsigned int x, unsigned int y)
+{
+        input_mt_slot(dev, slot);
+        input_mt_report_slot_state(dev, MT_TOOL_FINGER, active);
+        if (active) {
+                input_report_abs(dev, ABS_MT_POSITION_X, x);
+                input_report_abs(dev, ABS_MT_POSITION_Y, y);
+        }
+}
+
+/* x1 < x2 and y1 < y2 when two fingers, x = y = 0 when not pressed */
+static void elantech_report_semi_mt_data(struct input_dev *dev,
+                                         unsigned int num_fingers,
+                                         unsigned int x1, unsigned int y1,
+                                         unsigned int x2, unsigned int y2)
+{
+        elantech_set_slot(dev, 0, num_fingers != 0, x1, y1);
+        elantech_set_slot(dev, 1, num_fingers == 2, x2, y2);
+}
+
 /*
  * Interpret complete data packets and report absolute mode input events for
  * hardware version 2. (6 byte packets)
  */
 static void elantech_report_absolute_v2(struct psmouse *psmouse)
 {
+        struct elantech_data *etd = psmouse->private;
         struct input_dev *dev = psmouse->dev;
         unsigned char *packet = psmouse->packet;
-        int fingers, x1, y1, x2, y2;
+        unsigned int fingers, x1 = 0, y1 = 0, x2 = 0, y2 = 0, width = 0, pres = 0;
 
         /* byte 0: n1  n0   .   .   .   .   R   L */
         fingers = (packet[0] & 0xc0) >> 6;
@@ -270,14 +293,18 @@ static void elantech_report_absolute_v2(struct psmouse *psmouse)
                  * byte 1:  .   .   .   .   .  x10 x9  x8
                  * byte 2: x7  x6  x5  x4  x4  x2  x1  x0
                  */
-                input_report_abs(dev, ABS_X,
-                        ((packet[1] & 0x07) << 8) | packet[2]);
+                x1 = ((packet[1] & 0x07) << 8) | packet[2];
                 /*
                  * byte 4:  .   .   .   .   .   .  y9  y8
                  * byte 5: y7  y6  y5  y4  y3  y2  y1  y0
                  */
-                input_report_abs(dev, ABS_Y,
-                        ETP_YMAX_V2 - (((packet[4] & 0x03) << 8) | packet[5]));
+                y1 = ETP_YMAX_V2 - (((packet[4] & 0x03) << 8) | packet[5]);
+
+                input_report_abs(dev, ABS_X, x1);
+                input_report_abs(dev, ABS_Y, y1);
+
+                pres = (packet[1] & 0xf0) | ((packet[4] & 0xf0) >> 4);
+                width = ((packet[0] & 0x30) >> 2) | ((packet[3] & 0x30) >> 4);
                 break;
 
         case 2:
@@ -303,23 +330,24 @@ static void elantech_report_absolute_v2(struct psmouse *psmouse)
                  */
                 input_report_abs(dev, ABS_X, x1 << 2);
                 input_report_abs(dev, ABS_Y, y1 << 2);
-                /*
-                 * For compatibility with the proprietary X Elantech driver
-                 * report both coordinates as hat coordinates
-                 */
-                input_report_abs(dev, ABS_HAT0X, x1);
-                input_report_abs(dev, ABS_HAT0Y, y1);
-                input_report_abs(dev, ABS_HAT1X, x2);
-                input_report_abs(dev, ABS_HAT1Y, y2);
+
+                /* Unknown so just report sensible values */
+                pres = 127;
+                width = 7;
                 break;
         }
 
+        elantech_report_semi_mt_data(dev, fingers, x1, y1, x2, y2);
         input_report_key(dev, BTN_TOOL_FINGER, fingers == 1);
         input_report_key(dev, BTN_TOOL_DOUBLETAP, fingers == 2);
         input_report_key(dev, BTN_TOOL_TRIPLETAP, fingers == 3);
         input_report_key(dev, BTN_TOOL_QUADTAP, fingers == 4);
         input_report_key(dev, BTN_LEFT, packet[0] & 0x01);
         input_report_key(dev, BTN_RIGHT, packet[0] & 0x02);
+        if (etd->reports_pressure) {
+                input_report_abs(dev, ABS_PRESSURE, pres);
+                input_report_abs(dev, ABS_TOOL_WIDTH, width);
+        }
 
         input_sync(dev);
 }
@@ -478,10 +506,16 @@ static void elantech_set_input_params(struct psmouse *psmouse)
                 __set_bit(BTN_TOOL_QUADTAP, dev->keybit);
                 input_set_abs_params(dev, ABS_X, ETP_XMIN_V2, ETP_XMAX_V2, 0, 0);
                 input_set_abs_params(dev, ABS_Y, ETP_YMIN_V2, ETP_YMAX_V2, 0, 0);
-                input_set_abs_params(dev, ABS_HAT0X, ETP_2FT_XMIN, ETP_2FT_XMAX, 0, 0);
-                input_set_abs_params(dev, ABS_HAT0Y, ETP_2FT_YMIN, ETP_2FT_YMAX, 0, 0);
-                input_set_abs_params(dev, ABS_HAT1X, ETP_2FT_XMIN, ETP_2FT_XMAX, 0, 0);
-                input_set_abs_params(dev, ABS_HAT1Y, ETP_2FT_YMIN, ETP_2FT_YMAX, 0, 0);
+                if (etd->reports_pressure) {
+                        input_set_abs_params(dev, ABS_PRESSURE, ETP_PMIN_V2,
+                                             ETP_PMAX_V2, 0, 0);
+                        input_set_abs_params(dev, ABS_TOOL_WIDTH, ETP_WMIN_V2,
+                                             ETP_WMAX_V2, 0, 0);
+                }
+                __set_bit(INPUT_PROP_SEMI_MT, dev->propbit);
+                input_mt_init_slots(dev, 2);
+                input_set_abs_params(dev, ABS_MT_POSITION_X, ETP_XMIN_V2, ETP_XMAX_V2, 0, 0);
+                input_set_abs_params(dev, ABS_MT_POSITION_Y, ETP_YMIN_V2, ETP_YMAX_V2, 0, 0);
                 break;
         }
 }
@@ -699,7 +733,7 @@ int elantech_init(struct psmouse *psmouse)
 
         psmouse->private = etd = kzalloc(sizeof(struct elantech_data), GFP_KERNEL);
         if (!etd)
-                return -1;
+                return -ENOMEM;
 
         etd->parity[0] = 1;
         for (i = 1; i < 256; i++)
@@ -725,6 +759,10 @@ int elantech_init(struct psmouse *psmouse)
                 etd->debug = 1;
                 /* Don't know how to do parity checking for version 2 */
                 etd->paritycheck = 0;
+
+                if (etd->fw_version >= 0x020800)
+                        etd->reports_pressure = true;
+
         } else {
                 etd->hw_version = 1;
                 etd->paritycheck = 1;
diff --git a/drivers/input/mouse/elantech.h b/drivers/input/mouse/elantech.h
index aa4aac5d2198..fabb2b99615c 100644
--- a/drivers/input/mouse/elantech.h
+++ b/drivers/input/mouse/elantech.h
@@ -77,6 +77,11 @@
 #define ETP_YMIN_V2                     (   0 + ETP_EDGE_FUZZ_V2)
 #define ETP_YMAX_V2                     ( 768 - ETP_EDGE_FUZZ_V2)
 
+#define ETP_PMIN_V2                     0
+#define ETP_PMAX_V2                     255
+#define ETP_WMIN_V2                     0
+#define ETP_WMAX_V2                     15
+
 /*
  * For two finger touches the coordinate of each finger gets reported
  * separately but with reduced resolution.
@@ -102,6 +107,7 @@ struct elantech_data {
         unsigned char capabilities;
         bool paritycheck;
         bool jumpy_cursor;
+        bool reports_pressure;
         unsigned char hw_version;
         unsigned int fw_version;
         unsigned int single_finger_reports;
diff --git a/drivers/input/mouse/hgpk.c b/drivers/input/mouse/hgpk.c
index 1d2205b24800..95577c15ae56 100644
--- a/drivers/input/mouse/hgpk.c
+++ b/drivers/input/mouse/hgpk.c
@@ -40,6 +40,8 @@
 #include "psmouse.h"
 #include "hgpk.h"
 
+#define ILLEGAL_XY 999999
+
 static bool tpdebug;
 module_param(tpdebug, bool, 0644);
 MODULE_PARM_DESC(tpdebug, "enable debugging, dumping packets to KERN_DEBUG.");
@@ -47,48 +49,150 @@ MODULE_PARM_DESC(tpdebug, "enable debugging, dumping packets to KERN_DEBUG.");
 static int recalib_delta = 100;
 module_param(recalib_delta, int, 0644);
 MODULE_PARM_DESC(recalib_delta,
-        "packets containing a delta this large will cause a recalibration.");
+        "packets containing a delta this large will be discarded, and a "
+        "recalibration may be scheduled.");
 
-static int jumpy_delay = 1000;
+static int jumpy_delay = 20;
 module_param(jumpy_delay, int, 0644);
 MODULE_PARM_DESC(jumpy_delay,
         "delay (ms) before recal after jumpiness detected");
 
-static int spew_delay = 1000;
+static int spew_delay = 1;
 module_param(spew_delay, int, 0644);
 MODULE_PARM_DESC(spew_delay,
         "delay (ms) before recal after packet spew detected");
 
-static int recal_guard_time = 2000;
+static int recal_guard_time;
 module_param(recal_guard_time, int, 0644);
 MODULE_PARM_DESC(recal_guard_time,
         "interval (ms) during which recal will be restarted if packet received");
 
-static int post_interrupt_delay = 1000;
+static int post_interrupt_delay = 40;
 module_param(post_interrupt_delay, int, 0644);
 MODULE_PARM_DESC(post_interrupt_delay,
         "delay (ms) before recal after recal interrupt detected");
 
+static bool autorecal = true;
+module_param(autorecal, bool, 0644);
+MODULE_PARM_DESC(autorecal, "enable recalibration in the driver");
+
+static char hgpk_mode_name[16];
+module_param_string(hgpk_mode, hgpk_mode_name, sizeof(hgpk_mode_name), 0644);
+MODULE_PARM_DESC(hgpk_mode,
+        "default hgpk mode: mouse, glidesensor or pentablet");
+
+static int hgpk_default_mode = HGPK_MODE_MOUSE;
+
+static const char * const hgpk_mode_names[] = {
+        [HGPK_MODE_MOUSE] = "Mouse",
+        [HGPK_MODE_GLIDESENSOR] = "GlideSensor",
+        [HGPK_MODE_PENTABLET] = "PenTablet",
+};
+
+static int hgpk_mode_from_name(const char *buf, int len)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(hgpk_mode_names); i++) {
+                const char *name = hgpk_mode_names[i];
+                if (strlen(name) == len && !strncasecmp(name, buf, len))
+                        return i;
+        }
+
+        return HGPK_MODE_INVALID;
+}
+
+/*
+ * see if new value is within 20% of half of old value
+ */
+static int approx_half(int curr, int prev)
+{
+        int belowhalf, abovehalf;
+
+        if (curr < 5 || prev < 5)
+                return 0;
+
+        belowhalf = (prev * 8) / 20;
+        abovehalf = (prev * 12) / 20;
+
+        return belowhalf < curr && curr <= abovehalf;
+}
+
 /*
- * When the touchpad gets ultra-sensitive, one can keep their finger 1/2"
- * above the pad and still have it send packets.  This causes a jump cursor
- * when one places their finger on the pad.  We can probably detect the
- * jump as we see a large deltas (>= 100px).  In mouse mode, I've been
- * unable to even come close to 100px deltas during normal usage, so I think
- * this threshold is safe.  If a large delta occurs, trigger a recalibration.
+ * Throw out oddly large delta packets, and any that immediately follow whose
+ * values are each approximately half of the previous.  It seems that the ALPS
+ * firmware emits errant packets, and they get averaged out slowly.
  */
-static void hgpk_jumpy_hack(struct psmouse *psmouse, int x, int y)
+static int hgpk_discard_decay_hack(struct psmouse *psmouse, int x, int y)
 {
         struct hgpk_data *priv = psmouse->private;
+        int avx, avy;
+        bool do_recal = false;
+
+        avx = abs(x);
+        avy = abs(y);
+
+        /* discard if too big, or half that but > 4 times the prev delta */
+        if (avx > recalib_delta ||
+                (avx > recalib_delta / 2 && ((avx / 4) > priv->xlast))) {
+                hgpk_err(psmouse, "detected %dpx jump in x\n", x);
+                priv->xbigj = avx;
+        } else if (approx_half(avx, priv->xbigj)) {
+                hgpk_err(psmouse, "detected secondary %dpx jump in x\n", x);
+                priv->xbigj = avx;
+                priv->xsaw_secondary++;
+        } else {
+                if (priv->xbigj && priv->xsaw_secondary > 1)
+                        do_recal = true;
+                priv->xbigj = 0;
+                priv->xsaw_secondary = 0;
+        }
+
+        if (avy > recalib_delta ||
+                (avy > recalib_delta / 2 && ((avy / 4) > priv->ylast))) {
+                hgpk_err(psmouse, "detected %dpx jump in y\n", y);
+                priv->ybigj = avy;
+        } else if (approx_half(avy, priv->ybigj)) {
+                hgpk_err(psmouse, "detected secondary %dpx jump in y\n", y);
+                priv->ybigj = avy;
+                priv->ysaw_secondary++;
+        } else {
+                if (priv->ybigj && priv->ysaw_secondary > 1)
+                        do_recal = true;
+                priv->ybigj = 0;
+                priv->ysaw_secondary = 0;
+        }
 
-        if (abs(x) > recalib_delta || abs(y) > recalib_delta) {
-                hgpk_err(psmouse, ">%dpx jump detected (%d,%d)\n",
-                                recalib_delta, x, y);
-                /* My car gets forty rods to the hogshead and that's the
-                 * way I likes it! */
+        priv->xlast = avx;
+        priv->ylast = avy;
+
+        if (do_recal && jumpy_delay) {
+                hgpk_err(psmouse, "scheduling recalibration\n");
                 psmouse_queue_work(psmouse, &priv->recalib_wq,
                                 msecs_to_jiffies(jumpy_delay));
         }
+
+        return priv->xbigj || priv->ybigj;
+}
+
+static void hgpk_reset_spew_detection(struct hgpk_data *priv)
+{
+        priv->spew_count = 0;
+        priv->dupe_count = 0;
+        priv->x_tally = 0;
+        priv->y_tally = 0;
+        priv->spew_flag = NO_SPEW;
+}
+
+static void hgpk_reset_hack_state(struct psmouse *psmouse)
+{
+        struct hgpk_data *priv = psmouse->private;
+
+        priv->abs_x = priv->abs_y = -1;
+        priv->xlast = priv->ylast = ILLEGAL_XY;
+        priv->xbigj = priv->ybigj = 0;
+        priv->xsaw_secondary = priv->ysaw_secondary = 0;
+        hgpk_reset_spew_detection(priv);
 }
 
 /*
@@ -116,20 +220,57 @@ static void hgpk_spewing_hack(struct psmouse *psmouse,
         if (l || r)
                 return;
 
+        /* don't track spew if the workaround feature has been turned off */
+        if (!spew_delay)
+                return;
+
+        if (abs(x) > 3 || abs(y) > 3) {
+                /* no spew, or spew ended */
+                hgpk_reset_spew_detection(priv);
+                return;
+        }
+
+        /* Keep a tally of the overall delta to the cursor position caused by
+         * the spew */
         priv->x_tally += x;
         priv->y_tally += y;
 
-        if (++priv->count > 100) {
+        switch (priv->spew_flag) {
+        case NO_SPEW:
+                /* we're not spewing, but this packet might be the start */
+                priv->spew_flag = MAYBE_SPEWING;
+
+                /* fall-through */
+
+        case MAYBE_SPEWING:
+                priv->spew_count++;
+
+                if (priv->spew_count < SPEW_WATCH_COUNT)
+                        break;
+
+                /* excessive spew detected, request recalibration */
+                priv->spew_flag = SPEW_DETECTED;
+
+                /* fall-through */
+
+        case SPEW_DETECTED:
+                /* only recalibrate when the overall delta to the cursor
+                 * is really small. if the spew is causing significant cursor
+                 * movement, it is probably a case of the user moving the
+                 * cursor very slowly across the screen. */
                 if (abs(priv->x_tally) < 3 && abs(priv->y_tally) < 3) {
-                        hgpk_dbg(psmouse, "packet spew detected (%d,%d)\n",
+                        hgpk_err(psmouse, "packet spew detected (%d,%d)\n",
                                  priv->x_tally, priv->y_tally);
+                        priv->spew_flag = RECALIBRATING;
                         psmouse_queue_work(psmouse, &priv->recalib_wq,
                                            msecs_to_jiffies(spew_delay));
                 }
-                /* reset every 100 packets */
-                priv->count = 0;
-                priv->x_tally = 0;
-                priv->y_tally = 0;
+
+                break;
+        case RECALIBRATING:
+                /* we already detected a spew and requested a recalibration,
+                 * just wait for the queue to kick into action. */
+                break;
         }
 }
 
@@ -143,25 +284,168 @@ static void hgpk_spewing_hack(struct psmouse *psmouse,
  * swr/swl are the left/right buttons.
  * x-neg/y-neg are the x and y delta negative bits
  * x-over/y-over are the x and y overflow bits
+ *
+ * ---
+ *
+ * HGPK Advanced Mode - single-mode format
+ *
+ * byte 0(PT):  1    1    0    0    1    1     1     1
+ * byte 0(GS):  1    1    1    1    1    1     1     1
+ * byte 1:      0   x6   x5   x4   x3   x2    x1    x0
+ * byte 2(PT):  0    0   x9   x8   x7    ? pt-dsw    0
+ * byte 2(GS):  0  x10   x9   x8   x7    ? gs-dsw pt-dsw
+ * byte 3:      0   y9   y8   y7    1    0   swr   swl
+ * byte 4:      0   y6   y5   y4   y3   y2    y1    y0
+ * byte 5:      0   z6   z5   z4   z3   z2    z1    z0
+ *
+ * ?'s are not defined in the protocol spec, may vary between models.
+ *
+ * swr/swl are the left/right buttons.
+ *
+ * pt-dsw/gs-dsw indicate that the pt/gs sensor is detecting a
+ * pen/finger
  */
-static int hgpk_validate_byte(unsigned char *packet)
+static bool hgpk_is_byte_valid(struct psmouse *psmouse, unsigned char *packet)
 {
-        return (packet[0] & 0x0C) != 0x08;
+        struct hgpk_data *priv = psmouse->private;
+        int pktcnt = psmouse->pktcnt;
+        bool valid;
+
+        switch (priv->mode) {
+        case HGPK_MODE_MOUSE:
+                valid = (packet[0] & 0x0C) == 0x08;
+                break;
+
+        case HGPK_MODE_GLIDESENSOR:
+                valid = pktcnt == 1 ?
+                        packet[0] == HGPK_GS : !(packet[pktcnt - 1] & 0x80);
+                break;
+
+        case HGPK_MODE_PENTABLET:
+                valid = pktcnt == 1 ?
+                        packet[0] == HGPK_PT : !(packet[pktcnt - 1] & 0x80);
+                break;
+
+        default:
+                valid = false;
+                break;
+        }
+
+        if (!valid)
+                hgpk_dbg(psmouse,
+                         "bad data, mode %d (%d) %02x %02x %02x %02x %02x %02x\n",
+                         priv->mode, pktcnt,
+                         psmouse->packet[0], psmouse->packet[1],
+                         psmouse->packet[2], psmouse->packet[3],
+                         psmouse->packet[4], psmouse->packet[5]);
+
+        return valid;
 }
 
-static void hgpk_process_packet(struct psmouse *psmouse)
+static void hgpk_process_advanced_packet(struct psmouse *psmouse)
 {
-        struct input_dev *dev = psmouse->dev;
+        struct hgpk_data *priv = psmouse->private;
+        struct input_dev *idev = psmouse->dev;
         unsigned char *packet = psmouse->packet;
-        int x, y, left, right;
+        int down = !!(packet[2] & 2);
+        int left = !!(packet[3] & 1);
+        int right = !!(packet[3] & 2);
+        int x = packet[1] | ((packet[2] & 0x78) << 4);
+        int y = packet[4] | ((packet[3] & 0x70) << 3);
+
+        if (priv->mode == HGPK_MODE_GLIDESENSOR) {
+                int pt_down = !!(packet[2] & 1);
+                int finger_down = !!(packet[2] & 2);
+                int z = packet[5];
+
+                input_report_abs(idev, ABS_PRESSURE, z);
+                if (tpdebug)
+                        hgpk_dbg(psmouse, "pd=%d fd=%d z=%d",
+                                 pt_down, finger_down, z);
+        } else {
+                /*
+                 * PenTablet mode does not report pressure, so we don't
+                 * report it here
+                 */
+                if (tpdebug)
+                        hgpk_dbg(psmouse, "pd=%d ", down);
+        }
+
+        if (tpdebug)
+                hgpk_dbg(psmouse, "l=%d r=%d x=%d y=%d\n", left, right, x, y);
+
+        input_report_key(idev, BTN_TOUCH, down);
+        input_report_key(idev, BTN_LEFT, left);
+        input_report_key(idev, BTN_RIGHT, right);
+
+        /*
+         * If this packet says that the finger was removed, reset our position
+         * tracking so that we don't erroneously detect a jump on next press.
+         */
+        if (!down) {
+                hgpk_reset_hack_state(psmouse);
+                goto done;
+        }
+
+        /*
+         * Weed out duplicate packets (we get quite a few, and they mess up
+         * our jump detection)
+         */
+        if (x == priv->abs_x && y == priv->abs_y) {
+                if (++priv->dupe_count > SPEW_WATCH_COUNT) {
+                        if (tpdebug)
+                                hgpk_dbg(psmouse, "hard spew detected\n");
+                        priv->spew_flag = RECALIBRATING;
+                        psmouse_queue_work(psmouse, &priv->recalib_wq,
+                                           msecs_to_jiffies(spew_delay));
+                }
+                goto done;
+        }
 
-        left = packet[0] & 1;
-        right = (packet[0] >> 1) & 1;
+        /* not a duplicate, continue with position reporting */
+        priv->dupe_count = 0;
+
+        /* Don't apply hacks in PT mode, it seems reliable */
+        if (priv->mode != HGPK_MODE_PENTABLET && priv->abs_x != -1) {
+                int x_diff = priv->abs_x - x;
+                int y_diff = priv->abs_y - y;
+                if (hgpk_discard_decay_hack(psmouse, x_diff, y_diff)) {
+                        if (tpdebug)
+                                hgpk_dbg(psmouse, "discarding\n");
+                        goto done;
+                }
+                hgpk_spewing_hack(psmouse, left, right, x_diff, y_diff);
+        }
 
-        x = packet[1] - ((packet[0] << 4) & 0x100);
-        y = ((packet[0] << 3) & 0x100) - packet[2];
+        input_report_abs(idev, ABS_X, x);
+        input_report_abs(idev, ABS_Y, y);
+        priv->abs_x = x;
+        priv->abs_y = y;
+
+done:
+        input_sync(idev);
+}
+
+static void hgpk_process_simple_packet(struct psmouse *psmouse)
+{
+        struct input_dev *dev = psmouse->dev;
+        unsigned char *packet = psmouse->packet;
+        int left = packet[0] & 1;
+        int right = (packet[0] >> 1) & 1;
+        int x = packet[1] - ((packet[0] << 4) & 0x100);
+        int y = ((packet[0] << 3) & 0x100) - packet[2];
+
+        if (packet[0] & 0xc0)
+                hgpk_dbg(psmouse,
+                         "overflow -- 0x%02x 0x%02x 0x%02x\n",
+                         packet[0], packet[1], packet[2]);
+
+        if (hgpk_discard_decay_hack(psmouse, x, y)) {
+                if (tpdebug)
+                        hgpk_dbg(psmouse, "discarding\n");
+                return;
+        }
 
-        hgpk_jumpy_hack(psmouse, x, y);
         hgpk_spewing_hack(psmouse, left, right, x, y);
 
         if (tpdebug)
@@ -180,15 +464,14 @@ static psmouse_ret_t hgpk_process_byte(struct psmouse *psmouse)
 {
         struct hgpk_data *priv = psmouse->private;
 
-        if (hgpk_validate_byte(psmouse->packet)) {
-                hgpk_dbg(psmouse, "%s: (%d) %02x %02x %02x\n",
-                                __func__, psmouse->pktcnt, psmouse->packet[0],
-                                psmouse->packet[1], psmouse->packet[2]);
+        if (!hgpk_is_byte_valid(psmouse, psmouse->packet))
                 return PSMOUSE_BAD_DATA;
-        }
 
         if (psmouse->pktcnt >= psmouse->pktsize) {
-                hgpk_process_packet(psmouse);
+                if (priv->mode == HGPK_MODE_MOUSE)
+                        hgpk_process_simple_packet(psmouse);
+                else
+                        hgpk_process_advanced_packet(psmouse);
                 return PSMOUSE_FULL_PACKET;
         }
 
@@ -210,33 +493,176 @@ static psmouse_ret_t hgpk_process_byte(struct psmouse *psmouse)
         return PSMOUSE_GOOD_DATA;
 }
 
+static int hgpk_select_mode(struct psmouse *psmouse)
+{
+        struct ps2dev *ps2dev = &psmouse->ps2dev;
+        struct hgpk_data *priv = psmouse->private;
+        int i;
+        int cmd;
+
+        /*
+         * 4 disables to enable advanced mode
+         * then 3 0xf2 bytes as the preamble for GS/PT selection
+         */
+        const int advanced_init[] = {
+                PSMOUSE_CMD_DISABLE, PSMOUSE_CMD_DISABLE,
+                PSMOUSE_CMD_DISABLE, PSMOUSE_CMD_DISABLE,
+                0xf2, 0xf2, 0xf2,
+        };
+
+        switch (priv->mode) {
+        case HGPK_MODE_MOUSE:
+                psmouse->pktsize = 3;
+                break;
+
+        case HGPK_MODE_GLIDESENSOR:
+        case HGPK_MODE_PENTABLET:
+                psmouse->pktsize = 6;
+
+                /* Switch to 'Advanced mode.', four disables in a row. */
+                for (i = 0; i < ARRAY_SIZE(advanced_init); i++)
+                        if (ps2_command(ps2dev, NULL, advanced_init[i]))
+                                return -EIO;
+
+                /* select between GlideSensor (mouse) or PenTablet */
+                cmd = priv->mode == HGPK_MODE_GLIDESENSOR ?
+                        PSMOUSE_CMD_SETSCALE11 : PSMOUSE_CMD_SETSCALE21;
+
+                if (ps2_command(ps2dev, NULL, cmd))
+                        return -EIO;
+                break;
+
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static void hgpk_setup_input_device(struct input_dev *input,
+                                    struct input_dev *old_input,
+                                    enum hgpk_mode mode)
+{
+        if (old_input) {
+                input->name = old_input->name;
+                input->phys = old_input->phys;
+                input->id = old_input->id;
+                input->dev.parent = old_input->dev.parent;
+        }
+
+        memset(input->evbit, 0, sizeof(input->evbit));
+        memset(input->relbit, 0, sizeof(input->relbit));
+        memset(input->keybit, 0, sizeof(input->keybit));
+
+        /* All modes report left and right buttons */
+        __set_bit(EV_KEY, input->evbit);
+        __set_bit(BTN_LEFT, input->keybit);
+        __set_bit(BTN_RIGHT, input->keybit);
+
+        switch (mode) {
+        case HGPK_MODE_MOUSE:
+                __set_bit(EV_REL, input->evbit);
+                __set_bit(REL_X, input->relbit);
+                __set_bit(REL_Y, input->relbit);
+                break;
+
+        case HGPK_MODE_GLIDESENSOR:
+                __set_bit(BTN_TOUCH, input->keybit);
+                __set_bit(BTN_TOOL_FINGER, input->keybit);
+
+                __set_bit(EV_ABS, input->evbit);
+
+                /* GlideSensor has pressure sensor, PenTablet does not */
+                input_set_abs_params(input, ABS_PRESSURE, 0, 15, 0, 0);
+
+                /* From device specs */
+                input_set_abs_params(input, ABS_X, 0, 399, 0, 0);
+                input_set_abs_params(input, ABS_Y, 0, 290, 0, 0);
+
+                /* Calculated by hand based on usable size (52mm x 38mm) */
+                input_abs_set_res(input, ABS_X, 8);
+                input_abs_set_res(input, ABS_Y, 8);
+                break;
+
+        case HGPK_MODE_PENTABLET:
+                __set_bit(BTN_TOUCH, input->keybit);
+                __set_bit(BTN_TOOL_FINGER, input->keybit);
+
+                __set_bit(EV_ABS, input->evbit);
+
+                /* From device specs */
+                input_set_abs_params(input, ABS_X, 0, 999, 0, 0);
+                input_set_abs_params(input, ABS_Y, 5, 239, 0, 0);
+
+                /* Calculated by hand based on usable size (156mm x 38mm) */
+                input_abs_set_res(input, ABS_X, 6);
+                input_abs_set_res(input, ABS_Y, 8);
+                break;
+
+        default:
+                BUG();
+        }
+}
+
+static int hgpk_reset_device(struct psmouse *psmouse, bool recalibrate)
+{
+        int err;
+
+        psmouse_reset(psmouse);
+
+        if (recalibrate) {
+                struct ps2dev *ps2dev = &psmouse->ps2dev;
+
+                /* send the recalibrate request */
+                if (ps2_command(ps2dev, NULL, 0xf5) ||
+                    ps2_command(ps2dev, NULL, 0xf5) ||
+                    ps2_command(ps2dev, NULL, 0xe6) ||
+                    ps2_command(ps2dev, NULL, 0xf5)) {
+                        return -1;
+                }
+
+                /* according to ALPS, 150mS is required for recalibration */
+                msleep(150);
+        }
+
+        err = hgpk_select_mode(psmouse);
+        if (err) {
+                hgpk_err(psmouse, "failed to select mode\n");
+                return err;
+        }
+
+        hgpk_reset_hack_state(psmouse);
+
+        return 0;
+}
+
 static int hgpk_force_recalibrate(struct psmouse *psmouse)
 {
         struct ps2dev *ps2dev = &psmouse->ps2dev;
         struct hgpk_data *priv = psmouse->private;
+        int err;
 
         /* C-series touchpads added the recalibrate command */
         if (psmouse->model < HGPK_MODEL_C)
                 return 0;
 
+        if (!autorecal) {
+                hgpk_dbg(psmouse, "recalibrations disabled, ignoring\n");
+                return 0;
+        }
+
+        hgpk_dbg(psmouse, "recalibrating touchpad..\n");
+
         /* we don't want to race with the irq handler, nor with resyncs */
         psmouse_set_state(psmouse, PSMOUSE_INITIALIZING);
 
         /* start by resetting the device */
-        psmouse_reset(psmouse);
-
-        /* send the recalibrate request */
-        if (ps2_command(ps2dev, NULL, 0xf5) ||
-            ps2_command(ps2dev, NULL, 0xf5) ||
-            ps2_command(ps2dev, NULL, 0xe6) ||
-            ps2_command(ps2dev, NULL, 0xf5)) {
-                return -1;
-        }
-
-        /* according to ALPS, 150mS is required for recalibration */
-        msleep(150);
+        err = hgpk_reset_device(psmouse, true);
+        if (err)
+                return err;
 
-        /* XXX: If a finger is down during this delay, recalibration will
+        /*
+         * XXX: If a finger is down during this delay, recalibration will
          * detect capacitance incorrectly.  This is a hardware bug, and
          * we don't have a good way to deal with it.  The 2s window stuff
          * (below) is our best option for now.
@@ -247,25 +673,35 @@ static int hgpk_force_recalibrate(struct psmouse *psmouse)
 
         psmouse_set_state(psmouse, PSMOUSE_ACTIVATED);
 
-        /* After we recalibrate, we shouldn't get any packets for 2s.  If
-         * we do, it's likely that someone's finger was on the touchpad.
-         * If someone's finger *was* on the touchpad, it's probably
-         * miscalibrated.  So, we should schedule another recalibration
+        if (tpdebug)
+                hgpk_dbg(psmouse, "touchpad reactivated\n");
+
+        /*
+         * If we get packets right away after recalibrating, it's likely
+         * that a finger was on the touchpad.  If so, it's probably
+         * miscalibrated, so we optionally schedule another.
          */
-        priv->recalib_window = jiffies +  msecs_to_jiffies(recal_guard_time);
+        if (recal_guard_time)
+                priv->recalib_window = jiffies +
+                        msecs_to_jiffies(recal_guard_time);
 
         return 0;
 }
 
 /*
- * This kills power to the touchpad; according to ALPS, current consumption
- * goes down to 50uA after running this.  To turn power back on, we drive
- * MS-DAT low.
+ * This puts the touchpad in a power saving mode; according to ALPS, current
+ * consumption goes down to 50uA after running this.  To turn power back on,
+ * we drive MS-DAT low.  Measuring with a 1mA resolution ammeter says that
+ * the current on the SUS_3.3V rail drops from 3mA or 4mA to 0 when we do this.
+ *
+ * We have no formal spec that details this operation -- the low-power
+ * sequence came from a long-lost email trail.
  */
-static int hgpk_toggle_power(struct psmouse *psmouse, int enable)
+static int hgpk_toggle_powersave(struct psmouse *psmouse, int enable)
 {
         struct ps2dev *ps2dev = &psmouse->ps2dev;
         int timeo;
+        int err;
 
         /* Added on D-series touchpads */
         if (psmouse->model < HGPK_MODEL_D)
@@ -279,24 +715,27 @@ static int hgpk_toggle_power(struct psmouse *psmouse, int enable)
                  * the controller.  Once we get an ACK back from it, it
                  * means we can continue with the touchpad re-init.  ALPS
                  * tells us that 1s should be long enough, so set that as
-                 * the upper bound.
+                 * the upper bound. (in practice, it takes about 3 loops.)
                  */
                 for (timeo = 20; timeo > 0; timeo--) {
                         if (!ps2_sendbyte(&psmouse->ps2dev,
                                         PSMOUSE_CMD_DISABLE, 20))
                                 break;
-                        msleep(50);
+                        msleep(25);
                 }
 
-                psmouse_reset(psmouse);
+                err = hgpk_reset_device(psmouse, false);
+                if (err) {
+                        hgpk_err(psmouse, "Failed to reset device!\n");
+                        return err;
+                }
 
                 /* should be all set, enable the touchpad */
                 ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_ENABLE);
                 psmouse_set_state(psmouse, PSMOUSE_ACTIVATED);
-
+                hgpk_dbg(psmouse, "Touchpad powered up.\n");
         } else {
                 hgpk_dbg(psmouse, "Powering off touchpad.\n");
-                psmouse_set_state(psmouse, PSMOUSE_IGNORE);
 
                 if (ps2_command(ps2dev, NULL, 0xec) ||
                     ps2_command(ps2dev, NULL, 0xec) ||
@@ -304,6 +743,8 @@ static int hgpk_toggle_power(struct psmouse *psmouse, int enable)
                         return -1;
                 }
 
+                psmouse_set_state(psmouse, PSMOUSE_IGNORE);
+
                 /* probably won't see an ACK, the touchpad will be off */
                 ps2_sendbyte(&psmouse->ps2dev, 0xec, 20);
         }
@@ -319,17 +760,20 @@ static int hgpk_poll(struct psmouse *psmouse)
 
 static int hgpk_reconnect(struct psmouse *psmouse)
 {
-        /* During suspend/resume the ps2 rails remain powered.  We don't want
+        struct hgpk_data *priv = psmouse->private;
+
+        /*
+         * During suspend/resume the ps2 rails remain powered.  We don't want
          * to do a reset because it's flush data out of buffers; however,
-         * earlier prototypes (B1) had some brokenness that required a reset. */
+         * earlier prototypes (B1) had some brokenness that required a reset.
+         */
         if (olpc_board_at_least(olpc_board(0xb2)))
                 if (psmouse->ps2dev.serio->dev.power.power_state.event !=
                                 PM_EVENT_ON)
                         return 0;
 
-        psmouse_reset(psmouse);
-
-        return 0;
+        priv->powered = 1;
+        return hgpk_reset_device(psmouse, false);
 }
 
 static ssize_t hgpk_show_powered(struct psmouse *psmouse, void *data, char *buf)
@@ -355,7 +799,7 @@ static ssize_t hgpk_set_powered(struct psmouse *psmouse, void *data,
                  * hgpk_toggle_power will deal w/ state so
                  * we're not racing w/ irq
                  */
-                err = hgpk_toggle_power(psmouse, value);
+                err = hgpk_toggle_powersave(psmouse, value);
                 if (!err)
                         priv->powered = value;
         }
@@ -366,6 +810,65 @@ static ssize_t hgpk_set_powered(struct psmouse *psmouse, void *data,
 __PSMOUSE_DEFINE_ATTR(powered, S_IWUSR | S_IRUGO, NULL,
                       hgpk_show_powered, hgpk_set_powered, false);
 
+static ssize_t attr_show_mode(struct psmouse *psmouse, void *data, char *buf)
+{
+        struct hgpk_data *priv = psmouse->private;
+
+        return sprintf(buf, "%s\n", hgpk_mode_names[priv->mode]);
+}
+
+static ssize_t attr_set_mode(struct psmouse *psmouse, void *data,
+                             const char *buf, size_t len)
+{
+        struct hgpk_data *priv = psmouse->private;
+        enum hgpk_mode old_mode = priv->mode;
+        enum hgpk_mode new_mode = hgpk_mode_from_name(buf, len);
+        struct input_dev *old_dev = psmouse->dev;
+        struct input_dev *new_dev;
+        int err;
+
+        if (new_mode == HGPK_MODE_INVALID)
+                return -EINVAL;
+
+        if (old_mode == new_mode)
+                return len;
+
+        new_dev = input_allocate_device();
+        if (!new_dev)
+                return -ENOMEM;
+
+        psmouse_set_state(psmouse, PSMOUSE_INITIALIZING);
+
+        /* Switch device into the new mode */
+        priv->mode = new_mode;
+        err = hgpk_reset_device(psmouse, false);
+        if (err)
+                goto err_try_restore;
+
+        hgpk_setup_input_device(new_dev, old_dev, new_mode);
+
+        psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
+
+        err = input_register_device(new_dev);
+        if (err)
+                goto err_try_restore;
+
+        psmouse->dev = new_dev;
+        input_unregister_device(old_dev);
+
+        return len;
+
+err_try_restore:
+        input_free_device(new_dev);
+        priv->mode = old_mode;
+        hgpk_reset_device(psmouse, false);
+
+        return err;
+}
+
+PSMOUSE_DEFINE_ATTR(hgpk_mode, S_IWUSR | S_IRUGO, NULL,
+                    attr_show_mode, attr_set_mode);
+
 static ssize_t hgpk_trigger_recal_show(struct psmouse *psmouse,
                 void *data, char *buf)
 {
@@ -401,6 +904,8 @@ static void hgpk_disconnect(struct psmouse *psmouse)
 
         device_remove_file(&psmouse->ps2dev.serio->dev,
                            &psmouse_attr_powered.dattr);
+        device_remove_file(&psmouse->ps2dev.serio->dev,
+                           &psmouse_attr_hgpk_mode.dattr);
 
         if (psmouse->model >= HGPK_MODEL_C)
                 device_remove_file(&psmouse->ps2dev.serio->dev,
@@ -416,14 +921,13 @@ static void hgpk_recalib_work(struct work_struct *work)
         struct hgpk_data *priv = container_of(w, struct hgpk_data, recalib_wq);
         struct psmouse *psmouse = priv->psmouse;
 
-        hgpk_dbg(psmouse, "recalibrating touchpad..\n");
-
         if (hgpk_force_recalibrate(psmouse))
                 hgpk_err(psmouse, "recalibration failed!\n");
 }
 
 static int hgpk_register(struct psmouse *psmouse)
 {
+        struct hgpk_data *priv = psmouse->private;
         int err;
 
         /* register handlers */
@@ -431,13 +935,14 @@ static int hgpk_register(struct psmouse *psmouse)
         psmouse->poll = hgpk_poll;
         psmouse->disconnect = hgpk_disconnect;
         psmouse->reconnect = hgpk_reconnect;
-        psmouse->pktsize = 3;
 
         /* Disable the idle resync. */
         psmouse->resync_time = 0;
         /* Reset after a lot of bad bytes. */
         psmouse->resetafter = 1024;
 
+        hgpk_setup_input_device(psmouse->dev, NULL, priv->mode);
+
         err = device_create_file(&psmouse->ps2dev.serio->dev,
                                  &psmouse_attr_powered.dattr);
         if (err) {
@@ -445,6 +950,13 @@ static int hgpk_register(struct psmouse *psmouse)
                 return err;
         }
 
+        err = device_create_file(&psmouse->ps2dev.serio->dev,
+                                 &psmouse_attr_hgpk_mode.dattr);
+        if (err) {
+                hgpk_err(psmouse, "Failed creating 'hgpk_mode' sysfs node\n");
+                goto err_remove_powered;
+        }
+
         /* C-series touchpads added the recalibrate command */
         if (psmouse->model >= HGPK_MODEL_C) {
                 err = device_create_file(&psmouse->ps2dev.serio->dev,
@@ -452,30 +964,40 @@ static int hgpk_register(struct psmouse *psmouse)
                 if (err) {
                         hgpk_err(psmouse,
                                 "Failed creating 'recalibrate' sysfs node\n");
-                        device_remove_file(&psmouse->ps2dev.serio->dev,
-                                        &psmouse_attr_powered.dattr);
-                        return err;
+                        goto err_remove_mode;
                 }
         }
 
         return 0;
+
+err_remove_mode:
+        device_remove_file(&psmouse->ps2dev.serio->dev,
+                           &psmouse_attr_hgpk_mode.dattr);
+err_remove_powered:
+        device_remove_file(&psmouse->ps2dev.serio->dev,
+                           &psmouse_attr_powered.dattr);
+        return err;
 }
 
 int hgpk_init(struct psmouse *psmouse)
 {
         struct hgpk_data *priv;
-        int err = -ENOMEM;
+        int err;
 
         priv = kzalloc(sizeof(struct hgpk_data), GFP_KERNEL);
-        if (!priv)
+        if (!priv) {
+                err = -ENOMEM;
                 goto alloc_fail;
+        }
 
         psmouse->private = priv;
+
         priv->psmouse = psmouse;
         priv->powered = true;
+        priv->mode = hgpk_default_mode;
         INIT_DELAYED_WORK(&priv->recalib_wq, hgpk_recalib_work);
 
-        err = psmouse_reset(psmouse);
+        err = hgpk_reset_device(psmouse, false);
         if (err)
                 goto init_fail;
 
@@ -531,3 +1053,14 @@ int hgpk_detect(struct psmouse *psmouse, bool set_properties)
 
         return 0;
 }
+
+void hgpk_module_init(void)
+{
+        hgpk_default_mode = hgpk_mode_from_name(hgpk_mode_name,
+                                                strlen(hgpk_mode_name));
+        if (hgpk_default_mode == HGPK_MODE_INVALID) {
+                hgpk_default_mode = HGPK_MODE_MOUSE;
+                strlcpy(hgpk_mode_name, hgpk_mode_names[HGPK_MODE_MOUSE],
+                        sizeof(hgpk_mode_name));
+        }
+}
diff --git a/drivers/input/mouse/hgpk.h b/drivers/input/mouse/hgpk.h
index d61cfd3ee9cb..311c0e87fcbf 100644
--- a/drivers/input/mouse/hgpk.h
+++ b/drivers/input/mouse/hgpk.h
@@ -5,6 +5,9 @@
 #ifndef _HGPK_H
 #define _HGPK_H
 
+#define HGPK_GS         0xff       /* The GlideSensor */
+#define HGPK_PT         0xcf       /* The PenTablet */
+
 enum hgpk_model_t {
         HGPK_MODEL_PREA = 0x0a, /* pre-B1s */
         HGPK_MODEL_A = 0x14,    /* found on B1s, PT disabled in hardware */
@@ -13,12 +16,34 @@ enum hgpk_model_t {
         HGPK_MODEL_D = 0x50,    /* C1, mass production */
 };
 
+enum hgpk_spew_flag {
+        NO_SPEW,
+        MAYBE_SPEWING,
+        SPEW_DETECTED,
+        RECALIBRATING,
+};
+
+#define SPEW_WATCH_COUNT 42  /* at 12ms/packet, this is 1/2 second */
+
+enum hgpk_mode {
+        HGPK_MODE_MOUSE,
+        HGPK_MODE_GLIDESENSOR,
+        HGPK_MODE_PENTABLET,
+        HGPK_MODE_INVALID
+};
+
 struct hgpk_data {
         struct psmouse *psmouse;
+        enum hgpk_mode mode;
         bool powered;
-        int count, x_tally, y_tally;    /* hardware workaround stuff */
+        enum hgpk_spew_flag spew_flag;
+        int spew_count, x_tally, y_tally;       /* spew detection */
         unsigned long recalib_window;
         struct delayed_work recalib_wq;
+        int abs_x, abs_y;
+        int dupe_count;
+        int xbigj, ybigj, xlast, ylast; /* jumpiness detection */
+        int xsaw_secondary, ysaw_secondary; /* jumpiness detection */
 };
 
 #define hgpk_dbg(psmouse, format, arg...)               \
@@ -33,9 +58,13 @@ struct hgpk_data {
         dev_notice(&(psmouse)->ps2dev.serio->dev, format, ## arg)
 
 #ifdef CONFIG_MOUSE_PS2_OLPC
+void hgpk_module_init(void);
 int hgpk_detect(struct psmouse *psmouse, bool set_properties);
 int hgpk_init(struct psmouse *psmouse);
 #else
+static inline void hgpk_module_init(void)
+{
+}
 static inline int hgpk_detect(struct psmouse *psmouse, bool set_properties)
 {
         return -ENODEV;
diff --git a/drivers/input/mouse/psmouse-base.c b/drivers/input/mouse/psmouse-base.c
index 73a7af2542a8..3f74baee102b 100644
--- a/drivers/input/mouse/psmouse-base.c
+++ b/drivers/input/mouse/psmouse-base.c
@@ -1584,10 +1584,10 @@ static ssize_t psmouse_attr_set_protocol(struct psmouse *psmouse, void *data, co
         if (!new_dev)
                 return -ENOMEM;
 
-        while (serio->child) {
+        while (!list_empty(&serio->children)) {
                 if (++retry > 3) {
                         printk(KERN_WARNING
-                                "psmouse: failed to destroy child port, "
+                                "psmouse: failed to destroy children ports, "
                                 "protocol change aborted.\n");
                         input_free_device(new_dev);
                         return -EIO;
@@ -1711,6 +1711,7 @@ static int __init psmouse_init(void)
 
         lifebook_module_init();
         synaptics_module_init();
+        hgpk_module_init();
 
         kpsmoused_wq = create_singlethread_workqueue("kpsmoused");
         if (!kpsmoused_wq) {
diff --git a/drivers/input/mouse/synaptics.c b/drivers/input/mouse/synaptics.c
index 96b70a43515f..e06e045bf907 100644
--- a/drivers/input/mouse/synaptics.c
+++ b/drivers/input/mouse/synaptics.c
@@ -25,7 +25,7 @@
 
 #include <linux/module.h>
 #include <linux/dmi.h>
-#include <linux/input.h>
+#include <linux/input/mt.h>
 #include <linux/serio.h>
 #include <linux/libps2.h>
 #include <linux/slab.h>
@@ -279,6 +279,25 @@ static void synaptics_set_rate(struct psmouse *psmouse, unsigned int rate)
         synaptics_mode_cmd(psmouse, priv->mode);
 }
 
+static int synaptics_set_advanced_gesture_mode(struct psmouse *psmouse)
+{
+        static unsigned char param = 0xc8;
+        struct synaptics_data *priv = psmouse->private;
+
+        if (!SYN_CAP_ADV_GESTURE(priv->ext_cap_0c))
+                return 0;
+
+        if (psmouse_sliced_command(psmouse, SYN_QUE_MODEL))
+                return -1;
+        if (ps2_command(&psmouse->ps2dev, &param, PSMOUSE_CMD_SETRATE))
+                return -1;
+
+        /* Advanced gesture mode also sends multi finger data */
+        priv->capabilities |= BIT(1);
+
+        return 0;
+}
+
 /*****************************************************************************
  *      Synaptics pass-through PS/2 port support
  ****************************************************************************/
@@ -294,7 +313,29 @@ static int synaptics_pt_write(struct serio *serio, unsigned char c)
         return 0;
 }
 
-static inline int synaptics_is_pt_packet(unsigned char *buf)
+static int synaptics_pt_start(struct serio *serio)
+{
+        struct psmouse *parent = serio_get_drvdata(serio->parent);
+        struct synaptics_data *priv = parent->private;
+
+        serio_pause_rx(parent->ps2dev.serio);
+        priv->pt_port = serio;
+        serio_continue_rx(parent->ps2dev.serio);
+
+        return 0;
+}
+
+static void synaptics_pt_stop(struct serio *serio)
+{
+        struct psmouse *parent = serio_get_drvdata(serio->parent);
+        struct synaptics_data *priv = parent->private;
+
+        serio_pause_rx(parent->ps2dev.serio);
+        priv->pt_port = NULL;
+        serio_continue_rx(parent->ps2dev.serio);
+}
+
+static int synaptics_is_pt_packet(unsigned char *buf)
 {
         return (buf[0] & 0xFC) == 0x84 && (buf[3] & 0xCC) == 0xC4;
 }
@@ -315,9 +356,8 @@ static void synaptics_pass_pt_packet(struct serio *ptport, unsigned char *packet
 
 static void synaptics_pt_activate(struct psmouse *psmouse)
 {
-        struct serio *ptport = psmouse->ps2dev.serio->child;
-        struct psmouse *child = serio_get_drvdata(ptport);
         struct synaptics_data *priv = psmouse->private;
+        struct psmouse *child = serio_get_drvdata(priv->pt_port);
 
         /* adjust the touchpad to child's choice of protocol */
         if (child) {
@@ -345,6 +385,8 @@ static void synaptics_pt_create(struct psmouse *psmouse)
         strlcpy(serio->name, "Synaptics pass-through", sizeof(serio->name));
         strlcpy(serio->phys, "synaptics-pt/serio0", sizeof(serio->name));
         serio->write = synaptics_pt_write;
+        serio->start = synaptics_pt_start;
+        serio->stop = synaptics_pt_stop;
         serio->parent = psmouse->ps2dev.serio;
 
         psmouse->pt_activate = synaptics_pt_activate;
@@ -357,7 +399,9 @@ static void synaptics_pt_create(struct psmouse *psmouse)
  *      Functions to interpret the absolute mode packets
  ****************************************************************************/
 
-static void synaptics_parse_hw_state(unsigned char buf[], struct synaptics_data *priv, struct synaptics_hw_state *hw)
+static int synaptics_parse_hw_state(const unsigned char buf[],
+                                    struct synaptics_data *priv,
+                                    struct synaptics_hw_state *hw)
 {
         memset(hw, 0, sizeof(struct synaptics_hw_state));
 
@@ -374,6 +418,14 @@ static void synaptics_parse_hw_state(unsigned char buf[], struct synaptics_data
                          ((buf[0] & 0x04) >> 1) |
                          ((buf[3] & 0x04) >> 2));
 
+                if (SYN_CAP_ADV_GESTURE(priv->ext_cap_0c) && hw->w == 2) {
+                        /* Gesture packet: (x, y, z) at half resolution */
+                        priv->mt.x = (((buf[4] & 0x0f) << 8) | buf[1]) << 1;
+                        priv->mt.y = (((buf[4] & 0xf0) << 4) | buf[2]) << 1;
+                        priv->mt.z = ((buf[3] & 0x30) | (buf[5] & 0x0f)) << 1;
+                        return 1;
+                }
+
                 hw->left  = (buf[0] & 0x01) ? 1 : 0;
                 hw->right = (buf[0] & 0x02) ? 1 : 0;
 
@@ -429,6 +481,36 @@ static void synaptics_parse_hw_state(unsigned char buf[], struct synaptics_data
                 hw->left  = (buf[0] & 0x01) ? 1 : 0;
                 hw->right = (buf[0] & 0x02) ? 1 : 0;
         }
+
+        return 0;
+}
+
+static void set_slot(struct input_dev *dev, int slot, bool active, int x, int y)
+{
+        input_mt_slot(dev, slot);
+        input_mt_report_slot_state(dev, MT_TOOL_FINGER, active);
+        if (active) {
+                input_report_abs(dev, ABS_MT_POSITION_X, x);
+                input_report_abs(dev, ABS_MT_POSITION_Y,
+                                 YMAX_NOMINAL + YMIN_NOMINAL - y);
+        }
+}
+
+static void synaptics_report_semi_mt_data(struct input_dev *dev,
+                                          const struct synaptics_hw_state *a,
+                                          const struct synaptics_hw_state *b,
+                                          int num_fingers)
+{
+        if (num_fingers >= 2) {
+                set_slot(dev, 0, true, min(a->x, b->x), min(a->y, b->y));
+                set_slot(dev, 1, true, max(a->x, b->x), max(a->y, b->y));
+        } else if (num_fingers == 1) {
+                set_slot(dev, 0, true, a->x, a->y);
+                set_slot(dev, 1, false, 0, 0);
+        } else {
+                set_slot(dev, 0, false, 0, 0);
+                set_slot(dev, 1, false, 0, 0);
+        }
 }
 
 /*
@@ -443,7 +525,8 @@ static void synaptics_process_packet(struct psmouse *psmouse)
         int finger_width;
         int i;
 
-        synaptics_parse_hw_state(psmouse->packet, priv, &hw);
+        if (synaptics_parse_hw_state(psmouse->packet, priv, &hw))
+                return;
 
         if (hw.scroll) {
                 priv->scroll += hw.scroll;
@@ -465,7 +548,7 @@ static void synaptics_process_packet(struct psmouse *psmouse)
                 return;
         }
 
-        if (hw.z > 0) {
+        if (hw.z > 0 && hw.x > 1) {
                 num_fingers = 1;
                 finger_width = 5;
                 if (SYN_CAP_EXTENDED(priv->capabilities)) {
@@ -489,6 +572,9 @@ static void synaptics_process_packet(struct psmouse *psmouse)
                 finger_width = 0;
         }
 
+        if (SYN_CAP_ADV_GESTURE(priv->ext_cap_0c))
+                synaptics_report_semi_mt_data(dev, &hw, &priv->mt, num_fingers);
+
         /* Post events
          * BTN_TOUCH has to be first as mousedev relies on it when doing
          * absolute -> relative conversion
@@ -496,7 +582,7 @@ static void synaptics_process_packet(struct psmouse *psmouse)
         if (hw.z > 30) input_report_key(dev, BTN_TOUCH, 1);
         if (hw.z < 25) input_report_key(dev, BTN_TOUCH, 0);
 
-        if (hw.z > 0) {
+        if (num_fingers > 0) {
                 input_report_abs(dev, ABS_X, hw.x);
                 input_report_abs(dev, ABS_Y, YMAX_NOMINAL + YMIN_NOMINAL - hw.y);
         }
@@ -578,9 +664,10 @@ static psmouse_ret_t synaptics_process_byte(struct psmouse *psmouse)
                 if (unlikely(priv->pkt_type == SYN_NEWABS))
                         priv->pkt_type = synaptics_detect_pkt_type(psmouse);
 
-                if (SYN_CAP_PASS_THROUGH(priv->capabilities) && synaptics_is_pt_packet(psmouse->packet)) {
-                        if (psmouse->ps2dev.serio->child)
-                                synaptics_pass_pt_packet(psmouse->ps2dev.serio->child, psmouse->packet);
+                if (SYN_CAP_PASS_THROUGH(priv->capabilities) &&
+                    synaptics_is_pt_packet(psmouse->packet)) {
+                        if (priv->pt_port)
+                                synaptics_pass_pt_packet(priv->pt_port, psmouse->packet);
                 } else
                         synaptics_process_packet(psmouse);
 
@@ -598,6 +685,8 @@ static void set_input_params(struct input_dev *dev, struct synaptics_data *priv)
 {
         int i;
 
+        __set_bit(INPUT_PROP_POINTER, dev->propbit);
+
         __set_bit(EV_ABS, dev->evbit);
         input_set_abs_params(dev, ABS_X,
                              XMIN_NOMINAL, priv->x_max ?: XMAX_NOMINAL, 0, 0);
@@ -605,6 +694,15 @@ static void set_input_params(struct input_dev *dev, struct synaptics_data *priv)
                              YMIN_NOMINAL, priv->y_max ?: YMAX_NOMINAL, 0, 0);
         input_set_abs_params(dev, ABS_PRESSURE, 0, 255, 0, 0);
 
+        if (SYN_CAP_ADV_GESTURE(priv->ext_cap_0c)) {
+                __set_bit(INPUT_PROP_SEMI_MT, dev->propbit);
+                input_mt_init_slots(dev, 2);
+                input_set_abs_params(dev, ABS_MT_POSITION_X, XMIN_NOMINAL,
+                                     priv->x_max ?: XMAX_NOMINAL, 0, 0);
+                input_set_abs_params(dev, ABS_MT_POSITION_Y, YMIN_NOMINAL,
+                                     priv->y_max ?: YMAX_NOMINAL, 0, 0);
+        }
+
         if (SYN_CAP_PALMDETECT(priv->capabilities))
                 input_set_abs_params(dev, ABS_TOOL_WIDTH, 0, 15, 0, 0);
 
@@ -639,6 +737,7 @@ static void set_input_params(struct input_dev *dev, struct synaptics_data *priv)
         input_abs_set_res(dev, ABS_Y, priv->y_res);
 
         if (SYN_CAP_CLICKPAD(priv->ext_cap_0c)) {
+                __set_bit(INPUT_PROP_BUTTONPAD, dev->propbit);
                 /* Clickpads report only left button */
                 __clear_bit(BTN_RIGHT, dev->keybit);
                 __clear_bit(BTN_MIDDLE, dev->keybit);
@@ -656,25 +755,46 @@ static int synaptics_reconnect(struct psmouse *psmouse)
 {
         struct synaptics_data *priv = psmouse->private;
         struct synaptics_data old_priv = *priv;
+        int retry = 0;
+        int error;
 
-        psmouse_reset(psmouse);
+        do {
+                psmouse_reset(psmouse);
+                error = synaptics_detect(psmouse, 0);
+        } while (error && ++retry < 3);
 
-        if (synaptics_detect(psmouse, 0))
+        if (error)
                 return -1;
 
+        if (retry > 1)
+                printk(KERN_DEBUG "Synaptics reconnected after %d tries\n",
+                        retry);
+
         if (synaptics_query_hardware(psmouse)) {
                 printk(KERN_ERR "Unable to query Synaptics hardware.\n");
                 return -1;
         }
 
+        if (synaptics_set_absolute_mode(psmouse)) {
+                printk(KERN_ERR "Unable to initialize Synaptics hardware.\n");
+                return -1;
+        }
+
+        if (synaptics_set_advanced_gesture_mode(psmouse)) {
+                printk(KERN_ERR "Advanced gesture mode reconnect failed.\n");
+                return -1;
+        }
+
         if (old_priv.identity != priv->identity ||
             old_priv.model_id != priv->model_id ||
             old_priv.capabilities != priv->capabilities ||
-            old_priv.ext_cap != priv->ext_cap)
-                return -1;
-
-        if (synaptics_set_absolute_mode(psmouse)) {
-                printk(KERN_ERR "Unable to initialize Synaptics hardware.\n");
+            old_priv.ext_cap != priv->ext_cap) {
+                printk(KERN_ERR "Synaptics hardware appears to be different: "
+                        "id(%ld-%ld), model(%ld-%ld), caps(%lx-%lx), ext(%lx-%lx).\n",
+                        old_priv.identity, priv->identity,
+                        old_priv.model_id, priv->model_id,
+                        old_priv.capabilities, priv->capabilities,
+                        old_priv.ext_cap, priv->ext_cap);
                 return -1;
         }
 
@@ -716,22 +836,52 @@ static const struct dmi_system_id __initconst toshiba_dmi_table[] = {
                 },
 
         },
+#endif
         { }
+};
+
+static bool broken_olpc_ec;
+
+static const struct dmi_system_id __initconst olpc_dmi_table[] = {
+#if defined(CONFIG_DMI) && defined(CONFIG_OLPC)
+        {
+                /* OLPC XO-1 or XO-1.5 */
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "OLPC"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "XO"),
+                },
+        },
 #endif
+        { }
 };
 
 void __init synaptics_module_init(void)
 {
         impaired_toshiba_kbc = dmi_check_system(toshiba_dmi_table);
+        broken_olpc_ec = dmi_check_system(olpc_dmi_table);
 }
 
 int synaptics_init(struct psmouse *psmouse)
 {
         struct synaptics_data *priv;
 
+        /*
+         * The OLPC XO has issues with Synaptics' absolute mode; similarly to
+         * the HGPK, it quickly degrades and the hardware becomes jumpy and
+         * overly sensitive.  Not only that, but the constant packet spew
+         * (even at a lowered 40pps rate) overloads the EC such that key
+         * presses on the keyboard are missed.  Given all of that, don't
+         * even attempt to use Synaptics mode.  Relative mode seems to work
+         * just fine.
+         */
+        if (broken_olpc_ec) {
+                printk(KERN_INFO "synaptics: OLPC XO detected, not enabling Synaptics protocol.\n");
+                return -ENODEV;
+        }
+
         psmouse->private = priv = kzalloc(sizeof(struct synaptics_data), GFP_KERNEL);
         if (!priv)
-                return -1;
+                return -ENOMEM;
 
         psmouse_reset(psmouse);
 
@@ -745,6 +895,11 @@ int synaptics_init(struct psmouse *psmouse)
                 goto init_fail;
         }
 
+        if (synaptics_set_advanced_gesture_mode(psmouse)) {
+                printk(KERN_ERR "Advanced gesture mode init failed.\n");
+                goto init_fail;
+        }
+
         priv->pkt_type = SYN_MODEL_NEWABS(priv->model_id) ? SYN_NEWABS : SYN_OLDABS;
 
         printk(KERN_INFO "Synaptics Touchpad, model: %ld, fw: %ld.%ld, id: %#lx, caps: %#lx/%#lx/%#lx\n",
@@ -778,8 +933,8 @@ int synaptics_init(struct psmouse *psmouse)
 
         /*
          * Toshiba's KBC seems to have trouble handling data from
-         * Synaptics as full rate, switch to lower rate which is roughly
-         * thye same as rate of standard PS/2 mouse.
+         * Synaptics at full rate.  Switch to a lower rate (roughly
+         * the same rate as a standard PS/2 mouse).
          */
         if (psmouse->rate >= 80 && impaired_toshiba_kbc) {
                 printk(KERN_INFO "synaptics: Toshiba %s detected, limiting rate to 40pps.\n",
diff --git a/drivers/input/mouse/synaptics.h b/drivers/input/mouse/synaptics.h
index b6aa7d20d8a3..7453938bf5ef 100644
--- a/drivers/input/mouse/synaptics.h
+++ b/drivers/input/mouse/synaptics.h
@@ -51,8 +51,33 @@
 #define SYN_EXT_CAP_REQUESTS(c)         (((c) & 0x700000) >> 20)
 #define SYN_CAP_MULTI_BUTTON_NO(ec)     (((ec) & 0x00f000) >> 12)
 #define SYN_CAP_PRODUCT_ID(ec)          (((ec) & 0xff0000) >> 16)
-#define SYN_CAP_CLICKPAD(ex0c)          ((ex0c) & 0x100100)
+
+/*
+ * The following describes response for the 0x0c query.
+ *
+ * byte mask    name                    meaning
+ * ---- ----    -------                 ------------
+ * 1    0x01    adjustable threshold    capacitive button sensitivity
+ *                                      can be adjusted
+ * 1    0x02    report max              query 0x0d gives max coord reported
+ * 1    0x04    clearpad                sensor is ClearPad product
+ * 1    0x08    advanced gesture        not particularly meaningful
+ * 1    0x10    clickpad bit 0          1-button ClickPad
+ * 1    0x60    multifinger mode        identifies firmware finger counting
+ *                                      (not reporting!) algorithm.
+ *                                      Not particularly meaningful
+ * 1    0x80    covered pad             W clipped to 14, 15 == pad mostly covered
+ * 2    0x01    clickpad bit 1          2-button ClickPad
+ * 2    0x02    deluxe LED controls     touchpad support LED commands
+ *                                      ala multimedia control bar
+ * 2    0x04    reduced filtering       firmware does less filtering on
+ *                                      position data, driver should watch
+ *                                      for noise.
+ */
+#define SYN_CAP_CLICKPAD(ex0c)          ((ex0c) & 0x100000) /* 1-button ClickPad */
+#define SYN_CAP_CLICKPAD2BTN(ex0c)      ((ex0c) & 0x000100) /* 2-button ClickPad */
 #define SYN_CAP_MAX_DIMENSIONS(ex0c)    ((ex0c) & 0x020000)
+#define SYN_CAP_ADV_GESTURE(ex0c)       ((ex0c) & 0x080000)
 
 /* synaptics modes query bits */
 #define SYN_MODE_ABSOLUTE(m)            ((m) & (1 << 7))
@@ -110,6 +135,10 @@ struct synaptics_data {
         unsigned char pkt_type;                 /* packet type - old, new, etc */
         unsigned char mode;                     /* current mode byte */
         int scroll;
+
+        struct serio *pt_port;                  /* Pass-through serio port */
+
+        struct synaptics_hw_state mt;           /* current gesture packet */
 };
 
 void synaptics_module_init(void);
diff --git a/drivers/input/mouse/synaptics_i2c.c b/drivers/input/mouse/synaptics_i2c.c
index 0ae62f0bcb32..cba3c84d2f21 100644
--- a/drivers/input/mouse/synaptics_i2c.c
+++ b/drivers/input/mouse/synaptics_i2c.c
@@ -18,6 +18,7 @@
 #include <linux/delay.h>
 #include <linux/workqueue.h>
 #include <linux/slab.h>
+#include <linux/pm.h>
 
 #define DRIVER_NAME             "synaptics_i2c"
 /* maximum product id is 15 characters */
@@ -461,7 +462,7 @@ static void synaptics_i2c_work_handler(struct work_struct *work)
          * While interrupt driven, there is no real need to poll the device.
          * But touchpads are very sensitive, so there could be errors
          * related to physical environment and the attention line isn't
-         * neccesarily asserted. In such case we can lose the touchpad.
+         * necessarily asserted. In such case we can lose the touchpad.
          * We poll the device once in THREAD_IRQ_SLEEP_SECS and
          * if error is detected, we try to reset and reconfigure the touchpad.
          */
@@ -619,8 +620,9 @@ static int __devexit synaptics_i2c_remove(struct i2c_client *client)
 }
 
 #ifdef CONFIG_PM
-static int synaptics_i2c_suspend(struct i2c_client *client, pm_message_t mesg)
+static int synaptics_i2c_suspend(struct device *dev)
 {
+        struct i2c_client *client = to_i2c_client(dev);
         struct synaptics_i2c *touch = i2c_get_clientdata(client);
 
         cancel_delayed_work_sync(&touch->dwork);
@@ -631,9 +633,10 @@ static int synaptics_i2c_suspend(struct i2c_client *client, pm_message_t mesg)
         return 0;
 }
 
-static int synaptics_i2c_resume(struct i2c_client *client)
+static int synaptics_i2c_resume(struct device *dev)
 {
         int ret;
+        struct i2c_client *client = to_i2c_client(dev);
         struct synaptics_i2c *touch = i2c_get_clientdata(client);
 
         ret = synaptics_i2c_reset_config(client);
@@ -645,11 +648,11 @@ static int synaptics_i2c_resume(struct i2c_client *client)
 
         return 0;
 }
-#else
-#define synaptics_i2c_suspend   NULL
-#define synaptics_i2c_resume    NULL
 #endif
 
+static SIMPLE_DEV_PM_OPS(synaptics_i2c_pm, synaptics_i2c_suspend,
+                         synaptics_i2c_resume);
+
 static const struct i2c_device_id synaptics_i2c_id_table[] = {
         { "synaptics_i2c", 0 },
         { },
@@ -660,13 +663,12 @@ static struct i2c_driver synaptics_i2c_driver = {
         .driver = {
                 .name   = DRIVER_NAME,
                 .owner  = THIS_MODULE,
+                .pm     = &synaptics_i2c_pm,
         },
 
         .probe          = synaptics_i2c_probe,
         .remove         = __devexit_p(synaptics_i2c_remove),
 
-        .suspend        = synaptics_i2c_suspend,
-        .resume         = synaptics_i2c_resume,
         .id_table       = synaptics_i2c_id_table,
 };
 
diff --git a/drivers/input/mouse/touchkit_ps2.c b/drivers/input/mouse/touchkit_ps2.c
index 88121c59c3cc..1fd8f5e192f9 100644
--- a/drivers/input/mouse/touchkit_ps2.c
+++ b/drivers/input/mouse/touchkit_ps2.c
@@ -21,8 +21,8 @@
  *
  * Based upon touchkitusb.c
  *
- * Vendor documentation is available in support section of:
- * http://www.egalax.com.tw/
+ * Vendor documentation is available at:
+ * http://home.eeti.com.tw/web20/drivers/Software%20Programming%20Guide_v2.0.pdf 
  */
 
 #include <linux/kernel.h>
diff --git a/drivers/input/mouse/trackpoint.c b/drivers/input/mouse/trackpoint.c
index 0643e49ca603..54b2fa892e19 100644
--- a/drivers/input/mouse/trackpoint.c
+++ b/drivers/input/mouse/trackpoint.c
@@ -303,7 +303,7 @@ int trackpoint_detect(struct psmouse *psmouse, bool set_properties)
 
         psmouse->private = kzalloc(sizeof(struct trackpoint_data), GFP_KERNEL);
         if (!psmouse->private)
-                return -1;
+                return -ENOMEM;
 
         psmouse->vendor = "IBM";
         psmouse->name = "TrackPoint";
diff --git a/drivers/input/mouse/vsxxxaa.c b/drivers/input/mouse/vsxxxaa.c
index bf2c0c80d6cc..eb9a3cfbeefa 100644
--- a/drivers/input/mouse/vsxxxaa.c
+++ b/drivers/input/mouse/vsxxxaa.c
@@ -334,7 +334,7 @@ static void vsxxxaa_handle_POR_packet(struct vsxxxaa *mouse)
          * M: manufacturer location code
          * R: revision code
          * E: Error code. If it's in the range of 0x00..0x1f, only some
-         *    minor problem occured. Errors >= 0x20 are considered bad
+         *    minor problem occurred. Errors >= 0x20 are considered bad
          *    and the device may not work properly...
          * D: <0010> == mouse, <0100> == tablet
          */
diff --git a/drivers/input/mousedev.c b/drivers/input/mousedev.c
index d528a2dba064..0110b5a3a167 100644
--- a/drivers/input/mousedev.c
+++ b/drivers/input/mousedev.c
@@ -9,6 +9,8 @@
  * the Free Software Foundation.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #define MOUSEDEV_MINOR_BASE     32
 #define MOUSEDEV_MINORS         32
 #define MOUSEDEV_MIX            31
@@ -185,7 +187,7 @@ static void mousedev_abs_event(struct input_dev *dev, struct mousedev *mousedev,
                 if (size == 0)
                         size = xres ? : 1;
 
-                clamp(value, min, max);
+                value = clamp(value, min, max);
 
                 mousedev->packet.x = ((value - min) * xres) / size;
                 mousedev->packet.abs_event = 1;
@@ -199,7 +201,7 @@ static void mousedev_abs_event(struct input_dev *dev, struct mousedev *mousedev,
                 if (size == 0)
                         size = yres ? : 1;
 
-                clamp(value, min, max);
+                value = clamp(value, min, max);
 
                 mousedev->packet.y = yres - ((value - min) * yres) / size;
                 mousedev->packet.abs_event = 1;
@@ -506,7 +508,6 @@ static void mousedev_attach_client(struct mousedev *mousedev,
         spin_lock(&mousedev->client_lock);
         list_add_tail_rcu(&client->node, &mousedev->client_list);
         spin_unlock(&mousedev->client_lock);
-        synchronize_rcu();
 }
 
 static void mousedev_detach_client(struct mousedev *mousedev,
@@ -792,6 +793,7 @@ static const struct file_operations mousedev_fops = {
         .open =         mousedev_open,
         .release =      mousedev_release,
         .fasync =       mousedev_fasync,
+        .llseek = noop_llseek,
 };
 
 static int mousedev_install_chrdev(struct mousedev *mousedev)
@@ -866,7 +868,7 @@ static struct mousedev *mousedev_create(struct input_dev *dev,
         spin_lock_init(&mousedev->client_lock);
         mutex_init(&mousedev->mutex);
         lockdep_set_subclass(&mousedev->mutex,
-                             minor == MOUSEDEV_MIX ? MOUSEDEV_MIX : 0);
+                             minor == MOUSEDEV_MIX ? SINGLE_DEPTH_NESTING : 0);
         init_waitqueue_head(&mousedev->wait);
 
         if (minor == MOUSEDEV_MIX)
@@ -976,7 +978,7 @@ static int mousedev_connect(struct input_handler *handler,
                         break;
 
         if (minor == MOUSEDEV_MINORS) {
-                printk(KERN_ERR "mousedev: no more free mousedev devices\n");
+                pr_err("no more free mousedev devices\n");
                 return -ENFILE;
         }
 
@@ -1086,13 +1088,13 @@ static int __init mousedev_init(void)
 #ifdef CONFIG_INPUT_MOUSEDEV_PSAUX
         error = misc_register(&psaux_mouse);
         if (error)
-                printk(KERN_WARNING "mice: could not register psaux device, "
-                        "error: %d\n", error);
+                pr_warning("could not register psaux device, error: %d\n",
+                           error);
         else
                 psaux_registered = 1;
 #endif
 
-        printk(KERN_INFO "mice: PS/2 mouse device common for all mice\n");
+        pr_info("PS/2 mouse device common for all mice\n");
 
         return 0;
 }
diff --git a/drivers/input/serio/Kconfig b/drivers/input/serio/Kconfig
index 3bfe8fafc6ad..55f2c2293ec6 100644
--- a/drivers/input/serio/Kconfig
+++ b/drivers/input/serio/Kconfig
@@ -2,7 +2,7 @@
 # Input core configuration
 #
 config SERIO
-        tristate "Serial I/O support" if EMBEDDED || !X86
+        tristate "Serial I/O support" if EXPERT || !X86
         default y
         help
           Say Yes here if you have any input device that uses serial I/O to
@@ -19,7 +19,7 @@ config SERIO
 if SERIO
 
 config SERIO_I8042
-        tristate "i8042 PC Keyboard controller" if EMBEDDED || !X86
+        tristate "i8042 PC Keyboard controller" if EXPERT || !X86
         default y
         depends on !PARISC && (!ARM || ARCH_SHARK || FOOTBRIDGE_HOST) && \
                    (!SUPERH || SH_CAYMAN) && !M68K && !BLACKFIN
@@ -168,7 +168,7 @@ config SERIO_MACEPS2
           module will be called maceps2.
 
 config SERIO_LIBPS2
-        tristate "PS/2 driver library" if EMBEDDED
+        tristate "PS/2 driver library" if EXPERT
         depends on SERIO_I8042 || SERIO_I8042=n
         help
           Say Y here if you are using a driver for device connected
@@ -214,7 +214,6 @@ config SERIO_AMS_DELTA
         tristate "Amstrad Delta (E3) mailboard support"
         depends on MACH_AMS_DELTA
         default y
-        select AMS_DELTA_FIQ
         ---help---
           Say Y here if you have an E3 and want to use its mailboard,
           or any standard AT keyboard connected to the mailboard port.
@@ -226,4 +225,13 @@ config SERIO_AMS_DELTA
           To compile this driver as a module, choose M here;
           the module will be called ams_delta_serio.
 
+config SERIO_PS2MULT
+        tristate "TQC PS/2 multiplexer"
+        help
+          Say Y here if you have the PS/2 line multiplexer like the one
+          present on TQC boards.
+
+          To compile this driver as a module, choose M here: the
+          module will be called ps2mult.
+
 endif
diff --git a/drivers/input/serio/Makefile b/drivers/input/serio/Makefile
index 84c80bf7185e..dbbe37616c92 100644
--- a/drivers/input/serio/Makefile
+++ b/drivers/input/serio/Makefile
@@ -18,6 +18,7 @@ obj-$(CONFIG_SERIO_GSCPS2)	+= gscps2.o
 obj-$(CONFIG_HP_SDC)            += hp_sdc.o
 obj-$(CONFIG_HIL_MLC)           += hp_sdc_mlc.o hil_mlc.o
 obj-$(CONFIG_SERIO_PCIPS2)      += pcips2.o
+obj-$(CONFIG_SERIO_PS2MULT)     += ps2mult.o
 obj-$(CONFIG_SERIO_MACEPS2)     += maceps2.o
 obj-$(CONFIG_SERIO_LIBPS2)      += libps2.o
 obj-$(CONFIG_SERIO_RAW)         += serio_raw.o
diff --git a/drivers/input/serio/altera_ps2.c b/drivers/input/serio/altera_ps2.c
index 7998560a1904..d363dc4571a3 100644
--- a/drivers/input/serio/altera_ps2.c
+++ b/drivers/input/serio/altera_ps2.c
@@ -19,6 +19,7 @@
 #include <linux/platform_device.h>
 #include <linux/io.h>
 #include <linux/slab.h>
+#include <linux/of.h>
 
 #define DRV_NAME "altera_ps2"
 
@@ -173,6 +174,16 @@ static int __devexit altera_ps2_remove(struct platform_device *pdev)
         return 0;
 }
 
+#ifdef CONFIG_OF
+static const struct of_device_id altera_ps2_match[] = {
+        { .compatible = "ALTR,ps2-1.0", },
+        {},
+};
+MODULE_DEVICE_TABLE(of, altera_ps2_match);
+#else /* CONFIG_OF */
+#define altera_ps2_match NULL
+#endif /* CONFIG_OF */
+
 /*
  * Our device driver structure
  */
@@ -182,6 +193,7 @@ static struct platform_driver altera_ps2_driver = {
         .driver = {
                 .name   = DRV_NAME,
                 .owner  = THIS_MODULE,
+                .of_match_table = altera_ps2_match,
         },
 };
 
@@ -189,13 +201,12 @@ static int __init altera_ps2_init(void)
 {
         return platform_driver_register(&altera_ps2_driver);
 }
+module_init(altera_ps2_init);
 
 static void __exit altera_ps2_exit(void)
 {
         platform_driver_unregister(&altera_ps2_driver);
 }
-
-module_init(altera_ps2_init);
 module_exit(altera_ps2_exit);
 
 MODULE_DESCRIPTION("Altera University Program PS2 controller driver");
diff --git a/drivers/input/serio/ambakmi.c b/drivers/input/serio/ambakmi.c
index 92563a681d65..12abc50508e5 100644
--- a/drivers/input/serio/ambakmi.c
+++ b/drivers/input/serio/ambakmi.c
@@ -107,7 +107,8 @@ static void amba_kmi_close(struct serio *io)
         clk_disable(kmi->clk);
 }
 
-static int __devinit amba_kmi_probe(struct amba_device *dev, struct amba_id *id)
+static int __devinit amba_kmi_probe(struct amba_device *dev,
+        const struct amba_id *id)
 {
         struct amba_kmi_port *kmi;
         struct serio *io;
diff --git a/drivers/input/serio/ams_delta_serio.c b/drivers/input/serio/ams_delta_serio.c
index 8f1770e1e08b..4b2a42f9f0bb 100644
--- a/drivers/input/serio/ams_delta_serio.c
+++ b/drivers/input/serio/ams_delta_serio.c
@@ -149,7 +149,7 @@ static int __init ams_delta_serio_init(void)
          * at FIQ level, switch back from edge to simple interrupt handler
          * to avoid bad interaction.
          */
-        set_irq_handler(gpio_to_irq(AMS_DELTA_GPIO_PIN_KEYBRD_CLK),
+        irq_set_handler(gpio_to_irq(AMS_DELTA_GPIO_PIN_KEYBRD_CLK),
                         handle_simple_irq);
 
         serio_register_port(ams_delta_serio);
@@ -172,6 +172,5 @@ static void __exit ams_delta_serio_exit(void)
         free_irq(OMAP_GPIO_IRQ(AMS_DELTA_GPIO_PIN_KEYBRD_CLK), 0);
         gpio_free(AMS_DELTA_GPIO_PIN_KEYBRD_CLK);
         gpio_free(AMS_DELTA_GPIO_PIN_KEYBRD_DATA);
-        kfree(ams_delta_serio);
 }
 module_exit(ams_delta_serio_exit);
diff --git a/drivers/input/serio/ct82c710.c b/drivers/input/serio/ct82c710.c
index 4a3084695c00..852816567241 100644
--- a/drivers/input/serio/ct82c710.c
+++ b/drivers/input/serio/ct82c710.c
@@ -111,9 +111,11 @@ static void ct82c710_close(struct serio *serio)
 static int ct82c710_open(struct serio *serio)
 {
         unsigned char status;
+        int err;
 
-        if (request_irq(CT82C710_IRQ, ct82c710_interrupt, 0, "ct82c710", NULL))
-                return -1;
+        err = request_irq(CT82C710_IRQ, ct82c710_interrupt, 0, "ct82c710", NULL);
+        if (err)
+                return err;
 
         status = inb_p(CT82C710_STATUS);
 
@@ -131,7 +133,7 @@ static int ct82c710_open(struct serio *serio)
                 status &= ~(CT82C710_ENABLE | CT82C710_INTS_ON);
                 outb_p(status, CT82C710_STATUS);
                 free_irq(CT82C710_IRQ, NULL);
-                return -1;
+                return -EBUSY;
         }
 
         return 0;
@@ -191,6 +193,9 @@ static int __devinit ct82c710_probe(struct platform_device *dev)
 
         serio_register_port(ct82c710_port);
 
+        printk(KERN_INFO "serio: C&T 82c710 mouse port at %#llx irq %d\n",
+                (unsigned long long)CT82C710_DATA, CT82C710_IRQ);
+
         return 0;
 }
 
@@ -237,11 +242,6 @@ static int __init ct82c710_init(void)
         if (error)
                 goto err_free_device;
 
-        serio_register_port(ct82c710_port);
-
-        printk(KERN_INFO "serio: C&T 82c710 mouse port at %#llx irq %d\n",
-                (unsigned long long)CT82C710_DATA, CT82C710_IRQ);
-
         return 0;
 
  err_free_device:
diff --git a/drivers/input/serio/gscps2.c b/drivers/input/serio/gscps2.c
index 3c287dd879d3..4225f5d6b15f 100644
--- a/drivers/input/serio/gscps2.c
+++ b/drivers/input/serio/gscps2.c
@@ -358,7 +358,7 @@ static int __devinit gscps2_probe(struct parisc_device *dev)
         gscps2_reset(ps2port);
         ps2port->id = readb(ps2port->addr + GSC_ID) & 0x0f;
 
-        snprintf(serio->name, sizeof(serio->name), "GSC PS/2 %s",
+        snprintf(serio->name, sizeof(serio->name), "gsc-ps2-%s",
                  (ps2port->id == GSC_ID_KEYBOARD) ? "keyboard" : "mouse");
         strlcpy(serio->phys, dev_name(&dev->dev), sizeof(serio->phys));
         serio->id.type          = SERIO_8042;
diff --git a/drivers/input/serio/hil_mlc.c b/drivers/input/serio/hil_mlc.c
index c92f4edfee7b..bfd3865d886b 100644
--- a/drivers/input/serio/hil_mlc.c
+++ b/drivers/input/serio/hil_mlc.c
@@ -915,15 +915,15 @@ int hil_mlc_register(hil_mlc *mlc)
         mlc->ostarted = 0;
 
         rwlock_init(&mlc->lock);
-        init_MUTEX(&mlc->osem);
+        sema_init(&mlc->osem, 1);
 
-        init_MUTEX(&mlc->isem);
+        sema_init(&mlc->isem, 1);
         mlc->icount = -1;
         mlc->imatch = 0;
 
         mlc->opercnt = 0;
 
-        init_MUTEX_LOCKED(&(mlc->csem));
+        sema_init(&(mlc->csem), 0);
 
         hil_mlc_clear_di_scratch(mlc);
         hil_mlc_clear_di_map(mlc, 0);
@@ -932,6 +932,11 @@ int hil_mlc_register(hil_mlc *mlc)
                 hil_mlc_copy_di_scratch(mlc, i);
                 mlc_serio = kzalloc(sizeof(*mlc_serio), GFP_KERNEL);
                 mlc->serio[i] = mlc_serio;
+                if (!mlc->serio[i]) {
+                        for (; i >= 0; i--)
+                                kfree(mlc->serio[i]);
+                        return -ENOMEM;
+                }
                 snprintf(mlc_serio->name, sizeof(mlc_serio->name)-1, "HIL_SERIO%d", i);
                 snprintf(mlc_serio->phys, sizeof(mlc_serio->phys)-1, "HIL%d", i);
                 mlc_serio->id                   = hil_mlc_serio_id;
diff --git a/drivers/input/serio/hp_sdc.c b/drivers/input/serio/hp_sdc.c
index bcc2d30ec245..42206205e4f5 100644
--- a/drivers/input/serio/hp_sdc.c
+++ b/drivers/input/serio/hp_sdc.c
@@ -905,7 +905,7 @@ static int __init hp_sdc_init(void)
         ts_sync[1]      = 0x0f;
         ts_sync[2] = ts_sync[3] = ts_sync[4] = ts_sync[5] = 0;
         t_sync.act.semaphore = &s_sync;
-        init_MUTEX_LOCKED(&s_sync);
+        sema_init(&s_sync, 0);
         hp_sdc_enqueue_transaction(&t_sync);
         down(&s_sync); /* Wait for t_sync to complete */
 
@@ -955,7 +955,7 @@ static int __init hp_sdc_init_hppa(struct parisc_device *d)
         INIT_DELAYED_WORK(&moduleloader_work, request_module_delayed);
 
         ret = hp_sdc_init();
-        /* after successfull initialization give SDC some time to settle
+        /* after successful initialization give SDC some time to settle
          * and then load the hp_sdc_mlc upper layer driver */
         if (!ret)
                 schedule_delayed_work(&moduleloader_work,
@@ -1039,7 +1039,7 @@ static int __init hp_sdc_register(void)
                 return hp_sdc.dev_err;
         }
 
-        init_MUTEX_LOCKED(&tq_init_sem);
+        sema_init(&tq_init_sem, 0);
 
         tq_init.actidx          = 0;
         tq_init.idx             = 1;
diff --git a/drivers/input/serio/hp_sdc_mlc.c b/drivers/input/serio/hp_sdc_mlc.c
index 7d2b820ef58d..d50f0678bf47 100644
--- a/drivers/input/serio/hp_sdc_mlc.c
+++ b/drivers/input/serio/hp_sdc_mlc.c
@@ -305,6 +305,7 @@ static void hp_sdc_mlc_out(hil_mlc *mlc)
 static int __init hp_sdc_mlc_init(void)
 {
         hil_mlc *mlc = &hp_sdc_mlc;
+        int err;
 
 #ifdef __mc68000__
         if (!MACH_IS_HP300)
@@ -323,22 +324,21 @@ static int __init hp_sdc_mlc_init(void)
         mlc->out = &hp_sdc_mlc_out;
         mlc->priv = &hp_sdc_mlc_priv;
 
-        if (hil_mlc_register(mlc)) {
+        err = hil_mlc_register(mlc);
+        if (err) {
                 printk(KERN_WARNING PREFIX "Failed to register MLC structure with hil_mlc\n");
-                goto err0;
+                return err;
         }
 
         if (hp_sdc_request_hil_irq(&hp_sdc_mlc_isr)) {
                 printk(KERN_WARNING PREFIX "Request for raw HIL ISR hook denied\n");
-                goto err1;
+                if (hil_mlc_unregister(mlc))
+                        printk(KERN_ERR PREFIX "Failed to unregister MLC structure with hil_mlc.\n"
+                                "This is bad.  Could cause an oops.\n");
+                return -EBUSY;
         }
+
         return 0;
- err1:
-        if (hil_mlc_unregister(mlc))
-                printk(KERN_ERR PREFIX "Failed to unregister MLC structure with hil_mlc.\n"
-                        "This is bad.  Could cause an oops.\n");
- err0:
-        return -EBUSY;
 }
 
 static void __exit hp_sdc_mlc_exit(void)
diff --git a/drivers/input/serio/i8042-sparcio.h b/drivers/input/serio/i8042-sparcio.h
index c5cc4508d6df..395a9af3adcd 100644
--- a/drivers/input/serio/i8042-sparcio.h
+++ b/drivers/input/serio/i8042-sparcio.h
@@ -49,7 +49,7 @@ static inline void i8042_write_command(int val)
 #define OBP_PS2MS_NAME1         "kdmouse"
 #define OBP_PS2MS_NAME2         "mouse"
 
-static int __devinit sparc_i8042_probe(struct platform_device *op, const struct of_device_id *match)
+static int __devinit sparc_i8042_probe(struct platform_device *op)
 {
         struct device_node *dp = op->dev.of_node;
 
@@ -95,7 +95,7 @@ static const struct of_device_id sparc_i8042_match[] = {
 };
 MODULE_DEVICE_TABLE(of, sparc_i8042_match);
 
-static struct of_platform_driver sparc_i8042_driver = {
+static struct platform_driver sparc_i8042_driver = {
         .driver = {
                 .name = "i8042",
                 .owner = THIS_MODULE,
@@ -116,7 +116,7 @@ static int __init i8042_platform_init(void)
                 if (!kbd_iobase)
                         return -ENODEV;
         } else {
-                int err = of_register_platform_driver(&sparc_i8042_driver);
+                int err = platform_driver_register(&sparc_i8042_driver);
                 if (err)
                         return err;
 
@@ -140,7 +140,7 @@ static inline void i8042_platform_exit(void)
         struct device_node *root = of_find_node_by_path("/");
 
         if (strcmp(root->name, "SUNW,JavaStation-1"))
-                of_unregister_platform_driver(&sparc_i8042_driver);
+                platform_driver_unregister(&sparc_i8042_driver);
 }
 
 #else /* !CONFIG_PCI */
diff --git a/drivers/input/serio/i8042-unicore32io.h b/drivers/input/serio/i8042-unicore32io.h
new file mode 100644
index 000000000000..73f5cc124a36
--- /dev/null
+++ b/drivers/input/serio/i8042-unicore32io.h
@@ -0,0 +1,73 @@
+/*
+ * Code specific to PKUnity SoC and UniCore ISA
+ *
+ *      Maintained by GUAN Xue-tao <gxt@mprc.pku.edu.cn>
+ *      Copyright (C) 2001-2011 Guan Xuetao
+ *
+ * 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.
+ */
+#ifndef _I8042_UNICORE32_H
+#define _I8042_UNICORE32_H
+
+#include <mach/hardware.h>
+
+/*
+ * Names.
+ */
+#define I8042_KBD_PHYS_DESC "isa0060/serio0"
+#define I8042_AUX_PHYS_DESC "isa0060/serio1"
+#define I8042_MUX_PHYS_DESC "isa0060/serio%d"
+
+/*
+ * IRQs.
+ */
+#define I8042_KBD_IRQ           IRQ_PS2_KBD
+#define I8042_AUX_IRQ           IRQ_PS2_AUX
+
+/*
+ * Register numbers.
+ */
+#define I8042_COMMAND_REG       PS2_COMMAND
+#define I8042_STATUS_REG        PS2_STATUS
+#define I8042_DATA_REG          PS2_DATA
+
+#define I8042_REGION_START      (resource_size_t)(PS2_DATA)
+#define I8042_REGION_SIZE       (resource_size_t)(16)
+
+static inline int i8042_read_data(void)
+{
+        return readb(I8042_DATA_REG);
+}
+
+static inline int i8042_read_status(void)
+{
+        return readb(I8042_STATUS_REG);
+}
+
+static inline void i8042_write_data(int val)
+{
+        writeb(val, I8042_DATA_REG);
+}
+
+static inline void i8042_write_command(int val)
+{
+        writeb(val, I8042_COMMAND_REG);
+}
+
+static inline int i8042_platform_init(void)
+{
+        if (!request_mem_region(I8042_REGION_START, I8042_REGION_SIZE, "i8042"))
+                return -EBUSY;
+
+        i8042_reset = 1;
+        return 0;
+}
+
+static inline void i8042_platform_exit(void)
+{
+        release_mem_region(I8042_REGION_START, I8042_REGION_SIZE);
+}
+
+#endif /* _I8042_UNICORE32_H */
diff --git a/drivers/input/serio/i8042-x86ia64io.h b/drivers/input/serio/i8042-x86ia64io.h
index ed7ad7416b24..bb9f5d31f0d0 100644
--- a/drivers/input/serio/i8042-x86ia64io.h
+++ b/drivers/input/serio/i8042-x86ia64io.h
@@ -351,6 +351,17 @@ static const struct dmi_system_id __initconst i8042_dmi_nomux_table[] = {
                 },
         },
         {
+                /*
+                 * Most (all?) VAIOs do not have external PS/2 ports nor
+                 * they implement active multiplexing properly, and
+                 * MUX discovery usually messes up keyboard/touchpad.
+                 */
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
+                        DMI_MATCH(DMI_BOARD_NAME, "VAIO"),
+                },
+        },
+        {
                 /* Amoi M636/A737 */
                 .matches = {
                         DMI_MATCH(DMI_SYS_VENDOR, "Amoi Electronics CO.,LTD."),
@@ -413,6 +424,13 @@ static const struct dmi_system_id __initconst i8042_dmi_nomux_table[] = {
                         DMI_MATCH(DMI_PRODUCT_VERSION, "0100"),
                 },
         },
+        {
+                /* Dell Vostro V13 */
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "Vostro V13"),
+                },
+        },
         { }
 };
 
@@ -534,6 +552,17 @@ static const struct dmi_system_id __initconst i8042_dmi_laptop_table[] = {
 };
 #endif
 
+static const struct dmi_system_id __initconst i8042_dmi_notimeout_table[] = {
+        {
+                /* Dell Vostro V13 */
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "Vostro V13"),
+                },
+        },
+        { }
+};
+
 /*
  * Some Wistron based laptops need us to explicitly enable the 'Dritek
  * keyboard extension' to make their extra keys start generating scancodes.
@@ -542,6 +571,13 @@ static const struct dmi_system_id __initconst i8042_dmi_laptop_table[] = {
  */
 static const struct dmi_system_id __initconst i8042_dmi_dritek_table[] = {
         {
+                /* Acer Aspire 5100 */
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5100"),
+                },
+        },
+        {
                 /* Acer Aspire 5610 */
                 .matches = {
                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
@@ -741,7 +777,7 @@ static int __init i8042_pnp_init(void)
 #endif
 
         if (i8042_nopnp) {
-                printk(KERN_INFO "i8042: PNP detection disabled\n");
+                pr_info("PNP detection disabled\n");
                 return 0;
         }
 
@@ -758,7 +794,7 @@ static int __init i8042_pnp_init(void)
 #if defined(__ia64__)
                 return -ENODEV;
 #else
-                printk(KERN_INFO "PNP: No PS/2 controller found. Probing ports directly.\n");
+                pr_info("PNP: No PS/2 controller found. Probing ports directly.\n");
                 return 0;
 #endif
         }
@@ -770,7 +806,7 @@ static int __init i8042_pnp_init(void)
                 snprintf(aux_irq_str, sizeof(aux_irq_str),
                         "%d", i8042_pnp_aux_irq);
 
-        printk(KERN_INFO "PNP: PS/2 Controller [%s%s%s] at %#x,%#x irq %s%s%s\n",
+        pr_info("PNP: PS/2 Controller [%s%s%s] at %#x,%#x irq %s%s%s\n",
                 i8042_pnp_kbd_name, (i8042_pnp_kbd_devices && i8042_pnp_aux_devices) ? "," : "",
                 i8042_pnp_aux_name,
                 i8042_pnp_data_reg, i8042_pnp_command_reg,
@@ -787,9 +823,7 @@ static int __init i8042_pnp_init(void)
         if (((i8042_pnp_data_reg & ~0xf) == (i8042_data_reg & ~0xf) &&
               i8042_pnp_data_reg != i8042_data_reg) ||
             !i8042_pnp_data_reg) {
-                printk(KERN_WARNING
-                        "PNP: PS/2 controller has invalid data port %#x; "
-                        "using default %#x\n",
+                pr_warn("PNP: PS/2 controller has invalid data port %#x; using default %#x\n",
                         i8042_pnp_data_reg, i8042_data_reg);
                 i8042_pnp_data_reg = i8042_data_reg;
                 pnp_data_busted = true;
@@ -798,33 +832,27 @@ static int __init i8042_pnp_init(void)
         if (((i8042_pnp_command_reg & ~0xf) == (i8042_command_reg & ~0xf) &&
               i8042_pnp_command_reg != i8042_command_reg) ||
             !i8042_pnp_command_reg) {
-                printk(KERN_WARNING
-                        "PNP: PS/2 controller has invalid command port %#x; "
-                        "using default %#x\n",
+                pr_warn("PNP: PS/2 controller has invalid command port %#x; using default %#x\n",
                         i8042_pnp_command_reg, i8042_command_reg);
                 i8042_pnp_command_reg = i8042_command_reg;
                 pnp_data_busted = true;
         }
 
         if (!i8042_nokbd && !i8042_pnp_kbd_irq) {
-                printk(KERN_WARNING
-                        "PNP: PS/2 controller doesn't have KBD irq; "
-                        "using default %d\n", i8042_kbd_irq);
+                pr_warn("PNP: PS/2 controller doesn't have KBD irq; using default %d\n",
+                        i8042_kbd_irq);
                 i8042_pnp_kbd_irq = i8042_kbd_irq;
                 pnp_data_busted = true;
         }
 
         if (!i8042_noaux && !i8042_pnp_aux_irq) {
                 if (!pnp_data_busted && i8042_pnp_kbd_irq) {
-                        printk(KERN_WARNING
-                                "PNP: PS/2 appears to have AUX port disabled, "
-                                "if this is incorrect please boot with "
-                                "i8042.nopnp\n");
+                        pr_warn("PNP: PS/2 appears to have AUX port disabled, "
+                                "if this is incorrect please boot with i8042.nopnp\n");
                         i8042_noaux = true;
                 } else {
-                        printk(KERN_WARNING
-                                "PNP: PS/2 controller doesn't have AUX irq; "
-                                "using default %d\n", i8042_aux_irq);
+                        pr_warn("PNP: PS/2 controller doesn't have AUX irq; using default %d\n",
+                                i8042_aux_irq);
                         i8042_pnp_aux_irq = i8042_aux_irq;
                 }
         }
@@ -886,6 +914,9 @@ static int __init i8042_platform_init(void)
         if (dmi_check_system(i8042_dmi_nomux_table))
                 i8042_nomux = true;
 
+        if (dmi_check_system(i8042_dmi_notimeout_table))
+                i8042_notimeout = true;
+
         if (dmi_check_system(i8042_dmi_dritek_table))
                 i8042_dritek = true;
 #endif /* CONFIG_X86 */
diff --git a/drivers/input/serio/i8042.c b/drivers/input/serio/i8042.c
index f58513160480..d37a48e099d0 100644
--- a/drivers/input/serio/i8042.c
+++ b/drivers/input/serio/i8042.c
@@ -10,6 +10,8 @@
  * the Free Software Foundation.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/types.h>
 #include <linux/delay.h>
 #include <linux/module.h>
@@ -61,6 +63,10 @@ static bool i8042_noloop;
 module_param_named(noloop, i8042_noloop, bool, 0);
 MODULE_PARM_DESC(noloop, "Disable the AUX Loopback command while probing for the AUX port");
 
+static bool i8042_notimeout;
+module_param_named(notimeout, i8042_notimeout, bool, 0);
+MODULE_PARM_DESC(notimeout, "Ignore timeouts signalled by i8042");
+
 #ifdef CONFIG_X86
 static bool i8042_dritek;
 module_param_named(dritek, i8042_dritek, bool, 0);
@@ -225,8 +231,8 @@ static int i8042_flush(void)
                 udelay(50);
                 data = i8042_read_data();
                 i++;
-                dbg("%02x <- i8042 (flush, %s)", data,
-                        str & I8042_STR_AUXDATA ? "aux" : "kbd");
+                dbg("%02x <- i8042 (flush, %s)\n",
+                    data, str & I8042_STR_AUXDATA ? "aux" : "kbd");
         }
 
         spin_unlock_irqrestore(&i8042_lock, flags);
@@ -253,32 +259,32 @@ static int __i8042_command(unsigned char *param, int command)
         if (error)
                 return error;
 
-        dbg("%02x -> i8042 (command)", command & 0xff);
+        dbg("%02x -> i8042 (command)\n", command & 0xff);
         i8042_write_command(command & 0xff);
 
         for (i = 0; i < ((command >> 12) & 0xf); i++) {
                 error = i8042_wait_write();
                 if (error)
                         return error;
-                dbg("%02x -> i8042 (parameter)", param[i]);
+                dbg("%02x -> i8042 (parameter)\n", param[i]);
                 i8042_write_data(param[i]);
         }
 
         for (i = 0; i < ((command >> 8) & 0xf); i++) {
                 error = i8042_wait_read();
                 if (error) {
-                        dbg("     -- i8042 (timeout)");
+                        dbg("     -- i8042 (timeout)\n");
                         return error;
                 }
 
                 if (command == I8042_CMD_AUX_LOOP &&
                     !(i8042_read_status() & I8042_STR_AUXDATA)) {
-                        dbg("     -- i8042 (auxerr)");
+                        dbg("     -- i8042 (auxerr)\n");
                         return -1;
                 }
 
                 param[i] = i8042_read_data();
-                dbg("%02x <- i8042 (return)", param[i]);
+                dbg("%02x <- i8042 (return)\n", param[i]);
         }
 
         return 0;
@@ -309,7 +315,7 @@ static int i8042_kbd_write(struct serio *port, unsigned char c)
         spin_lock_irqsave(&i8042_lock, flags);
 
         if (!(retval = i8042_wait_write())) {
-                dbg("%02x -> i8042 (kbd-data)", c);
+                dbg("%02x -> i8042 (kbd-data)\n", c);
                 i8042_write_data(c);
         }
 
@@ -355,17 +361,14 @@ static void i8042_port_close(struct serio *serio)
 
         i8042_ctr &= ~irq_bit;
         if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR))
-                printk(KERN_WARNING
-                        "i8042.c: Can't write CTR while closing %s port.\n",
-                        port_name);
+                pr_warn("Can't write CTR while closing %s port\n", port_name);
 
         udelay(50);
 
         i8042_ctr &= ~disable_bit;
         i8042_ctr |= irq_bit;
         if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR))
-                printk(KERN_ERR "i8042.c: Can't reactivate %s port.\n",
-                        port_name);
+                pr_err("Can't reactivate %s port\n", port_name);
 
         /*
          * See if there is any data appeared while we were messing with
@@ -456,7 +459,8 @@ static irqreturn_t i8042_interrupt(int irq, void *dev_id)
         str = i8042_read_status();
         if (unlikely(~str & I8042_STR_OBF)) {
                 spin_unlock_irqrestore(&i8042_lock, flags);
-                if (irq) dbg("Interrupt %d, without any data", irq);
+                if (irq)
+                        dbg("Interrupt %d, without any data\n", irq);
                 ret = 0;
                 goto out;
         }
@@ -469,7 +473,8 @@ static irqreturn_t i8042_interrupt(int irq, void *dev_id)
 
                 dfl = 0;
                 if (str & I8042_STR_MUXERR) {
-                        dbg("MUX error, status is %02x, data is %02x", str, data);
+                        dbg("MUX error, status is %02x, data is %02x\n",
+                            str, data);
 /*
  * When MUXERR condition is signalled the data register can only contain
  * 0xfd, 0xfe or 0xff if implementation follows the spec. Unfortunately
@@ -503,7 +508,7 @@ static irqreturn_t i8042_interrupt(int irq, void *dev_id)
         } else {
 
                 dfl = ((str & I8042_STR_PARITY) ? SERIO_PARITY : 0) |
-                      ((str & I8042_STR_TIMEOUT) ? SERIO_TIMEOUT : 0);
+                      ((str & I8042_STR_TIMEOUT && !i8042_notimeout) ? SERIO_TIMEOUT : 0);
 
                 port_no = (str & I8042_STR_AUXDATA) ?
                                 I8042_AUX_PORT_NO : I8042_KBD_PORT_NO;
@@ -512,7 +517,7 @@ static irqreturn_t i8042_interrupt(int irq, void *dev_id)
         port = &i8042_ports[port_no];
         serio = port->exists ? port->serio : NULL;
 
-        dbg("%02x <- i8042 (interrupt, %d, %d%s%s)",
+        dbg("%02x <- i8042 (interrupt, %d, %d%s%s)\n",
             data, port_no, irq,
             dfl & SERIO_PARITY ? ", bad parity" : "",
             dfl & SERIO_TIMEOUT ? ", timeout" : "");
@@ -540,7 +545,7 @@ static int i8042_enable_kbd_port(void)
         if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR)) {
                 i8042_ctr &= ~I8042_CTR_KBDINT;
                 i8042_ctr |= I8042_CTR_KBDDIS;
-                printk(KERN_ERR "i8042.c: Failed to enable KBD port.\n");
+                pr_err("Failed to enable KBD port\n");
                 return -EIO;
         }
 
@@ -559,7 +564,7 @@ static int i8042_enable_aux_port(void)
         if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR)) {
                 i8042_ctr &= ~I8042_CTR_AUXINT;
                 i8042_ctr |= I8042_CTR_AUXDIS;
-                printk(KERN_ERR "i8042.c: Failed to enable AUX port.\n");
+                pr_err("Failed to enable AUX port\n");
                 return -EIO;
         }
 
@@ -641,7 +646,7 @@ static int __init i8042_check_mux(void)
         if (i8042_set_mux_mode(true, &mux_version))
                 return -1;
 
-        printk(KERN_INFO "i8042.c: Detected active multiplexing controller, rev %d.%d.\n",
+        pr_info("Detected active multiplexing controller, rev %d.%d\n",
                 (mux_version >> 4) & 0xf, mux_version & 0xf);
 
 /*
@@ -651,7 +656,7 @@ static int __init i8042_check_mux(void)
         i8042_ctr &= ~I8042_CTR_AUXINT;
 
         if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR)) {
-                printk(KERN_ERR "i8042.c: Failed to disable AUX port, can't use MUX.\n");
+                pr_err("Failed to disable AUX port, can't use MUX\n");
                 return -EIO;
         }
 
@@ -676,8 +681,8 @@ static irqreturn_t __init i8042_aux_test_irq(int irq, void *dev_id)
         str = i8042_read_status();
         if (str & I8042_STR_OBF) {
                 data = i8042_read_data();
-                dbg("%02x <- i8042 (aux_test_irq, %s)",
-                        data, str & I8042_STR_AUXDATA ? "aux" : "kbd");
+                dbg("%02x <- i8042 (aux_test_irq, %s)\n",
+                    data, str & I8042_STR_AUXDATA ? "aux" : "kbd");
                 if (i8042_irq_being_tested &&
                     data == 0xa5 && (str & I8042_STR_AUXDATA))
                         complete(&i8042_aux_irq_delivered);
@@ -770,8 +775,8 @@ static int __init i8042_check_aux(void)
  */
 
         if (i8042_toggle_aux(false)) {
-                printk(KERN_WARNING "Failed to disable AUX port, but continuing anyway... Is this a SiS?\n");
-                printk(KERN_WARNING "If AUX port is really absent please use the 'i8042.noaux' option.\n");
+                pr_warn("Failed to disable AUX port, but continuing anyway... Is this a SiS?\n");
+                pr_warn("If AUX port is really absent please use the 'i8042.noaux' option\n");
         }
 
         if (i8042_toggle_aux(true))
@@ -819,7 +824,7 @@ static int __init i8042_check_aux(void)
  * AUX IRQ was never delivered so we need to flush the controller to
  * get rid of the byte we put there; otherwise keyboard may not work.
  */
-                dbg("     -- i8042 (aux irq test timeout)");
+                dbg("     -- i8042 (aux irq test timeout)\n");
                 i8042_flush();
                 retval = -1;
         }
@@ -845,7 +850,7 @@ static int __init i8042_check_aux(void)
 static int i8042_controller_check(void)
 {
         if (i8042_flush() == I8042_BUFFER_SIZE) {
-                printk(KERN_ERR "i8042.c: No controller found.\n");
+                pr_err("No controller found\n");
                 return -ENODEV;
         }
 
@@ -864,15 +869,15 @@ static int i8042_controller_selftest(void)
         do {
 
                 if (i8042_command(&param, I8042_CMD_CTL_TEST)) {
-                        printk(KERN_ERR "i8042.c: i8042 controller self test timeout.\n");
+                        pr_err("i8042 controller selftest timeout\n");
                         return -ENODEV;
                 }
 
                 if (param == I8042_RET_CTL_TEST)
                         return 0;
 
-                printk(KERN_ERR "i8042.c: i8042 controller selftest failed. (%#x != %#x)\n",
-                        param, I8042_RET_CTL_TEST);
+                dbg("i8042 controller selftest: %#x != %#x\n",
+                    param, I8042_RET_CTL_TEST);
                 msleep(50);
         } while (i++ < 5);
 
@@ -883,10 +888,10 @@ static int i8042_controller_selftest(void)
          * and user will still get a working keyboard. This is especially
          * important on netbooks. On other arches we trust hardware more.
          */
-        printk(KERN_INFO
-                "i8042: giving up on controller selftest, continuing anyway...\n");
+        pr_info("giving up on controller selftest, continuing anyway...\n");
         return 0;
 #else
+        pr_err("i8042 controller selftest failed\n");
         return -EIO;
 #endif
 }
@@ -909,8 +914,7 @@ static int i8042_controller_init(void)
 
         do {
                 if (n >= 10) {
-                        printk(KERN_ERR
-                                "i8042.c: Unable to get stable CTR read.\n");
+                        pr_err("Unable to get stable CTR read\n");
                         return -EIO;
                 }
 
@@ -918,8 +922,7 @@ static int i8042_controller_init(void)
                         udelay(50);
 
                 if (i8042_command(&ctr[n++ % 2], I8042_CMD_CTL_RCTR)) {
-                        printk(KERN_ERR
-                                "i8042.c: Can't read CTR while initializing i8042.\n");
+                        pr_err("Can't read CTR while initializing i8042\n");
                         return -EIO;
                 }
 
@@ -943,7 +946,7 @@ static int i8042_controller_init(void)
                 if (i8042_unlock)
                         i8042_ctr |= I8042_CTR_IGNKEYLOCK;
                 else
-                        printk(KERN_WARNING "i8042.c: Warning: Keylock active.\n");
+                        pr_warn("Warning: Keylock active\n");
         }
         spin_unlock_irqrestore(&i8042_lock, flags);
 
@@ -970,7 +973,7 @@ static int i8042_controller_init(void)
  */
 
         if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR)) {
-                printk(KERN_ERR "i8042.c: Can't write CTR while initializing i8042.\n");
+                pr_err("Can't write CTR while initializing i8042\n");
                 return -EIO;
         }
 
@@ -1000,7 +1003,7 @@ static void i8042_controller_reset(void)
         i8042_ctr &= ~(I8042_CTR_KBDINT | I8042_CTR_AUXINT);
 
         if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR))
-                printk(KERN_WARNING "i8042.c: Can't write CTR while resetting.\n");
+                pr_warn("Can't write CTR while resetting\n");
 
 /*
  * Disable MUX mode if present.
@@ -1021,7 +1024,7 @@ static void i8042_controller_reset(void)
  */
 
         if (i8042_command(&i8042_initial_ctr, I8042_CMD_CTL_WCTR))
-                printk(KERN_WARNING "i8042.c: Can't restore CTR.\n");
+                pr_warn("Can't restore CTR\n");
 }
 
 
@@ -1045,14 +1048,14 @@ static long i8042_panic_blink(int state)
         led = (state) ? 0x01 | 0x04 : 0;
         while (i8042_read_status() & I8042_STR_IBF)
                 DELAY;
-        dbg("%02x -> i8042 (panic blink)", 0xed);
+        dbg("%02x -> i8042 (panic blink)\n", 0xed);
         i8042_suppress_kbd_ack = 2;
         i8042_write_data(0xed); /* set leds */
         DELAY;
         while (i8042_read_status() & I8042_STR_IBF)
                 DELAY;
         DELAY;
-        dbg("%02x -> i8042 (panic blink)", led);
+        dbg("%02x -> i8042 (panic blink)\n", led);
         i8042_write_data(led);
         DELAY;
         return delay;
@@ -1063,14 +1066,12 @@ static long i8042_panic_blink(int state)
 #ifdef CONFIG_X86
 static void i8042_dritek_enable(void)
 {
-        char param = 0x90;
+        unsigned char param = 0x90;
         int error;
 
         error = i8042_command(&param, 0x1059);
         if (error)
-                printk(KERN_WARNING
-                        "Failed to enable DRITEK extension: %d\n",
-                        error);
+                pr_warn("Failed to enable DRITEK extension: %d\n", error);
 }
 #endif
 
@@ -1105,10 +1106,10 @@ static int i8042_controller_resume(bool force_reset)
         i8042_ctr |= I8042_CTR_AUXDIS | I8042_CTR_KBDDIS;
         i8042_ctr &= ~(I8042_CTR_AUXINT | I8042_CTR_KBDINT);
         if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR)) {
-                printk(KERN_WARNING "i8042: Can't write CTR to resume, retrying...\n");
+                pr_warn("Can't write CTR to resume, retrying...\n");
                 msleep(50);
                 if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR)) {
-                        printk(KERN_ERR "i8042: CTR write retry failed\n");
+                        pr_err("CTR write retry failed\n");
                         return -EIO;
                 }
         }
@@ -1121,9 +1122,7 @@ static int i8042_controller_resume(bool force_reset)
 
         if (i8042_mux_present) {
                 if (i8042_set_mux_mode(true, NULL) || i8042_enable_mux_ports())
-                        printk(KERN_WARNING
-                                "i8042: failed to resume active multiplexor, "
-                                "mouse won't work.\n");
+                        pr_warn("failed to resume active multiplexor, mouse won't work\n");
         } else if (i8042_ports[I8042_AUX_PORT_NO].serio)
                 i8042_enable_aux_port();
 
diff --git a/drivers/input/serio/i8042.h b/drivers/input/serio/i8042.h
index cbc1beb66574..3452708fbe3b 100644
--- a/drivers/input/serio/i8042.h
+++ b/drivers/input/serio/i8042.h
@@ -26,6 +26,8 @@
 #include "i8042-sparcio.h"
 #elif defined(CONFIG_X86) || defined(CONFIG_IA64)
 #include "i8042-x86ia64io.h"
+#elif defined(CONFIG_UNICORE32)
+#include "i8042-unicore32io.h"
 #else
 #include "i8042-io.h"
 #endif
@@ -89,15 +91,19 @@
 #ifdef DEBUG
 static unsigned long i8042_start_time;
 #define dbg_init() do { i8042_start_time = jiffies; } while (0)
-#define dbg(format, arg...)                                                     \
-        do {                                                                    \
+#define dbg(format, arg...)                                                     \
+        do {                                                                    \
                 if (i8042_debug)                                                \
-                        printk(KERN_DEBUG __FILE__ ": " format " [%d]\n" ,      \
-                                ## arg, (int) (jiffies - i8042_start_time));    \
+                        printk(KERN_DEBUG KBUILD_MODNAME ": [%d] " format,      \
+                               (int) (jiffies - i8042_start_time), ##arg);      \
         } while (0)
 #else
 #define dbg_init() do { } while (0)
-#define dbg(format, arg...) do {} while (0)
+#define dbg(format, arg...)                                                     \
+        do {                                                                    \
+                if (0)                                                          \
+                        printk(KERN_DEBUG pr_fmt(format), ##arg);               \
+        } while (0)
 #endif
 
 #endif /* _I8042_H */
diff --git a/drivers/input/serio/ps2mult.c b/drivers/input/serio/ps2mult.c
new file mode 100644
index 000000000000..15aa81c9f1fb
--- /dev/null
+++ b/drivers/input/serio/ps2mult.c
@@ -0,0 +1,318 @@
+/*
+ * TQC PS/2 Multiplexer driver
+ *
+ * Copyright (C) 2010 Dmitry Eremin-Solenikov
+ *
+ * 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/slab.h>
+#include <linux/module.h>
+#include <linux/serio.h>
+
+MODULE_AUTHOR("Dmitry Eremin-Solenikov <dbaryshkov@gmail.com>");
+MODULE_DESCRIPTION("TQC PS/2 Multiplexer driver");
+MODULE_LICENSE("GPL");
+
+#define PS2MULT_KB_SELECTOR             0xA0
+#define PS2MULT_MS_SELECTOR             0xA1
+#define PS2MULT_ESCAPE                  0x7D
+#define PS2MULT_BSYNC                   0x7E
+#define PS2MULT_SESSION_START           0x55
+#define PS2MULT_SESSION_END             0x56
+
+struct ps2mult_port {
+        struct serio *serio;
+        unsigned char sel;
+        bool registered;
+};
+
+#define PS2MULT_NUM_PORTS       2
+#define PS2MULT_KBD_PORT        0
+#define PS2MULT_MOUSE_PORT      1
+
+struct ps2mult {
+        struct serio *mx_serio;
+        struct ps2mult_port ports[PS2MULT_NUM_PORTS];
+
+        spinlock_t lock;
+        struct ps2mult_port *in_port;
+        struct ps2mult_port *out_port;
+        bool escape;
+};
+
+/* First MUST come PS2MULT_NUM_PORTS selectors */
+static const unsigned char ps2mult_controls[] = {
+        PS2MULT_KB_SELECTOR, PS2MULT_MS_SELECTOR,
+        PS2MULT_ESCAPE, PS2MULT_BSYNC,
+        PS2MULT_SESSION_START, PS2MULT_SESSION_END,
+};
+
+static const struct serio_device_id ps2mult_serio_ids[] = {
+        {
+                .type   = SERIO_RS232,
+                .proto  = SERIO_PS2MULT,
+                .id     = SERIO_ANY,
+                .extra  = SERIO_ANY,
+        },
+        { 0 }
+};
+
+MODULE_DEVICE_TABLE(serio, ps2mult_serio_ids);
+
+static void ps2mult_select_port(struct ps2mult *psm, struct ps2mult_port *port)
+{
+        struct serio *mx_serio = psm->mx_serio;
+
+        serio_write(mx_serio, port->sel);
+        psm->out_port = port;
+        dev_dbg(&mx_serio->dev, "switched to sel %02x\n", port->sel);
+}
+
+static int ps2mult_serio_write(struct serio *serio, unsigned char data)
+{
+        struct serio *mx_port = serio->parent;
+        struct ps2mult *psm = serio_get_drvdata(mx_port);
+        struct ps2mult_port *port = serio->port_data;
+        bool need_escape;
+        unsigned long flags;
+
+        spin_lock_irqsave(&psm->lock, flags);
+
+        if (psm->out_port != port)
+                ps2mult_select_port(psm, port);
+
+        need_escape = memchr(ps2mult_controls, data, sizeof(ps2mult_controls));
+
+        dev_dbg(&serio->dev,
+                "write: %s%02x\n", need_escape ? "ESC " : "", data);
+
+        if (need_escape)
+                serio_write(mx_port, PS2MULT_ESCAPE);
+
+        serio_write(mx_port, data);
+
+        spin_unlock_irqrestore(&psm->lock, flags);
+
+        return 0;
+}
+
+static int ps2mult_serio_start(struct serio *serio)
+{
+        struct ps2mult *psm = serio_get_drvdata(serio->parent);
+        struct ps2mult_port *port = serio->port_data;
+        unsigned long flags;
+
+        spin_lock_irqsave(&psm->lock, flags);
+        port->registered = true;
+        spin_unlock_irqrestore(&psm->lock, flags);
+
+        return 0;
+}
+
+static void ps2mult_serio_stop(struct serio *serio)
+{
+        struct ps2mult *psm = serio_get_drvdata(serio->parent);
+        struct ps2mult_port *port = serio->port_data;
+        unsigned long flags;
+
+        spin_lock_irqsave(&psm->lock, flags);
+        port->registered = false;
+        spin_unlock_irqrestore(&psm->lock, flags);
+}
+
+static int ps2mult_create_port(struct ps2mult *psm, int i)
+{
+        struct serio *mx_serio = psm->mx_serio;
+        struct serio *serio;
+
+        serio = kzalloc(sizeof(struct serio), GFP_KERNEL);
+        if (!serio)
+                return -ENOMEM;
+
+        strlcpy(serio->name, "TQC PS/2 Multiplexer", sizeof(serio->name));
+        snprintf(serio->phys, sizeof(serio->phys),
+                 "%s/port%d", mx_serio->phys, i);
+        serio->id.type = SERIO_8042;
+        serio->write = ps2mult_serio_write;
+        serio->start = ps2mult_serio_start;
+        serio->stop = ps2mult_serio_stop;
+        serio->parent = psm->mx_serio;
+        serio->port_data = &psm->ports[i];
+
+        psm->ports[i].serio = serio;
+
+        return 0;
+}
+
+static void ps2mult_reset(struct ps2mult *psm)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&psm->lock, flags);
+
+        serio_write(psm->mx_serio, PS2MULT_SESSION_END);
+        serio_write(psm->mx_serio, PS2MULT_SESSION_START);
+
+        ps2mult_select_port(psm, &psm->ports[PS2MULT_KBD_PORT]);
+
+        spin_unlock_irqrestore(&psm->lock, flags);
+}
+
+static int ps2mult_connect(struct serio *serio, struct serio_driver *drv)
+{
+        struct ps2mult *psm;
+        int i;
+        int error;
+
+        if (!serio->write)
+                return -EINVAL;
+
+        psm = kzalloc(sizeof(*psm), GFP_KERNEL);
+        if (!psm)
+                return -ENOMEM;
+
+        spin_lock_init(&psm->lock);
+        psm->mx_serio = serio;
+
+        for (i = 0; i < PS2MULT_NUM_PORTS; i++) {
+                psm->ports[i].sel = ps2mult_controls[i];
+                error = ps2mult_create_port(psm, i);
+                if (error)
+                        goto err_out;
+        }
+
+        psm->in_port = psm->out_port = &psm->ports[PS2MULT_KBD_PORT];
+
+        serio_set_drvdata(serio, psm);
+        error = serio_open(serio, drv);
+        if (error)
+                goto err_out;
+
+        ps2mult_reset(psm);
+
+        for (i = 0; i <  PS2MULT_NUM_PORTS; i++) {
+                struct serio *s = psm->ports[i].serio;
+
+                dev_info(&serio->dev, "%s port at %s\n", s->name, serio->phys);
+                serio_register_port(s);
+        }
+
+        return 0;
+
+err_out:
+        while (--i >= 0)
+                kfree(psm->ports[i].serio);
+        kfree(psm);
+        return error;
+}
+
+static void ps2mult_disconnect(struct serio *serio)
+{
+        struct ps2mult *psm = serio_get_drvdata(serio);
+
+        /* Note that serio core already take care of children ports */
+        serio_write(serio, PS2MULT_SESSION_END);
+        serio_close(serio);
+        kfree(psm);
+
+        serio_set_drvdata(serio, NULL);
+}
+
+static int ps2mult_reconnect(struct serio *serio)
+{
+        struct ps2mult *psm = serio_get_drvdata(serio);
+
+        ps2mult_reset(psm);
+
+        return 0;
+}
+
+static irqreturn_t ps2mult_interrupt(struct serio *serio,
+                                     unsigned char data, unsigned int dfl)
+{
+        struct ps2mult *psm = serio_get_drvdata(serio);
+        struct ps2mult_port *in_port;
+        unsigned long flags;
+
+        dev_dbg(&serio->dev, "Received %02x flags %02x\n", data, dfl);
+
+        spin_lock_irqsave(&psm->lock, flags);
+
+        if (psm->escape) {
+                psm->escape = false;
+                in_port = psm->in_port;
+                if (in_port->registered)
+                        serio_interrupt(in_port->serio, data, dfl);
+                goto out;
+        }
+
+        switch (data) {
+        case PS2MULT_ESCAPE:
+                dev_dbg(&serio->dev, "ESCAPE\n");
+                psm->escape = true;
+                break;
+
+        case PS2MULT_BSYNC:
+                dev_dbg(&serio->dev, "BSYNC\n");
+                psm->in_port = psm->out_port;
+                break;
+
+        case PS2MULT_SESSION_START:
+                dev_dbg(&serio->dev, "SS\n");
+                break;
+
+        case PS2MULT_SESSION_END:
+                dev_dbg(&serio->dev, "SE\n");
+                break;
+
+        case PS2MULT_KB_SELECTOR:
+                dev_dbg(&serio->dev, "KB\n");
+                psm->in_port = &psm->ports[PS2MULT_KBD_PORT];
+                break;
+
+        case PS2MULT_MS_SELECTOR:
+                dev_dbg(&serio->dev, "MS\n");
+                psm->in_port = &psm->ports[PS2MULT_MOUSE_PORT];
+                break;
+
+        default:
+                in_port = psm->in_port;
+                if (in_port->registered)
+                        serio_interrupt(in_port->serio, data, dfl);
+                break;
+        }
+
+ out:
+        spin_unlock_irqrestore(&psm->lock, flags);
+        return IRQ_HANDLED;
+}
+
+static struct serio_driver ps2mult_drv = {
+        .driver         = {
+                .name   = "ps2mult",
+        },
+        .description    = "TQC PS/2 Multiplexer driver",
+        .id_table       = ps2mult_serio_ids,
+        .interrupt      = ps2mult_interrupt,
+        .connect        = ps2mult_connect,
+        .disconnect     = ps2mult_disconnect,
+        .reconnect      = ps2mult_reconnect,
+};
+
+static int __init ps2mult_init(void)
+{
+        return serio_register_driver(&ps2mult_drv);
+}
+
+static void __exit ps2mult_exit(void)
+{
+        serio_unregister_driver(&ps2mult_drv);
+}
+
+module_init(ps2mult_init);
+module_exit(ps2mult_exit);
diff --git a/drivers/input/serio/rpckbd.c b/drivers/input/serio/rpckbd.c
index 9da6fbcaaa7e..7ec3c97dc1b9 100644
--- a/drivers/input/serio/rpckbd.c
+++ b/drivers/input/serio/rpckbd.c
@@ -90,7 +90,7 @@ static int rpckbd_open(struct serio *port)
 
         if (request_irq(IRQ_KEYBOARDTX, rpckbd_tx, 0, "rpckbd", port) != 0) {
                 printk(KERN_ERR "rpckbd.c: Could not allocate keyboard transmit IRQ\n");
-                free_irq(IRQ_KEYBOARDRX, NULL);
+                free_irq(IRQ_KEYBOARDRX, port);
                 return -EBUSY;
         }
 
diff --git a/drivers/input/serio/serio.c b/drivers/input/serio/serio.c
index c3b626e9eae7..ba70058e2be3 100644
--- a/drivers/input/serio/serio.c
+++ b/drivers/input/serio/serio.c
@@ -32,12 +32,10 @@
 #include <linux/module.h>
 #include <linux/serio.h>
 #include <linux/errno.h>
-#include <linux/wait.h>
 #include <linux/sched.h>
 #include <linux/slab.h>
-#include <linux/kthread.h>
+#include <linux/workqueue.h>
 #include <linux/mutex.h>
-#include <linux/freezer.h>
 
 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
 MODULE_DESCRIPTION("Serio abstraction core");
@@ -45,7 +43,7 @@ MODULE_LICENSE("GPL");
 
 /*
  * serio_mutex protects entire serio subsystem and is taken every time
- * serio port or driver registrered or unregistered.
+ * serio port or driver registered or unregistered.
  */
 static DEFINE_MUTEX(serio_mutex);
 
@@ -56,7 +54,7 @@ static struct bus_type serio_bus;
 static void serio_add_port(struct serio *serio);
 static int serio_reconnect_port(struct serio *serio);
 static void serio_disconnect_port(struct serio *serio);
-static void serio_reconnect_chain(struct serio *serio);
+static void serio_reconnect_subtree(struct serio *serio);
 static void serio_attach_driver(struct serio_driver *drv);
 
 static int serio_connect_driver(struct serio *serio, struct serio_driver *drv)
@@ -152,7 +150,7 @@ static void serio_find_driver(struct serio *serio)
 enum serio_event_type {
         SERIO_RESCAN_PORT,
         SERIO_RECONNECT_PORT,
-        SERIO_RECONNECT_CHAIN,
+        SERIO_RECONNECT_SUBTREE,
         SERIO_REGISTER_PORT,
         SERIO_ATTACH_DRIVER,
 };
@@ -166,58 +164,22 @@ struct serio_event {
 
 static DEFINE_SPINLOCK(serio_event_lock);       /* protects serio_event_list */
 static LIST_HEAD(serio_event_list);
-static DECLARE_WAIT_QUEUE_HEAD(serio_wait);
-static struct task_struct *serio_task;
 
-static int serio_queue_event(void *object, struct module *owner,
-                             enum serio_event_type event_type)
+static struct serio_event *serio_get_event(void)
 {
+        struct serio_event *event = NULL;
         unsigned long flags;
-        struct serio_event *event;
-        int retval = 0;
 
         spin_lock_irqsave(&serio_event_lock, flags);
 
-        /*
-         * Scan event list for the other events for the same serio port,
-         * starting with the most recent one. If event is the same we
-         * do not need add new one. If event is of different type we
-         * need to add this event and should not look further because
-         * we need to preseve sequence of distinct events.
-         */
-        list_for_each_entry_reverse(event, &serio_event_list, node) {
-                if (event->object == object) {
-                        if (event->type == event_type)
-                                goto out;
-                        break;
-                }
-        }
-
-        event = kmalloc(sizeof(struct serio_event), GFP_ATOMIC);
-        if (!event) {
-                pr_err("Not enough memory to queue event %d\n", event_type);
-                retval = -ENOMEM;
-                goto out;
-        }
-
-        if (!try_module_get(owner)) {
-                pr_warning("Can't get module reference, dropping event %d\n",
-                           event_type);
-                kfree(event);
-                retval = -EINVAL;
-                goto out;
+        if (!list_empty(&serio_event_list)) {
+                event = list_first_entry(&serio_event_list,
+                                         struct serio_event, node);
+                list_del_init(&event->node);
         }
 
-        event->type = event_type;
-        event->object = object;
-        event->owner = owner;
-
-        list_add_tail(&event->node, &serio_event_list);
-        wake_up(&serio_wait);
-
-out:
         spin_unlock_irqrestore(&serio_event_lock, flags);
-        return retval;
+        return event;
 }
 
 static void serio_free_event(struct serio_event *event)
@@ -226,7 +188,8 @@ static void serio_free_event(struct serio_event *event)
         kfree(event);
 }
 
-static void serio_remove_duplicate_events(struct serio_event *event)
+static void serio_remove_duplicate_events(void *object,
+                                          enum serio_event_type type)
 {
         struct serio_event *e, *next;
         unsigned long flags;
@@ -234,13 +197,13 @@ static void serio_remove_duplicate_events(struct serio_event *event)
         spin_lock_irqsave(&serio_event_lock, flags);
 
         list_for_each_entry_safe(e, next, &serio_event_list, node) {
-                if (event->object == e->object) {
+                if (object == e->object) {
                         /*
                          * If this event is of different type we should not
                          * look further - we only suppress duplicate events
                          * that were sent back-to-back.
                          */
-                        if (event->type != e->type)
+                        if (type != e->type)
                                 break;
 
                         list_del_init(&e->node);
@@ -251,25 +214,7 @@ static void serio_remove_duplicate_events(struct serio_event *event)
         spin_unlock_irqrestore(&serio_event_lock, flags);
 }
 
-
-static struct serio_event *serio_get_event(void)
-{
-        struct serio_event *event = NULL;
-        unsigned long flags;
-
-        spin_lock_irqsave(&serio_event_lock, flags);
-
-        if (!list_empty(&serio_event_list)) {
-                event = list_first_entry(&serio_event_list,
-                                         struct serio_event, node);
-                list_del_init(&event->node);
-        }
-
-        spin_unlock_irqrestore(&serio_event_lock, flags);
-        return event;
-}
-
-static void serio_handle_event(void)
+static void serio_handle_event(struct work_struct *work)
 {
         struct serio_event *event;
 
@@ -292,8 +237,8 @@ static void serio_handle_event(void)
                         serio_find_driver(event->object);
                         break;
 
-                case SERIO_RECONNECT_CHAIN:
-                        serio_reconnect_chain(event->object);
+                case SERIO_RECONNECT_SUBTREE:
+                        serio_reconnect_subtree(event->object);
                         break;
 
                 case SERIO_ATTACH_DRIVER:
@@ -301,13 +246,66 @@ static void serio_handle_event(void)
                         break;
                 }
 
-                serio_remove_duplicate_events(event);
+                serio_remove_duplicate_events(event->object, event->type);
                 serio_free_event(event);
         }
 
         mutex_unlock(&serio_mutex);
 }
 
+static DECLARE_WORK(serio_event_work, serio_handle_event);
+
+static int serio_queue_event(void *object, struct module *owner,
+                             enum serio_event_type event_type)
+{
+        unsigned long flags;
+        struct serio_event *event;
+        int retval = 0;
+
+        spin_lock_irqsave(&serio_event_lock, flags);
+
+        /*
+         * Scan event list for the other events for the same serio port,
+         * starting with the most recent one. If event is the same we
+         * do not need add new one. If event is of different type we
+         * need to add this event and should not look further because
+         * we need to preseve sequence of distinct events.
+         */
+        list_for_each_entry_reverse(event, &serio_event_list, node) {
+                if (event->object == object) {
+                        if (event->type == event_type)
+                                goto out;
+                        break;
+                }
+        }
+
+        event = kmalloc(sizeof(struct serio_event), GFP_ATOMIC);
+        if (!event) {
+                pr_err("Not enough memory to queue event %d\n", event_type);
+                retval = -ENOMEM;
+                goto out;
+        }
+
+        if (!try_module_get(owner)) {
+                pr_warning("Can't get module reference, dropping event %d\n",
+                           event_type);
+                kfree(event);
+                retval = -EINVAL;
+                goto out;
+        }
+
+        event->type = event_type;
+        event->object = object;
+        event->owner = owner;
+
+        list_add_tail(&event->node, &serio_event_list);
+        queue_work(system_long_wq, &serio_event_work);
+
+out:
+        spin_unlock_irqrestore(&serio_event_lock, flags);
+        return retval;
+}
+
 /*
  * Remove all events that have been submitted for a given
  * object, be it serio port or driver.
@@ -330,12 +328,10 @@ static void serio_remove_pending_events(void *object)
 }
 
 /*
- * Destroy child serio port (if any) that has not been fully registered yet.
+ * Locate child serio port (if any) that has not been fully registered yet.
  *
- * Note that we rely on the fact that port can have only one child and therefore
- * only one child registration request can be pending. Additionally, children
- * are registered by driver's connect() handler so there can't be a grandchild
- * pending registration together with a child.
+ * Children are registered by driver's connect() handler so there can't be a
+ * grandchild pending registration together with a child.
  */
 static struct serio *serio_get_pending_child(struct serio *parent)
 {
@@ -359,18 +355,6 @@ static struct serio *serio_get_pending_child(struct serio *parent)
         return child;
 }
 
-static int serio_thread(void *nothing)
-{
-        do {
-                serio_handle_event();
-                wait_event_interruptible(serio_wait,
-                        kthread_should_stop() || !list_empty(&serio_event_list));
-        } while (!kthread_should_stop());
-
-        return 0;
-}
-
-
 /*
  * Serio port operations
  */
@@ -449,14 +433,16 @@ static ssize_t serio_rebind_driver(struct device *dev, struct device_attribute *
         if (!strncmp(buf, "none", count)) {
                 serio_disconnect_port(serio);
         } else if (!strncmp(buf, "reconnect", count)) {
-                serio_reconnect_chain(serio);
+                serio_reconnect_subtree(serio);
         } else if (!strncmp(buf, "rescan", count)) {
                 serio_disconnect_port(serio);
                 serio_find_driver(serio);
+                serio_remove_duplicate_events(serio, SERIO_RESCAN_PORT);
         } else if ((drv = driver_find(buf, &serio_bus)) != NULL) {
                 serio_disconnect_port(serio);
                 error = serio_bind_driver(serio, to_serio_driver(drv));
                 put_driver(drv);
+                serio_remove_duplicate_events(serio, SERIO_RESCAN_PORT);
         } else {
                 error = -EINVAL;
         }
@@ -516,6 +502,8 @@ static void serio_init_port(struct serio *serio)
         __module_get(THIS_MODULE);
 
         INIT_LIST_HEAD(&serio->node);
+        INIT_LIST_HEAD(&serio->child_node);
+        INIT_LIST_HEAD(&serio->children);
         spin_lock_init(&serio->lock);
         mutex_init(&serio->drv_mutex);
         device_initialize(&serio->dev);
@@ -538,12 +526,13 @@ static void serio_init_port(struct serio *serio)
  */
 static void serio_add_port(struct serio *serio)
 {
+        struct serio *parent = serio->parent;
         int error;
 
-        if (serio->parent) {
-                serio_pause_rx(serio->parent);
-                serio->parent->child = serio;
-                serio_continue_rx(serio->parent);
+        if (parent) {
+                serio_pause_rx(parent);
+                list_add_tail(&serio->child_node, &parent->children);
+                serio_continue_rx(parent);
         }
 
         list_add_tail(&serio->node, &serio_list);
@@ -559,15 +548,14 @@ static void serio_add_port(struct serio *serio)
 }
 
 /*
- * serio_destroy_port() completes deregistration process and removes
+ * serio_destroy_port() completes unregistration process and removes
  * port from the system
  */
 static void serio_destroy_port(struct serio *serio)
 {
         struct serio *child;
 
-        child = serio_get_pending_child(serio);
-        if (child) {
+        while ((child = serio_get_pending_child(serio)) != NULL) {
                 serio_remove_pending_events(child);
                 put_device(&child->dev);
         }
@@ -577,7 +565,7 @@ static void serio_destroy_port(struct serio *serio)
 
         if (serio->parent) {
                 serio_pause_rx(serio->parent);
-                serio->parent->child = NULL;
+                list_del_init(&serio->child_node);
                 serio_continue_rx(serio->parent);
                 serio->parent = NULL;
         }
@@ -609,46 +597,82 @@ static int serio_reconnect_port(struct serio *serio)
 }
 
 /*
- * Reconnect serio port and all its children (re-initialize attached devices)
+ * Reconnect serio port and all its children (re-initialize attached
+ * devices).
  */
-static void serio_reconnect_chain(struct serio *serio)
+static void serio_reconnect_subtree(struct serio *root)
 {
+        struct serio *s = root;
+        int error;
+
         do {
-                if (serio_reconnect_port(serio)) {
-                        /* Ok, old children are now gone, we are done */
-                        break;
+                error = serio_reconnect_port(s);
+                if (!error) {
+                        /*
+                         * Reconnect was successful, move on to do the
+                         * first child.
+                         */
+                        if (!list_empty(&s->children)) {
+                                s = list_first_entry(&s->children,
+                                                     struct serio, child_node);
+                                continue;
+                        }
+                }
+
+                /*
+                 * Either it was a leaf node or reconnect failed and it
+                 * became a leaf node. Continue reconnecting starting with
+                 * the next sibling of the parent node.
+                 */
+                while (s != root) {
+                        struct serio *parent = s->parent;
+
+                        if (!list_is_last(&s->child_node, &parent->children)) {
+                                s = list_entry(s->child_node.next,
+                                               struct serio, child_node);
+                                break;
+                        }
+
+                        s = parent;
                 }
-                serio = serio->child;
-        } while (serio);
+        } while (s != root);
 }
 
 /*
  * serio_disconnect_port() unbinds a port from its driver. As a side effect
- * all child ports are unbound and destroyed.
+ * all children ports are unbound and destroyed.
  */
 static void serio_disconnect_port(struct serio *serio)
 {
-        struct serio *s, *parent;
+        struct serio *s = serio;
+
+        /*
+         * Children ports should be disconnected and destroyed
+         * first; we travel the tree in depth-first order.
+         */
+        while (!list_empty(&serio->children)) {
+
+                /* Locate a leaf */
+                while (!list_empty(&s->children))
+                        s = list_first_entry(&s->children,
+                                             struct serio, child_node);
 
-        if (serio->child) {
                 /*
-                 * Children ports should be disconnected and destroyed
-                 * first, staring with the leaf one, since we don't want
-                 * to do recursion
+                 * Prune this leaf node unless it is the one we
+                 * started with.
                  */
-                for (s = serio; s->child; s = s->child)
-                        /* empty */;
-
-                do {
-                        parent = s->parent;
+                if (s != serio) {
+                        struct serio *parent = s->parent;
 
                         device_release_driver(&s->dev);
                         serio_destroy_port(s);
-                } while ((s = parent) != serio);
+
+                        s = parent;
+                }
         }
 
         /*
-         * Ok, no children left, now disconnect this port
+         * OK, no children left, now disconnect this port.
          */
         device_release_driver(&serio->dev);
 }
@@ -661,7 +685,7 @@ EXPORT_SYMBOL(serio_rescan);
 
 void serio_reconnect(struct serio *serio)
 {
-        serio_queue_event(serio, NULL, SERIO_RECONNECT_CHAIN);
+        serio_queue_event(serio, NULL, SERIO_RECONNECT_SUBTREE);
 }
 EXPORT_SYMBOL(serio_reconnect);
 
@@ -689,14 +713,16 @@ void serio_unregister_port(struct serio *serio)
 EXPORT_SYMBOL(serio_unregister_port);
 
 /*
- * Safely unregisters child port if one is present.
+ * Safely unregisters children ports if they are present.
  */
 void serio_unregister_child_port(struct serio *serio)
 {
+        struct serio *s, *next;
+
         mutex_lock(&serio_mutex);
-        if (serio->child) {
-                serio_disconnect_port(serio->child);
-                serio_destroy_port(serio->child);
+        list_for_each_entry_safe(s, next, &serio->children, child_node) {
+                serio_disconnect_port(s);
+                serio_destroy_port(s);
         }
         mutex_unlock(&serio_mutex);
 }
@@ -1003,21 +1029,18 @@ static int __init serio_init(void)
                 return error;
         }
 
-        serio_task = kthread_run(serio_thread, NULL, "kseriod");
-        if (IS_ERR(serio_task)) {
-                bus_unregister(&serio_bus);
-                error = PTR_ERR(serio_task);
-                pr_err("Failed to start kseriod, error: %d\n", error);
-                return error;
-        }
-
         return 0;
 }
 
 static void __exit serio_exit(void)
 {
         bus_unregister(&serio_bus);
-        kthread_stop(serio_task);
+
+        /*
+         * There should not be any outstanding events but work may
+         * still be scheduled so simply cancel it.
+         */
+        cancel_work_sync(&serio_event_work);
 }
 
 subsys_initcall(serio_init);
diff --git a/drivers/input/serio/serio_raw.c b/drivers/input/serio/serio_raw.c
index 998664854440..b7ba4597f7f0 100644
--- a/drivers/input/serio/serio_raw.c
+++ b/drivers/input/serio/serio_raw.c
@@ -11,7 +11,6 @@
 
 #include <linux/sched.h>
 #include <linux/slab.h>
-#include <linux/smp_lock.h>
 #include <linux/poll.h>
 #include <linux/module.h>
 #include <linux/serio.h>
@@ -243,6 +242,7 @@ static const struct file_operations serio_raw_fops = {
         .write =        serio_raw_write,
         .poll =         serio_raw_poll,
         .fasync =       serio_raw_fasync,
+        .llseek = noop_llseek,
 };
 
 
diff --git a/drivers/input/serio/serport.c b/drivers/input/serio/serport.c
index 6d345112bcb7..8755f5f3ad37 100644
--- a/drivers/input/serio/serport.c
+++ b/drivers/input/serio/serport.c
@@ -116,14 +116,15 @@ static void serport_ldisc_close(struct tty_struct *tty)
 
 /*
  * serport_ldisc_receive() is called by the low level tty driver when characters
- * are ready for us. We forward the characters, one by one to the 'interrupt'
- * routine.
+ * are ready for us. We forward the characters and flags, one by one to the
+ * 'interrupt' routine.
  */
 
 static void serport_ldisc_receive(struct tty_struct *tty, const unsigned char *cp, char *fp, int count)
 {
         struct serport *serport = (struct serport*) tty->disc_data;
         unsigned long flags;
+        unsigned int ch_flags;
         int i;
 
         spin_lock_irqsave(&serport->lock, flags);
@@ -131,8 +132,23 @@ static void serport_ldisc_receive(struct tty_struct *tty, const unsigned char *c
         if (!test_bit(SERPORT_ACTIVE, &serport->flags))
                 goto out;
 
-        for (i = 0; i < count; i++)
-                serio_interrupt(serport->serio, cp[i], 0);
+        for (i = 0; i < count; i++) {
+                switch (fp[i]) {
+                case TTY_FRAME:
+                        ch_flags = SERIO_FRAME;
+                        break;
+
+                case TTY_PARITY:
+                        ch_flags = SERIO_PARITY;
+                        break;
+
+                default:
+                        ch_flags = 0;
+                        break;
+                }
+
+                serio_interrupt(serport->serio, cp[i], ch_flags);
+        }
 
 out:
         spin_unlock_irqrestore(&serport->lock, flags);
@@ -165,6 +181,7 @@ static ssize_t serport_ldisc_read(struct tty_struct * tty, struct file * file, u
         serio->open = serport_serio_open;
         serio->close = serport_serio_close;
         serio->port_data = serport;
+        serio->dev.parent = tty->dev;
 
         serio_register_port(serport->serio);
         printk(KERN_INFO "serio: Serial port %s\n", tty_name(tty, name));
diff --git a/drivers/input/serio/xilinx_ps2.c b/drivers/input/serio/xilinx_ps2.c
index bb14449fb022..80baa53da5b1 100644
--- a/drivers/input/serio/xilinx_ps2.c
+++ b/drivers/input/serio/xilinx_ps2.c
@@ -225,15 +225,14 @@ static void sxps2_close(struct serio *pserio)
 /**
  * xps2_of_probe - probe method for the PS/2 device.
  * @of_dev:     pointer to OF device structure
- * @match:      pointer to the stucture used for matching a device
+ * @match:      pointer to the structure used for matching a device
  *
  * This function probes the PS/2 device in the device tree.
  * It initializes the driver data structure and the hardware.
  * It returns 0, if the driver is bound to the PS/2 device, or a negative
  * value if there is an error.
  */
-static int __devinit xps2_of_probe(struct platform_device *ofdev,
-                                   const struct of_device_id *match)
+static int __devinit xps2_of_probe(struct platform_device *ofdev)
 {
         struct resource r_irq; /* Interrupt resources */
         struct resource r_mem; /* IO mem resources */
@@ -361,7 +360,7 @@ static const struct of_device_id xps2_of_match[] __devinitconst = {
 };
 MODULE_DEVICE_TABLE(of, xps2_of_match);
 
-static struct of_platform_driver xps2_of_driver = {
+static struct platform_driver xps2_of_driver = {
         .driver = {
                 .name = DRIVER_NAME,
                 .owner = THIS_MODULE,
@@ -373,12 +372,12 @@ static struct of_platform_driver xps2_of_driver = {
 
 static int __init xps2_init(void)
 {
-        return of_register_platform_driver(&xps2_of_driver);
+        return platform_driver_register(&xps2_of_driver);
 }
 
 static void __exit xps2_cleanup(void)
 {
-        of_unregister_platform_driver(&xps2_of_driver);
+        platform_driver_unregister(&xps2_of_driver);
 }
 
 module_init(xps2_init);
diff --git a/drivers/input/sparse-keymap.c b/drivers/input/sparse-keymap.c
index 014248344763..fdb6a3976f94 100644
--- a/drivers/input/sparse-keymap.c
+++ b/drivers/input/sparse-keymap.c
@@ -22,6 +22,37 @@ MODULE_DESCRIPTION("Generic support for sparse keymaps");
 MODULE_LICENSE("GPL v2");
 MODULE_VERSION("0.1");
 
+static unsigned int sparse_keymap_get_key_index(struct input_dev *dev,
+                                                const struct key_entry *k)
+{
+        struct key_entry *key;
+        unsigned int idx = 0;
+
+        for (key = dev->keycode; key->type != KE_END; key++) {
+                if (key->type == KE_KEY) {
+                        if (key == k)
+                                break;
+                        idx++;
+                }
+        }
+
+        return idx;
+}
+
+static struct key_entry *sparse_keymap_entry_by_index(struct input_dev *dev,
+                                                      unsigned int index)
+{
+        struct key_entry *key;
+        unsigned int key_cnt = 0;
+
+        for (key = dev->keycode; key->type != KE_END; key++)
+                if (key->type == KE_KEY)
+                        if (key_cnt++ == index)
+                                return key;
+
+        return NULL;
+}
+
 /**
  * sparse_keymap_entry_from_scancode - perform sparse keymap lookup
  * @dev: Input device using sparse keymap
@@ -64,16 +95,36 @@ struct key_entry *sparse_keymap_entry_from_keycode(struct input_dev *dev,
 }
 EXPORT_SYMBOL(sparse_keymap_entry_from_keycode);
 
+static struct key_entry *sparse_keymap_locate(struct input_dev *dev,
+                                        const struct input_keymap_entry *ke)
+{
+        struct key_entry *key;
+        unsigned int scancode;
+
+        if (ke->flags & INPUT_KEYMAP_BY_INDEX)
+                key = sparse_keymap_entry_by_index(dev, ke->index);
+        else if (input_scancode_to_scalar(ke, &scancode) == 0)
+                key = sparse_keymap_entry_from_scancode(dev, scancode);
+        else
+                key = NULL;
+
+        return key;
+}
+
 static int sparse_keymap_getkeycode(struct input_dev *dev,
-                                    unsigned int scancode,
-                                    unsigned int *keycode)
+                                    struct input_keymap_entry *ke)
 {
         const struct key_entry *key;
 
         if (dev->keycode) {
-                key = sparse_keymap_entry_from_scancode(dev, scancode);
+                key = sparse_keymap_locate(dev, ke);
                 if (key && key->type == KE_KEY) {
-                        *keycode = key->keycode;
+                        ke->keycode = key->keycode;
+                        if (!(ke->flags & INPUT_KEYMAP_BY_INDEX))
+                                ke->index =
+                                        sparse_keymap_get_key_index(dev, key);
+                        ke->len = sizeof(key->code);
+                        memcpy(ke->scancode, &key->code, sizeof(key->code));
                         return 0;
                 }
         }
@@ -82,20 +133,19 @@ static int sparse_keymap_getkeycode(struct input_dev *dev,
 }
 
 static int sparse_keymap_setkeycode(struct input_dev *dev,
-                                    unsigned int scancode,
-                                    unsigned int keycode)
+                                    const struct input_keymap_entry *ke,
+                                    unsigned int *old_keycode)
 {
         struct key_entry *key;
-        int old_keycode;
 
         if (dev->keycode) {
-                key = sparse_keymap_entry_from_scancode(dev, scancode);
+                key = sparse_keymap_locate(dev, ke);
                 if (key && key->type == KE_KEY) {
-                        old_keycode = key->keycode;
-                        key->keycode = keycode;
-                        set_bit(keycode, dev->keybit);
-                        if (!sparse_keymap_entry_from_keycode(dev, old_keycode))
-                                clear_bit(old_keycode, dev->keybit);
+                        *old_keycode = key->keycode;
+                        key->keycode = ke->keycode;
+                        set_bit(ke->keycode, dev->keybit);
+                        if (!sparse_keymap_entry_from_keycode(dev, *old_keycode))
+                                clear_bit(*old_keycode, dev->keybit);
                         return 0;
                 }
         }
@@ -151,12 +201,19 @@ int sparse_keymap_setup(struct input_dev *dev,
                         break;
 
                 case KE_SW:
+                case KE_VSW:
                         __set_bit(EV_SW, dev->evbit);
                         __set_bit(entry->sw.code, dev->swbit);
                         break;
                 }
         }
 
+        if (test_bit(EV_KEY, dev->evbit)) {
+                __set_bit(KEY_UNKNOWN, dev->keybit);
+                __set_bit(EV_MSC, dev->evbit);
+                __set_bit(MSC_SCAN, dev->mscbit);
+        }
+
         dev->keycode = map;
         dev->keycodemax = map_size;
         dev->getkeycode = sparse_keymap_getkeycode;
@@ -167,7 +224,6 @@ int sparse_keymap_setup(struct input_dev *dev,
  err_out:
         kfree(map);
         return error;
-
 }
 EXPORT_SYMBOL(sparse_keymap_setup);
 
@@ -218,6 +274,7 @@ void sparse_keymap_report_entry(struct input_dev *dev, const struct key_entry *k
 {
         switch (ke->type) {
         case KE_KEY:
+                input_event(dev, EV_MSC, MSC_SCAN, ke->code);
                 input_report_key(dev, ke->keycode, value);
                 input_sync(dev);
                 if (value && autorelease) {
@@ -255,12 +312,19 @@ bool sparse_keymap_report_event(struct input_dev *dev, unsigned int code,
 {
         const struct key_entry *ke =
                 sparse_keymap_entry_from_scancode(dev, code);
+        struct key_entry unknown_ke;
 
         if (ke) {
                 sparse_keymap_report_entry(dev, ke, value, autorelease);
                 return true;
         }
 
+        /* Report an unknown key event as a debugging aid */
+        unknown_ke.type = KE_KEY;
+        unknown_ke.code = code;
+        unknown_ke.keycode = KEY_UNKNOWN;
+        sparse_keymap_report_entry(dev, &unknown_ke, value, true);
+
         return false;
 }
 EXPORT_SYMBOL(sparse_keymap_report_event);
diff --git a/drivers/input/tablet/Kconfig b/drivers/input/tablet/Kconfig
index effb49ea24aa..58a87755b936 100644
--- a/drivers/input/tablet/Kconfig
+++ b/drivers/input/tablet/Kconfig
@@ -49,6 +49,17 @@ config TABLET_USB_GTCO
           To compile this driver as a module, choose M here: the
           module will be called gtco.
 
+config TABLET_USB_HANWANG
+        tristate "Hanwang Art Master III tablet support (USB)"
+        depends on USB_ARCH_HAS_HCD
+        select USB
+        help
+          Say Y here if you want to use the USB version of the Hanwang Art
+          Master III tablet.
+
+          To compile this driver as a module, choose M here: the
+          module will be called hanwang.
+
 config TABLET_USB_KBTAB
         tristate "KB Gear JamStudio tablet support (USB)"
         depends on USB_ARCH_HAS_HCD
diff --git a/drivers/input/tablet/Makefile b/drivers/input/tablet/Makefile
index ce8b9a9cfa40..3f6c25220638 100644
--- a/drivers/input/tablet/Makefile
+++ b/drivers/input/tablet/Makefile
@@ -8,5 +8,6 @@ wacom-objs	:= wacom_wac.o wacom_sys.o
 obj-$(CONFIG_TABLET_USB_ACECAD) += acecad.o
 obj-$(CONFIG_TABLET_USB_AIPTEK) += aiptek.o
 obj-$(CONFIG_TABLET_USB_GTCO)   += gtco.o
+obj-$(CONFIG_TABLET_USB_HANWANG) += hanwang.o
 obj-$(CONFIG_TABLET_USB_KBTAB)  += kbtab.o
 obj-$(CONFIG_TABLET_USB_WACOM)  += wacom.o
diff --git a/drivers/input/tablet/acecad.c b/drivers/input/tablet/acecad.c
index aea9a9399a36..d94f7e9aa997 100644
--- a/drivers/input/tablet/acecad.c
+++ b/drivers/input/tablet/acecad.c
@@ -229,12 +229,13 @@ static int usb_acecad_probe(struct usb_interface *intf, const struct usb_device_
 
         err = input_register_device(acecad->input);
         if (err)
-                goto fail2;
+                goto fail3;
 
         usb_set_intfdata(intf, acecad);
 
         return 0;
 
+ fail3: usb_free_urb(acecad->irq);
  fail2: usb_free_coherent(dev, 8, acecad->data, acecad->data_dma);
  fail1: input_free_device(input_dev);
         kfree(acecad);
diff --git a/drivers/input/tablet/aiptek.c b/drivers/input/tablet/aiptek.c
index 57b25b84d1fc..0a619c558bfb 100644
--- a/drivers/input/tablet/aiptek.c
+++ b/drivers/input/tablet/aiptek.c
@@ -1097,7 +1097,7 @@ store_tabletPointerMode(struct device *dev, struct device_attribute *attr, const
 }
 
 static DEVICE_ATTR(pointer_mode,
-                   S_IRUGO | S_IWUGO,
+                   S_IRUGO | S_IWUSR,
                    show_tabletPointerMode, store_tabletPointerMode);
 
 /***********************************************************************
@@ -1134,7 +1134,7 @@ store_tabletCoordinateMode(struct device *dev, struct device_attribute *attr, co
 }
 
 static DEVICE_ATTR(coordinate_mode,
-                   S_IRUGO | S_IWUGO,
+                   S_IRUGO | S_IWUSR,
                    show_tabletCoordinateMode, store_tabletCoordinateMode);
 
 /***********************************************************************
@@ -1176,7 +1176,7 @@ store_tabletToolMode(struct device *dev, struct device_attribute *attr, const ch
 }
 
 static DEVICE_ATTR(tool_mode,
-                   S_IRUGO | S_IWUGO,
+                   S_IRUGO | S_IWUSR,
                    show_tabletToolMode, store_tabletToolMode);
 
 /***********************************************************************
@@ -1219,7 +1219,7 @@ store_tabletXtilt(struct device *dev, struct device_attribute *attr, const char
 }
 
 static DEVICE_ATTR(xtilt,
-                   S_IRUGO | S_IWUGO, show_tabletXtilt, store_tabletXtilt);
+                   S_IRUGO | S_IWUSR, show_tabletXtilt, store_tabletXtilt);
 
 /***********************************************************************
  * support routines for the 'ytilt' file. Note that this file
@@ -1261,7 +1261,7 @@ store_tabletYtilt(struct device *dev, struct device_attribute *attr, const char
 }
 
 static DEVICE_ATTR(ytilt,
-                   S_IRUGO | S_IWUGO, show_tabletYtilt, store_tabletYtilt);
+                   S_IRUGO | S_IWUSR, show_tabletYtilt, store_tabletYtilt);
 
 /***********************************************************************
  * support routines for the 'jitter' file. Note that this file
@@ -1288,7 +1288,7 @@ store_tabletJitterDelay(struct device *dev, struct device_attribute *attr, const
 }
 
 static DEVICE_ATTR(jitter,
-                   S_IRUGO | S_IWUGO,
+                   S_IRUGO | S_IWUSR,
                    show_tabletJitterDelay, store_tabletJitterDelay);
 
 /***********************************************************************
@@ -1317,7 +1317,7 @@ store_tabletProgrammableDelay(struct device *dev, struct device_attribute *attr,
 }
 
 static DEVICE_ATTR(delay,
-                   S_IRUGO | S_IWUGO,
+                   S_IRUGO | S_IWUSR,
                    show_tabletProgrammableDelay, store_tabletProgrammableDelay);
 
 /***********************************************************************
@@ -1406,7 +1406,7 @@ store_tabletStylusUpper(struct device *dev, struct device_attribute *attr, const
 }
 
 static DEVICE_ATTR(stylus_upper,
-                   S_IRUGO | S_IWUGO,
+                   S_IRUGO | S_IWUSR,
                    show_tabletStylusUpper, store_tabletStylusUpper);
 
 /***********************************************************************
@@ -1437,7 +1437,7 @@ store_tabletStylusLower(struct device *dev, struct device_attribute *attr, const
 }
 
 static DEVICE_ATTR(stylus_lower,
-                   S_IRUGO | S_IWUGO,
+                   S_IRUGO | S_IWUSR,
                    show_tabletStylusLower, store_tabletStylusLower);
 
 /***********************************************************************
@@ -1475,7 +1475,7 @@ store_tabletMouseLeft(struct device *dev, struct device_attribute *attr, const c
 }
 
 static DEVICE_ATTR(mouse_left,
-                   S_IRUGO | S_IWUGO,
+                   S_IRUGO | S_IWUSR,
                    show_tabletMouseLeft, store_tabletMouseLeft);
 
 /***********************************************************************
@@ -1505,7 +1505,7 @@ store_tabletMouseMiddle(struct device *dev, struct device_attribute *attr, const
 }
 
 static DEVICE_ATTR(mouse_middle,
-                   S_IRUGO | S_IWUGO,
+                   S_IRUGO | S_IWUSR,
                    show_tabletMouseMiddle, store_tabletMouseMiddle);
 
 /***********************************************************************
@@ -1535,7 +1535,7 @@ store_tabletMouseRight(struct device *dev, struct device_attribute *attr, const
 }
 
 static DEVICE_ATTR(mouse_right,
-                   S_IRUGO | S_IWUGO,
+                   S_IRUGO | S_IWUSR,
                    show_tabletMouseRight, store_tabletMouseRight);
 
 /***********************************************************************
@@ -1567,7 +1567,7 @@ store_tabletWheel(struct device *dev, struct device_attribute *attr, const char
 }
 
 static DEVICE_ATTR(wheel,
-                   S_IRUGO | S_IWUGO, show_tabletWheel, store_tabletWheel);
+                   S_IRUGO | S_IWUSR, show_tabletWheel, store_tabletWheel);
 
 /***********************************************************************
  * support routines for the 'execute' file. Note that this file
@@ -1600,7 +1600,7 @@ store_tabletExecute(struct device *dev, struct device_attribute *attr, const cha
 }
 
 static DEVICE_ATTR(execute,
-                   S_IRUGO | S_IWUGO, show_tabletExecute, store_tabletExecute);
+                   S_IRUGO | S_IWUSR, show_tabletExecute, store_tabletExecute);
 
 /***********************************************************************
  * support routines for the 'odm_code' file. Note that this file
diff --git a/drivers/input/tablet/hanwang.c b/drivers/input/tablet/hanwang.c
new file mode 100644
index 000000000000..6504b627b234
--- /dev/null
+++ b/drivers/input/tablet/hanwang.c
@@ -0,0 +1,446 @@
+/*
+ *  USB Hanwang tablet support
+ *
+ *  Copyright (c) 2010 Xing Wei <weixing@hanwang.com.cn>
+ *
+ */
+
+/*
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/usb/input.h>
+
+#define DRIVER_AUTHOR   "Xing Wei <weixing@hanwang.com.cn>"
+#define DRIVER_DESC     "USB Hanwang tablet driver"
+#define DRIVER_LICENSE  "GPL"
+
+MODULE_AUTHOR(DRIVER_AUTHOR);
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_LICENSE(DRIVER_LICENSE);
+
+#define USB_VENDOR_ID_HANWANG           0x0b57
+#define HANWANG_TABLET_INT_CLASS        0x0003
+#define HANWANG_TABLET_INT_SUB_CLASS    0x0001
+#define HANWANG_TABLET_INT_PROTOCOL     0x0002
+
+#define ART_MASTER_PKGLEN_MAX   10
+
+/* device IDs */
+#define STYLUS_DEVICE_ID        0x02
+#define TOUCH_DEVICE_ID         0x03
+#define CURSOR_DEVICE_ID        0x06
+#define ERASER_DEVICE_ID        0x0A
+#define PAD_DEVICE_ID           0x0F
+
+/* match vendor and interface info  */
+#define HANWANG_TABLET_DEVICE(vend, cl, sc, pr) \
+        .match_flags = USB_DEVICE_ID_MATCH_VENDOR \
+                | USB_DEVICE_ID_MATCH_INT_INFO, \
+        .idVendor = (vend), \
+        .bInterfaceClass = (cl), \
+        .bInterfaceSubClass = (sc), \
+        .bInterfaceProtocol = (pr)
+
+enum hanwang_tablet_type {
+        HANWANG_ART_MASTER_III,
+        HANWANG_ART_MASTER_HD,
+};
+
+struct hanwang {
+        unsigned char *data;
+        dma_addr_t data_dma;
+        struct input_dev *dev;
+        struct usb_device *usbdev;
+        struct urb *irq;
+        const struct hanwang_features *features;
+        unsigned int current_tool;
+        unsigned int current_id;
+        char name[64];
+        char phys[32];
+};
+
+struct hanwang_features {
+        unsigned short pid;
+        char *name;
+        enum hanwang_tablet_type type;
+        int pkg_len;
+        int max_x;
+        int max_y;
+        int max_tilt_x;
+        int max_tilt_y;
+        int max_pressure;
+};
+
+static const struct hanwang_features features_array[] = {
+        { 0x8528, "Hanwang Art Master III 0906", HANWANG_ART_MASTER_III,
+          ART_MASTER_PKGLEN_MAX, 0x5757, 0x3692, 0x3f, 0x7f, 2048 },
+        { 0x8529, "Hanwang Art Master III 0604", HANWANG_ART_MASTER_III,
+          ART_MASTER_PKGLEN_MAX, 0x3d84, 0x2672, 0x3f, 0x7f, 2048 },
+        { 0x852a, "Hanwang Art Master III 1308", HANWANG_ART_MASTER_III,
+          ART_MASTER_PKGLEN_MAX, 0x7f00, 0x4f60, 0x3f, 0x7f, 2048 },
+        { 0x8401, "Hanwang Art Master HD 5012", HANWANG_ART_MASTER_HD,
+          ART_MASTER_PKGLEN_MAX, 0x678e, 0x4150, 0x3f, 0x7f, 1024 },
+};
+
+static const int hw_eventtypes[] = {
+        EV_KEY, EV_ABS, EV_MSC,
+};
+
+static const int hw_absevents[] = {
+        ABS_X, ABS_Y, ABS_TILT_X, ABS_TILT_Y, ABS_WHEEL,
+        ABS_RX, ABS_RY, ABS_PRESSURE, ABS_MISC,
+};
+
+static const int hw_btnevents[] = {
+        BTN_STYLUS, BTN_STYLUS2, BTN_TOOL_PEN, BTN_TOOL_RUBBER,
+        BTN_TOOL_MOUSE, BTN_TOOL_FINGER,
+        BTN_0, BTN_1, BTN_2, BTN_3, BTN_4, BTN_5, BTN_6, BTN_7, BTN_8,
+};
+
+static const int hw_mscevents[] = {
+        MSC_SERIAL,
+};
+
+static void hanwang_parse_packet(struct hanwang *hanwang)
+{
+        unsigned char *data = hanwang->data;
+        struct input_dev *input_dev = hanwang->dev;
+        struct usb_device *dev = hanwang->usbdev;
+        enum hanwang_tablet_type type = hanwang->features->type;
+        int i;
+        u16 x, y, p;
+
+        switch (data[0]) {
+        case 0x02:      /* data packet */
+                switch (data[1]) {
+                case 0x80:      /* tool prox out */
+                        hanwang->current_id = 0;
+                        input_report_key(input_dev, hanwang->current_tool, 0);
+                        break;
+
+                case 0xc2:      /* first time tool prox in */
+                        switch (data[3] & 0xf0) {
+                        case 0x20:      /* art_master III */
+                        case 0x30:      /* art_master_HD */
+                                hanwang->current_id = STYLUS_DEVICE_ID;
+                                hanwang->current_tool = BTN_TOOL_PEN;
+                                input_report_key(input_dev, BTN_TOOL_PEN, 1);
+                                break;
+                        case 0xa0:      /* art_master III */
+                        case 0xb0:      /* art_master_HD */
+                                hanwang->current_id = ERASER_DEVICE_ID;
+                                hanwang->current_tool = BTN_TOOL_RUBBER;
+                                input_report_key(input_dev, BTN_TOOL_RUBBER, 1);
+                                break;
+                        default:
+                                hanwang->current_id = 0;
+                                dev_dbg(&dev->dev,
+                                        "unknown tablet tool %02x ", data[0]);
+                                break;
+                        }
+                        break;
+
+                default:        /* tool data packet */
+                        x = (data[2] << 8) | data[3];
+                        y = (data[4] << 8) | data[5];
+
+                        switch (type) {
+                        case HANWANG_ART_MASTER_III:
+                                p = (data[6] << 3) |
+                                    ((data[7] & 0xc0) >> 5) |
+                                    (data[1] & 0x01);
+                                break;
+
+                        case HANWANG_ART_MASTER_HD:
+                                p = (data[7] >> 6) | (data[6] << 2);
+                                break;
+
+                        default:
+                                p = 0;
+                                break;
+                        }
+
+                        input_report_abs(input_dev, ABS_X,
+                                                le16_to_cpup((__le16 *)&x));
+                        input_report_abs(input_dev, ABS_Y,
+                                                le16_to_cpup((__le16 *)&y));
+                        input_report_abs(input_dev, ABS_PRESSURE,
+                                                le16_to_cpup((__le16 *)&p));
+                        input_report_abs(input_dev, ABS_TILT_X, data[7] & 0x3f);
+                        input_report_abs(input_dev, ABS_TILT_Y, data[8] & 0x7f);
+                        input_report_key(input_dev, BTN_STYLUS, data[1] & 0x02);
+                        input_report_key(input_dev, BTN_STYLUS2, data[1] & 0x04);
+                        break;
+                }
+                input_report_abs(input_dev, ABS_MISC, hanwang->current_id);
+                input_event(input_dev, EV_MSC, MSC_SERIAL,
+                                hanwang->features->pid);
+                break;
+
+        case 0x0c:
+                /* roll wheel */
+                hanwang->current_id = PAD_DEVICE_ID;
+
+                switch (type) {
+                case HANWANG_ART_MASTER_III:
+                        input_report_key(input_dev, BTN_TOOL_FINGER, data[1] ||
+                                                        data[2] || data[3]);
+                        input_report_abs(input_dev, ABS_WHEEL, data[1]);
+                        input_report_key(input_dev, BTN_0, data[2]);
+                        for (i = 0; i < 8; i++)
+                                input_report_key(input_dev,
+                                         BTN_1 + i, data[3] & (1 << i));
+                        break;
+
+                case HANWANG_ART_MASTER_HD:
+                        input_report_key(input_dev, BTN_TOOL_FINGER, data[1] ||
+                                        data[2] || data[3] || data[4] ||
+                                        data[5] || data[6]);
+                        input_report_abs(input_dev, ABS_RX,
+                                        ((data[1] & 0x1f) << 8) | data[2]);
+                        input_report_abs(input_dev, ABS_RY,
+                                        ((data[3] & 0x1f) << 8) | data[4]);
+                        input_report_key(input_dev, BTN_0, data[5] & 0x01);
+                        for (i = 0; i < 4; i++) {
+                                input_report_key(input_dev,
+                                         BTN_1 + i, data[5] & (1 << i));
+                                input_report_key(input_dev,
+                                         BTN_5 + i, data[6] & (1 << i));
+                        }
+                        break;
+                }
+
+                input_report_abs(input_dev, ABS_MISC, hanwang->current_id);
+                input_event(input_dev, EV_MSC, MSC_SERIAL, 0xffffffff);
+                break;
+
+        default:
+                dev_dbg(&dev->dev, "error packet  %02x ", data[0]);
+                break;
+        }
+
+        input_sync(input_dev);
+}
+
+static void hanwang_irq(struct urb *urb)
+{
+        struct hanwang *hanwang = urb->context;
+        struct usb_device *dev = hanwang->usbdev;
+        int retval;
+
+        switch (urb->status) {
+        case 0:
+                /* success */;
+                hanwang_parse_packet(hanwang);
+                break;
+        case -ECONNRESET:
+        case -ENOENT:
+        case -ESHUTDOWN:
+                /* this urb is terminated, clean up */
+                dev_err(&dev->dev, "%s - urb shutting down with status: %d",
+                        __func__, urb->status);
+                return;
+        default:
+                dev_err(&dev->dev, "%s - nonzero urb status received: %d",
+                        __func__, urb->status);
+                break;
+        }
+
+        retval = usb_submit_urb(urb, GFP_ATOMIC);
+        if (retval)
+                dev_err(&dev->dev, "%s - usb_submit_urb failed with result %d",
+                        __func__, retval);
+}
+
+static int hanwang_open(struct input_dev *dev)
+{
+        struct hanwang *hanwang = input_get_drvdata(dev);
+
+        hanwang->irq->dev = hanwang->usbdev;
+        if (usb_submit_urb(hanwang->irq, GFP_KERNEL))
+                return -EIO;
+
+        return 0;
+}
+
+static void hanwang_close(struct input_dev *dev)
+{
+        struct hanwang *hanwang = input_get_drvdata(dev);
+
+        usb_kill_urb(hanwang->irq);
+}
+
+static bool get_features(struct usb_device *dev, struct hanwang *hanwang)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(features_array); i++) {
+                if (le16_to_cpu(dev->descriptor.idProduct) ==
+                                features_array[i].pid) {
+                        hanwang->features = &features_array[i];
+                        return true;
+                }
+        }
+
+        return false;
+}
+
+
+static int hanwang_probe(struct usb_interface *intf, const struct usb_device_id *id)
+{
+        struct usb_device *dev = interface_to_usbdev(intf);
+        struct usb_endpoint_descriptor *endpoint;
+        struct hanwang *hanwang;
+        struct input_dev *input_dev;
+        int error;
+        int i;
+
+        hanwang = kzalloc(sizeof(struct hanwang), GFP_KERNEL);
+        input_dev = input_allocate_device();
+        if (!hanwang || !input_dev) {
+                error = -ENOMEM;
+                goto fail1;
+        }
+
+        if (!get_features(dev, hanwang)) {
+                error = -ENXIO;
+                goto fail1;
+        }
+
+        hanwang->data = usb_alloc_coherent(dev, hanwang->features->pkg_len,
+                                        GFP_KERNEL, &hanwang->data_dma);
+        if (!hanwang->data) {
+                error = -ENOMEM;
+                goto fail1;
+        }
+
+        hanwang->irq = usb_alloc_urb(0, GFP_KERNEL);
+        if (!hanwang->irq) {
+                error = -ENOMEM;
+                goto fail2;
+        }
+
+        hanwang->usbdev = dev;
+        hanwang->dev = input_dev;
+
+        usb_make_path(dev, hanwang->phys, sizeof(hanwang->phys));
+        strlcat(hanwang->phys, "/input0", sizeof(hanwang->phys));
+
+        strlcpy(hanwang->name, hanwang->features->name, sizeof(hanwang->name));
+        input_dev->name = hanwang->name;
+        input_dev->phys = hanwang->phys;
+        usb_to_input_id(dev, &input_dev->id);
+        input_dev->dev.parent = &intf->dev;
+
+        input_set_drvdata(input_dev, hanwang);
+
+        input_dev->open = hanwang_open;
+        input_dev->close = hanwang_close;
+
+        for (i = 0; i < ARRAY_SIZE(hw_eventtypes); ++i)
+                __set_bit(hw_eventtypes[i], input_dev->evbit);
+
+        for (i = 0; i < ARRAY_SIZE(hw_absevents); ++i)
+                __set_bit(hw_absevents[i], input_dev->absbit);
+
+        for (i = 0; i < ARRAY_SIZE(hw_btnevents); ++i)
+                __set_bit(hw_btnevents[i], input_dev->keybit);
+
+        for (i = 0; i < ARRAY_SIZE(hw_mscevents); ++i)
+                __set_bit(hw_mscevents[i], input_dev->mscbit);
+
+        input_set_abs_params(input_dev, ABS_X,
+                             0, hanwang->features->max_x, 4, 0);
+        input_set_abs_params(input_dev, ABS_Y,
+                             0, hanwang->features->max_y, 4, 0);
+        input_set_abs_params(input_dev, ABS_TILT_X,
+                             0, hanwang->features->max_tilt_x, 0, 0);
+        input_set_abs_params(input_dev, ABS_TILT_Y,
+                             0, hanwang->features->max_tilt_y, 0, 0);
+        input_set_abs_params(input_dev, ABS_PRESSURE,
+                             0, hanwang->features->max_pressure, 0, 0);
+
+        endpoint = &intf->cur_altsetting->endpoint[0].desc;
+        usb_fill_int_urb(hanwang->irq, dev,
+                        usb_rcvintpipe(dev, endpoint->bEndpointAddress),
+                        hanwang->data, hanwang->features->pkg_len,
+                        hanwang_irq, hanwang, endpoint->bInterval);
+        hanwang->irq->transfer_dma = hanwang->data_dma;
+        hanwang->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
+
+        error = input_register_device(hanwang->dev);
+        if (error)
+                goto fail3;
+
+        usb_set_intfdata(intf, hanwang);
+
+        return 0;
+
+ fail3: usb_free_urb(hanwang->irq);
+ fail2: usb_free_coherent(dev, hanwang->features->pkg_len,
+                        hanwang->data, hanwang->data_dma);
+ fail1: input_free_device(input_dev);
+        kfree(hanwang);
+        return error;
+
+}
+
+static void hanwang_disconnect(struct usb_interface *intf)
+{
+        struct hanwang *hanwang = usb_get_intfdata(intf);
+
+        input_unregister_device(hanwang->dev);
+        usb_free_urb(hanwang->irq);
+        usb_free_coherent(interface_to_usbdev(intf),
+                        hanwang->features->pkg_len, hanwang->data,
+                        hanwang->data_dma);
+        kfree(hanwang);
+        usb_set_intfdata(intf, NULL);
+}
+
+static const struct usb_device_id hanwang_ids[] = {
+        { HANWANG_TABLET_DEVICE(USB_VENDOR_ID_HANWANG, HANWANG_TABLET_INT_CLASS,
+                HANWANG_TABLET_INT_SUB_CLASS, HANWANG_TABLET_INT_PROTOCOL) },
+        {}
+};
+
+MODULE_DEVICE_TABLE(usb, hanwang_ids);
+
+static struct usb_driver hanwang_driver = {
+        .name           = "hanwang",
+        .probe          = hanwang_probe,
+        .disconnect     = hanwang_disconnect,
+        .id_table       = hanwang_ids,
+};
+
+static int __init hanwang_init(void)
+{
+        return usb_register(&hanwang_driver);
+}
+
+static void __exit hanwang_exit(void)
+{
+        usb_deregister(&hanwang_driver);
+}
+
+module_init(hanwang_init);
+module_exit(hanwang_exit);
diff --git a/drivers/input/tablet/wacom.h b/drivers/input/tablet/wacom.h
index 284dfaab6b8c..23317bd09c82 100644
--- a/drivers/input/tablet/wacom.h
+++ b/drivers/input/tablet/wacom.h
@@ -103,6 +103,7 @@ MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE(DRIVER_LICENSE);
 
 #define USB_VENDOR_ID_WACOM     0x056a
+#define USB_VENDOR_ID_LENOVO    0x17ef
 
 struct wacom {
         dma_addr_t data_dma;
@@ -118,6 +119,7 @@ struct wacom {
 extern const struct usb_device_id wacom_ids[];
 
 void wacom_wac_irq(struct wacom_wac *wacom_wac, size_t len);
+void wacom_setup_device_quirks(struct wacom_features *features);
 void wacom_setup_input_capabilities(struct input_dev *input_dev,
                                     struct wacom_wac *wacom_wac);
 #endif
diff --git a/drivers/input/tablet/wacom_sys.c b/drivers/input/tablet/wacom_sys.c
index b35876ee6908..449c0a46dbac 100644
--- a/drivers/input/tablet/wacom_sys.c
+++ b/drivers/input/tablet/wacom_sys.c
@@ -120,14 +120,16 @@ static int wacom_open(struct input_dev *dev)
 
 out:
         mutex_unlock(&wacom->lock);
-        if (retval)
-                usb_autopm_put_interface(wacom->intf);
+        usb_autopm_put_interface(wacom->intf);
         return retval;
 }
 
 static void wacom_close(struct input_dev *dev)
 {
         struct wacom *wacom = input_get_drvdata(dev);
+        int autopm_error;
+
+        autopm_error = usb_autopm_get_interface(wacom->intf);
 
         mutex_lock(&wacom->lock);
         usb_kill_urb(wacom->irq);
@@ -135,7 +137,8 @@ static void wacom_close(struct input_dev *dev)
         wacom->intf->needs_remote_wakeup = 0;
         mutex_unlock(&wacom->lock);
 
-        usb_autopm_put_interface(wacom->intf);
+        if (!autopm_error)
+                usb_autopm_put_interface(wacom->intf);
 }
 
 static int wacom_parse_hid(struct usb_interface *intf, struct hid_descriptor *hid_desc,
@@ -190,23 +193,36 @@ static int wacom_parse_hid(struct usb_interface *intf, struct hid_descriptor *hi
                         case HID_USAGE_X:
                                 if (usage == WCM_DESKTOP) {
                                         if (finger) {
-                                                features->device_type = BTN_TOOL_DOUBLETAP;
+                                                features->device_type = BTN_TOOL_FINGER;
                                                 if (features->type == TABLETPC2FG) {
                                                         /* need to reset back */
                                                         features->pktlen = WACOM_PKGLEN_TPC2FG;
-                                                        features->device_type = BTN_TOOL_TRIPLETAP;
+                                                        features->device_type = BTN_TOOL_DOUBLETAP;
+                                                }
+                                                if (features->type == BAMBOO_PT) {
+                                                        /* need to reset back */
+                                                        features->pktlen = WACOM_PKGLEN_BBTOUCH;
+                                                        features->device_type = BTN_TOOL_DOUBLETAP;
+                                                        features->x_phy =
+                                                                get_unaligned_le16(&report[i + 5]);
+                                                        features->x_max =
+                                                                get_unaligned_le16(&report[i + 8]);
+                                                        i += 15;
+                                                } else {
+                                                        features->x_max =
+                                                                get_unaligned_le16(&report[i + 3]);
+                                                        features->x_phy =
+                                                                get_unaligned_le16(&report[i + 6]);
+                                                        features->unit = report[i + 9];
+                                                        features->unitExpo = report[i + 11];
+                                                        i += 12;
                                                 }
-                                                features->x_max =
-                                                        get_unaligned_le16(&report[i + 3]);
-                                                features->x_phy =
-                                                        get_unaligned_le16(&report[i + 6]);
-                                                features->unit = report[i + 9];
-                                                features->unitExpo = report[i + 11];
-                                                i += 12;
                                         } else if (pen) {
                                                 /* penabled only accepts exact bytes of data */
                                                 if (features->type == TABLETPC2FG)
                                                         features->pktlen = WACOM_PKGLEN_GRAPHIRE;
+                                                if (features->type == BAMBOO_PT)
+                                                        features->pktlen = WACOM_PKGLEN_BBFUN;
                                                 features->device_type = BTN_TOOL_PEN;
                                                 features->x_max =
                                                         get_unaligned_le16(&report[i + 3]);
@@ -225,16 +241,25 @@ static int wacom_parse_hid(struct usb_interface *intf, struct hid_descriptor *hi
                         case HID_USAGE_Y:
                                 if (usage == WCM_DESKTOP) {
                                         if (finger) {
-                                                features->device_type = BTN_TOOL_DOUBLETAP;
+                                                features->device_type = BTN_TOOL_FINGER;
                                                 if (features->type == TABLETPC2FG) {
                                                         /* need to reset back */
                                                         features->pktlen = WACOM_PKGLEN_TPC2FG;
-                                                        features->device_type = BTN_TOOL_TRIPLETAP;
+                                                        features->device_type = BTN_TOOL_DOUBLETAP;
                                                         features->y_max =
                                                                 get_unaligned_le16(&report[i + 3]);
                                                         features->y_phy =
                                                                 get_unaligned_le16(&report[i + 6]);
                                                         i += 7;
+                                                } else if (features->type == BAMBOO_PT) {
+                                                        /* need to reset back */
+                                                        features->pktlen = WACOM_PKGLEN_BBTOUCH;
+                                                        features->device_type = BTN_TOOL_DOUBLETAP;
+                                                        features->y_phy =
+                                                                get_unaligned_le16(&report[i + 3]);
+                                                        features->y_max =
+                                                                get_unaligned_le16(&report[i + 6]);
+                                                        i += 12;
                                                 } else {
                                                         features->y_max =
                                                                 features->x_max;
@@ -246,6 +271,8 @@ static int wacom_parse_hid(struct usb_interface *intf, struct hid_descriptor *hi
                                                 /* penabled only accepts exact bytes of data */
                                                 if (features->type == TABLETPC2FG)
                                                         features->pktlen = WACOM_PKGLEN_GRAPHIRE;
+                                                if (features->type == BAMBOO_PT)
+                                                        features->pktlen = WACOM_PKGLEN_BBFUN;
                                                 features->device_type = BTN_TOOL_PEN;
                                                 features->y_max =
                                                         get_unaligned_le16(&report[i + 3]);
@@ -296,8 +323,9 @@ static int wacom_query_tablet_data(struct usb_interface *intf, struct wacom_feat
         if (!rep_data)
                 return error;
 
-        /* ask to report tablet data if it is 2FGT or not a Tablet PC */
-        if (features->device_type == BTN_TOOL_TRIPLETAP) {
+        /* ask to report tablet data if it is 2FGT Tablet PC or
+         * not a Tablet PC */
+        if (features->type == TABLETPC2FG) {
                 do {
                         rep_data[0] = 3;
                         rep_data[1] = 4;
@@ -309,7 +337,7 @@ static int wacom_query_tablet_data(struct usb_interface *intf, struct wacom_feat
                                         WAC_HID_FEATURE_REPORT, report_id,
                                         rep_data, 3);
                 } while ((error < 0 || rep_data[1] != 4) && limit++ < 5);
-        } else if (features->type != TABLETPC && features->type != TABLETPC2FG) {
+        } else if (features->type != TABLETPC) {
                 do {
                         rep_data[0] = 2;
                         rep_data[1] = 2;
@@ -334,11 +362,16 @@ static int wacom_retrieve_hid_descriptor(struct usb_interface *intf,
         struct usb_host_interface *interface = intf->cur_altsetting;
         struct hid_descriptor *hid_desc;
 
-        /* default device to penabled */
+        /* default features */
         features->device_type = BTN_TOOL_PEN;
-
-        /* only Tablet PCs need to retrieve the info */
-        if ((features->type != TABLETPC) && (features->type != TABLETPC2FG))
+        features->x_fuzz = 4;
+        features->y_fuzz = 4;
+        features->pressure_fuzz = 0;
+        features->distance_fuzz = 0;
+
+        /* only Tablet PCs and Bamboo P&T need to retrieve the info */
+        if ((features->type != TABLETPC) && (features->type != TABLETPC2FG) &&
+            (features->type != BAMBOO_PT))
                 goto out;
 
         if (usb_get_extra_descriptor(interface, HID_DEVICET_HID, &hid_desc)) {
@@ -353,12 +386,6 @@ static int wacom_retrieve_hid_descriptor(struct usb_interface *intf,
         if (error)
                 goto out;
 
-        /* touch device found but size is not defined. use default */
-        if (features->device_type == BTN_TOOL_DOUBLETAP && !features->x_max) {
-                features->x_max = 1023;
-                features->y_max = 1023;
-        }
-
  out:
         return error;
 }
@@ -492,11 +519,13 @@ static int wacom_probe(struct usb_interface *intf, const struct usb_device_id *i
         /* Retrieve the physical and logical size for OEM devices */
         error = wacom_retrieve_hid_descriptor(intf, features);
         if (error)
-                goto fail2;
+                goto fail3;
+
+        wacom_setup_device_quirks(features);
 
         strlcpy(wacom_wac->name, features->name, sizeof(wacom_wac->name));
 
-        if (features->type == TABLETPC || features->type == TABLETPC2FG) {
+        if (features->quirks & WACOM_QUIRK_MULTI_INPUT) {
                 /* Append the device type to the name */
                 strlcat(wacom_wac->name,
                         features->device_type == BTN_TOOL_PEN ?
diff --git a/drivers/input/tablet/wacom_wac.c b/drivers/input/tablet/wacom_wac.c
index 47fd7a041c52..08ba5ad9c9be 100644
--- a/drivers/input/tablet/wacom_wac.c
+++ b/drivers/input/tablet/wacom_wac.c
@@ -14,6 +14,15 @@
 
 #include "wacom_wac.h"
 #include "wacom.h"
+#include <linux/input/mt.h>
+
+/* resolution for penabled devices */
+#define WACOM_PL_RES            20
+#define WACOM_PENPRTN_RES       40
+#define WACOM_VOLITO_RES        50
+#define WACOM_GRAPHIRE_RES      80
+#define WACOM_INTUOS_RES        100
+#define WACOM_INTUOS3_RES       200
 
 static int wacom_penpartner_irq(struct wacom_wac *wacom)
 {
@@ -674,187 +683,234 @@ static int wacom_intuos_irq(struct wacom_wac *wacom)
         return 1;
 }
 
-
-static void wacom_tpc_finger_in(struct wacom_wac *wacom, char *data, int idx)
+static int wacom_tpc_mt_touch(struct wacom_wac *wacom)
 {
         struct input_dev *input = wacom->input;
-        int finger = idx + 1;
-        int x = le16_to_cpup((__le16 *)&data[finger * 2]) & 0x7fff;
-        int y = le16_to_cpup((__le16 *)&data[4 + finger * 2]) & 0x7fff;
+        unsigned char *data = wacom->data;
+        int contact_with_no_pen_down_count = 0;
+        int i;
 
-        /*
-         * Work around input core suppressing "duplicate" events since
-         * we are abusing ABS_X/ABS_Y to transmit multi-finger data.
-         * This should go away once we switch to true multitouch
-         * protocol.
-         */
-        if (wacom->last_finger != finger) {
-                if (x == input_abs_get_val(input, ABS_X))
-                        x++;
+        for (i = 0; i < 2; i++) {
+                int p = data[1] & (1 << i);
+                bool touch = p && !wacom->shared->stylus_in_proximity;
 
-                if (y == input_abs_get_val(input, ABS_Y))
-                        y++;
+                input_mt_slot(input, i);
+                input_mt_report_slot_state(input, MT_TOOL_FINGER, touch);
+                if (touch) {
+                        int x = le16_to_cpup((__le16 *)&data[i * 2 + 2]) & 0x7fff;
+                        int y = le16_to_cpup((__le16 *)&data[i * 2 + 6]) & 0x7fff;
+
+                        input_report_abs(input, ABS_MT_POSITION_X, x);
+                        input_report_abs(input, ABS_MT_POSITION_Y, y);
+                        contact_with_no_pen_down_count++;
+                }
         }
 
-        input_report_abs(input, ABS_X, x);
-        input_report_abs(input, ABS_Y, y);
-        input_report_abs(input, ABS_MISC, wacom->id[0]);
-        input_report_key(input, wacom->tool[finger], 1);
-        if (!idx)
-                input_report_key(input, BTN_TOUCH, 1);
-        input_event(input, EV_MSC, MSC_SERIAL, finger);
-        input_sync(input);
+        /* keep touch state for pen event */
+        wacom->shared->touch_down = (contact_with_no_pen_down_count > 0);
 
-        wacom->last_finger = finger;
-}
+        input_mt_report_pointer_emulation(input, true);
 
-static void wacom_tpc_touch_out(struct wacom_wac *wacom, int idx)
-{
-        struct input_dev *input = wacom->input;
-        int finger = idx + 1;
-
-        input_report_abs(input, ABS_X, 0);
-        input_report_abs(input, ABS_Y, 0);
-        input_report_abs(input, ABS_MISC, 0);
-        input_report_key(input, wacom->tool[finger], 0);
-        if (!idx)
-                input_report_key(input, BTN_TOUCH, 0);
-        input_event(input, EV_MSC, MSC_SERIAL, finger);
-        input_sync(input);
+        return 1;
 }
 
-static void wacom_tpc_touch_in(struct wacom_wac *wacom, size_t len)
+static int wacom_tpc_single_touch(struct wacom_wac *wacom, size_t len)
 {
         char *data = wacom->data;
         struct input_dev *input = wacom->input;
+        bool prox;
+        int x = 0, y = 0;
 
-        wacom->tool[1] = BTN_TOOL_DOUBLETAP;
-        wacom->id[0] = TOUCH_DEVICE_ID;
-        wacom->tool[2] = BTN_TOOL_TRIPLETAP;
+        if (!wacom->shared->stylus_in_proximity) {
+                if (len == WACOM_PKGLEN_TPC1FG) {
+                        prox = data[0] & 0x01;
+                        x = get_unaligned_le16(&data[1]);
+                        y = get_unaligned_le16(&data[3]);
+                } else { /* with capacity */
+                        prox = data[1] & 0x01;
+                        x = le16_to_cpup((__le16 *)&data[2]);
+                        y = le16_to_cpup((__le16 *)&data[4]);
+                }
+        } else
+                /* force touch out when pen is in prox */
+                prox = 0;
 
-        if (len != WACOM_PKGLEN_TPC1FG) {
+        if (prox) {
+                input_report_abs(input, ABS_X, x);
+                input_report_abs(input, ABS_Y, y);
+        }
+        input_report_key(input, BTN_TOUCH, prox);
 
-                switch (data[0]) {
+        /* keep touch state for pen events */
+        wacom->shared->touch_down = prox;
 
-                case WACOM_REPORT_TPC1FG:
-                        input_report_abs(input, ABS_X, le16_to_cpup((__le16 *)&data[2]));
-                        input_report_abs(input, ABS_Y, le16_to_cpup((__le16 *)&data[4]));
-                        input_report_abs(input, ABS_PRESSURE, le16_to_cpup((__le16 *)&data[6]));
-                        input_report_key(input, BTN_TOUCH, le16_to_cpup((__le16 *)&data[6]));
-                        input_report_abs(input, ABS_MISC, wacom->id[0]);
-                        input_report_key(input, wacom->tool[1], 1);
-                        input_sync(input);
-                        break;
+        return 1;
+}
 
-                case WACOM_REPORT_TPC2FG:
-                        if (data[1] & 0x01)
-                                wacom_tpc_finger_in(wacom, data, 0);
-                        else if (wacom->id[1] & 0x01)
-                                wacom_tpc_touch_out(wacom, 0);
+static int wacom_tpc_pen(struct wacom_wac *wacom)
+{
+        struct wacom_features *features = &wacom->features;
+        char *data = wacom->data;
+        struct input_dev *input = wacom->input;
+        int pressure;
+        bool prox = data[1] & 0x20;
 
-                        if (data[1] & 0x02)
-                                wacom_tpc_finger_in(wacom, data, 1);
-                        else if (wacom->id[1] & 0x02)
-                                wacom_tpc_touch_out(wacom, 1);
-                        break;
-                }
-        } else {
-                input_report_abs(input, ABS_X, get_unaligned_le16(&data[1]));
-                input_report_abs(input, ABS_Y, get_unaligned_le16(&data[3]));
-                input_report_key(input, BTN_TOUCH, 1);
-                input_report_abs(input, ABS_MISC, wacom->id[1]);
-                input_report_key(input, wacom->tool[1], 1);
-                input_sync(input);
+        if (!wacom->shared->stylus_in_proximity) /* first in prox */
+                /* Going into proximity select tool */
+                wacom->tool[0] = (data[1] & 0x0c) ? BTN_TOOL_RUBBER : BTN_TOOL_PEN;
+
+        /* keep pen state for touch events */
+        wacom->shared->stylus_in_proximity = prox;
+
+        /* send pen events only when touch is up or forced out */
+        if (!wacom->shared->touch_down) {
+                input_report_key(input, BTN_STYLUS, data[1] & 0x02);
+                input_report_key(input, BTN_STYLUS2, data[1] & 0x10);
+                input_report_abs(input, ABS_X, le16_to_cpup((__le16 *)&data[2]));
+                input_report_abs(input, ABS_Y, le16_to_cpup((__le16 *)&data[4]));
+                pressure = ((data[7] & 0x01) << 8) | data[6];
+                if (pressure < 0)
+                        pressure = features->pressure_max + pressure + 1;
+                input_report_abs(input, ABS_PRESSURE, pressure);
+                input_report_key(input, BTN_TOUCH, data[1] & 0x05);
+                input_report_key(input, wacom->tool[0], prox);
+                return 1;
         }
+
+        return 0;
 }
 
 static int wacom_tpc_irq(struct wacom_wac *wacom, size_t len)
 {
-        struct wacom_features *features = &wacom->features;
         char *data = wacom->data;
-        struct input_dev *input = wacom->input;
-        int prox = 0, pressure;
-        int retval = 0;
 
         dbg("wacom_tpc_irq: received report #%d", data[0]);
 
-        if (len == WACOM_PKGLEN_TPC1FG ||                /* single touch */
-            data[0] == WACOM_REPORT_TPC1FG ||            /* single touch */
-            data[0] == WACOM_REPORT_TPC2FG) {            /* 2FG touch */
+        if (len == WACOM_PKGLEN_TPC1FG || data[0] == WACOM_REPORT_TPC1FG)
+                return wacom_tpc_single_touch(wacom, len);
+        else if (data[0] == WACOM_REPORT_TPC2FG)
+                return wacom_tpc_mt_touch(wacom);
+        else if (data[0] == WACOM_REPORT_PENABLED)
+                return wacom_tpc_pen(wacom);
 
-                if (wacom->shared->stylus_in_proximity) {
-                        if (wacom->id[1] & 0x01)
-                                wacom_tpc_touch_out(wacom, 0);
+        return 0;
+}
 
-                        if (wacom->id[1] & 0x02)
-                                wacom_tpc_touch_out(wacom, 1);
+static int wacom_bpt_touch(struct wacom_wac *wacom)
+{
+        struct wacom_features *features = &wacom->features;
+        struct input_dev *input = wacom->input;
+        unsigned char *data = wacom->data;
+        int i;
 
-                        wacom->id[1] = 0;
-                        return 0;
-                }
+        for (i = 0; i < 2; i++) {
+                int p = data[9 * i + 2];
+                bool touch = p && !wacom->shared->stylus_in_proximity;
 
-                if (len == WACOM_PKGLEN_TPC1FG) {       /* with touch */
-                        prox = data[0] & 0x01;
-                } else {  /* with capacity */
-                        if (data[0] == WACOM_REPORT_TPC1FG)
-                                /* single touch */
-                                prox = data[1] & 0x01;
-                        else
-                                /* 2FG touch data */
-                                prox = data[1] & 0x03;
+                input_mt_slot(input, i);
+                input_mt_report_slot_state(input, MT_TOOL_FINGER, touch);
+                /*
+                 * Touch events need to be disabled while stylus is
+                 * in proximity because user's hand is resting on touchpad
+                 * and sending unwanted events.  User expects tablet buttons
+                 * to continue working though.
+                 */
+                if (touch) {
+                        int x = get_unaligned_be16(&data[9 * i + 3]) & 0x7ff;
+                        int y = get_unaligned_be16(&data[9 * i + 5]) & 0x7ff;
+                        if (features->quirks & WACOM_QUIRK_BBTOUCH_LOWRES) {
+                                x <<= 5;
+                                y <<= 5;
+                        }
+                        input_report_abs(input, ABS_MT_PRESSURE, p);
+                        input_report_abs(input, ABS_MT_POSITION_X, x);
+                        input_report_abs(input, ABS_MT_POSITION_Y, y);
                 }
+        }
 
-                if (prox) {
-                        if (!wacom->id[1])
-                                wacom->last_finger = 1;
-                        wacom_tpc_touch_in(wacom, len);
-                } else {
-                        if (data[0] == WACOM_REPORT_TPC2FG) {
-                                /* 2FGT out-prox */
-                                if (wacom->id[1] & 0x01)
-                                        wacom_tpc_touch_out(wacom, 0);
+        input_mt_report_pointer_emulation(input, true);
 
-                                if (wacom->id[1] & 0x02)
-                                        wacom_tpc_touch_out(wacom, 1);
-                        } else
-                                /* one finger touch */
-                                wacom_tpc_touch_out(wacom, 0);
+        input_report_key(input, BTN_LEFT, (data[1] & 0x08) != 0);
+        input_report_key(input, BTN_FORWARD, (data[1] & 0x04) != 0);
+        input_report_key(input, BTN_BACK, (data[1] & 0x02) != 0);
+        input_report_key(input, BTN_RIGHT, (data[1] & 0x01) != 0);
 
-                        wacom->id[0] = 0;
-                }
-                /* keep prox bit to send proper out-prox event */
-                wacom->id[1] = prox;
-        } else if (data[0] == WACOM_REPORT_PENABLED) { /* Penabled */
-                prox = data[1] & 0x20;
-
-                if (!wacom->shared->stylus_in_proximity) { /* first in prox */
-                        /* Going into proximity select tool */
-                        wacom->tool[0] = (data[1] & 0x0c) ? BTN_TOOL_RUBBER : BTN_TOOL_PEN;
-                        if (wacom->tool[0] == BTN_TOOL_PEN)
-                                wacom->id[0] = STYLUS_DEVICE_ID;
-                        else
-                                wacom->id[0] = ERASER_DEVICE_ID;
+        input_sync(input);
+
+        return 0;
+}
+
+static int wacom_bpt_pen(struct wacom_wac *wacom)
+{
+        struct input_dev *input = wacom->input;
+        unsigned char *data = wacom->data;
+        int prox = 0, x = 0, y = 0, p = 0, d = 0, pen = 0, btn1 = 0, btn2 = 0;
 
+        /*
+         * Similar to Graphire protocol, data[1] & 0x20 is proximity and
+         * data[1] & 0x18 is tool ID.  0x30 is safety check to ignore
+         * 2 unused tool ID's.
+         */
+        prox = (data[1] & 0x30) == 0x30;
+
+        /*
+         * All reports shared between PEN and RUBBER tool must be
+         * forced to a known starting value (zero) when transitioning to
+         * out-of-prox.
+         *
+         * If not reset then, to userspace, it will look like lost events
+         * if new tool comes in-prox with same values as previous tool sent.
+         *
+         * Hardware does report zero in most out-of-prox cases but not all.
+         */
+        if (prox) {
+                if (!wacom->shared->stylus_in_proximity) {
+                        if (data[1] & 0x08) {
+                                wacom->tool[0] = BTN_TOOL_RUBBER;
+                                wacom->id[0] = ERASER_DEVICE_ID;
+                        } else {
+                                wacom->tool[0] = BTN_TOOL_PEN;
+                                wacom->id[0] = STYLUS_DEVICE_ID;
+                        }
                         wacom->shared->stylus_in_proximity = true;
                 }
-                input_report_key(input, BTN_STYLUS, data[1] & 0x02);
-                input_report_key(input, BTN_STYLUS2, data[1] & 0x10);
-                input_report_abs(input, ABS_X, le16_to_cpup((__le16 *)&data[2]));
-                input_report_abs(input, ABS_Y, le16_to_cpup((__le16 *)&data[4]));
-                pressure = ((data[7] & 0x01) << 8) | data[6];
-                if (pressure < 0)
-                        pressure = features->pressure_max + pressure + 1;
-                input_report_abs(input, ABS_PRESSURE, pressure);
-                input_report_key(input, BTN_TOUCH, data[1] & 0x05);
-                if (!prox) { /* out-prox */
-                        wacom->id[0] = 0;
-                        wacom->shared->stylus_in_proximity = false;
-                }
-                input_report_key(input, wacom->tool[0], prox);
-                input_report_abs(input, ABS_MISC, wacom->id[0]);
-                retval = 1;
+                x = le16_to_cpup((__le16 *)&data[2]);
+                y = le16_to_cpup((__le16 *)&data[4]);
+                p = le16_to_cpup((__le16 *)&data[6]);
+                d = data[8];
+                pen = data[1] & 0x01;
+                btn1 = data[1] & 0x02;
+                btn2 = data[1] & 0x04;
         }
-        return retval;
+
+        input_report_key(input, BTN_TOUCH, pen);
+        input_report_key(input, BTN_STYLUS, btn1);
+        input_report_key(input, BTN_STYLUS2, btn2);
+
+        input_report_abs(input, ABS_X, x);
+        input_report_abs(input, ABS_Y, y);
+        input_report_abs(input, ABS_PRESSURE, p);
+        input_report_abs(input, ABS_DISTANCE, d);
+
+        if (!prox) {
+                wacom->id[0] = 0;
+                wacom->shared->stylus_in_proximity = false;
+        }
+
+        input_report_key(input, wacom->tool[0], prox); /* PEN or RUBBER */
+        input_report_abs(input, ABS_MISC, wacom->id[0]); /* TOOL ID */
+
+        return 1;
+}
+
+static int wacom_bpt_irq(struct wacom_wac *wacom, size_t len)
+{
+        if (len == WACOM_PKGLEN_BBTOUCH)
+                return wacom_bpt_touch(wacom);
+        else if (len == WACOM_PKGLEN_BBFUN)
+                return wacom_bpt_pen(wacom);
+
+        return 0;
 }
 
 void wacom_wac_irq(struct wacom_wac *wacom_wac, size_t len)
@@ -902,6 +958,10 @@ void wacom_wac_irq(struct wacom_wac *wacom_wac, size_t len)
                 sync = wacom_tpc_irq(wacom_wac, len);
                 break;
 
+        case BAMBOO_PT:
+                sync = wacom_bpt_irq(wacom_wac, len);
+                break;
+
         default:
                 sync = false;
                 break;
@@ -911,26 +971,17 @@ void wacom_wac_irq(struct wacom_wac *wacom_wac, size_t len)
                 input_sync(wacom_wac->input);
 }
 
-static void wacom_setup_intuos(struct wacom_wac *wacom_wac)
+static void wacom_setup_cintiq(struct wacom_wac *wacom_wac)
 {
         struct input_dev *input_dev = wacom_wac->input;
 
         input_set_capability(input_dev, EV_MSC, MSC_SERIAL);
-        input_set_capability(input_dev, EV_REL, REL_WHEEL);
-
-        __set_bit(BTN_LEFT, input_dev->keybit);
-        __set_bit(BTN_RIGHT, input_dev->keybit);
-        __set_bit(BTN_MIDDLE, input_dev->keybit);
-        __set_bit(BTN_SIDE, input_dev->keybit);
-        __set_bit(BTN_EXTRA, input_dev->keybit);
 
         __set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
         __set_bit(BTN_TOOL_PEN, input_dev->keybit);
-        __set_bit(BTN_TOOL_MOUSE, input_dev->keybit);
         __set_bit(BTN_TOOL_BRUSH, input_dev->keybit);
         __set_bit(BTN_TOOL_PENCIL, input_dev->keybit);
         __set_bit(BTN_TOOL_AIRBRUSH, input_dev->keybit);
-        __set_bit(BTN_TOOL_LENS, input_dev->keybit);
         __set_bit(BTN_STYLUS, input_dev->keybit);
         __set_bit(BTN_STYLUS2, input_dev->keybit);
 
@@ -939,10 +990,62 @@ static void wacom_setup_intuos(struct wacom_wac *wacom_wac)
         input_set_abs_params(input_dev, ABS_WHEEL, 0, 1023, 0, 0);
         input_set_abs_params(input_dev, ABS_TILT_X, 0, 127, 0, 0);
         input_set_abs_params(input_dev, ABS_TILT_Y, 0, 127, 0, 0);
+}
+
+static void wacom_setup_intuos(struct wacom_wac *wacom_wac)
+{
+        struct input_dev *input_dev = wacom_wac->input;
+
+        input_set_capability(input_dev, EV_REL, REL_WHEEL);
+
+        wacom_setup_cintiq(wacom_wac);
+
+        __set_bit(BTN_LEFT, input_dev->keybit);
+        __set_bit(BTN_RIGHT, input_dev->keybit);
+        __set_bit(BTN_MIDDLE, input_dev->keybit);
+        __set_bit(BTN_SIDE, input_dev->keybit);
+        __set_bit(BTN_EXTRA, input_dev->keybit);
+        __set_bit(BTN_TOOL_MOUSE, input_dev->keybit);
+        __set_bit(BTN_TOOL_LENS, input_dev->keybit);
+
         input_set_abs_params(input_dev, ABS_RZ, -900, 899, 0, 0);
         input_set_abs_params(input_dev, ABS_THROTTLE, -1023, 1023, 0, 0);
 }
 
+void wacom_setup_device_quirks(struct wacom_features *features)
+{
+
+        /* touch device found but size is not defined. use default */
+        if (features->device_type == BTN_TOOL_FINGER && !features->x_max) {
+                features->x_max = 1023;
+                features->y_max = 1023;
+        }
+
+        /* these device have multiple inputs */
+        if (features->type == TABLETPC || features->type == TABLETPC2FG ||
+            features->type == BAMBOO_PT)
+                features->quirks |= WACOM_QUIRK_MULTI_INPUT;
+
+        /* quirks for bamboo touch */
+        if (features->type == BAMBOO_PT &&
+            features->device_type == BTN_TOOL_DOUBLETAP) {
+                features->x_max <<= 5;
+                features->y_max <<= 5;
+                features->x_fuzz <<= 5;
+                features->y_fuzz <<= 5;
+                features->pressure_max = 256;
+                features->pressure_fuzz = 16;
+                features->quirks |= WACOM_QUIRK_BBTOUCH_LOWRES;
+        }
+}
+
+static unsigned int wacom_calculate_touch_res(unsigned int logical_max,
+                                              unsigned int physical_max)
+{
+       /* Touch physical dimensions are in 100th of mm */
+       return (logical_max * 100) / physical_max;
+}
+
 void wacom_setup_input_capabilities(struct input_dev *input_dev,
                                     struct wacom_wac *wacom_wac)
 {
@@ -953,9 +1056,25 @@ void wacom_setup_input_capabilities(struct input_dev *input_dev,
 
         __set_bit(BTN_TOUCH, input_dev->keybit);
 
-        input_set_abs_params(input_dev, ABS_X, 0, features->x_max, 4, 0);
-        input_set_abs_params(input_dev, ABS_Y, 0, features->y_max, 4, 0);
-        input_set_abs_params(input_dev, ABS_PRESSURE, 0, features->pressure_max, 0, 0);
+        input_set_abs_params(input_dev, ABS_X, 0, features->x_max,
+                             features->x_fuzz, 0);
+        input_set_abs_params(input_dev, ABS_Y, 0, features->y_max,
+                             features->y_fuzz, 0);
+        input_set_abs_params(input_dev, ABS_PRESSURE, 0, features->pressure_max,
+                             features->pressure_fuzz, 0);
+
+        if (features->device_type == BTN_TOOL_PEN) {
+                /* penabled devices have fixed resolution for each model */
+                input_abs_set_res(input_dev, ABS_X, features->x_resolution);
+                input_abs_set_res(input_dev, ABS_Y, features->y_resolution);
+        } else {
+                input_abs_set_res(input_dev, ABS_X,
+                        wacom_calculate_touch_res(features->x_max,
+                                                features->x_phy));
+                input_abs_set_res(input_dev, ABS_Y,
+                        wacom_calculate_touch_res(features->y_max,
+                                                features->y_phy));
+        }
 
         __set_bit(ABS_MISC, input_dev->absbit);
 
@@ -1005,9 +1124,19 @@ void wacom_setup_input_capabilities(struct input_dev *input_dev,
                 __set_bit(BTN_9, input_dev->keybit);
                 /* fall through */
 
+        case CINTIQ:
+                for (i = 0; i < 8; i++)
+                        __set_bit(BTN_0 + i, input_dev->keybit);
+                __set_bit(BTN_TOOL_FINGER, input_dev->keybit);
+
+                input_set_abs_params(input_dev, ABS_RX, 0, 4096, 0, 0);
+                input_set_abs_params(input_dev, ABS_RY, 0, 4096, 0, 0);
+                input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
+                wacom_setup_cintiq(wacom_wac);
+                break;
+
         case INTUOS3:
         case INTUOS3L:
-        case CINTIQ:
                 __set_bit(BTN_4, input_dev->keybit);
                 __set_bit(BTN_5, input_dev->keybit);
                 __set_bit(BTN_6, input_dev->keybit);
@@ -1048,19 +1177,20 @@ void wacom_setup_input_capabilities(struct input_dev *input_dev,
                 break;
 
         case TABLETPC2FG:
-                if (features->device_type == BTN_TOOL_TRIPLETAP) {
-                        __set_bit(BTN_TOOL_TRIPLETAP, input_dev->keybit);
-                        input_set_capability(input_dev, EV_MSC, MSC_SERIAL);
+                if (features->device_type == BTN_TOOL_DOUBLETAP) {
+
+                        input_mt_init_slots(input_dev, 2);
+                        input_set_abs_params(input_dev, ABS_MT_TOOL_TYPE,
+                                        0, MT_TOOL_MAX, 0, 0);
+                        input_set_abs_params(input_dev, ABS_MT_POSITION_X,
+                                        0, features->x_max, 0, 0);
+                        input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
+                                        0, features->y_max, 0, 0);
                 }
                 /* fall through */
 
         case TABLETPC:
-                if (features->device_type == BTN_TOOL_DOUBLETAP ||
-                    features->device_type == BTN_TOOL_TRIPLETAP) {
-                        input_set_abs_params(input_dev, ABS_RX, 0, features->x_phy, 0, 0);
-                        input_set_abs_params(input_dev, ABS_RY, 0, features->y_phy, 0, 0);
-                        __set_bit(BTN_TOOL_DOUBLETAP, input_dev->keybit);
-                }
+                __clear_bit(ABS_MISC, input_dev->absbit);
 
                 if (features->device_type != BTN_TOOL_PEN)
                         break;  /* no need to process stylus stuff */
@@ -1078,148 +1208,285 @@ void wacom_setup_input_capabilities(struct input_dev *input_dev,
         case PENPARTNER:
                 __set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
                 break;
+
+        case BAMBOO_PT:
+                __clear_bit(ABS_MISC, input_dev->absbit);
+
+                if (features->device_type == BTN_TOOL_DOUBLETAP) {
+                        __set_bit(BTN_LEFT, input_dev->keybit);
+                        __set_bit(BTN_FORWARD, input_dev->keybit);
+                        __set_bit(BTN_BACK, input_dev->keybit);
+                        __set_bit(BTN_RIGHT, input_dev->keybit);
+
+                        __set_bit(BTN_TOOL_FINGER, input_dev->keybit);
+                        __set_bit(BTN_TOOL_DOUBLETAP, input_dev->keybit);
+
+                        input_mt_init_slots(input_dev, 2);
+                        input_set_abs_params(input_dev, ABS_MT_POSITION_X,
+                                             0, features->x_max,
+                                             features->x_fuzz, 0);
+                        input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
+                                             0, features->y_max,
+                                             features->y_fuzz, 0);
+                        input_set_abs_params(input_dev, ABS_MT_PRESSURE,
+                                             0, features->pressure_max,
+                                             features->pressure_fuzz, 0);
+                } else if (features->device_type == BTN_TOOL_PEN) {
+                        __set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
+                        __set_bit(BTN_TOOL_PEN, input_dev->keybit);
+                        __set_bit(BTN_STYLUS, input_dev->keybit);
+                        __set_bit(BTN_STYLUS2, input_dev->keybit);
+                }
+                break;
         }
 }
 
 static const struct wacom_features wacom_features_0x00 =
-        { "Wacom Penpartner",     WACOM_PKGLEN_PENPRTN,    5040,  3780,  255,  0, PENPARTNER };
+        { "Wacom Penpartner",     WACOM_PKGLEN_PENPRTN,    5040,  3780,  255,
+          0, PENPARTNER, WACOM_PENPRTN_RES, WACOM_PENPRTN_RES };
 static const struct wacom_features wacom_features_0x10 =
-        { "Wacom Graphire",       WACOM_PKGLEN_GRAPHIRE,  10206,  7422,  511, 63, GRAPHIRE };
+        { "Wacom Graphire",       WACOM_PKGLEN_GRAPHIRE,  10206,  7422,  511,
+          63, GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
 static const struct wacom_features wacom_features_0x11 =
-        { "Wacom Graphire2 4x5",  WACOM_PKGLEN_GRAPHIRE,  10206,  7422,  511, 63, GRAPHIRE };
+        { "Wacom Graphire2 4x5",  WACOM_PKGLEN_GRAPHIRE,  10206,  7422,  511,
+          63, GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
 static const struct wacom_features wacom_features_0x12 =
-        { "Wacom Graphire2 5x7",  WACOM_PKGLEN_GRAPHIRE,  13918, 10206,  511, 63, GRAPHIRE };
+        { "Wacom Graphire2 5x7",  WACOM_PKGLEN_GRAPHIRE,  13918, 10206,  511,
+          63, GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
 static const struct wacom_features wacom_features_0x13 =
-        { "Wacom Graphire3",      WACOM_PKGLEN_GRAPHIRE,  10208,  7424,  511, 63, GRAPHIRE };
+        { "Wacom Graphire3",      WACOM_PKGLEN_GRAPHIRE,  10208,  7424,  511,
+          63, GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
 static const struct wacom_features wacom_features_0x14 =
-        { "Wacom Graphire3 6x8",  WACOM_PKGLEN_GRAPHIRE,  16704, 12064,  511, 63, GRAPHIRE };
+        { "Wacom Graphire3 6x8",  WACOM_PKGLEN_GRAPHIRE,  16704, 12064,  511,
+          63, GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
 static const struct wacom_features wacom_features_0x15 =
-        { "Wacom Graphire4 4x5",  WACOM_PKGLEN_GRAPHIRE,  10208,  7424,  511, 63, WACOM_G4 };
+        { "Wacom Graphire4 4x5",  WACOM_PKGLEN_GRAPHIRE,  10208,  7424,  511,
+          63, WACOM_G4, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
 static const struct wacom_features wacom_features_0x16 =
-        { "Wacom Graphire4 6x8",  WACOM_PKGLEN_GRAPHIRE,  16704, 12064,  511, 63, WACOM_G4 };
+        { "Wacom Graphire4 6x8",  WACOM_PKGLEN_GRAPHIRE,  16704, 12064,  511,
+          63, WACOM_G4, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
 static const struct wacom_features wacom_features_0x17 =
-        { "Wacom BambooFun 4x5",  WACOM_PKGLEN_BBFUN,     14760,  9225,  511, 63, WACOM_MO };
+        { "Wacom BambooFun 4x5",  WACOM_PKGLEN_BBFUN,     14760,  9225,  511,
+          63, WACOM_MO, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
 static const struct wacom_features wacom_features_0x18 =
-        { "Wacom BambooFun 6x8",  WACOM_PKGLEN_BBFUN,     21648, 13530,  511, 63, WACOM_MO };
+        { "Wacom BambooFun 6x8",  WACOM_PKGLEN_BBFUN,     21648, 13530,  511,
+          63, WACOM_MO, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
 static const struct wacom_features wacom_features_0x19 =
-        { "Wacom Bamboo1 Medium", WACOM_PKGLEN_GRAPHIRE,  16704, 12064,  511, 63, GRAPHIRE };
+        { "Wacom Bamboo1 Medium", WACOM_PKGLEN_GRAPHIRE,  16704, 12064,  511,
+          63, GRAPHIRE, WACOM_GRAPHIRE_RES, WACOM_GRAPHIRE_RES };
 static const struct wacom_features wacom_features_0x60 =
-        { "Wacom Volito",         WACOM_PKGLEN_GRAPHIRE,   5104,  3712,  511, 63, GRAPHIRE };
+        { "Wacom Volito",         WACOM_PKGLEN_GRAPHIRE,   5104,  3712,  511,
+          63, GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
 static const struct wacom_features wacom_features_0x61 =
-        { "Wacom PenStation2",    WACOM_PKGLEN_GRAPHIRE,   3250,  2320,  255, 63, GRAPHIRE };
+        { "Wacom PenStation2",    WACOM_PKGLEN_GRAPHIRE,   3250,  2320,  255,
+          63, GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
 static const struct wacom_features wacom_features_0x62 =
-        { "Wacom Volito2 4x5",    WACOM_PKGLEN_GRAPHIRE,   5104,  3712,  511, 63, GRAPHIRE };
+        { "Wacom Volito2 4x5",    WACOM_PKGLEN_GRAPHIRE,   5104,  3712,  511,
+          63, GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
 static const struct wacom_features wacom_features_0x63 =
-        { "Wacom Volito2 2x3",    WACOM_PKGLEN_GRAPHIRE,   3248,  2320,  511, 63, GRAPHIRE };
+        { "Wacom Volito2 2x3",    WACOM_PKGLEN_GRAPHIRE,   3248,  2320,  511,
+          63, GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
 static const struct wacom_features wacom_features_0x64 =
-        { "Wacom PenPartner2",    WACOM_PKGLEN_GRAPHIRE,   3250,  2320,  511, 63, GRAPHIRE };
+        { "Wacom PenPartner2",    WACOM_PKGLEN_GRAPHIRE,   3250,  2320,  511,
+          63, GRAPHIRE, WACOM_VOLITO_RES, WACOM_VOLITO_RES };
 static const struct wacom_features wacom_features_0x65 =
-        { "Wacom Bamboo",         WACOM_PKGLEN_BBFUN,     14760,  9225,  511, 63, WACOM_MO };
+        { "Wacom Bamboo",         WACOM_PKGLEN_BBFUN,     14760,  9225,  511,
+          63, WACOM_MO, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
 static const struct wacom_features wacom_features_0x69 =
-        { "Wacom Bamboo1",        WACOM_PKGLEN_GRAPHIRE,   5104,  3712,  511, 63, GRAPHIRE };
+        { "Wacom Bamboo1",        WACOM_PKGLEN_GRAPHIRE,   5104,  3712,  511,
+          63, GRAPHIRE, WACOM_PENPRTN_RES, WACOM_PENPRTN_RES };
 static const struct wacom_features wacom_features_0x20 =
-        { "Wacom Intuos 4x5",     WACOM_PKGLEN_INTUOS,    12700, 10600, 1023, 31, INTUOS };
+        { "Wacom Intuos 4x5",     WACOM_PKGLEN_INTUOS,    12700, 10600, 1023,
+          31, INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
 static const struct wacom_features wacom_features_0x21 =
-        { "Wacom Intuos 6x8",     WACOM_PKGLEN_INTUOS,    20320, 16240, 1023, 31, INTUOS };
+        { "Wacom Intuos 6x8",     WACOM_PKGLEN_INTUOS,    20320, 16240, 1023,
+          31, INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
 static const struct wacom_features wacom_features_0x22 =
-        { "Wacom Intuos 9x12",    WACOM_PKGLEN_INTUOS,    30480, 24060, 1023, 31, INTUOS };
+        { "Wacom Intuos 9x12",    WACOM_PKGLEN_INTUOS,    30480, 24060, 1023,
+          31, INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
 static const struct wacom_features wacom_features_0x23 =
-        { "Wacom Intuos 12x12",   WACOM_PKGLEN_INTUOS,    30480, 31680, 1023, 31, INTUOS };
+        { "Wacom Intuos 12x12",   WACOM_PKGLEN_INTUOS,    30480, 31680, 1023,
+          31, INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
 static const struct wacom_features wacom_features_0x24 =
-        { "Wacom Intuos 12x18",   WACOM_PKGLEN_INTUOS,    45720, 31680, 1023, 31, INTUOS };
+        { "Wacom Intuos 12x18",   WACOM_PKGLEN_INTUOS,    45720, 31680, 1023,
+          31, INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
 static const struct wacom_features wacom_features_0x30 =
-        { "Wacom PL400",          WACOM_PKGLEN_GRAPHIRE,   5408,  4056,  255,  0, PL };
+        { "Wacom PL400",          WACOM_PKGLEN_GRAPHIRE,   5408,  4056,  255,
+          0, PL, WACOM_PL_RES, WACOM_PL_RES };
 static const struct wacom_features wacom_features_0x31 =
-        { "Wacom PL500",          WACOM_PKGLEN_GRAPHIRE,   6144,  4608,  255,  0, PL };
+        { "Wacom PL500",          WACOM_PKGLEN_GRAPHIRE,   6144,  4608,  255,
+          0, PL, WACOM_PL_RES, WACOM_PL_RES };
 static const struct wacom_features wacom_features_0x32 =
-        { "Wacom PL600",          WACOM_PKGLEN_GRAPHIRE,   6126,  4604,  255,  0, PL };
+        { "Wacom PL600",          WACOM_PKGLEN_GRAPHIRE,   6126,  4604,  255,
+          0, PL, WACOM_PL_RES, WACOM_PL_RES };
 static const struct wacom_features wacom_features_0x33 =
-        { "Wacom PL600SX",        WACOM_PKGLEN_GRAPHIRE,   6260,  5016,  255,  0, PL };
+        { "Wacom PL600SX",        WACOM_PKGLEN_GRAPHIRE,   6260,  5016,  255,
+          0, PL, WACOM_PL_RES, WACOM_PL_RES };
 static const struct wacom_features wacom_features_0x34 =
-        { "Wacom PL550",          WACOM_PKGLEN_GRAPHIRE,   6144,  4608,  511,  0, PL };
+        { "Wacom PL550",          WACOM_PKGLEN_GRAPHIRE,   6144,  4608,  511,
+          0, PL, WACOM_PL_RES, WACOM_PL_RES };
 static const struct wacom_features wacom_features_0x35 =
-        { "Wacom PL800",          WACOM_PKGLEN_GRAPHIRE,   7220,  5780,  511,  0, PL };
+        { "Wacom PL800",          WACOM_PKGLEN_GRAPHIRE,   7220,  5780,  511,
+          0, PL, WACOM_PL_RES, WACOM_PL_RES };
 static const struct wacom_features wacom_features_0x37 =
-        { "Wacom PL700",          WACOM_PKGLEN_GRAPHIRE,   6758,  5406,  511,  0, PL };
+        { "Wacom PL700",          WACOM_PKGLEN_GRAPHIRE,   6758,  5406,  511,
+          0, PL, WACOM_PL_RES, WACOM_PL_RES };
 static const struct wacom_features wacom_features_0x38 =
-        { "Wacom PL510",          WACOM_PKGLEN_GRAPHIRE,   6282,  4762,  511,  0, PL };
+        { "Wacom PL510",          WACOM_PKGLEN_GRAPHIRE,   6282,  4762,  511,
+          0, PL, WACOM_PL_RES, WACOM_PL_RES };
 static const struct wacom_features wacom_features_0x39 =
-        { "Wacom DTU710",         WACOM_PKGLEN_GRAPHIRE,  34080, 27660,  511,  0, PL };
+        { "Wacom DTU710",         WACOM_PKGLEN_GRAPHIRE,  34080, 27660,  511,
+          0, PL, WACOM_PL_RES, WACOM_PL_RES };
 static const struct wacom_features wacom_features_0xC4 =
-        { "Wacom DTF521",         WACOM_PKGLEN_GRAPHIRE,   6282,  4762,  511,  0, PL };
+        { "Wacom DTF521",         WACOM_PKGLEN_GRAPHIRE,   6282,  4762,  511,
+          0, PL, WACOM_PL_RES, WACOM_PL_RES };
 static const struct wacom_features wacom_features_0xC0 =
-        { "Wacom DTF720",         WACOM_PKGLEN_GRAPHIRE,   6858,  5506,  511,  0, PL };
+        { "Wacom DTF720",         WACOM_PKGLEN_GRAPHIRE,   6858,  5506,  511,
+          0, PL, WACOM_PL_RES, WACOM_PL_RES };
 static const struct wacom_features wacom_features_0xC2 =
-        { "Wacom DTF720a",        WACOM_PKGLEN_GRAPHIRE,   6858,  5506,  511,  0, PL };
+        { "Wacom DTF720a",        WACOM_PKGLEN_GRAPHIRE,   6858,  5506,  511,
+          0, PL, WACOM_PL_RES, WACOM_PL_RES };
 static const struct wacom_features wacom_features_0x03 =
-        { "Wacom Cintiq Partner", WACOM_PKGLEN_GRAPHIRE,  20480, 15360,  511,  0, PTU };
+        { "Wacom Cintiq Partner", WACOM_PKGLEN_GRAPHIRE,  20480, 15360,  511,
+          0, PTU, WACOM_PL_RES, WACOM_PL_RES };
 static const struct wacom_features wacom_features_0x41 =
-        { "Wacom Intuos2 4x5",    WACOM_PKGLEN_INTUOS,    12700, 10600, 1023, 31, INTUOS };
+        { "Wacom Intuos2 4x5",    WACOM_PKGLEN_INTUOS,    12700, 10600, 1023,
+          31, INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
 static const struct wacom_features wacom_features_0x42 =
-        { "Wacom Intuos2 6x8",    WACOM_PKGLEN_INTUOS,    20320, 16240, 1023, 31, INTUOS };
+        { "Wacom Intuos2 6x8",    WACOM_PKGLEN_INTUOS,    20320, 16240, 1023,
+          31, INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
 static const struct wacom_features wacom_features_0x43 =
-        { "Wacom Intuos2 9x12",   WACOM_PKGLEN_INTUOS,    30480, 24060, 1023, 31, INTUOS };
+        { "Wacom Intuos2 9x12",   WACOM_PKGLEN_INTUOS,    30480, 24060, 1023,
+          31, INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
 static const struct wacom_features wacom_features_0x44 =
-        { "Wacom Intuos2 12x12",  WACOM_PKGLEN_INTUOS,    30480, 31680, 1023, 31, INTUOS };
+        { "Wacom Intuos2 12x12",  WACOM_PKGLEN_INTUOS,    30480, 31680, 1023,
+          31, INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
 static const struct wacom_features wacom_features_0x45 =
-        { "Wacom Intuos2 12x18",  WACOM_PKGLEN_INTUOS,    45720, 31680, 1023, 31, INTUOS };
+        { "Wacom Intuos2 12x18",  WACOM_PKGLEN_INTUOS,    45720, 31680, 1023,
+          31, INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
 static const struct wacom_features wacom_features_0xB0 =
-        { "Wacom Intuos3 4x5",    WACOM_PKGLEN_INTUOS,    25400, 20320, 1023, 63, INTUOS3S };
+        { "Wacom Intuos3 4x5",    WACOM_PKGLEN_INTUOS,    25400, 20320, 1023,
+          63, INTUOS3S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
 static const struct wacom_features wacom_features_0xB1 =
-        { "Wacom Intuos3 6x8",    WACOM_PKGLEN_INTUOS,    40640, 30480, 1023, 63, INTUOS3 };
+        { "Wacom Intuos3 6x8",    WACOM_PKGLEN_INTUOS,    40640, 30480, 1023,
+          63, INTUOS3, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
 static const struct wacom_features wacom_features_0xB2 =
-        { "Wacom Intuos3 9x12",   WACOM_PKGLEN_INTUOS,    60960, 45720, 1023, 63, INTUOS3 };
+        { "Wacom Intuos3 9x12",   WACOM_PKGLEN_INTUOS,    60960, 45720, 1023,
+          63, INTUOS3, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
 static const struct wacom_features wacom_features_0xB3 =
-        { "Wacom Intuos3 12x12",  WACOM_PKGLEN_INTUOS,    60960, 60960, 1023, 63, INTUOS3L };
+        { "Wacom Intuos3 12x12",  WACOM_PKGLEN_INTUOS,    60960, 60960, 1023,
+          63, INTUOS3L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
 static const struct wacom_features wacom_features_0xB4 =
-        { "Wacom Intuos3 12x19",  WACOM_PKGLEN_INTUOS,    97536, 60960, 1023, 63, INTUOS3L };
+        { "Wacom Intuos3 12x19",  WACOM_PKGLEN_INTUOS,    97536, 60960, 1023,
+          63, INTUOS3L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
 static const struct wacom_features wacom_features_0xB5 =
-        { "Wacom Intuos3 6x11",   WACOM_PKGLEN_INTUOS,    54204, 31750, 1023, 63, INTUOS3 };
+        { "Wacom Intuos3 6x11",   WACOM_PKGLEN_INTUOS,    54204, 31750, 1023,
+          63, INTUOS3, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
 static const struct wacom_features wacom_features_0xB7 =
-        { "Wacom Intuos3 4x6",    WACOM_PKGLEN_INTUOS,    31496, 19685, 1023, 63, INTUOS3S };
+        { "Wacom Intuos3 4x6",    WACOM_PKGLEN_INTUOS,    31496, 19685, 1023,
+          63, INTUOS3S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
 static const struct wacom_features wacom_features_0xB8 =
-        { "Wacom Intuos4 4x6",    WACOM_PKGLEN_INTUOS,    31496, 19685, 2047, 63, INTUOS4S };
+        { "Wacom Intuos4 4x6",    WACOM_PKGLEN_INTUOS,    31496, 19685, 2047,
+          63, INTUOS4S, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
 static const struct wacom_features wacom_features_0xB9 =
-        { "Wacom Intuos4 6x9",    WACOM_PKGLEN_INTUOS,    44704, 27940, 2047, 63, INTUOS4 };
+        { "Wacom Intuos4 6x9",    WACOM_PKGLEN_INTUOS,    44704, 27940, 2047,
+          63, INTUOS4, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
 static const struct wacom_features wacom_features_0xBA =
-        { "Wacom Intuos4 8x13",   WACOM_PKGLEN_INTUOS,    65024, 40640, 2047, 63, INTUOS4L };
+        { "Wacom Intuos4 8x13",   WACOM_PKGLEN_INTUOS,    65024, 40640, 2047,
+          63, INTUOS4L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
 static const struct wacom_features wacom_features_0xBB =
-        { "Wacom Intuos4 12x19",  WACOM_PKGLEN_INTUOS,    97536, 60960, 2047, 63, INTUOS4L };
+        { "Wacom Intuos4 12x19",  WACOM_PKGLEN_INTUOS,    97536, 60960, 2047,
+          63, INTUOS4L, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
 static const struct wacom_features wacom_features_0xBC =
-        { "Wacom Intuos4 WL",     WACOM_PKGLEN_INTUOS,    40840, 25400, 2047, 63, INTUOS4 };
+        { "Wacom Intuos4 WL",     WACOM_PKGLEN_INTUOS,    40840, 25400, 2047,
+          63, INTUOS4, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
 static const struct wacom_features wacom_features_0x3F =
-        { "Wacom Cintiq 21UX",    WACOM_PKGLEN_INTUOS,    87200, 65600, 1023, 63, CINTIQ };
+        { "Wacom Cintiq 21UX",    WACOM_PKGLEN_INTUOS,    87200, 65600, 1023,
+          63, CINTIQ, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
 static const struct wacom_features wacom_features_0xC5 =
-        { "Wacom Cintiq 20WSX",   WACOM_PKGLEN_INTUOS,    86680, 54180, 1023, 63, WACOM_BEE };
+        { "Wacom Cintiq 20WSX",   WACOM_PKGLEN_INTUOS,    86680, 54180, 1023,
+          63, WACOM_BEE, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
 static const struct wacom_features wacom_features_0xC6 =
-        { "Wacom Cintiq 12WX",    WACOM_PKGLEN_INTUOS,    53020, 33440, 1023, 63, WACOM_BEE };
+        { "Wacom Cintiq 12WX",    WACOM_PKGLEN_INTUOS,    53020, 33440, 1023,
+          63, WACOM_BEE, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
 static const struct wacom_features wacom_features_0xC7 =
-        { "Wacom DTU1931",        WACOM_PKGLEN_GRAPHIRE,  37832, 30305,  511,  0, PL };
+        { "Wacom DTU1931",        WACOM_PKGLEN_GRAPHIRE,  37832, 30305,  511,
+          0, PL, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
 static const struct wacom_features wacom_features_0xCE =
-        { "Wacom DTU2231",        WACOM_PKGLEN_GRAPHIRE,  47864, 27011,  511,  0, DTU };
+        { "Wacom DTU2231",        WACOM_PKGLEN_GRAPHIRE,  47864, 27011,  511,
+          0, DTU, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
 static const struct wacom_features wacom_features_0xF0 =
-        { "Wacom DTU1631",        WACOM_PKGLEN_GRAPHIRE,  34623, 19553,  511,  0, DTU };
+        { "Wacom DTU1631",        WACOM_PKGLEN_GRAPHIRE,  34623, 19553,  511,
+          0, DTU, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
 static const struct wacom_features wacom_features_0xCC =
-        { "Wacom Cintiq 21UX2",   WACOM_PKGLEN_INTUOS,    87200, 65600, 2047, 63, WACOM_21UX2 };
+        { "Wacom Cintiq 21UX2",   WACOM_PKGLEN_INTUOS,    87200, 65600, 2047,
+          63, WACOM_21UX2, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
 static const struct wacom_features wacom_features_0x90 =
-        { "Wacom ISDv4 90",       WACOM_PKGLEN_GRAPHIRE,  26202, 16325,  255,  0, TABLETPC };
+        { "Wacom ISDv4 90",       WACOM_PKGLEN_GRAPHIRE,  26202, 16325,  255,
+          0, TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
 static const struct wacom_features wacom_features_0x93 =
-        { "Wacom ISDv4 93",       WACOM_PKGLEN_GRAPHIRE,  26202, 16325,  255,  0, TABLETPC };
+        { "Wacom ISDv4 93",       WACOM_PKGLEN_GRAPHIRE,  26202, 16325,  255,
+          0, TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
 static const struct wacom_features wacom_features_0x9A =
-        { "Wacom ISDv4 9A",       WACOM_PKGLEN_GRAPHIRE,  26202, 16325,  255,  0, TABLETPC };
+        { "Wacom ISDv4 9A",       WACOM_PKGLEN_GRAPHIRE,  26202, 16325,  255,
+          0, TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
 static const struct wacom_features wacom_features_0x9F =
-        { "Wacom ISDv4 9F",       WACOM_PKGLEN_GRAPHIRE,  26202, 16325,  255,  0, TABLETPC };
+        { "Wacom ISDv4 9F",       WACOM_PKGLEN_GRAPHIRE,  26202, 16325,  255,
+          0, TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
 static const struct wacom_features wacom_features_0xE2 =
-        { "Wacom ISDv4 E2",       WACOM_PKGLEN_TPC2FG,    26202, 16325,  255,  0, TABLETPC2FG };
+        { "Wacom ISDv4 E2",       WACOM_PKGLEN_TPC2FG,    26202, 16325,  255,
+          0, TABLETPC2FG, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
 static const struct wacom_features wacom_features_0xE3 =
-        { "Wacom ISDv4 E3",       WACOM_PKGLEN_TPC2FG,    26202, 16325,  255,  0, TABLETPC2FG };
+        { "Wacom ISDv4 E3",       WACOM_PKGLEN_TPC2FG,    26202, 16325,  255,
+          0, TABLETPC2FG, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
+static const struct wacom_features wacom_features_0xE6 =
+        { "Wacom ISDv4 E6",       WACOM_PKGLEN_TPC2FG,    27760, 15694,  255,
+          0, TABLETPC2FG, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
 static const struct wacom_features wacom_features_0x47 =
-        { "Wacom Intuos2 6x8",    WACOM_PKGLEN_INTUOS,    20320, 16240, 1023, 31, INTUOS };
+        { "Wacom Intuos2 6x8",    WACOM_PKGLEN_INTUOS,    20320, 16240, 1023,
+          31, INTUOS, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
+static const struct wacom_features wacom_features_0xD0 =
+        { "Wacom Bamboo 2FG",     WACOM_PKGLEN_BBFUN,     14720,  9200, 1023,
+          63, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
+static const struct wacom_features wacom_features_0xD1 =
+        { "Wacom Bamboo 2FG 4x5", WACOM_PKGLEN_BBFUN,     14720,  9200, 1023,
+          63, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
+static const struct wacom_features wacom_features_0xD2 =
+        { "Wacom Bamboo Craft",   WACOM_PKGLEN_BBFUN,     14720,  9200, 1023,
+          63, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
+static const struct wacom_features wacom_features_0xD3 =
+        { "Wacom Bamboo 2FG 6x8", WACOM_PKGLEN_BBFUN,     21648, 13530, 1023,
+          63, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
+static const struct wacom_features wacom_features_0xD4 =
+        { "Wacom Bamboo Pen",     WACOM_PKGLEN_BBFUN,     14720,  9200,  255,
+          63, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
+static const struct wacom_features wacom_features_0xD6 =
+        { "Wacom BambooPT 2FG 4x5", WACOM_PKGLEN_BBFUN,   14720,  9200, 1023,
+          63, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
+static const struct wacom_features wacom_features_0xD7 =
+        { "Wacom BambooPT 2FG Small", WACOM_PKGLEN_BBFUN, 14720,  9200, 1023,
+          63, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
+static const struct wacom_features wacom_features_0xD8 =
+        { "Wacom Bamboo Comic 2FG", WACOM_PKGLEN_BBFUN,   21648, 13530, 1023,
+          63, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
+static const struct wacom_features wacom_features_0xDA =
+        { "Wacom Bamboo 2FG 4x5 SE", WACOM_PKGLEN_BBFUN,  14720,  9200, 1023,
+          63, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
+static struct wacom_features wacom_features_0xDB =
+        { "Wacom Bamboo 2FG 6x8 SE", WACOM_PKGLEN_BBFUN,  21648, 13530, 1023,
+          63, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
+static const struct wacom_features wacom_features_0x6004 =
+        { "ISD-V4",               WACOM_PKGLEN_GRAPHIRE,  12800,  8000,  255,
+          0, TABLETPC, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
 
 #define USB_DEVICE_WACOM(prod)                                  \
         USB_DEVICE(USB_VENDOR_ID_WACOM, prod),                  \
         .driver_info = (kernel_ulong_t)&wacom_features_##prod
 
+#define USB_DEVICE_LENOVO(prod)                                 \
+        USB_DEVICE(USB_VENDOR_ID_LENOVO, prod),                 \
+        .driver_info = (kernel_ulong_t)&wacom_features_##prod
+
 const struct usb_device_id wacom_ids[] = {
         { USB_DEVICE_WACOM(0x00) },
         { USB_DEVICE_WACOM(0x10) },
@@ -1279,6 +1546,16 @@ const struct usb_device_id wacom_ids[] = {
         { USB_DEVICE_WACOM(0xC6) },
         { USB_DEVICE_WACOM(0xC7) },
         { USB_DEVICE_WACOM(0xCE) },
+        { USB_DEVICE_WACOM(0xD0) },
+        { USB_DEVICE_WACOM(0xD1) },
+        { USB_DEVICE_WACOM(0xD2) },
+        { USB_DEVICE_WACOM(0xD3) },
+        { USB_DEVICE_WACOM(0xD4) },
+        { USB_DEVICE_WACOM(0xD6) },
+        { USB_DEVICE_WACOM(0xD7) },
+        { USB_DEVICE_WACOM(0xD8) },
+        { USB_DEVICE_WACOM(0xDA) },
+        { USB_DEVICE_WACOM(0xDB) },
         { USB_DEVICE_WACOM(0xF0) },
         { USB_DEVICE_WACOM(0xCC) },
         { USB_DEVICE_WACOM(0x90) },
@@ -1287,7 +1564,9 @@ const struct usb_device_id wacom_ids[] = {
         { USB_DEVICE_WACOM(0x9F) },
         { USB_DEVICE_WACOM(0xE2) },
         { USB_DEVICE_WACOM(0xE3) },
+        { USB_DEVICE_WACOM(0xE6) },
         { USB_DEVICE_WACOM(0x47) },
+        { USB_DEVICE_LENOVO(0x6004) },
         { }
 };
 MODULE_DEVICE_TABLE(usb, wacom_ids);
diff --git a/drivers/input/tablet/wacom_wac.h b/drivers/input/tablet/wacom_wac.h
index 99e1a54cd305..53eb71b68330 100644
--- a/drivers/input/tablet/wacom_wac.h
+++ b/drivers/input/tablet/wacom_wac.h
@@ -21,6 +21,7 @@
 #define WACOM_PKGLEN_INTUOS     10
 #define WACOM_PKGLEN_TPC1FG      5
 #define WACOM_PKGLEN_TPC2FG     14
+#define WACOM_PKGLEN_BBTOUCH    20
 
 /* device IDs */
 #define STYLUS_DEVICE_ID        0x02
@@ -37,6 +38,10 @@
 #define WACOM_REPORT_TPC1FG             6
 #define WACOM_REPORT_TPC2FG             13
 
+/* device quirks */
+#define WACOM_QUIRK_MULTI_INPUT         0x0001
+#define WACOM_QUIRK_BBTOUCH_LOWRES      0x0002
+
 enum {
         PENPARTNER = 0,
         GRAPHIRE,
@@ -44,6 +49,7 @@ enum {
         PTU,
         PL,
         DTU,
+        BAMBOO_PT,
         INTUOS,
         INTUOS3S,
         INTUOS3,
@@ -68,24 +74,31 @@ struct wacom_features {
         int pressure_max;
         int distance_max;
         int type;
+        int x_resolution;
+        int y_resolution;
         int device_type;
         int x_phy;
         int y_phy;
         unsigned char unit;
         unsigned char unitExpo;
+        int x_fuzz;
+        int y_fuzz;
+        int pressure_fuzz;
+        int distance_fuzz;
+        unsigned quirks;
 };
 
 struct wacom_shared {
         bool stylus_in_proximity;
+        bool touch_down;
 };
 
 struct wacom_wac {
         char name[64];
         unsigned char *data;
-        int tool[3];
-        int id[3];
+        int tool[2];
+        int id[2];
         __u32 serial[2];
-        int last_finger;
         struct wacom_features features;
         struct wacom_shared *shared;
         struct input_dev *input;
diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig
index 0069d9703fda..cabd9e54863f 100644
--- a/drivers/input/touchscreen/Kconfig
+++ b/drivers/input/touchscreen/Kconfig
@@ -86,6 +86,18 @@ config TOUCHSCREEN_AD7879_SPI
           To compile this driver as a module, choose M here: the
           module will be called ad7879-spi.
 
+config TOUCHSCREEN_ATMEL_MXT
+        tristate "Atmel mXT I2C Touchscreen"
+        depends on I2C
+        help
+          Say Y here if you have Atmel mXT series I2C touchscreen,
+          such as AT42QT602240/ATMXT224, connected to your system.
+
+          If unsure, say N.
+
+          To compile this driver as a module, choose M here: the
+          module will be called atmel_mxt_ts.
+
 config TOUCHSCREEN_BITSY
         tristate "Compaq iPAQ H3600 (Bitsy) touchscreen"
         depends on SA1100_BITSY
@@ -98,6 +110,18 @@ config TOUCHSCREEN_BITSY
           To compile this driver as a module, choose M here: the
           module will be called h3600_ts_input.
 
+config TOUCHSCREEN_BU21013
+        tristate "BU21013 based touch panel controllers"
+        depends on I2C
+        help
+          Say Y here if you have a bu21013 touchscreen connected to
+          your system.
+
+          If unsure, say N.
+
+          To compile this driver as a module, choose M here: the
+          module will be called bu21013_ts.
+
 config TOUCHSCREEN_CY8CTMG110
         tristate "cy8ctmg110 touchscreen"
         depends on I2C
@@ -214,6 +238,28 @@ config TOUCHSCREEN_WACOM_W8001
           To compile this driver as a module, choose M here: the
           module will be called wacom_w8001.
 
+config TOUCHSCREEN_LPC32XX
+        tristate "LPC32XX touchscreen controller"
+        depends on ARCH_LPC32XX
+        help
+          Say Y here if you have a LPC32XX device and want
+          to support the built-in touchscreen.
+
+          To compile this driver as a module, choose M here: the
+          module will be called lpc32xx_ts.
+
+config TOUCHSCREEN_MAX11801
+        tristate "MAX11801 based touchscreens"
+        depends on I2C
+        help
+          Say Y here if you have a MAX11801 based touchscreen
+          controller.
+
+          If unsure, say N.
+
+          To compile this driver as a module, choose M here: the
+          module will be called max11801_ts.
+
 config TOUCHSCREEN_MCS5000
         tristate "MELFAS MCS-5000 touchscreen"
         depends on I2C
@@ -250,6 +296,18 @@ config TOUCHSCREEN_INEXIO
           To compile this driver as a module, choose M here: the
           module will be called inexio.
 
+config TOUCHSCREEN_INTEL_MID
+        tristate "Intel MID platform resistive touchscreen"
+        depends on INTEL_SCU_IPC
+        help
+          Say Y here if you have a Intel MID based touchscreen in
+          your system.
+
+          If unsure, say N.
+
+          To compile this driver as a module, choose M here: the
+          module will be called intel_mid_touch.
+
 config TOUCHSCREEN_MK712
         tristate "ICS MicroClock MK712 touchscreen"
         help
@@ -305,18 +363,6 @@ config TOUCHSCREEN_PENMOUNT
           To compile this driver as a module, choose M here: the
           module will be called penmount.
 
-config TOUCHSCREEN_QT602240
-        tristate "QT602240 I2C Touchscreen"
-        depends on I2C
-        help
-          Say Y here if you have the AT42QT602240/ATMXT224 I2C touchscreen
-          connected to your system.
-
-          If unsure, say N.
-
-          To compile this driver as a module, choose M here: the
-          module will be called qt602240_ts.
-
 config TOUCHSCREEN_MIGOR
         tristate "Renesas MIGO-R touchscreen"
         depends on SH_MIGOR && I2C
@@ -328,6 +374,15 @@ config TOUCHSCREEN_MIGOR
           To compile this driver as a module, choose M here: the
           module will be called migor_ts.
 
+config TOUCHSCREEN_TNETV107X
+        tristate "TI TNETV107X touchscreen support"
+        depends on ARCH_DAVINCI_TNETV107X
+        help
+          Say Y here if you want to use the TNETV107X touchscreen.
+
+          To compile this driver as a module, choose M here: the
+          module will be called tnetv107x-ts.
+
 config TOUCHSCREEN_TOUCHRIGHT
         tristate "Touchright serial touchscreen"
         select SERIO
@@ -380,6 +435,16 @@ config TOUCHSCREEN_UCB1400
           To compile this driver as a module, choose M here: the
           module will be called ucb1400_ts.
 
+config TOUCHSCREEN_WM831X
+        tristate "Support for WM831x touchscreen controllers"
+        depends on MFD_WM831X
+        help
+          This enables support for the touchscreen controller on the WM831x
+          series of PMICs.
+
+          To compile this driver as a module, choose M here: the
+          module will be called wm831x-ts.
+
 config TOUCHSCREEN_WM97XX
         tristate "Support for WM97xx AC97 touchscreen controllers"
         depends on AC97_BUS
@@ -497,62 +562,62 @@ config TOUCHSCREEN_MC13783
 
 config TOUCHSCREEN_USB_EGALAX
         default y
-        bool "eGalax, eTurboTouch CT-410/510/700 device support" if EMBEDDED
+        bool "eGalax, eTurboTouch CT-410/510/700 device support" if EXPERT
         depends on TOUCHSCREEN_USB_COMPOSITE
 
 config TOUCHSCREEN_USB_PANJIT
         default y
-        bool "PanJit device support" if EMBEDDED
+        bool "PanJit device support" if EXPERT
         depends on TOUCHSCREEN_USB_COMPOSITE
 
 config TOUCHSCREEN_USB_3M
         default y
-        bool "3M/Microtouch EX II series device support" if EMBEDDED
+        bool "3M/Microtouch EX II series device support" if EXPERT
         depends on TOUCHSCREEN_USB_COMPOSITE
 
 config TOUCHSCREEN_USB_ITM
         default y
-        bool "ITM device support" if EMBEDDED
+        bool "ITM device support" if EXPERT
         depends on TOUCHSCREEN_USB_COMPOSITE
 
 config TOUCHSCREEN_USB_ETURBO
         default y
-        bool "eTurboTouch (non-eGalax compatible) device support" if EMBEDDED
+        bool "eTurboTouch (non-eGalax compatible) device support" if EXPERT
         depends on TOUCHSCREEN_USB_COMPOSITE
 
 config TOUCHSCREEN_USB_GUNZE
         default y
-        bool "Gunze AHL61 device support" if EMBEDDED
+        bool "Gunze AHL61 device support" if EXPERT
         depends on TOUCHSCREEN_USB_COMPOSITE
 
 config TOUCHSCREEN_USB_DMC_TSC10
         default y
-        bool "DMC TSC-10/25 device support" if EMBEDDED
+        bool "DMC TSC-10/25 device support" if EXPERT
         depends on TOUCHSCREEN_USB_COMPOSITE
 
 config TOUCHSCREEN_USB_IRTOUCH
         default y
-        bool "IRTOUCHSYSTEMS/UNITOP device support" if EMBEDDED
+        bool "IRTOUCHSYSTEMS/UNITOP device support" if EXPERT
         depends on TOUCHSCREEN_USB_COMPOSITE
 
 config TOUCHSCREEN_USB_IDEALTEK
         default y
-        bool "IdealTEK URTC1000 device support" if EMBEDDED
+        bool "IdealTEK URTC1000 device support" if EXPERT
         depends on TOUCHSCREEN_USB_COMPOSITE
 
 config TOUCHSCREEN_USB_GENERAL_TOUCH
         default y
-        bool "GeneralTouch Touchscreen device support" if EMBEDDED
+        bool "GeneralTouch Touchscreen device support" if EXPERT
         depends on TOUCHSCREEN_USB_COMPOSITE
 
 config TOUCHSCREEN_USB_GOTOP
         default y
-        bool "GoTop Super_Q2/GogoPen/PenPower tablet device support" if EMBEDDED
+        bool "GoTop Super_Q2/GogoPen/PenPower tablet device support" if EXPERT
         depends on TOUCHSCREEN_USB_COMPOSITE
 
 config TOUCHSCREEN_USB_JASTEC
         default y
-        bool "JASTEC/DigiTech DTR-02U USB touch controller device support" if EMBEDDED
+        bool "JASTEC/DigiTech DTR-02U USB touch controller device support" if EXPERT
         depends on TOUCHSCREEN_USB_COMPOSITE
 
 config TOUCHSCREEN_USB_E2I
@@ -562,17 +627,17 @@ config TOUCHSCREEN_USB_E2I
 
 config TOUCHSCREEN_USB_ZYTRONIC
         default y
-        bool "Zytronic controller" if EMBEDDED
+        bool "Zytronic controller" if EXPERT
         depends on TOUCHSCREEN_USB_COMPOSITE
 
 config TOUCHSCREEN_USB_ETT_TC45USB
         default y
-        bool "ET&T USB series TC4UM/TC5UH touchscreen controler support" if EMBEDDED
+        bool "ET&T USB series TC4UM/TC5UH touchscreen controller support" if EXPERT
         depends on TOUCHSCREEN_USB_COMPOSITE
 
 config TOUCHSCREEN_USB_NEXIO
         default y
-        bool "NEXIO/iNexio device support" if EMBEDDED
+        bool "NEXIO/iNexio device support" if EXPERT
         depends on TOUCHSCREEN_USB_COMPOSITE
 
 config TOUCHSCREEN_TOUCHIT213
@@ -586,6 +651,17 @@ config TOUCHSCREEN_TOUCHIT213
           To compile this driver as a module, choose M here: the
           module will be called touchit213.
 
+config TOUCHSCREEN_TSC2005
+        tristate "TSC2005 based touchscreens"
+        depends on SPI_MASTER && GENERIC_HARDIRQS
+        help
+          Say Y here if you have a TSC2005 based touchscreen.
+
+          If unsure, say N.
+
+          To compile this driver as a module, choose M here: the
+          module will be called tsc2005.
+
 config TOUCHSCREEN_TSC2007
         tristate "TSC2007 based touchscreens"
         depends on I2C
@@ -616,17 +692,17 @@ config TOUCHSCREEN_PCAP
           To compile this driver as a module, choose M here: the
           module will be called pcap_ts.
 
-config TOUCHSCREEN_TPS6507X
-        tristate "TPS6507x based touchscreens"
+config TOUCHSCREEN_ST1232
+        tristate "Sitronix ST1232 touchscreen controllers"
         depends on I2C
         help
-          Say Y here if you have a TPS6507x based touchscreen
-          controller.
+          Say Y here if you want to support Sitronix ST1232
+          touchscreen controller.
 
           If unsure, say N.
 
           To compile this driver as a module, choose M here: the
-          module will be called tps6507x_ts.
+          module will be called st1232_ts.
 
 config TOUCHSCREEN_STMPE
         tristate "STMicroelectronics STMPE touchscreens"
@@ -638,4 +714,16 @@ config TOUCHSCREEN_STMPE
           To compile this driver as a module, choose M here: the
           module will be called stmpe-ts.
 
+config TOUCHSCREEN_TPS6507X
+        tristate "TPS6507x based touchscreens"
+        depends on I2C
+        help
+          Say Y here if you have a TPS6507x based touchscreen
+          controller.
+
+          If unsure, say N.
+
+          To compile this driver as a module, choose M here: the
+          module will be called tps6507x_ts.
+
 endif
diff --git a/drivers/input/touchscreen/Makefile b/drivers/input/touchscreen/Makefile
index 28217e1dcafd..282d6f76ae26 100644
--- a/drivers/input/touchscreen/Makefile
+++ b/drivers/input/touchscreen/Makefile
@@ -12,8 +12,10 @@ obj-$(CONFIG_TOUCHSCREEN_AD7879)	+= ad7879.o
 obj-$(CONFIG_TOUCHSCREEN_AD7879_I2C)    += ad7879-i2c.o
 obj-$(CONFIG_TOUCHSCREEN_AD7879_SPI)    += ad7879-spi.o
 obj-$(CONFIG_TOUCHSCREEN_ADS7846)       += ads7846.o
+obj-$(CONFIG_TOUCHSCREEN_ATMEL_MXT)     += atmel_mxt_ts.o
 obj-$(CONFIG_TOUCHSCREEN_ATMEL_TSADCC)  += atmel_tsadcc.o
 obj-$(CONFIG_TOUCHSCREEN_BITSY)         += h3600_ts_input.o
+obj-$(CONFIG_TOUCHSCREEN_BU21013)       += bu21013_ts.o
 obj-$(CONFIG_TOUCHSCREEN_CY8CTMG110)    += cy8ctmg110_ts.o
 obj-$(CONFIG_TOUCHSCREEN_DA9034)        += da9034-ts.o
 obj-$(CONFIG_TOUCHSCREEN_DYNAPRO)       += dynapro.o
@@ -23,6 +25,9 @@ obj-$(CONFIG_TOUCHSCREEN_EETI)		+= eeti_ts.o
 obj-$(CONFIG_TOUCHSCREEN_ELO)           += elo.o
 obj-$(CONFIG_TOUCHSCREEN_FUJITSU)       += fujitsu_ts.o
 obj-$(CONFIG_TOUCHSCREEN_INEXIO)        += inexio.o
+obj-$(CONFIG_TOUCHSCREEN_INTEL_MID)     += intel-mid-touch.o
+obj-$(CONFIG_TOUCHSCREEN_LPC32XX)       += lpc32xx_ts.o
+obj-$(CONFIG_TOUCHSCREEN_MAX11801)      += max11801_ts.o
 obj-$(CONFIG_TOUCHSCREEN_MC13783)       += mc13783_ts.o
 obj-$(CONFIG_TOUCHSCREEN_MCS5000)       += mcs5000_ts.o
 obj-$(CONFIG_TOUCHSCREEN_MIGOR)         += migor_ts.o
@@ -34,15 +39,18 @@ obj-$(CONFIG_TOUCHSCREEN_HTCPEN)	+= htcpen.o
 obj-$(CONFIG_TOUCHSCREEN_USB_COMPOSITE) += usbtouchscreen.o
 obj-$(CONFIG_TOUCHSCREEN_PCAP)          += pcap_ts.o
 obj-$(CONFIG_TOUCHSCREEN_PENMOUNT)      += penmount.o
-obj-$(CONFIG_TOUCHSCREEN_QT602240)      += qt602240_ts.o
 obj-$(CONFIG_TOUCHSCREEN_S3C2410)       += s3c2410_ts.o
+obj-$(CONFIG_TOUCHSCREEN_ST1232)        += st1232.o
 obj-$(CONFIG_TOUCHSCREEN_STMPE)         += stmpe-ts.o
+obj-$(CONFIG_TOUCHSCREEN_TNETV107X)     += tnetv107x-ts.o
 obj-$(CONFIG_TOUCHSCREEN_TOUCHIT213)    += touchit213.o
 obj-$(CONFIG_TOUCHSCREEN_TOUCHRIGHT)    += touchright.o
 obj-$(CONFIG_TOUCHSCREEN_TOUCHWIN)      += touchwin.o
+obj-$(CONFIG_TOUCHSCREEN_TSC2005)       += tsc2005.o
 obj-$(CONFIG_TOUCHSCREEN_TSC2007)       += tsc2007.o
 obj-$(CONFIG_TOUCHSCREEN_UCB1400)       += ucb1400_ts.o
 obj-$(CONFIG_TOUCHSCREEN_WACOM_W8001)   += wacom_w8001.o
+obj-$(CONFIG_TOUCHSCREEN_WM831X)        += wm831x-ts.o
 obj-$(CONFIG_TOUCHSCREEN_WM97XX)        += wm97xx-ts.o
 wm97xx-ts-$(CONFIG_TOUCHSCREEN_WM9705)  += wm9705.o
 wm97xx-ts-$(CONFIG_TOUCHSCREEN_WM9712)  += wm9712.o
diff --git a/drivers/input/touchscreen/ad7877.c b/drivers/input/touchscreen/ad7877.c
index 5f0221cffef9..714d4e0f9f95 100644
--- a/drivers/input/touchscreen/ad7877.c
+++ b/drivers/input/touchscreen/ad7877.c
@@ -41,6 +41,7 @@
 #include <linux/delay.h>
 #include <linux/input.h>
 #include <linux/interrupt.h>
+#include <linux/pm.h>
 #include <linux/slab.h>
 #include <linux/spi/spi.h>
 #include <linux/spi/ad7877.h>
@@ -191,13 +192,12 @@ struct ad7877 {
         struct spi_message      msg;
 
         struct mutex            mutex;
-        unsigned                disabled:1;     /* P: mutex */
-        unsigned                gpio3:1;        /* P: mutex */
-        unsigned                gpio4:1;        /* P: mutex */
+        bool                    disabled;       /* P: mutex */
+        bool                    gpio3;          /* P: mutex */
+        bool                    gpio4;          /* P: mutex */
 
         spinlock_t              lock;
         struct timer_list       timer;          /* P: lock */
-        unsigned                pending:1;      /* P: lock */
 
         /*
          * DMA (thus cache coherency maintenance) requires the
@@ -206,8 +206,8 @@ struct ad7877 {
         u16 conversion_data[AD7877_NR_SENSE] ____cacheline_aligned;
 };
 
-static int gpio3;
-module_param(gpio3, int, 0);
+static bool gpio3;
+module_param(gpio3, bool, 0);
 MODULE_PARM_DESC(gpio3, "If gpio3 is set to 1 AUX3 acts as GPIO3");
 
 /*
@@ -230,6 +230,7 @@ static int ad7877_read(struct spi_device *spi, u16 reg)
                         AD7877_READADD(reg));
         req->xfer[0].tx_buf = &req->command;
         req->xfer[0].len = 2;
+        req->xfer[0].cs_change = 1;
 
         req->xfer[1].rx_buf = &req->sample;
         req->xfer[1].len = 2;
@@ -295,20 +296,25 @@ static int ad7877_read_adc(struct spi_device *spi, unsigned command)
 
         req->xfer[0].tx_buf = &req->reset;
         req->xfer[0].len = 2;
+        req->xfer[0].cs_change = 1;
 
         req->xfer[1].tx_buf = &req->ref_on;
         req->xfer[1].len = 2;
         req->xfer[1].delay_usecs = ts->vref_delay_usecs;
+        req->xfer[1].cs_change = 1;
 
         req->xfer[2].tx_buf = &req->command;
         req->xfer[2].len = 2;
         req->xfer[2].delay_usecs = ts->vref_delay_usecs;
+        req->xfer[2].cs_change = 1;
 
         req->xfer[3].rx_buf = &req->sample;
         req->xfer[3].len = 2;
+        req->xfer[3].cs_change = 1;
 
         req->xfer[4].tx_buf = &ts->cmd_crtl2;   /*REF OFF*/
         req->xfer[4].len = 2;
+        req->xfer[4].cs_change = 1;
 
         req->xfer[5].tx_buf = &ts->cmd_crtl1;   /*DEFAULT*/
         req->xfer[5].len = 2;
@@ -327,7 +333,7 @@ static int ad7877_read_adc(struct spi_device *spi, unsigned command)
         return status ? : sample;
 }
 
-static void ad7877_rx(struct ad7877 *ts)
+static int ad7877_process_data(struct ad7877 *ts)
 {
         struct input_dev *input_dev = ts->input;
         unsigned Rt;
@@ -354,11 +360,25 @@ static void ad7877_rx(struct ad7877 *ts)
                 Rt /= z1;
                 Rt = (Rt + 2047) >> 12;
 
+                /*
+                 * Sample found inconsistent, pressure is beyond
+                 * the maximum. Don't report it to user space.
+                 */
+                if (Rt > ts->pressure_max)
+                        return -EINVAL;
+
+                if (!timer_pending(&ts->timer))
+                        input_report_key(input_dev, BTN_TOUCH, 1);
+
                 input_report_abs(input_dev, ABS_X, x);
                 input_report_abs(input_dev, ABS_Y, y);
                 input_report_abs(input_dev, ABS_PRESSURE, Rt);
                 input_sync(input_dev);
+
+                return 0;
         }
+
+        return -EINVAL;
 }
 
 static inline void ad7877_ts_event_release(struct ad7877 *ts)
@@ -366,72 +386,56 @@ static inline void ad7877_ts_event_release(struct ad7877 *ts)
         struct input_dev *input_dev = ts->input;
 
         input_report_abs(input_dev, ABS_PRESSURE, 0);
+        input_report_key(input_dev, BTN_TOUCH, 0);
         input_sync(input_dev);
 }
 
 static void ad7877_timer(unsigned long handle)
 {
         struct ad7877 *ts = (void *)handle;
+        unsigned long flags;
 
+        spin_lock_irqsave(&ts->lock, flags);
         ad7877_ts_event_release(ts);
+        spin_unlock_irqrestore(&ts->lock, flags);
 }
 
 static irqreturn_t ad7877_irq(int irq, void *handle)
 {
         struct ad7877 *ts = handle;
         unsigned long flags;
-        int status;
+        int error;
 
-        /*
-         * The repeated conversion sequencer controlled by TMR kicked off
-         * too fast. We ignore the last and process the sample sequence
-         * currently in the queue. It can't be older than 9.4ms, and we
-         * need to avoid that ts->msg doesn't get issued twice while in work.
-         */
+        error = spi_sync(ts->spi, &ts->msg);
+        if (error) {
+                dev_err(&ts->spi->dev, "spi_sync --> %d\n", error);
+                goto out;
+        }
 
         spin_lock_irqsave(&ts->lock, flags);
-        if (!ts->pending) {
-                ts->pending = 1;
-
-                status = spi_async(ts->spi, &ts->msg);
-                if (status)
-                        dev_err(&ts->spi->dev, "spi_sync --> %d\n", status);
-        }
+        error = ad7877_process_data(ts);
+        if (!error)
+                mod_timer(&ts->timer, jiffies + TS_PEN_UP_TIMEOUT);
         spin_unlock_irqrestore(&ts->lock, flags);
 
+out:
         return IRQ_HANDLED;
 }
 
-static void ad7877_callback(void *_ts)
-{
-        struct ad7877 *ts = _ts;
-
-        spin_lock_irq(&ts->lock);
-
-        ad7877_rx(ts);
-        ts->pending = 0;
-        mod_timer(&ts->timer, jiffies + TS_PEN_UP_TIMEOUT);
-
-        spin_unlock_irq(&ts->lock);
-}
-
 static void ad7877_disable(struct ad7877 *ts)
 {
         mutex_lock(&ts->mutex);
 
         if (!ts->disabled) {
-                ts->disabled = 1;
+                ts->disabled = true;
                 disable_irq(ts->spi->irq);
 
-                /* Wait for spi_async callback */
-                while (ts->pending)
-                        msleep(1);
-
                 if (del_timer_sync(&ts->timer))
                         ad7877_ts_event_release(ts);
         }
 
-        /* we know the chip's in lowpower mode since we always
+        /*
+         * We know the chip's in lowpower mode since we always
          * leave it that way after every request
          */
 
@@ -443,7 +447,7 @@ static void ad7877_enable(struct ad7877 *ts)
         mutex_lock(&ts->mutex);
 
         if (ts->disabled) {
-                ts->disabled = 0;
+                ts->disabled = false;
                 enable_irq(ts->spi->irq);
         }
 
@@ -453,7 +457,7 @@ static void ad7877_enable(struct ad7877 *ts)
 #define SHOW(name) static ssize_t \
 name ## _show(struct device *dev, struct device_attribute *attr, char *buf) \
 { \
-        struct ad7877   *ts = dev_get_drvdata(dev); \
+        struct ad7877 *ts = dev_get_drvdata(dev); \
         ssize_t v = ad7877_read_adc(ts->spi, \
                         AD7877_READ_CHAN(name)); \
         if (v < 0) \
@@ -473,7 +477,7 @@ SHOW(temp2)
 static ssize_t ad7877_disable_show(struct device *dev,
                                      struct device_attribute *attr, char *buf)
 {
-        struct ad7877   *ts = dev_get_drvdata(dev);
+        struct ad7877 *ts = dev_get_drvdata(dev);
 
         return sprintf(buf, "%u\n", ts->disabled);
 }
@@ -503,7 +507,7 @@ static DEVICE_ATTR(disable, 0664, ad7877_disable_show, ad7877_disable_store);
 static ssize_t ad7877_dac_show(struct device *dev,
                                      struct device_attribute *attr, char *buf)
 {
-        struct ad7877   *ts = dev_get_drvdata(dev);
+        struct ad7877 *ts = dev_get_drvdata(dev);
 
         return sprintf(buf, "%u\n", ts->dac);
 }
@@ -533,7 +537,7 @@ static DEVICE_ATTR(dac, 0664, ad7877_dac_show, ad7877_dac_store);
 static ssize_t ad7877_gpio3_show(struct device *dev,
                                      struct device_attribute *attr, char *buf)
 {
-        struct ad7877   *ts = dev_get_drvdata(dev);
+        struct ad7877 *ts = dev_get_drvdata(dev);
 
         return sprintf(buf, "%u\n", ts->gpio3);
 }
@@ -564,7 +568,7 @@ static DEVICE_ATTR(gpio3, 0664, ad7877_gpio3_show, ad7877_gpio3_store);
 static ssize_t ad7877_gpio4_show(struct device *dev,
                                      struct device_attribute *attr, char *buf)
 {
-        struct ad7877   *ts = dev_get_drvdata(dev);
+        struct ad7877 *ts = dev_get_drvdata(dev);
 
         return sprintf(buf, "%u\n", ts->gpio4);
 }
@@ -597,16 +601,35 @@ static struct attribute *ad7877_attributes[] = {
         &dev_attr_temp2.attr,
         &dev_attr_aux1.attr,
         &dev_attr_aux2.attr,
+        &dev_attr_aux3.attr,
         &dev_attr_bat1.attr,
         &dev_attr_bat2.attr,
         &dev_attr_disable.attr,
         &dev_attr_dac.attr,
+        &dev_attr_gpio3.attr,
         &dev_attr_gpio4.attr,
         NULL
 };
 
+static mode_t ad7877_attr_is_visible(struct kobject *kobj,
+                                     struct attribute *attr, int n)
+{
+        mode_t mode = attr->mode;
+
+        if (attr == &dev_attr_aux3.attr) {
+                if (gpio3)
+                        mode = 0;
+        } else if (attr == &dev_attr_gpio3.attr) {
+                if (!gpio3)
+                        mode = 0;
+        }
+
+        return mode;
+}
+
 static const struct attribute_group ad7877_attr_group = {
-        .attrs = ad7877_attributes,
+        .is_visible     = ad7877_attr_is_visible,
+        .attrs          = ad7877_attributes,
 };
 
 static void ad7877_setup_ts_def_msg(struct spi_device *spi, struct ad7877 *ts)
@@ -635,22 +658,25 @@ static void ad7877_setup_ts_def_msg(struct spi_device *spi, struct ad7877 *ts)
 
         spi_message_init(m);
 
-        m->complete = ad7877_callback;
         m->context = ts;
 
         ts->xfer[0].tx_buf = &ts->cmd_crtl1;
         ts->xfer[0].len = 2;
+        ts->xfer[0].cs_change = 1;
 
         spi_message_add_tail(&ts->xfer[0], m);
 
         ts->xfer[1].tx_buf = &ts->cmd_dummy; /* Send ZERO */
         ts->xfer[1].len = 2;
+        ts->xfer[1].cs_change = 1;
 
         spi_message_add_tail(&ts->xfer[1], m);
 
-        for (i = 0; i < 11; i++) {
+        for (i = 0; i < AD7877_NR_SENSE; i++) {
                 ts->xfer[i + 2].rx_buf = &ts->conversion_data[AD7877_SEQ_YPOS + i];
                 ts->xfer[i + 2].len = 2;
+                if (i < (AD7877_NR_SENSE - 1))
+                        ts->xfer[i + 2].cs_change = 1;
                 spi_message_add_tail(&ts->xfer[i + 2], m);
         }
 }
@@ -718,6 +744,8 @@ static int __devinit ad7877_probe(struct spi_device *spi)
         input_dev->phys = ts->phys;
         input_dev->dev.parent = &spi->dev;
 
+        __set_bit(EV_KEY, input_dev->evbit);
+        __set_bit(BTN_TOUCH, input_dev->keybit);
         __set_bit(EV_ABS, input_dev->evbit);
         __set_bit(ABS_X, input_dev->absbit);
         __set_bit(ABS_Y, input_dev->absbit);
@@ -752,8 +780,9 @@ static int __devinit ad7877_probe(struct spi_device *spi)
 
         /* Request AD7877 /DAV GPIO interrupt */
 
-        err = request_irq(spi->irq, ad7877_irq, IRQF_TRIGGER_FALLING,
-                        spi->dev.driver->name, ts);
+        err = request_threaded_irq(spi->irq, NULL, ad7877_irq,
+                                   IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
+                                   spi->dev.driver->name, ts);
         if (err) {
                 dev_dbg(&spi->dev, "irq %d busy?\n", spi->irq);
                 goto err_free_mem;
@@ -763,20 +792,12 @@ static int __devinit ad7877_probe(struct spi_device *spi)
         if (err)
                 goto err_free_irq;
 
-        err = device_create_file(&spi->dev,
-                                 gpio3 ? &dev_attr_gpio3 : &dev_attr_aux3);
-        if (err)
-                goto err_remove_attr_group;
-
         err = input_register_device(input_dev);
         if (err)
-                goto err_remove_attr;
+                goto err_remove_attr_group;
 
         return 0;
 
-err_remove_attr:
-        device_remove_file(&spi->dev,
-                           gpio3 ? &dev_attr_gpio3 : &dev_attr_aux3);
 err_remove_attr_group:
         sysfs_remove_group(&spi->dev.kobj, &ad7877_attr_group);
 err_free_irq:
@@ -790,11 +811,9 @@ err_free_mem:
 
 static int __devexit ad7877_remove(struct spi_device *spi)
 {
-        struct ad7877           *ts = dev_get_drvdata(&spi->dev);
+        struct ad7877 *ts = dev_get_drvdata(&spi->dev);
 
         sysfs_remove_group(&spi->dev.kobj, &ad7877_attr_group);
-        device_remove_file(&spi->dev,
-                           gpio3 ? &dev_attr_gpio3 : &dev_attr_aux3);
 
         ad7877_disable(ts);
         free_irq(ts->spi->irq, ts);
@@ -808,39 +827,37 @@ static int __devexit ad7877_remove(struct spi_device *spi)
         return 0;
 }
 
-#ifdef CONFIG_PM
-static int ad7877_suspend(struct spi_device *spi, pm_message_t message)
+#ifdef CONFIG_PM_SLEEP
+static int ad7877_suspend(struct device *dev)
 {
-        struct ad7877 *ts = dev_get_drvdata(&spi->dev);
+        struct ad7877 *ts = dev_get_drvdata(dev);
 
         ad7877_disable(ts);
 
         return 0;
 }
 
-static int ad7877_resume(struct spi_device *spi)
+static int ad7877_resume(struct device *dev)
 {
-        struct ad7877 *ts = dev_get_drvdata(&spi->dev);
+        struct ad7877 *ts = dev_get_drvdata(dev);
 
         ad7877_enable(ts);
 
         return 0;
 }
-#else
-#define ad7877_suspend NULL
-#define ad7877_resume  NULL
 #endif
 
+static SIMPLE_DEV_PM_OPS(ad7877_pm, ad7877_suspend, ad7877_resume);
+
 static struct spi_driver ad7877_driver = {
         .driver = {
                 .name   = "ad7877",
                 .bus    = &spi_bus_type,
                 .owner  = THIS_MODULE,
+                .pm     = &ad7877_pm,
         },
         .probe          = ad7877_probe,
         .remove         = __devexit_p(ad7877_remove),
-        .suspend        = ad7877_suspend,
-        .resume         = ad7877_resume,
 };
 
 static int __init ad7877_init(void)
diff --git a/drivers/input/touchscreen/ad7879-i2c.c b/drivers/input/touchscreen/ad7879-i2c.c
index d82a38ee9a3e..4e4e58cec6c8 100644
--- a/drivers/input/touchscreen/ad7879-i2c.c
+++ b/drivers/input/touchscreen/ad7879-i2c.c
@@ -10,14 +10,16 @@
 #include <linux/i2c.h>
 #include <linux/module.h>
 #include <linux/types.h>
+#include <linux/pm.h>
 
 #include "ad7879.h"
 
 #define AD7879_DEVID            0x79    /* AD7879-1/AD7889-1 */
 
 #ifdef CONFIG_PM
-static int ad7879_i2c_suspend(struct i2c_client *client, pm_message_t message)
+static int ad7879_i2c_suspend(struct device *dev)
 {
+        struct i2c_client *client = to_i2c_client(dev);
         struct ad7879 *ts = i2c_get_clientdata(client);
 
         ad7879_suspend(ts);
@@ -25,17 +27,17 @@ static int ad7879_i2c_suspend(struct i2c_client *client, pm_message_t message)
         return 0;
 }
 
-static int ad7879_i2c_resume(struct i2c_client *client)
+static int ad7879_i2c_resume(struct device *dev)
 {
+        struct i2c_client *client = to_i2c_client(dev);
         struct ad7879 *ts = i2c_get_clientdata(client);
 
         ad7879_resume(ts);
 
         return 0;
 }
-#else
-# define ad7879_i2c_suspend NULL
-# define ad7879_i2c_resume  NULL
+
+static SIMPLE_DEV_PM_OPS(ad7879_i2c_pm, ad7879_i2c_suspend, ad7879_i2c_resume);
 #endif
 
 /* All registers are word-sized.
@@ -117,11 +119,12 @@ static struct i2c_driver ad7879_i2c_driver = {
         .driver = {
                 .name   = "ad7879",
                 .owner  = THIS_MODULE,
+#ifdef CONFIG_PM
+                .pm     = &ad7879_i2c_pm,
+#endif
         },
         .probe          = ad7879_i2c_probe,
         .remove         = __devexit_p(ad7879_i2c_remove),
-        .suspend        = ad7879_i2c_suspend,
-        .resume         = ad7879_i2c_resume,
         .id_table       = ad7879_id,
 };
 
diff --git a/drivers/input/touchscreen/ad7879-spi.c b/drivers/input/touchscreen/ad7879-spi.c
index 59c6e68c4325..ddf732f3cafc 100644
--- a/drivers/input/touchscreen/ad7879-spi.c
+++ b/drivers/input/touchscreen/ad7879-spi.c
@@ -7,6 +7,7 @@
  */
 
 #include <linux/input.h>        /* BUS_SPI */
+#include <linux/pm.h>
 #include <linux/spi/spi.h>
 
 #include "ad7879.h"
@@ -20,9 +21,10 @@
 #define AD7879_WRITECMD(reg) (AD7879_CMD(reg))
 #define AD7879_READCMD(reg)  (AD7879_CMD(reg) | AD7879_CMD_READ)
 
-#ifdef CONFIG_PM
-static int ad7879_spi_suspend(struct spi_device *spi, pm_message_t message)
+#ifdef CONFIG_PM_SLEEP
+static int ad7879_spi_suspend(struct device *dev)
 {
+        struct spi_device *spi = to_spi_device(dev);
         struct ad7879 *ts = spi_get_drvdata(spi);
 
         ad7879_suspend(ts);
@@ -30,19 +32,19 @@ static int ad7879_spi_suspend(struct spi_device *spi, pm_message_t message)
         return 0;
 }
 
-static int ad7879_spi_resume(struct spi_device *spi)
+static int ad7879_spi_resume(struct device *dev)
 {
+        struct spi_device *spi = to_spi_device(dev);
         struct ad7879 *ts = spi_get_drvdata(spi);
 
         ad7879_resume(ts);
 
         return 0;
 }
-#else
-# define ad7879_spi_suspend NULL
-# define ad7879_spi_resume  NULL
 #endif
 
+static SIMPLE_DEV_PM_OPS(ad7879_spi_pm, ad7879_spi_suspend, ad7879_spi_resume);
+
 /*
  * ad7879_read/write are only used for initial setup and for sysfs controls.
  * The main traffic is done in ad7879_collect().
@@ -173,11 +175,10 @@ static struct spi_driver ad7879_spi_driver = {
                 .name   = "ad7879",
                 .bus    = &spi_bus_type,
                 .owner  = THIS_MODULE,
+                .pm     = &ad7879_spi_pm,
         },
         .probe          = ad7879_spi_probe,
         .remove         = __devexit_p(ad7879_spi_remove),
-        .suspend        = ad7879_spi_suspend,
-        .resume         = ad7879_spi_resume,
 };
 
 static int __init ad7879_spi_init(void)
diff --git a/drivers/input/touchscreen/ad7879.c b/drivers/input/touchscreen/ad7879.c
index ba6f0bd1e762..bc3b5187f3a3 100644
--- a/drivers/input/touchscreen/ad7879.c
+++ b/drivers/input/touchscreen/ad7879.c
@@ -129,6 +129,9 @@ struct ad7879 {
         u16                     cmd_crtl1;
         u16                     cmd_crtl2;
         u16                     cmd_crtl3;
+        int                     x;
+        int                     y;
+        int                     Rt;
 };
 
 static int ad7879_read(struct ad7879 *ts, u8 reg)
@@ -175,13 +178,32 @@ static int ad7879_report(struct ad7879 *ts)
                 Rt /= z1;
                 Rt = (Rt + 2047) >> 12;
 
-                if (!timer_pending(&ts->timer))
+                /*
+                 * Sample found inconsistent, pressure is beyond
+                 * the maximum. Don't report it to user space.
+                 */
+                if (Rt > ts->pressure_max)
+                        return -EINVAL;
+
+                /*
+                 * Note that we delay reporting events by one sample.
+                 * This is done to avoid reporting last sample of the
+                 * touch sequence, which may be incomplete if finger
+                 * leaves the surface before last reading is taken.
+                 */
+                if (timer_pending(&ts->timer)) {
+                        /* Touch continues */
                         input_report_key(input_dev, BTN_TOUCH, 1);
+                        input_report_abs(input_dev, ABS_X, ts->x);
+                        input_report_abs(input_dev, ABS_Y, ts->y);
+                        input_report_abs(input_dev, ABS_PRESSURE, ts->Rt);
+                        input_sync(input_dev);
+                }
+
+                ts->x = x;
+                ts->y = y;
+                ts->Rt = Rt;
 
-                input_report_abs(input_dev, ABS_X, x);
-                input_report_abs(input_dev, ABS_Y, y);
-                input_report_abs(input_dev, ABS_PRESSURE, Rt);
-                input_sync(input_dev);
                 return 0;
         }
 
diff --git a/drivers/input/touchscreen/ads7846.c b/drivers/input/touchscreen/ads7846.c
index 16031933a8f6..5196861b86ef 100644
--- a/drivers/input/touchscreen/ads7846.c
+++ b/drivers/input/touchscreen/ads7846.c
@@ -17,13 +17,16 @@
  *  it under the terms of the GNU General Public License version 2 as
  *  published by the Free Software Foundation.
  */
+#include <linux/types.h>
 #include <linux/hwmon.h>
 #include <linux/init.h>
 #include <linux/err.h>
+#include <linux/sched.h>
 #include <linux/delay.h>
 #include <linux/input.h>
 #include <linux/interrupt.h>
 #include <linux/slab.h>
+#include <linux/pm.h>
 #include <linux/gpio.h>
 #include <linux/spi/spi.h>
 #include <linux/spi/ads7846.h>
@@ -52,22 +55,23 @@
  * files.
  */
 
-#define TS_POLL_DELAY   (1 * 1000000)   /* ns delay before the first sample */
-#define TS_POLL_PERIOD  (5 * 1000000)   /* ns delay between samples */
+#define TS_POLL_DELAY   1       /* ms delay before the first sample */
+#define TS_POLL_PERIOD  5       /* ms delay between samples */
 
 /* this driver doesn't aim at the peak continuous sample rate */
 #define SAMPLE_BITS     (8 /*cmd*/ + 16 /*sample*/ + 2 /* before, after */)
 
 struct ts_event {
-        /* For portability, we can't read 12 bit values using SPI (which
-         * would make the controller deliver them as native byteorder u16
+        /*
+         * For portability, we can't read 12 bit values using SPI (which
+         * would make the controller deliver them as native byte order u16
          * with msbs zeroed).  Instead, we read them as two 8-bit values,
          * *** WHICH NEED BYTESWAPPING *** and range adjustment.
          */
         u16     x;
         u16     y;
         u16     z1, z2;
-        int     ignore;
+        bool    ignore;
         u8      x_buf[3];
         u8      y_buf[3];
 };
@@ -105,13 +109,17 @@ struct ads7846 {
         u16                     pressure_max;
 
         bool                    swap_xy;
+        bool                    use_internal;
 
         struct ads7846_packet   *packet;
 
         struct spi_transfer     xfer[18];
         struct spi_message      msg[5];
-        struct spi_message      *last_msg;
-        int                     msg_idx;
+        int                     msg_count;
+        wait_queue_head_t       wait;
+
+        bool                    pendown;
+
         int                     read_cnt;
         int                     read_rep;
         int                     last_read;
@@ -122,14 +130,10 @@ struct ads7846 {
 
         u16                     penirq_recheck_delay_usecs;
 
-        spinlock_t              lock;
-        struct hrtimer          timer;
-        unsigned                pendown:1;      /* P: lock */
-        unsigned                pending:1;      /* P: lock */
-// FIXME remove "irq_disabled"
-        unsigned                irq_disabled:1; /* P: lock */
-        unsigned                disabled:1;
-        unsigned                is_suspended:1;
+        struct mutex            lock;
+        bool                    stopped;        /* P: lock */
+        bool                    disabled;       /* P: lock */
+        bool                    suspended;      /* P: lock */
 
         int                     (*filter)(void *data, int data_idx, int *val);
         void                    *filter_data;
@@ -165,7 +169,7 @@ struct ads7846 {
 #define ADS_12_BIT              (0 << 3)
 #define ADS_SER                 (1 << 2)        /* non-differential */
 #define ADS_DFR                 (0 << 2)        /* differential */
-#define ADS_PD10_PDOWN          (0 << 0)        /* lowpower mode + penirq */
+#define ADS_PD10_PDOWN          (0 << 0)        /* low power mode + penirq */
 #define ADS_PD10_ADC_ON         (1 << 0)        /* ADC on */
 #define ADS_PD10_REF_ON         (2 << 0)        /* vREF on + penirq */
 #define ADS_PD10_ALL_ON         (3 << 0)        /* ADC + vREF on */
@@ -193,6 +197,78 @@ struct ads7846 {
 #define REF_ON  (READ_12BIT_DFR(x, 1, 1))
 #define REF_OFF (READ_12BIT_DFR(y, 0, 0))
 
+/* Must be called with ts->lock held */
+static void ads7846_stop(struct ads7846 *ts)
+{
+        if (!ts->disabled && !ts->suspended) {
+                /* Signal IRQ thread to stop polling and disable the handler. */
+                ts->stopped = true;
+                mb();
+                wake_up(&ts->wait);
+                disable_irq(ts->spi->irq);
+        }
+}
+
+/* Must be called with ts->lock held */
+static void ads7846_restart(struct ads7846 *ts)
+{
+        if (!ts->disabled && !ts->suspended) {
+                /* Tell IRQ thread that it may poll the device. */
+                ts->stopped = false;
+                mb();
+                enable_irq(ts->spi->irq);
+        }
+}
+
+/* Must be called with ts->lock held */
+static void __ads7846_disable(struct ads7846 *ts)
+{
+        ads7846_stop(ts);
+        regulator_disable(ts->reg);
+
+        /*
+         * We know the chip's in low power mode since we always
+         * leave it that way after every request
+         */
+}
+
+/* Must be called with ts->lock held */
+static void __ads7846_enable(struct ads7846 *ts)
+{
+        regulator_enable(ts->reg);
+        ads7846_restart(ts);
+}
+
+static void ads7846_disable(struct ads7846 *ts)
+{
+        mutex_lock(&ts->lock);
+
+        if (!ts->disabled) {
+
+                if  (!ts->suspended)
+                        __ads7846_disable(ts);
+
+                ts->disabled = true;
+        }
+
+        mutex_unlock(&ts->lock);
+}
+
+static void ads7846_enable(struct ads7846 *ts)
+{
+        mutex_lock(&ts->lock);
+
+        if (ts->disabled) {
+
+                ts->disabled = false;
+
+                if (!ts->suspended)
+                        __ads7846_enable(ts);
+        }
+
+        mutex_unlock(&ts->lock);
+}
+
 /*--------------------------------------------------------------------------*/
 
 /*
@@ -206,46 +282,41 @@ struct ser_req {
         u8                      command;
         u8                      ref_off;
         u16                     scratch;
-        __be16                  sample;
         struct spi_message      msg;
         struct spi_transfer     xfer[6];
+        /*
+         * DMA (thus cache coherency maintenance) requires the
+         * transfer buffers to live in their own cache lines.
+         */
+        __be16 sample ____cacheline_aligned;
 };
 
 struct ads7845_ser_req {
         u8                      command[3];
-        u8                      pwrdown[3];
-        u8                      sample[3];
         struct spi_message      msg;
         struct spi_transfer     xfer[2];
+        /*
+         * DMA (thus cache coherency maintenance) requires the
+         * transfer buffers to live in their own cache lines.
+         */
+        u8 sample[3] ____cacheline_aligned;
 };
 
-static void ads7846_enable(struct ads7846 *ts);
-static void ads7846_disable(struct ads7846 *ts);
-
-static int device_suspended(struct device *dev)
-{
-        struct ads7846 *ts = dev_get_drvdata(dev);
-        return ts->is_suspended || ts->disabled;
-}
-
 static int ads7846_read12_ser(struct device *dev, unsigned command)
 {
-        struct spi_device       *spi = to_spi_device(dev);
-        struct ads7846          *ts = dev_get_drvdata(dev);
-        struct ser_req          *req = kzalloc(sizeof *req, GFP_KERNEL);
-        int                     status;
-        int                     use_internal;
+        struct spi_device *spi = to_spi_device(dev);
+        struct ads7846 *ts = dev_get_drvdata(dev);
+        struct ser_req *req;
+        int status;
 
+        req = kzalloc(sizeof *req, GFP_KERNEL);
         if (!req)
                 return -ENOMEM;
 
         spi_message_init(&req->msg);
 
-        /* FIXME boards with ads7846 might use external vref instead ... */
-        use_internal = (ts->model == 7846);
-
         /* maybe turn on internal vREF, and let it settle */
-        if (use_internal) {
+        if (ts->use_internal) {
                 req->ref_on = REF_ON;
                 req->xfer[0].tx_buf = &req->ref_on;
                 req->xfer[0].len = 1;
@@ -257,8 +328,14 @@ static int ads7846_read12_ser(struct device *dev, unsigned command)
                 /* for 1uF, settle for 800 usec; no cap, 100 usec.  */
                 req->xfer[1].delay_usecs = ts->vref_delay_usecs;
                 spi_message_add_tail(&req->xfer[1], &req->msg);
+
+                /* Enable reference voltage */
+                command |= ADS_PD10_REF_ON;
         }
 
+        /* Enable ADC in every case */
+        command |= ADS_PD10_ADC_ON;
+
         /* take sample */
         req->command = (u8) command;
         req->xfer[2].tx_buf = &req->command;
@@ -282,11 +359,11 @@ static int ads7846_read12_ser(struct device *dev, unsigned command)
         CS_CHANGE(req->xfer[5]);
         spi_message_add_tail(&req->xfer[5], &req->msg);
 
-        ts->irq_disabled = 1;
-        disable_irq(spi->irq);
+        mutex_lock(&ts->lock);
+        ads7846_stop(ts);
         status = spi_sync(spi, &req->msg);
-        ts->irq_disabled = 0;
-        enable_irq(spi->irq);
+        ads7846_restart(ts);
+        mutex_unlock(&ts->lock);
 
         if (status == 0) {
                 /* on-wire is a must-ignore bit, a BE12 value, then padding */
@@ -301,11 +378,12 @@ static int ads7846_read12_ser(struct device *dev, unsigned command)
 
 static int ads7845_read12_ser(struct device *dev, unsigned command)
 {
-        struct spi_device       *spi = to_spi_device(dev);
-        struct ads7846          *ts = dev_get_drvdata(dev);
-        struct ads7845_ser_req  *req = kzalloc(sizeof *req, GFP_KERNEL);
-        int                     status;
+        struct spi_device *spi = to_spi_device(dev);
+        struct ads7846 *ts = dev_get_drvdata(dev);
+        struct ads7845_ser_req *req;
+        int status;
 
+        req = kzalloc(sizeof *req, GFP_KERNEL);
         if (!req)
                 return -ENOMEM;
 
@@ -317,11 +395,11 @@ static int ads7845_read12_ser(struct device *dev, unsigned command)
         req->xfer[0].len = 3;
         spi_message_add_tail(&req->xfer[0], &req->msg);
 
-        ts->irq_disabled = 1;
-        disable_irq(spi->irq);
+        mutex_lock(&ts->lock);
+        ads7846_stop(ts);
         status = spi_sync(spi, &req->msg);
-        ts->irq_disabled = 0;
-        enable_irq(spi->irq);
+        ads7846_restart(ts);
+        mutex_unlock(&ts->lock);
 
         if (status == 0) {
                 /* BE12 value, then padding */
@@ -341,7 +419,7 @@ name ## _show(struct device *dev, struct device_attribute *attr, char *buf) \
 { \
         struct ads7846 *ts = dev_get_drvdata(dev); \
         ssize_t v = ads7846_read12_ser(dev, \
-                        READ_12BIT_SER(var) | ADS_PD10_ALL_ON); \
+                        READ_12BIT_SER(var)); \
         if (v < 0) \
                 return v; \
         return sprintf(buf, "%u\n", adjust(ts, v)); \
@@ -374,6 +452,7 @@ static inline unsigned vaux_adjust(struct ads7846 *ts, ssize_t v)
         /* external resistors may scale vAUX into 0..vREF */
         retval *= ts->vref_mv;
         retval = retval >> 12;
+
         return retval;
 }
 
@@ -384,13 +463,13 @@ static inline unsigned vbatt_adjust(struct ads7846 *ts, ssize_t v)
         /* ads7846 has a resistor ladder to scale this signal down */
         if (ts->model == 7846)
                 retval *= 4;
+
         return retval;
 }
 
 SHOW(in0_input, vaux, vaux_adjust)
 SHOW(in1_input, vbatt, vbatt_adjust)
 
-
 static struct attribute *ads7846_attributes[] = {
         &dev_attr_temp0.attr,
         &dev_attr_temp1.attr,
@@ -433,6 +512,7 @@ static int ads784x_hwmon_register(struct spi_device *spi, struct ads7846 *ts)
                 if (!ts->vref_mv) {
                         dev_dbg(&spi->dev, "assuming 2.5V internal vREF\n");
                         ts->vref_mv = 2500;
+                        ts->use_internal = true;
                 }
                 break;
         case 7845:
@@ -498,17 +578,12 @@ static inline void ads784x_hwmon_unregister(struct spi_device *spi,
 }
 #endif
 
-static int is_pen_down(struct device *dev)
-{
-        struct ads7846  *ts = dev_get_drvdata(dev);
-
-        return ts->pendown;
-}
-
 static ssize_t ads7846_pen_down_show(struct device *dev,
                                      struct device_attribute *attr, char *buf)
 {
-        return sprintf(buf, "%u\n", is_pen_down(dev));
+        struct ads7846 *ts = dev_get_drvdata(dev);
+
+        return sprintf(buf, "%u\n", ts->pendown);
 }
 
 static DEVICE_ATTR(pen_down, S_IRUGO, ads7846_pen_down_show, NULL);
@@ -516,7 +591,7 @@ static DEVICE_ATTR(pen_down, S_IRUGO, ads7846_pen_down_show, NULL);
 static ssize_t ads7846_disable_show(struct device *dev,
                                      struct device_attribute *attr, char *buf)
 {
-        struct ads7846  *ts = dev_get_drvdata(dev);
+        struct ads7846 *ts = dev_get_drvdata(dev);
 
         return sprintf(buf, "%u\n", ts->disabled);
 }
@@ -531,15 +606,11 @@ static ssize_t ads7846_disable_store(struct device *dev,
         if (strict_strtoul(buf, 10, &i))
                 return -EINVAL;
 
-        spin_lock_irq(&ts->lock);
-
         if (i)
                 ads7846_disable(ts);
         else
                 ads7846_enable(ts);
 
-        spin_unlock_irq(&ts->lock);
-
         return count;
 }
 
@@ -569,23 +640,141 @@ static void null_wait_for_sync(void)
 {
 }
 
-/*
- * PENIRQ only kicks the timer.  The timer only reissues the SPI transfer,
- * to retrieve touchscreen status.
- *
- * The SPI transfer completion callback does the real work.  It reports
- * touchscreen events and reactivates the timer (or IRQ) as appropriate.
- */
+static int ads7846_debounce_filter(void *ads, int data_idx, int *val)
+{
+        struct ads7846 *ts = ads;
+
+        if (!ts->read_cnt || (abs(ts->last_read - *val) > ts->debounce_tol)) {
+                /* Start over collecting consistent readings. */
+                ts->read_rep = 0;
+                /*
+                 * Repeat it, if this was the first read or the read
+                 * wasn't consistent enough.
+                 */
+                if (ts->read_cnt < ts->debounce_max) {
+                        ts->last_read = *val;
+                        ts->read_cnt++;
+                        return ADS7846_FILTER_REPEAT;
+                } else {
+                        /*
+                         * Maximum number of debouncing reached and still
+                         * not enough number of consistent readings. Abort
+                         * the whole sample, repeat it in the next sampling
+                         * period.
+                         */
+                        ts->read_cnt = 0;
+                        return ADS7846_FILTER_IGNORE;
+                }
+        } else {
+                if (++ts->read_rep > ts->debounce_rep) {
+                        /*
+                         * Got a good reading for this coordinate,
+                         * go for the next one.
+                         */
+                        ts->read_cnt = 0;
+                        ts->read_rep = 0;
+                        return ADS7846_FILTER_OK;
+                } else {
+                        /* Read more values that are consistent. */
+                        ts->read_cnt++;
+                        return ADS7846_FILTER_REPEAT;
+                }
+        }
+}
+
+static int ads7846_no_filter(void *ads, int data_idx, int *val)
+{
+        return ADS7846_FILTER_OK;
+}
+
+static int ads7846_get_value(struct ads7846 *ts, struct spi_message *m)
+{
+        struct spi_transfer *t =
+                list_entry(m->transfers.prev, struct spi_transfer, transfer_list);
+
+        if (ts->model == 7845) {
+                return be16_to_cpup((__be16 *)&(((char*)t->rx_buf)[1])) >> 3;
+        } else {
+                /*
+                 * adjust:  on-wire is a must-ignore bit, a BE12 value, then
+                 * padding; built from two 8 bit values written msb-first.
+                 */
+                return be16_to_cpup((__be16 *)t->rx_buf) >> 3;
+        }
+}
+
+static void ads7846_update_value(struct spi_message *m, int val)
+{
+        struct spi_transfer *t =
+                list_entry(m->transfers.prev, struct spi_transfer, transfer_list);
 
-static void ads7846_rx(void *ads)
+        *(u16 *)t->rx_buf = val;
+}
+
+static void ads7846_read_state(struct ads7846 *ts)
 {
-        struct ads7846          *ts = ads;
-        struct ads7846_packet   *packet = ts->packet;
-        unsigned                Rt;
-        u16                     x, y, z1, z2;
+        struct ads7846_packet *packet = ts->packet;
+        struct spi_message *m;
+        int msg_idx = 0;
+        int val;
+        int action;
+        int error;
 
-        /* ads7846_rx_val() did in-place conversion (including byteswap) from
-         * on-the-wire format as part of debouncing to get stable readings.
+        while (msg_idx < ts->msg_count) {
+
+                ts->wait_for_sync();
+
+                m = &ts->msg[msg_idx];
+                error = spi_sync(ts->spi, m);
+                if (error) {
+                        dev_err(&ts->spi->dev, "spi_async --> %d\n", error);
+                        packet->tc.ignore = true;
+                        return;
+                }
+
+                /*
+                 * Last message is power down request, no need to convert
+                 * or filter the value.
+                 */
+                if (msg_idx < ts->msg_count - 1) {
+
+                        val = ads7846_get_value(ts, m);
+
+                        action = ts->filter(ts->filter_data, msg_idx, &val);
+                        switch (action) {
+                        case ADS7846_FILTER_REPEAT:
+                                continue;
+
+                        case ADS7846_FILTER_IGNORE:
+                                packet->tc.ignore = true;
+                                msg_idx = ts->msg_count - 1;
+                                continue;
+
+                        case ADS7846_FILTER_OK:
+                                ads7846_update_value(m, val);
+                                packet->tc.ignore = false;
+                                msg_idx++;
+                                break;
+
+                        default:
+                                BUG();
+                        }
+                } else {
+                        msg_idx++;
+                }
+        }
+}
+
+static void ads7846_report_state(struct ads7846 *ts)
+{
+        struct ads7846_packet *packet = ts->packet;
+        unsigned int Rt;
+        u16 x, y, z1, z2;
+
+        /*
+         * ads7846_get_value() does in-place conversion (including byte swap)
+         * from on-the-wire format as part of debouncing to get stable
+         * readings.
          */
         if (ts->model == 7845) {
                 x = *(u16 *)packet->tc.x_buf;
@@ -623,19 +812,19 @@ static void ads7846_rx(void *ads)
                 Rt = 0;
         }
 
-        /* Sample found inconsistent by debouncing or pressure is beyond
+        /*
+         * Sample found inconsistent by debouncing or pressure is beyond
          * the maximum. Don't report it to user space, repeat at least
          * once more the measurement
          */
         if (packet->tc.ignore || Rt > ts->pressure_max) {
                 dev_vdbg(&ts->spi->dev, "ignored %d pressure %d\n",
                          packet->tc.ignore, Rt);
-                hrtimer_start(&ts->timer, ktime_set(0, TS_POLL_PERIOD),
-                              HRTIMER_MODE_REL);
                 return;
         }
 
-        /* Maybe check the pendown state before reporting. This discards
+        /*
+         * Maybe check the pendown state before reporting. This discards
          * false readings when the pen is lifted.
          */
         if (ts->penirq_recheck_delay_usecs) {
@@ -644,8 +833,9 @@ static void ads7846_rx(void *ads)
                         Rt = 0;
         }
 
-        /* NOTE: We can't rely on the pressure to determine the pen down
-         * state, even this controller has a pressure sensor.  The pressure
+        /*
+         * NOTE: We can't rely on the pressure to determine the pen down
+         * state, even this controller has a pressure sensor. The pressure
          * value can fluctuate for quite a while after lifting the pen and
          * in some cases may not even settle at the expected value.
          *
@@ -655,15 +845,15 @@ static void ads7846_rx(void *ads)
         if (Rt) {
                 struct input_dev *input = ts->input;
 
+                if (ts->swap_xy)
+                        swap(x, y);
+
                 if (!ts->pendown) {
                         input_report_key(input, BTN_TOUCH, 1);
-                        ts->pendown = 1;
+                        ts->pendown = true;
                         dev_vdbg(&ts->spi->dev, "DOWN\n");
                 }
 
-                if (ts->swap_xy)
-                        swap(x, y);
-
                 input_report_abs(input, ABS_X, x);
                 input_report_abs(input, ABS_Y, y);
                 input_report_abs(input, ABS_PRESSURE, ts->pressure_max - Rt);
@@ -671,407 +861,161 @@ static void ads7846_rx(void *ads)
                 input_sync(input);
                 dev_vdbg(&ts->spi->dev, "%4d/%4d/%4d\n", x, y, Rt);
         }
-
-        hrtimer_start(&ts->timer, ktime_set(0, TS_POLL_PERIOD),
-                        HRTIMER_MODE_REL);
 }
 
-static int ads7846_debounce(void *ads, int data_idx, int *val)
+static irqreturn_t ads7846_hard_irq(int irq, void *handle)
 {
-        struct ads7846          *ts = ads;
+        struct ads7846 *ts = handle;
 
-        if (!ts->read_cnt || (abs(ts->last_read - *val) > ts->debounce_tol)) {
-                /* Start over collecting consistent readings. */
-                ts->read_rep = 0;
-                /* Repeat it, if this was the first read or the read
-                 * wasn't consistent enough. */
-                if (ts->read_cnt < ts->debounce_max) {
-                        ts->last_read = *val;
-                        ts->read_cnt++;
-                        return ADS7846_FILTER_REPEAT;
-                } else {
-                        /* Maximum number of debouncing reached and still
-                         * not enough number of consistent readings. Abort
-                         * the whole sample, repeat it in the next sampling
-                         * period.
-                         */
-                        ts->read_cnt = 0;
-                        return ADS7846_FILTER_IGNORE;
-                }
-        } else {
-                if (++ts->read_rep > ts->debounce_rep) {
-                        /* Got a good reading for this coordinate,
-                         * go for the next one. */
-                        ts->read_cnt = 0;
-                        ts->read_rep = 0;
-                        return ADS7846_FILTER_OK;
-                } else {
-                        /* Read more values that are consistent. */
-                        ts->read_cnt++;
-                        return ADS7846_FILTER_REPEAT;
-                }
-        }
+        return get_pendown_state(ts) ? IRQ_WAKE_THREAD : IRQ_HANDLED;
 }
 
-static int ads7846_no_filter(void *ads, int data_idx, int *val)
-{
-        return ADS7846_FILTER_OK;
-}
 
-static void ads7846_rx_val(void *ads)
+static irqreturn_t ads7846_irq(int irq, void *handle)
 {
-        struct ads7846 *ts = ads;
-        struct ads7846_packet *packet = ts->packet;
-        struct spi_message *m;
-        struct spi_transfer *t;
-        int val;
-        int action;
-        int status;
-
-        m = &ts->msg[ts->msg_idx];
-        t = list_entry(m->transfers.prev, struct spi_transfer, transfer_list);
+        struct ads7846 *ts = handle;
 
-        if (ts->model == 7845) {
-                val = be16_to_cpup((__be16 *)&(((char*)t->rx_buf)[1])) >> 3;
-        } else {
-                /* adjust:  on-wire is a must-ignore bit, a BE12 value, then
-                 * padding; built from two 8 bit values written msb-first.
-                 */
-                val = be16_to_cpup((__be16 *)t->rx_buf) >> 3;
-        }
+        /* Start with a small delay before checking pendown state */
+        msleep(TS_POLL_DELAY);
 
-        action = ts->filter(ts->filter_data, ts->msg_idx, &val);
-        switch (action) {
-        case ADS7846_FILTER_REPEAT:
-                break;
-        case ADS7846_FILTER_IGNORE:
-                packet->tc.ignore = 1;
-                /* Last message will contain ads7846_rx() as the
-                 * completion function.
-                 */
-                m = ts->last_msg;
-                break;
-        case ADS7846_FILTER_OK:
-                *(u16 *)t->rx_buf = val;
-                packet->tc.ignore = 0;
-                m = &ts->msg[++ts->msg_idx];
-                break;
-        default:
-                BUG();
-        }
-        ts->wait_for_sync();
-        status = spi_async(ts->spi, m);
-        if (status)
-                dev_err(&ts->spi->dev, "spi_async --> %d\n",
-                                status);
-}
+        while (!ts->stopped && get_pendown_state(ts)) {
 
-static enum hrtimer_restart ads7846_timer(struct hrtimer *handle)
-{
-        struct ads7846  *ts = container_of(handle, struct ads7846, timer);
-        int             status = 0;
+                /* pen is down, continue with the measurement */
+                ads7846_read_state(ts);
 
-        spin_lock(&ts->lock);
+                if (!ts->stopped)
+                        ads7846_report_state(ts);
 
-        if (unlikely(!get_pendown_state(ts) ||
-                     device_suspended(&ts->spi->dev))) {
-                if (ts->pendown) {
-                        struct input_dev *input = ts->input;
+                wait_event_timeout(ts->wait, ts->stopped,
+                                   msecs_to_jiffies(TS_POLL_PERIOD));
+        }
 
-                        input_report_key(input, BTN_TOUCH, 0);
-                        input_report_abs(input, ABS_PRESSURE, 0);
-                        input_sync(input);
+        if (ts->pendown) {
+                struct input_dev *input = ts->input;
 
-                        ts->pendown = 0;
-                        dev_vdbg(&ts->spi->dev, "UP\n");
-                }
+                input_report_key(input, BTN_TOUCH, 0);
+                input_report_abs(input, ABS_PRESSURE, 0);
+                input_sync(input);
 
-                /* measurement cycle ended */
-                if (!device_suspended(&ts->spi->dev)) {
-                        ts->irq_disabled = 0;
-                        enable_irq(ts->spi->irq);
-                }
-                ts->pending = 0;
-        } else {
-                /* pen is still down, continue with the measurement */
-                ts->msg_idx = 0;
-                ts->wait_for_sync();
-                status = spi_async(ts->spi, &ts->msg[0]);
-                if (status)
-                        dev_err(&ts->spi->dev, "spi_async --> %d\n", status);
+                ts->pendown = false;
+                dev_vdbg(&ts->spi->dev, "UP\n");
         }
 
-        spin_unlock(&ts->lock);
-        return HRTIMER_NORESTART;
+        return IRQ_HANDLED;
 }
 
-static irqreturn_t ads7846_irq(int irq, void *handle)
+#ifdef CONFIG_PM_SLEEP
+static int ads7846_suspend(struct device *dev)
 {
-        struct ads7846 *ts = handle;
-        unsigned long flags;
-
-        spin_lock_irqsave(&ts->lock, flags);
-        if (likely(get_pendown_state(ts))) {
-                if (!ts->irq_disabled) {
-                        /* The ARM do_simple_IRQ() dispatcher doesn't act
-                         * like the other dispatchers:  it will report IRQs
-                         * even after they've been disabled.  We work around
-                         * that here.  (The "generic irq" framework may help...)
-                         */
-                        ts->irq_disabled = 1;
-                        disable_irq_nosync(ts->spi->irq);
-                        ts->pending = 1;
-                        hrtimer_start(&ts->timer, ktime_set(0, TS_POLL_DELAY),
-                                        HRTIMER_MODE_REL);
-                }
-        }
-        spin_unlock_irqrestore(&ts->lock, flags);
+        struct ads7846 *ts = dev_get_drvdata(dev);
 
-        return IRQ_HANDLED;
-}
+        mutex_lock(&ts->lock);
 
-/*--------------------------------------------------------------------------*/
+        if (!ts->suspended) {
 
-/* Must be called with ts->lock held */
-static void ads7846_disable(struct ads7846 *ts)
-{
-        if (ts->disabled)
-                return;
+                if (!ts->disabled)
+                        __ads7846_disable(ts);
 
-        ts->disabled = 1;
+                if (device_may_wakeup(&ts->spi->dev))
+                        enable_irq_wake(ts->spi->irq);
 
-        /* are we waiting for IRQ, or polling? */
-        if (!ts->pending) {
-                ts->irq_disabled = 1;
-                disable_irq(ts->spi->irq);
-        } else {
-                /* the timer will run at least once more, and
-                 * leave everything in a clean state, IRQ disabled
-                 */
-                while (ts->pending) {
-                        spin_unlock_irq(&ts->lock);
-                        msleep(1);
-                        spin_lock_irq(&ts->lock);
-                }
+                ts->suspended = true;
         }
 
-        regulator_disable(ts->reg);
+        mutex_unlock(&ts->lock);
 
-        /* we know the chip's in lowpower mode since we always
-         * leave it that way after every request
-         */
+        return 0;
 }
 
-/* Must be called with ts->lock held */
-static void ads7846_enable(struct ads7846 *ts)
+static int ads7846_resume(struct device *dev)
 {
-        if (!ts->disabled)
-                return;
-
-        regulator_enable(ts->reg);
+        struct ads7846 *ts = dev_get_drvdata(dev);
 
-        ts->disabled = 0;
-        ts->irq_disabled = 0;
-        enable_irq(ts->spi->irq);
-}
+        mutex_lock(&ts->lock);
 
-static int ads7846_suspend(struct spi_device *spi, pm_message_t message)
-{
-        struct ads7846 *ts = dev_get_drvdata(&spi->dev);
+        if (ts->suspended) {
 
-        spin_lock_irq(&ts->lock);
+                ts->suspended = false;
 
-        ts->is_suspended = 1;
-        ads7846_disable(ts);
+                if (device_may_wakeup(&ts->spi->dev))
+                        disable_irq_wake(ts->spi->irq);
 
-        spin_unlock_irq(&ts->lock);
+                if (!ts->disabled)
+                        __ads7846_enable(ts);
+        }
 
-        if (device_may_wakeup(&ts->spi->dev))
-                enable_irq_wake(ts->spi->irq);
+        mutex_unlock(&ts->lock);
 
         return 0;
-
 }
+#endif
 
-static int ads7846_resume(struct spi_device *spi)
-{
-        struct ads7846 *ts = dev_get_drvdata(&spi->dev);
-
-        if (device_may_wakeup(&ts->spi->dev))
-                disable_irq_wake(ts->spi->irq);
-
-        spin_lock_irq(&ts->lock);
-
-        ts->is_suspended = 0;
-        ads7846_enable(ts);
-
-        spin_unlock_irq(&ts->lock);
-
-        return 0;
-}
+static SIMPLE_DEV_PM_OPS(ads7846_pm, ads7846_suspend, ads7846_resume);
 
-static int __devinit setup_pendown(struct spi_device *spi, struct ads7846 *ts)
+static int __devinit ads7846_setup_pendown(struct spi_device *spi, struct ads7846 *ts)
 {
         struct ads7846_platform_data *pdata = spi->dev.platform_data;
         int err;
 
-        /* REVISIT when the irq can be triggered active-low, or if for some
+        /*
+         * REVISIT when the irq can be triggered active-low, or if for some
          * reason the touchscreen isn't hooked up, we don't need to access
          * the pendown state.
          */
-        if (!pdata->get_pendown_state && !gpio_is_valid(pdata->gpio_pendown)) {
-                dev_err(&spi->dev, "no get_pendown_state nor gpio_pendown?\n");
-                return -EINVAL;
-        }
 
         if (pdata->get_pendown_state) {
                 ts->get_pendown_state = pdata->get_pendown_state;
-                return 0;
-        }
+        } else if (gpio_is_valid(pdata->gpio_pendown)) {
 
-        err = gpio_request(pdata->gpio_pendown, "ads7846_pendown");
-        if (err) {
-                dev_err(&spi->dev, "failed to request pendown GPIO%d\n",
+                err = gpio_request(pdata->gpio_pendown, "ads7846_pendown");
+                if (err) {
+                        dev_err(&spi->dev, "failed to request pendown GPIO%d\n",
                                 pdata->gpio_pendown);
-                return err;
-        }
-
-        ts->gpio_pendown = pdata->gpio_pendown;
-        return 0;
-}
-
-static int __devinit ads7846_probe(struct spi_device *spi)
-{
-        struct ads7846 *ts;
-        struct ads7846_packet *packet;
-        struct input_dev *input_dev;
-        const struct ads7846_platform_data *pdata = spi->dev.platform_data;
-        struct spi_message *m;
-        struct spi_transfer *x;
-        unsigned long irq_flags;
-        int vref;
-        int err;
-
-        if (!spi->irq) {
-                dev_dbg(&spi->dev, "no IRQ?\n");
-                return -ENODEV;
-        }
+                        return err;
+                }
+                err = gpio_direction_input(pdata->gpio_pendown);
+                if (err) {
+                        dev_err(&spi->dev, "failed to setup pendown GPIO%d\n",
+                                pdata->gpio_pendown);
+                        gpio_free(pdata->gpio_pendown);
+                        return err;
+                }
 
-        if (!pdata) {
-                dev_dbg(&spi->dev, "no platform data?\n");
-                return -ENODEV;
-        }
+                ts->gpio_pendown = pdata->gpio_pendown;
 
-        /* don't exceed max specified sample rate */
-        if (spi->max_speed_hz > (125000 * SAMPLE_BITS)) {
-                dev_dbg(&spi->dev, "f(sample) %d KHz?\n",
-                                (spi->max_speed_hz/SAMPLE_BITS)/1000);
+        } else {
+                dev_err(&spi->dev, "no get_pendown_state nor gpio_pendown?\n");
                 return -EINVAL;
         }
 
-        /* We'd set TX wordsize 8 bits and RX wordsize to 13 bits ... except
-         * that even if the hardware can do that, the SPI controller driver
-         * may not.  So we stick to very-portable 8 bit words, both RX and TX.
-         */
-        spi->bits_per_word = 8;
-        spi->mode = SPI_MODE_0;
-        err = spi_setup(spi);
-        if (err < 0)
-                return err;
-
-        ts = kzalloc(sizeof(struct ads7846), GFP_KERNEL);
-        packet = kzalloc(sizeof(struct ads7846_packet), GFP_KERNEL);
-        input_dev = input_allocate_device();
-        if (!ts || !packet || !input_dev) {
-                err = -ENOMEM;
-                goto err_free_mem;
-        }
-
-        dev_set_drvdata(&spi->dev, ts);
-
-        ts->packet = packet;
-        ts->spi = spi;
-        ts->input = input_dev;
-        ts->vref_mv = pdata->vref_mv;
-        ts->swap_xy = pdata->swap_xy;
-
-        hrtimer_init(&ts->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
-        ts->timer.function = ads7846_timer;
-
-        spin_lock_init(&ts->lock);
-
-        ts->model = pdata->model ? : 7846;
-        ts->vref_delay_usecs = pdata->vref_delay_usecs ? : 100;
-        ts->x_plate_ohms = pdata->x_plate_ohms ? : 400;
-        ts->pressure_max = pdata->pressure_max ? : ~0;
-
-        if (pdata->filter != NULL) {
-                if (pdata->filter_init != NULL) {
-                        err = pdata->filter_init(pdata, &ts->filter_data);
-                        if (err < 0)
-                                goto err_free_mem;
-                }
-                ts->filter = pdata->filter;
-                ts->filter_cleanup = pdata->filter_cleanup;
-        } else if (pdata->debounce_max) {
-                ts->debounce_max = pdata->debounce_max;
-                if (ts->debounce_max < 2)
-                        ts->debounce_max = 2;
-                ts->debounce_tol = pdata->debounce_tol;
-                ts->debounce_rep = pdata->debounce_rep;
-                ts->filter = ads7846_debounce;
-                ts->filter_data = ts;
-        } else
-                ts->filter = ads7846_no_filter;
-
-        err = setup_pendown(spi, ts);
-        if (err)
-                goto err_cleanup_filter;
-
-        if (pdata->penirq_recheck_delay_usecs)
-                ts->penirq_recheck_delay_usecs =
-                                pdata->penirq_recheck_delay_usecs;
-
-        ts->wait_for_sync = pdata->wait_for_sync ? : null_wait_for_sync;
-
-        snprintf(ts->phys, sizeof(ts->phys), "%s/input0", dev_name(&spi->dev));
-        snprintf(ts->name, sizeof(ts->name), "ADS%d Touchscreen", ts->model);
-
-        input_dev->name = ts->name;
-        input_dev->phys = ts->phys;
-        input_dev->dev.parent = &spi->dev;
-
-        input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
-        input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
-        input_set_abs_params(input_dev, ABS_X,
-                        pdata->x_min ? : 0,
-                        pdata->x_max ? : MAX_12BIT,
-                        0, 0);
-        input_set_abs_params(input_dev, ABS_Y,
-                        pdata->y_min ? : 0,
-                        pdata->y_max ? : MAX_12BIT,
-                        0, 0);
-        input_set_abs_params(input_dev, ABS_PRESSURE,
-                        pdata->pressure_min, pdata->pressure_max, 0, 0);
+        return 0;
+}
 
-        vref = pdata->keep_vref_on;
+/*
+ * Set up the transfers to read touchscreen state; this assumes we
+ * use formula #2 for pressure, not #3.
+ */
+static void __devinit ads7846_setup_spi_msg(struct ads7846 *ts,
+                                const struct ads7846_platform_data *pdata)
+{
+        struct spi_message *m = &ts->msg[0];
+        struct spi_transfer *x = ts->xfer;
+        struct ads7846_packet *packet = ts->packet;
+        int vref = pdata->keep_vref_on;
 
         if (ts->model == 7873) {
-                /* The AD7873 is almost identical to the ADS7846
+                /*
+                 * The AD7873 is almost identical to the ADS7846
                  * keep VREF off during differential/ratiometric
-                 * conversion modes
+                 * conversion modes.
                  */
                 ts->model = 7846;
                 vref = 0;
         }
 
-        /* set up the transfers to read touchscreen state; this assumes we
-         * use formula #2 for pressure, not #3.
-         */
-        m = &ts->msg[0];
-        x = ts->xfer;
-
+        ts->msg_count = 1;
         spi_message_init(m);
+        m->context = ts;
 
         if (ts->model == 7845) {
                 packet->read_y_cmd[0] = READ_Y(vref);
@@ -1094,7 +1038,8 @@ static int __devinit ads7846_probe(struct spi_device *spi)
                 spi_message_add_tail(x, m);
         }
 
-        /* the first sample after switching drivers can be low quality;
+        /*
+         * The first sample after switching drivers can be low quality;
          * optionally discard it, using a second one after the signals
          * have had enough time to stabilize.
          */
@@ -1112,11 +1057,10 @@ static int __devinit ads7846_probe(struct spi_device *spi)
                 spi_message_add_tail(x, m);
         }
 
-        m->complete = ads7846_rx_val;
-        m->context = ts;
-
+        ts->msg_count++;
         m++;
         spi_message_init(m);
+        m->context = ts;
 
         if (ts->model == 7845) {
                 x++;
@@ -1156,13 +1100,12 @@ static int __devinit ads7846_probe(struct spi_device *spi)
                 spi_message_add_tail(x, m);
         }
 
-        m->complete = ads7846_rx_val;
-        m->context = ts;
-
         /* turn y+ off, x- on; we'll use formula #2 */
         if (ts->model == 7846) {
+                ts->msg_count++;
                 m++;
                 spi_message_init(m);
+                m->context = ts;
 
                 x++;
                 packet->read_z1 = READ_Z1(vref);
@@ -1190,11 +1133,10 @@ static int __devinit ads7846_probe(struct spi_device *spi)
                         spi_message_add_tail(x, m);
                 }
 
-                m->complete = ads7846_rx_val;
-                m->context = ts;
-
+                ts->msg_count++;
                 m++;
                 spi_message_init(m);
+                m->context = ts;
 
                 x++;
                 packet->read_z2 = READ_Z2(vref);
@@ -1221,14 +1163,13 @@ static int __devinit ads7846_probe(struct spi_device *spi)
                         x->len = 2;
                         spi_message_add_tail(x, m);
                 }
-
-                m->complete = ads7846_rx_val;
-                m->context = ts;
         }
 
         /* power down */
+        ts->msg_count++;
         m++;
         spi_message_init(m);
+        m->context = ts;
 
         if (ts->model == 7845) {
                 x++;
@@ -1251,11 +1192,119 @@ static int __devinit ads7846_probe(struct spi_device *spi)
 
         CS_CHANGE(*x);
         spi_message_add_tail(x, m);
+}
 
-        m->complete = ads7846_rx;
-        m->context = ts;
+static int __devinit ads7846_probe(struct spi_device *spi)
+{
+        struct ads7846 *ts;
+        struct ads7846_packet *packet;
+        struct input_dev *input_dev;
+        struct ads7846_platform_data *pdata = spi->dev.platform_data;
+        unsigned long irq_flags;
+        int err;
+
+        if (!spi->irq) {
+                dev_dbg(&spi->dev, "no IRQ?\n");
+                return -ENODEV;
+        }
+
+        if (!pdata) {
+                dev_dbg(&spi->dev, "no platform data?\n");
+                return -ENODEV;
+        }
+
+        /* don't exceed max specified sample rate */
+        if (spi->max_speed_hz > (125000 * SAMPLE_BITS)) {
+                dev_dbg(&spi->dev, "f(sample) %d KHz?\n",
+                                (spi->max_speed_hz/SAMPLE_BITS)/1000);
+                return -EINVAL;
+        }
+
+        /* We'd set TX word size 8 bits and RX word size to 13 bits ... except
+         * that even if the hardware can do that, the SPI controller driver
+         * may not.  So we stick to very-portable 8 bit words, both RX and TX.
+         */
+        spi->bits_per_word = 8;
+        spi->mode = SPI_MODE_0;
+        err = spi_setup(spi);
+        if (err < 0)
+                return err;
+
+        ts = kzalloc(sizeof(struct ads7846), GFP_KERNEL);
+        packet = kzalloc(sizeof(struct ads7846_packet), GFP_KERNEL);
+        input_dev = input_allocate_device();
+        if (!ts || !packet || !input_dev) {
+                err = -ENOMEM;
+                goto err_free_mem;
+        }
+
+        dev_set_drvdata(&spi->dev, ts);
+
+        ts->packet = packet;
+        ts->spi = spi;
+        ts->input = input_dev;
+        ts->vref_mv = pdata->vref_mv;
+        ts->swap_xy = pdata->swap_xy;
+
+        mutex_init(&ts->lock);
+        init_waitqueue_head(&ts->wait);
+
+        ts->model = pdata->model ? : 7846;
+        ts->vref_delay_usecs = pdata->vref_delay_usecs ? : 100;
+        ts->x_plate_ohms = pdata->x_plate_ohms ? : 400;
+        ts->pressure_max = pdata->pressure_max ? : ~0;
+
+        if (pdata->filter != NULL) {
+                if (pdata->filter_init != NULL) {
+                        err = pdata->filter_init(pdata, &ts->filter_data);
+                        if (err < 0)
+                                goto err_free_mem;
+                }
+                ts->filter = pdata->filter;
+                ts->filter_cleanup = pdata->filter_cleanup;
+        } else if (pdata->debounce_max) {
+                ts->debounce_max = pdata->debounce_max;
+                if (ts->debounce_max < 2)
+                        ts->debounce_max = 2;
+                ts->debounce_tol = pdata->debounce_tol;
+                ts->debounce_rep = pdata->debounce_rep;
+                ts->filter = ads7846_debounce_filter;
+                ts->filter_data = ts;
+        } else {
+                ts->filter = ads7846_no_filter;
+        }
+
+        err = ads7846_setup_pendown(spi, ts);
+        if (err)
+                goto err_cleanup_filter;
+
+        if (pdata->penirq_recheck_delay_usecs)
+                ts->penirq_recheck_delay_usecs =
+                                pdata->penirq_recheck_delay_usecs;
+
+        ts->wait_for_sync = pdata->wait_for_sync ? : null_wait_for_sync;
+
+        snprintf(ts->phys, sizeof(ts->phys), "%s/input0", dev_name(&spi->dev));
+        snprintf(ts->name, sizeof(ts->name), "ADS%d Touchscreen", ts->model);
+
+        input_dev->name = ts->name;
+        input_dev->phys = ts->phys;
+        input_dev->dev.parent = &spi->dev;
+
+        input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
+        input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
+        input_set_abs_params(input_dev, ABS_X,
+                        pdata->x_min ? : 0,
+                        pdata->x_max ? : MAX_12BIT,
+                        0, 0);
+        input_set_abs_params(input_dev, ABS_Y,
+                        pdata->y_min ? : 0,
+                        pdata->y_max ? : MAX_12BIT,
+                        0, 0);
+        input_set_abs_params(input_dev, ABS_PRESSURE,
+                        pdata->pressure_min, pdata->pressure_max, 0, 0);
 
-        ts->last_msg = m;
+        ads7846_setup_spi_msg(ts, pdata);
 
         ts->reg = regulator_get(&spi->dev, "vcc");
         if (IS_ERR(ts->reg)) {
@@ -1271,16 +1320,17 @@ static int __devinit ads7846_probe(struct spi_device *spi)
         }
 
         irq_flags = pdata->irq_flags ? : IRQF_TRIGGER_FALLING;
+        irq_flags |= IRQF_ONESHOT;
 
-        err = request_irq(spi->irq, ads7846_irq, irq_flags,
-                          spi->dev.driver->name, ts);
-
+        err = request_threaded_irq(spi->irq, ads7846_hard_irq, ads7846_irq,
+                                   irq_flags, spi->dev.driver->name, ts);
         if (err && !pdata->irq_flags) {
                 dev_info(&spi->dev,
                         "trying pin change workaround on irq %d\n", spi->irq);
-                err = request_irq(spi->irq, ads7846_irq,
-                                  IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
-                                  spi->dev.driver->name, ts);
+                irq_flags |= IRQF_TRIGGER_RISING;
+                err = request_threaded_irq(spi->irq,
+                                  ads7846_hard_irq, ads7846_irq,
+                                  irq_flags, spi->dev.driver->name, ts);
         }
 
         if (err) {
@@ -1294,14 +1344,14 @@ static int __devinit ads7846_probe(struct spi_device *spi)
 
         dev_info(&spi->dev, "touchscreen, irq %d\n", spi->irq);
 
-        /* take a first sample, leaving nPENIRQ active and vREF off; avoid
+        /*
+         * Take a first sample, leaving nPENIRQ active and vREF off; avoid
          * the touchscreen, in case it's not connected.
          */
         if (ts->model == 7845)
                 ads7845_read12_ser(&spi->dev, PWRDOWN);
         else
-                (void) ads7846_read12_ser(&spi->dev,
-                                READ_12BIT_SER(vaux) | ADS_PD10_ALL_ON);
+                (void) ads7846_read12_ser(&spi->dev, READ_12BIT_SER(vaux));
 
         err = sysfs_create_group(&spi->dev.kobj, &ads784x_attr_group);
         if (err)
@@ -1326,7 +1376,7 @@ static int __devinit ads7846_probe(struct spi_device *spi)
  err_put_regulator:
         regulator_put(ts->reg);
  err_free_gpio:
-        if (ts->gpio_pendown != -1)
+        if (!ts->get_pendown_state)
                 gpio_free(ts->gpio_pendown);
  err_cleanup_filter:
         if (ts->filter_cleanup)
@@ -1340,26 +1390,29 @@ static int __devinit ads7846_probe(struct spi_device *spi)
 
 static int __devexit ads7846_remove(struct spi_device *spi)
 {
-        struct ads7846          *ts = dev_get_drvdata(&spi->dev);
+        struct ads7846 *ts = dev_get_drvdata(&spi->dev);
 
         device_init_wakeup(&spi->dev, false);
 
-        ads784x_hwmon_unregister(spi, ts);
-        input_unregister_device(ts->input);
-
-        ads7846_suspend(spi, PMSG_SUSPEND);
-
         sysfs_remove_group(&spi->dev.kobj, &ads784x_attr_group);
 
+        ads7846_disable(ts);
         free_irq(ts->spi->irq, ts);
-        /* suspend left the IRQ disabled */
-        enable_irq(ts->spi->irq);
+
+        input_unregister_device(ts->input);
+
+        ads784x_hwmon_unregister(spi, ts);
 
         regulator_disable(ts->reg);
         regulator_put(ts->reg);
 
-        if (ts->gpio_pendown != -1)
+        if (!ts->get_pendown_state) {
+                /*
+                 * If we are not using specialized pendown method we must
+                 * have been relying on gpio we set up ourselves.
+                 */
                 gpio_free(ts->gpio_pendown);
+        }
 
         if (ts->filter_cleanup)
                 ts->filter_cleanup(ts->filter_data);
@@ -1368,6 +1421,7 @@ static int __devexit ads7846_remove(struct spi_device *spi)
         kfree(ts);
 
         dev_dbg(&spi->dev, "unregistered touchscreen\n");
+
         return 0;
 }
 
@@ -1376,11 +1430,10 @@ static struct spi_driver ads7846_driver = {
                 .name   = "ads7846",
                 .bus    = &spi_bus_type,
                 .owner  = THIS_MODULE,
+                .pm     = &ads7846_pm,
         },
         .probe          = ads7846_probe,
         .remove         = __devexit_p(ads7846_remove),
-        .suspend        = ads7846_suspend,
-        .resume         = ads7846_resume,
 };
 
 static int __init ads7846_init(void)
diff --git a/drivers/input/touchscreen/atmel_mxt_ts.c b/drivers/input/touchscreen/atmel_mxt_ts.c
new file mode 100644
index 000000000000..1e61387c73ca
--- /dev/null
+++ b/drivers/input/touchscreen/atmel_mxt_ts.c
@@ -0,0 +1,1243 @@
+/*
+ * Atmel maXTouch Touchscreen driver
+ *
+ * Copyright (C) 2010 Samsung Electronics Co.Ltd
+ * Author: Joonyoung Shim <jy0922.shim@samsung.com>
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/firmware.h>
+#include <linux/i2c.h>
+#include <linux/i2c/atmel_mxt_ts.h>
+#include <linux/input/mt.h>
+#include <linux/interrupt.h>
+#include <linux/slab.h>
+
+/* Version */
+#define MXT_VER_20              20
+#define MXT_VER_21              21
+#define MXT_VER_22              22
+
+/* Slave addresses */
+#define MXT_APP_LOW             0x4a
+#define MXT_APP_HIGH            0x4b
+#define MXT_BOOT_LOW            0x24
+#define MXT_BOOT_HIGH           0x25
+
+/* Firmware */
+#define MXT_FW_NAME             "maxtouch.fw"
+
+/* Registers */
+#define MXT_FAMILY_ID           0x00
+#define MXT_VARIANT_ID          0x01
+#define MXT_VERSION             0x02
+#define MXT_BUILD               0x03
+#define MXT_MATRIX_X_SIZE       0x04
+#define MXT_MATRIX_Y_SIZE       0x05
+#define MXT_OBJECT_NUM          0x06
+#define MXT_OBJECT_START        0x07
+
+#define MXT_OBJECT_SIZE         6
+
+/* Object types */
+#define MXT_DEBUG_DIAGNOSTIC    37
+#define MXT_GEN_MESSAGE         5
+#define MXT_GEN_COMMAND         6
+#define MXT_GEN_POWER           7
+#define MXT_GEN_ACQUIRE         8
+#define MXT_TOUCH_MULTI         9
+#define MXT_TOUCH_KEYARRAY      15
+#define MXT_TOUCH_PROXIMITY     23
+#define MXT_PROCI_GRIPFACE      20
+#define MXT_PROCG_NOISE         22
+#define MXT_PROCI_ONETOUCH      24
+#define MXT_PROCI_TWOTOUCH      27
+#define MXT_PROCI_GRIP          40
+#define MXT_PROCI_PALM          41
+#define MXT_SPT_COMMSCONFIG     18
+#define MXT_SPT_GPIOPWM         19
+#define MXT_SPT_SELFTEST        25
+#define MXT_SPT_CTECONFIG       28
+#define MXT_SPT_USERDATA        38
+#define MXT_SPT_DIGITIZER       43
+#define MXT_SPT_MESSAGECOUNT    44
+
+/* MXT_GEN_COMMAND field */
+#define MXT_COMMAND_RESET       0
+#define MXT_COMMAND_BACKUPNV    1
+#define MXT_COMMAND_CALIBRATE   2
+#define MXT_COMMAND_REPORTALL   3
+#define MXT_COMMAND_DIAGNOSTIC  5
+
+/* MXT_GEN_POWER field */
+#define MXT_POWER_IDLEACQINT    0
+#define MXT_POWER_ACTVACQINT    1
+#define MXT_POWER_ACTV2IDLETO   2
+
+/* MXT_GEN_ACQUIRE field */
+#define MXT_ACQUIRE_CHRGTIME    0
+#define MXT_ACQUIRE_TCHDRIFT    2
+#define MXT_ACQUIRE_DRIFTST     3
+#define MXT_ACQUIRE_TCHAUTOCAL  4
+#define MXT_ACQUIRE_SYNC        5
+#define MXT_ACQUIRE_ATCHCALST   6
+#define MXT_ACQUIRE_ATCHCALSTHR 7
+
+/* MXT_TOUCH_MULTI field */
+#define MXT_TOUCH_CTRL          0
+#define MXT_TOUCH_XORIGIN       1
+#define MXT_TOUCH_YORIGIN       2
+#define MXT_TOUCH_XSIZE         3
+#define MXT_TOUCH_YSIZE         4
+#define MXT_TOUCH_BLEN          6
+#define MXT_TOUCH_TCHTHR        7
+#define MXT_TOUCH_TCHDI         8
+#define MXT_TOUCH_ORIENT        9
+#define MXT_TOUCH_MOVHYSTI      11
+#define MXT_TOUCH_MOVHYSTN      12
+#define MXT_TOUCH_NUMTOUCH      14
+#define MXT_TOUCH_MRGHYST       15
+#define MXT_TOUCH_MRGTHR        16
+#define MXT_TOUCH_AMPHYST       17
+#define MXT_TOUCH_XRANGE_LSB    18
+#define MXT_TOUCH_XRANGE_MSB    19
+#define MXT_TOUCH_YRANGE_LSB    20
+#define MXT_TOUCH_YRANGE_MSB    21
+#define MXT_TOUCH_XLOCLIP       22
+#define MXT_TOUCH_XHICLIP       23
+#define MXT_TOUCH_YLOCLIP       24
+#define MXT_TOUCH_YHICLIP       25
+#define MXT_TOUCH_XEDGECTRL     26
+#define MXT_TOUCH_XEDGEDIST     27
+#define MXT_TOUCH_YEDGECTRL     28
+#define MXT_TOUCH_YEDGEDIST     29
+#define MXT_TOUCH_JUMPLIMIT     30
+
+/* MXT_PROCI_GRIPFACE field */
+#define MXT_GRIPFACE_CTRL       0
+#define MXT_GRIPFACE_XLOGRIP    1
+#define MXT_GRIPFACE_XHIGRIP    2
+#define MXT_GRIPFACE_YLOGRIP    3
+#define MXT_GRIPFACE_YHIGRIP    4
+#define MXT_GRIPFACE_MAXTCHS    5
+#define MXT_GRIPFACE_SZTHR1     7
+#define MXT_GRIPFACE_SZTHR2     8
+#define MXT_GRIPFACE_SHPTHR1    9
+#define MXT_GRIPFACE_SHPTHR2    10
+#define MXT_GRIPFACE_SUPEXTTO   11
+
+/* MXT_PROCI_NOISE field */
+#define MXT_NOISE_CTRL          0
+#define MXT_NOISE_OUTFLEN       1
+#define MXT_NOISE_GCAFUL_LSB    3
+#define MXT_NOISE_GCAFUL_MSB    4
+#define MXT_NOISE_GCAFLL_LSB    5
+#define MXT_NOISE_GCAFLL_MSB    6
+#define MXT_NOISE_ACTVGCAFVALID 7
+#define MXT_NOISE_NOISETHR      8
+#define MXT_NOISE_FREQHOPSCALE  10
+#define MXT_NOISE_FREQ0         11
+#define MXT_NOISE_FREQ1         12
+#define MXT_NOISE_FREQ2         13
+#define MXT_NOISE_FREQ3         14
+#define MXT_NOISE_FREQ4         15
+#define MXT_NOISE_IDLEGCAFVALID 16
+
+/* MXT_SPT_COMMSCONFIG */
+#define MXT_COMMS_CTRL          0
+#define MXT_COMMS_CMD           1
+
+/* MXT_SPT_CTECONFIG field */
+#define MXT_CTE_CTRL            0
+#define MXT_CTE_CMD             1
+#define MXT_CTE_MODE            2
+#define MXT_CTE_IDLEGCAFDEPTH   3
+#define MXT_CTE_ACTVGCAFDEPTH   4
+#define MXT_CTE_VOLTAGE         5
+
+#define MXT_VOLTAGE_DEFAULT     2700000
+#define MXT_VOLTAGE_STEP        10000
+
+/* Define for MXT_GEN_COMMAND */
+#define MXT_BOOT_VALUE          0xa5
+#define MXT_BACKUP_VALUE        0x55
+#define MXT_BACKUP_TIME         25      /* msec */
+#define MXT_RESET_TIME          65      /* msec */
+
+#define MXT_FWRESET_TIME        175     /* msec */
+
+/* Command to unlock bootloader */
+#define MXT_UNLOCK_CMD_MSB      0xaa
+#define MXT_UNLOCK_CMD_LSB      0xdc
+
+/* Bootloader mode status */
+#define MXT_WAITING_BOOTLOAD_CMD        0xc0    /* valid 7 6 bit only */
+#define MXT_WAITING_FRAME_DATA  0x80    /* valid 7 6 bit only */
+#define MXT_FRAME_CRC_CHECK     0x02
+#define MXT_FRAME_CRC_FAIL      0x03
+#define MXT_FRAME_CRC_PASS      0x04
+#define MXT_APP_CRC_FAIL        0x40    /* valid 7 8 bit only */
+#define MXT_BOOT_STATUS_MASK    0x3f
+
+/* Touch status */
+#define MXT_SUPPRESS            (1 << 1)
+#define MXT_AMP                 (1 << 2)
+#define MXT_VECTOR              (1 << 3)
+#define MXT_MOVE                (1 << 4)
+#define MXT_RELEASE             (1 << 5)
+#define MXT_PRESS               (1 << 6)
+#define MXT_DETECT              (1 << 7)
+
+/* Touch orient bits */
+#define MXT_XY_SWITCH           (1 << 0)
+#define MXT_X_INVERT            (1 << 1)
+#define MXT_Y_INVERT            (1 << 2)
+
+/* Touchscreen absolute values */
+#define MXT_MAX_AREA            0xff
+
+#define MXT_MAX_FINGER          10
+
+struct mxt_info {
+        u8 family_id;
+        u8 variant_id;
+        u8 version;
+        u8 build;
+        u8 matrix_xsize;
+        u8 matrix_ysize;
+        u8 object_num;
+};
+
+struct mxt_object {
+        u8 type;
+        u16 start_address;
+        u8 size;
+        u8 instances;
+        u8 num_report_ids;
+
+        /* to map object and message */
+        u8 max_reportid;
+};
+
+struct mxt_message {
+        u8 reportid;
+        u8 message[7];
+        u8 checksum;
+};
+
+struct mxt_finger {
+        int status;
+        int x;
+        int y;
+        int area;
+};
+
+/* Each client has this additional data */
+struct mxt_data {
+        struct i2c_client *client;
+        struct input_dev *input_dev;
+        const struct mxt_platform_data *pdata;
+        struct mxt_object *object_table;
+        struct mxt_info info;
+        struct mxt_finger finger[MXT_MAX_FINGER];
+        unsigned int irq;
+        unsigned int max_x;
+        unsigned int max_y;
+};
+
+static bool mxt_object_readable(unsigned int type)
+{
+        switch (type) {
+        case MXT_GEN_MESSAGE:
+        case MXT_GEN_COMMAND:
+        case MXT_GEN_POWER:
+        case MXT_GEN_ACQUIRE:
+        case MXT_TOUCH_MULTI:
+        case MXT_TOUCH_KEYARRAY:
+        case MXT_TOUCH_PROXIMITY:
+        case MXT_PROCI_GRIPFACE:
+        case MXT_PROCG_NOISE:
+        case MXT_PROCI_ONETOUCH:
+        case MXT_PROCI_TWOTOUCH:
+        case MXT_PROCI_GRIP:
+        case MXT_PROCI_PALM:
+        case MXT_SPT_COMMSCONFIG:
+        case MXT_SPT_GPIOPWM:
+        case MXT_SPT_SELFTEST:
+        case MXT_SPT_CTECONFIG:
+        case MXT_SPT_USERDATA:
+                return true;
+        default:
+                return false;
+        }
+}
+
+static bool mxt_object_writable(unsigned int type)
+{
+        switch (type) {
+        case MXT_GEN_COMMAND:
+        case MXT_GEN_POWER:
+        case MXT_GEN_ACQUIRE:
+        case MXT_TOUCH_MULTI:
+        case MXT_TOUCH_KEYARRAY:
+        case MXT_TOUCH_PROXIMITY:
+        case MXT_PROCI_GRIPFACE:
+        case MXT_PROCG_NOISE:
+        case MXT_PROCI_ONETOUCH:
+        case MXT_PROCI_TWOTOUCH:
+        case MXT_PROCI_GRIP:
+        case MXT_PROCI_PALM:
+        case MXT_SPT_GPIOPWM:
+        case MXT_SPT_SELFTEST:
+        case MXT_SPT_CTECONFIG:
+                return true;
+        default:
+                return false;
+        }
+}
+
+static void mxt_dump_message(struct device *dev,
+                                  struct mxt_message *message)
+{
+        dev_dbg(dev, "reportid:\t0x%x\n", message->reportid);
+        dev_dbg(dev, "message1:\t0x%x\n", message->message[0]);
+        dev_dbg(dev, "message2:\t0x%x\n", message->message[1]);
+        dev_dbg(dev, "message3:\t0x%x\n", message->message[2]);
+        dev_dbg(dev, "message4:\t0x%x\n", message->message[3]);
+        dev_dbg(dev, "message5:\t0x%x\n", message->message[4]);
+        dev_dbg(dev, "message6:\t0x%x\n", message->message[5]);
+        dev_dbg(dev, "message7:\t0x%x\n", message->message[6]);
+        dev_dbg(dev, "checksum:\t0x%x\n", message->checksum);
+}
+
+static int mxt_check_bootloader(struct i2c_client *client,
+                                     unsigned int state)
+{
+        u8 val;
+
+recheck:
+        if (i2c_master_recv(client, &val, 1) != 1) {
+                dev_err(&client->dev, "%s: i2c recv failed\n", __func__);
+                return -EIO;
+        }
+
+        switch (state) {
+        case MXT_WAITING_BOOTLOAD_CMD:
+        case MXT_WAITING_FRAME_DATA:
+                val &= ~MXT_BOOT_STATUS_MASK;
+                break;
+        case MXT_FRAME_CRC_PASS:
+                if (val == MXT_FRAME_CRC_CHECK)
+                        goto recheck;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        if (val != state) {
+                dev_err(&client->dev, "Unvalid bootloader mode state\n");
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int mxt_unlock_bootloader(struct i2c_client *client)
+{
+        u8 buf[2];
+
+        buf[0] = MXT_UNLOCK_CMD_LSB;
+        buf[1] = MXT_UNLOCK_CMD_MSB;
+
+        if (i2c_master_send(client, buf, 2) != 2) {
+                dev_err(&client->dev, "%s: i2c send failed\n", __func__);
+                return -EIO;
+        }
+
+        return 0;
+}
+
+static int mxt_fw_write(struct i2c_client *client,
+                             const u8 *data, unsigned int frame_size)
+{
+        if (i2c_master_send(client, data, frame_size) != frame_size) {
+                dev_err(&client->dev, "%s: i2c send failed\n", __func__);
+                return -EIO;
+        }
+
+        return 0;
+}
+
+static int __mxt_read_reg(struct i2c_client *client,
+                               u16 reg, u16 len, void *val)
+{
+        struct i2c_msg xfer[2];
+        u8 buf[2];
+
+        buf[0] = reg & 0xff;
+        buf[1] = (reg >> 8) & 0xff;
+
+        /* Write register */
+        xfer[0].addr = client->addr;
+        xfer[0].flags = 0;
+        xfer[0].len = 2;
+        xfer[0].buf = buf;
+
+        /* Read data */
+        xfer[1].addr = client->addr;
+        xfer[1].flags = I2C_M_RD;
+        xfer[1].len = len;
+        xfer[1].buf = val;
+
+        if (i2c_transfer(client->adapter, xfer, 2) != 2) {
+                dev_err(&client->dev, "%s: i2c transfer failed\n", __func__);
+                return -EIO;
+        }
+
+        return 0;
+}
+
+static int mxt_read_reg(struct i2c_client *client, u16 reg, u8 *val)
+{
+        return __mxt_read_reg(client, reg, 1, val);
+}
+
+static int mxt_write_reg(struct i2c_client *client, u16 reg, u8 val)
+{
+        u8 buf[3];
+
+        buf[0] = reg & 0xff;
+        buf[1] = (reg >> 8) & 0xff;
+        buf[2] = val;
+
+        if (i2c_master_send(client, buf, 3) != 3) {
+                dev_err(&client->dev, "%s: i2c send failed\n", __func__);
+                return -EIO;
+        }
+
+        return 0;
+}
+
+static int mxt_read_object_table(struct i2c_client *client,
+                                      u16 reg, u8 *object_buf)
+{
+        return __mxt_read_reg(client, reg, MXT_OBJECT_SIZE,
+                                   object_buf);
+}
+
+static struct mxt_object *
+mxt_get_object(struct mxt_data *data, u8 type)
+{
+        struct mxt_object *object;
+        int i;
+
+        for (i = 0; i < data->info.object_num; i++) {
+                object = data->object_table + i;
+                if (object->type == type)
+                        return object;
+        }
+
+        dev_err(&data->client->dev, "Invalid object type\n");
+        return NULL;
+}
+
+static int mxt_read_message(struct mxt_data *data,
+                                 struct mxt_message *message)
+{
+        struct mxt_object *object;
+        u16 reg;
+
+        object = mxt_get_object(data, MXT_GEN_MESSAGE);
+        if (!object)
+                return -EINVAL;
+
+        reg = object->start_address;
+        return __mxt_read_reg(data->client, reg,
+                        sizeof(struct mxt_message), message);
+}
+
+static int mxt_read_object(struct mxt_data *data,
+                                u8 type, u8 offset, u8 *val)
+{
+        struct mxt_object *object;
+        u16 reg;
+
+        object = mxt_get_object(data, type);
+        if (!object)
+                return -EINVAL;
+
+        reg = object->start_address;
+        return __mxt_read_reg(data->client, reg + offset, 1, val);
+}
+
+static int mxt_write_object(struct mxt_data *data,
+                                 u8 type, u8 offset, u8 val)
+{
+        struct mxt_object *object;
+        u16 reg;
+
+        object = mxt_get_object(data, type);
+        if (!object)
+                return -EINVAL;
+
+        reg = object->start_address;
+        return mxt_write_reg(data->client, reg + offset, val);
+}
+
+static void mxt_input_report(struct mxt_data *data, int single_id)
+{
+        struct mxt_finger *finger = data->finger;
+        struct input_dev *input_dev = data->input_dev;
+        int status = finger[single_id].status;
+        int finger_num = 0;
+        int id;
+
+        for (id = 0; id < MXT_MAX_FINGER; id++) {
+                if (!finger[id].status)
+                        continue;
+
+                input_mt_slot(input_dev, id);
+                input_mt_report_slot_state(input_dev, MT_TOOL_FINGER,
+                                finger[id].status != MXT_RELEASE);
+
+                if (finger[id].status != MXT_RELEASE) {
+                        finger_num++;
+                        input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR,
+                                        finger[id].area);
+                        input_report_abs(input_dev, ABS_MT_POSITION_X,
+                                        finger[id].x);
+                        input_report_abs(input_dev, ABS_MT_POSITION_Y,
+                                        finger[id].y);
+                } else {
+                        finger[id].status = 0;
+                }
+        }
+
+        input_report_key(input_dev, BTN_TOUCH, finger_num > 0);
+
+        if (status != MXT_RELEASE) {
+                input_report_abs(input_dev, ABS_X, finger[single_id].x);
+                input_report_abs(input_dev, ABS_Y, finger[single_id].y);
+        }
+
+        input_sync(input_dev);
+}
+
+static void mxt_input_touchevent(struct mxt_data *data,
+                                      struct mxt_message *message, int id)
+{
+        struct mxt_finger *finger = data->finger;
+        struct device *dev = &data->client->dev;
+        u8 status = message->message[0];
+        int x;
+        int y;
+        int area;
+
+        /* Check the touch is present on the screen */
+        if (!(status & MXT_DETECT)) {
+                if (status & MXT_RELEASE) {
+                        dev_dbg(dev, "[%d] released\n", id);
+
+                        finger[id].status = MXT_RELEASE;
+                        mxt_input_report(data, id);
+                }
+                return;
+        }
+
+        /* Check only AMP detection */
+        if (!(status & (MXT_PRESS | MXT_MOVE)))
+                return;
+
+        x = (message->message[1] << 4) | ((message->message[3] >> 4) & 0xf);
+        y = (message->message[2] << 4) | ((message->message[3] & 0xf));
+        if (data->max_x < 1024)
+                x = x >> 2;
+        if (data->max_y < 1024)
+                y = y >> 2;
+
+        area = message->message[4];
+
+        dev_dbg(dev, "[%d] %s x: %d, y: %d, area: %d\n", id,
+                status & MXT_MOVE ? "moved" : "pressed",
+                x, y, area);
+
+        finger[id].status = status & MXT_MOVE ?
+                                MXT_MOVE : MXT_PRESS;
+        finger[id].x = x;
+        finger[id].y = y;
+        finger[id].area = area;
+
+        mxt_input_report(data, id);
+}
+
+static irqreturn_t mxt_interrupt(int irq, void *dev_id)
+{
+        struct mxt_data *data = dev_id;
+        struct mxt_message message;
+        struct mxt_object *object;
+        struct device *dev = &data->client->dev;
+        int id;
+        u8 reportid;
+        u8 max_reportid;
+        u8 min_reportid;
+
+        do {
+                if (mxt_read_message(data, &message)) {
+                        dev_err(dev, "Failed to read message\n");
+                        goto end;
+                }
+
+                reportid = message.reportid;
+
+                /* whether reportid is thing of MXT_TOUCH_MULTI */
+                object = mxt_get_object(data, MXT_TOUCH_MULTI);
+                if (!object)
+                        goto end;
+
+                max_reportid = object->max_reportid;
+                min_reportid = max_reportid - object->num_report_ids + 1;
+                id = reportid - min_reportid;
+
+                if (reportid >= min_reportid && reportid <= max_reportid)
+                        mxt_input_touchevent(data, &message, id);
+                else
+                        mxt_dump_message(dev, &message);
+        } while (reportid != 0xff);
+
+end:
+        return IRQ_HANDLED;
+}
+
+static int mxt_check_reg_init(struct mxt_data *data)
+{
+        const struct mxt_platform_data *pdata = data->pdata;
+        struct mxt_object *object;
+        struct device *dev = &data->client->dev;
+        int index = 0;
+        int i, j, config_offset;
+
+        if (!pdata->config) {
+                dev_dbg(dev, "No cfg data defined, skipping reg init\n");
+                return 0;
+        }
+
+        for (i = 0; i < data->info.object_num; i++) {
+                object = data->object_table + i;
+
+                if (!mxt_object_writable(object->type))
+                        continue;
+
+                for (j = 0; j < object->size + 1; j++) {
+                        config_offset = index + j;
+                        if (config_offset > pdata->config_length) {
+                                dev_err(dev, "Not enough config data!\n");
+                                return -EINVAL;
+                        }
+                        mxt_write_object(data, object->type, j,
+                                         pdata->config[config_offset]);
+                }
+                index += object->size + 1;
+        }
+
+        return 0;
+}
+
+static int mxt_make_highchg(struct mxt_data *data)
+{
+        struct device *dev = &data->client->dev;
+        struct mxt_message message;
+        int count = 10;
+        int error;
+
+        /* Read dummy message to make high CHG pin */
+        do {
+                error = mxt_read_message(data, &message);
+                if (error)
+                        return error;
+        } while (message.reportid != 0xff && --count);
+
+        if (!count) {
+                dev_err(dev, "CHG pin isn't cleared\n");
+                return -EBUSY;
+        }
+
+        return 0;
+}
+
+static void mxt_handle_pdata(struct mxt_data *data)
+{
+        const struct mxt_platform_data *pdata = data->pdata;
+        u8 voltage;
+
+        /* Set touchscreen lines */
+        mxt_write_object(data, MXT_TOUCH_MULTI, MXT_TOUCH_XSIZE,
+                        pdata->x_line);
+        mxt_write_object(data, MXT_TOUCH_MULTI, MXT_TOUCH_YSIZE,
+                        pdata->y_line);
+
+        /* Set touchscreen orient */
+        mxt_write_object(data, MXT_TOUCH_MULTI, MXT_TOUCH_ORIENT,
+                        pdata->orient);
+
+        /* Set touchscreen burst length */
+        mxt_write_object(data, MXT_TOUCH_MULTI,
+                        MXT_TOUCH_BLEN, pdata->blen);
+
+        /* Set touchscreen threshold */
+        mxt_write_object(data, MXT_TOUCH_MULTI,
+                        MXT_TOUCH_TCHTHR, pdata->threshold);
+
+        /* Set touchscreen resolution */
+        mxt_write_object(data, MXT_TOUCH_MULTI,
+                        MXT_TOUCH_XRANGE_LSB, (pdata->x_size - 1) & 0xff);
+        mxt_write_object(data, MXT_TOUCH_MULTI,
+                        MXT_TOUCH_XRANGE_MSB, (pdata->x_size - 1) >> 8);
+        mxt_write_object(data, MXT_TOUCH_MULTI,
+                        MXT_TOUCH_YRANGE_LSB, (pdata->y_size - 1) & 0xff);
+        mxt_write_object(data, MXT_TOUCH_MULTI,
+                        MXT_TOUCH_YRANGE_MSB, (pdata->y_size - 1) >> 8);
+
+        /* Set touchscreen voltage */
+        if (pdata->voltage) {
+                if (pdata->voltage < MXT_VOLTAGE_DEFAULT) {
+                        voltage = (MXT_VOLTAGE_DEFAULT - pdata->voltage) /
+                                MXT_VOLTAGE_STEP;
+                        voltage = 0xff - voltage + 1;
+                } else
+                        voltage = (pdata->voltage - MXT_VOLTAGE_DEFAULT) /
+                                MXT_VOLTAGE_STEP;
+
+                mxt_write_object(data, MXT_SPT_CTECONFIG,
+                                MXT_CTE_VOLTAGE, voltage);
+        }
+}
+
+static int mxt_get_info(struct mxt_data *data)
+{
+        struct i2c_client *client = data->client;
+        struct mxt_info *info = &data->info;
+        int error;
+        u8 val;
+
+        error = mxt_read_reg(client, MXT_FAMILY_ID, &val);
+        if (error)
+                return error;
+        info->family_id = val;
+
+        error = mxt_read_reg(client, MXT_VARIANT_ID, &val);
+        if (error)
+                return error;
+        info->variant_id = val;
+
+        error = mxt_read_reg(client, MXT_VERSION, &val);
+        if (error)
+                return error;
+        info->version = val;
+
+        error = mxt_read_reg(client, MXT_BUILD, &val);
+        if (error)
+                return error;
+        info->build = val;
+
+        error = mxt_read_reg(client, MXT_OBJECT_NUM, &val);
+        if (error)
+                return error;
+        info->object_num = val;
+
+        return 0;
+}
+
+static int mxt_get_object_table(struct mxt_data *data)
+{
+        int error;
+        int i;
+        u16 reg;
+        u8 reportid = 0;
+        u8 buf[MXT_OBJECT_SIZE];
+
+        for (i = 0; i < data->info.object_num; i++) {
+                struct mxt_object *object = data->object_table + i;
+
+                reg = MXT_OBJECT_START + MXT_OBJECT_SIZE * i;
+                error = mxt_read_object_table(data->client, reg, buf);
+                if (error)
+                        return error;
+
+                object->type = buf[0];
+                object->start_address = (buf[2] << 8) | buf[1];
+                object->size = buf[3];
+                object->instances = buf[4];
+                object->num_report_ids = buf[5];
+
+                if (object->num_report_ids) {
+                        reportid += object->num_report_ids *
+                                        (object->instances + 1);
+                        object->max_reportid = reportid;
+                }
+        }
+
+        return 0;
+}
+
+static int mxt_initialize(struct mxt_data *data)
+{
+        struct i2c_client *client = data->client;
+        struct mxt_info *info = &data->info;
+        int error;
+        u8 val;
+
+        error = mxt_get_info(data);
+        if (error)
+                return error;
+
+        data->object_table = kcalloc(info->object_num,
+                                     sizeof(struct mxt_object),
+                                     GFP_KERNEL);
+        if (!data->object_table) {
+                dev_err(&client->dev, "Failed to allocate memory\n");
+                return -ENOMEM;
+        }
+
+        /* Get object table information */
+        error = mxt_get_object_table(data);
+        if (error)
+                return error;
+
+        /* Check register init values */
+        error = mxt_check_reg_init(data);
+        if (error)
+                return error;
+
+        mxt_handle_pdata(data);
+
+        /* Backup to memory */
+        mxt_write_object(data, MXT_GEN_COMMAND,
+                        MXT_COMMAND_BACKUPNV,
+                        MXT_BACKUP_VALUE);
+        msleep(MXT_BACKUP_TIME);
+
+        /* Soft reset */
+        mxt_write_object(data, MXT_GEN_COMMAND,
+                        MXT_COMMAND_RESET, 1);
+        msleep(MXT_RESET_TIME);
+
+        /* Update matrix size at info struct */
+        error = mxt_read_reg(client, MXT_MATRIX_X_SIZE, &val);
+        if (error)
+                return error;
+        info->matrix_xsize = val;
+
+        error = mxt_read_reg(client, MXT_MATRIX_Y_SIZE, &val);
+        if (error)
+                return error;
+        info->matrix_ysize = val;
+
+        dev_info(&client->dev,
+                        "Family ID: %d Variant ID: %d Version: %d Build: %d\n",
+                        info->family_id, info->variant_id, info->version,
+                        info->build);
+
+        dev_info(&client->dev,
+                        "Matrix X Size: %d Matrix Y Size: %d Object Num: %d\n",
+                        info->matrix_xsize, info->matrix_ysize,
+                        info->object_num);
+
+        return 0;
+}
+
+static void mxt_calc_resolution(struct mxt_data *data)
+{
+        unsigned int max_x = data->pdata->x_size - 1;
+        unsigned int max_y = data->pdata->y_size - 1;
+
+        if (data->pdata->orient & MXT_XY_SWITCH) {
+                data->max_x = max_y;
+                data->max_y = max_x;
+        } else {
+                data->max_x = max_x;
+                data->max_y = max_y;
+        }
+}
+
+static ssize_t mxt_object_show(struct device *dev,
+                                    struct device_attribute *attr, char *buf)
+{
+        struct mxt_data *data = dev_get_drvdata(dev);
+        struct mxt_object *object;
+        int count = 0;
+        int i, j;
+        int error;
+        u8 val;
+
+        for (i = 0; i < data->info.object_num; i++) {
+                object = data->object_table + i;
+
+                count += sprintf(buf + count,
+                                "Object Table Element %d(Type %d)\n",
+                                i + 1, object->type);
+
+                if (!mxt_object_readable(object->type)) {
+                        count += sprintf(buf + count, "\n");
+                        continue;
+                }
+
+                for (j = 0; j < object->size + 1; j++) {
+                        error = mxt_read_object(data,
+                                                object->type, j, &val);
+                        if (error)
+                                return error;
+
+                        count += sprintf(buf + count,
+                                        "  Byte %d: 0x%x (%d)\n", j, val, val);
+                }
+
+                count += sprintf(buf + count, "\n");
+        }
+
+        return count;
+}
+
+static int mxt_load_fw(struct device *dev, const char *fn)
+{
+        struct mxt_data *data = dev_get_drvdata(dev);
+        struct i2c_client *client = data->client;
+        const struct firmware *fw = NULL;
+        unsigned int frame_size;
+        unsigned int pos = 0;
+        int ret;
+
+        ret = request_firmware(&fw, fn, dev);
+        if (ret) {
+                dev_err(dev, "Unable to open firmware %s\n", fn);
+                return ret;
+        }
+
+        /* Change to the bootloader mode */
+        mxt_write_object(data, MXT_GEN_COMMAND,
+                        MXT_COMMAND_RESET, MXT_BOOT_VALUE);
+        msleep(MXT_RESET_TIME);
+
+        /* Change to slave address of bootloader */
+        if (client->addr == MXT_APP_LOW)
+                client->addr = MXT_BOOT_LOW;
+        else
+                client->addr = MXT_BOOT_HIGH;
+
+        ret = mxt_check_bootloader(client, MXT_WAITING_BOOTLOAD_CMD);
+        if (ret)
+                goto out;
+
+        /* Unlock bootloader */
+        mxt_unlock_bootloader(client);
+
+        while (pos < fw->size) {
+                ret = mxt_check_bootloader(client,
+                                                MXT_WAITING_FRAME_DATA);
+                if (ret)
+                        goto out;
+
+                frame_size = ((*(fw->data + pos) << 8) | *(fw->data + pos + 1));
+
+                /* We should add 2 at frame size as the the firmware data is not
+                 * included the CRC bytes.
+                 */
+                frame_size += 2;
+
+                /* Write one frame to device */
+                mxt_fw_write(client, fw->data + pos, frame_size);
+
+                ret = mxt_check_bootloader(client,
+                                                MXT_FRAME_CRC_PASS);
+                if (ret)
+                        goto out;
+
+                pos += frame_size;
+
+                dev_dbg(dev, "Updated %d bytes / %zd bytes\n", pos, fw->size);
+        }
+
+out:
+        release_firmware(fw);
+
+        /* Change to slave address of application */
+        if (client->addr == MXT_BOOT_LOW)
+                client->addr = MXT_APP_LOW;
+        else
+                client->addr = MXT_APP_HIGH;
+
+        return ret;
+}
+
+static ssize_t mxt_update_fw_store(struct device *dev,
+                                        struct device_attribute *attr,
+                                        const char *buf, size_t count)
+{
+        struct mxt_data *data = dev_get_drvdata(dev);
+        int error;
+
+        disable_irq(data->irq);
+
+        error = mxt_load_fw(dev, MXT_FW_NAME);
+        if (error) {
+                dev_err(dev, "The firmware update failed(%d)\n", error);
+                count = error;
+        } else {
+                dev_dbg(dev, "The firmware update succeeded\n");
+
+                /* Wait for reset */
+                msleep(MXT_FWRESET_TIME);
+
+                kfree(data->object_table);
+                data->object_table = NULL;
+
+                mxt_initialize(data);
+        }
+
+        enable_irq(data->irq);
+
+        error = mxt_make_highchg(data);
+        if (error)
+                return error;
+
+        return count;
+}
+
+static DEVICE_ATTR(object, 0444, mxt_object_show, NULL);
+static DEVICE_ATTR(update_fw, 0664, NULL, mxt_update_fw_store);
+
+static struct attribute *mxt_attrs[] = {
+        &dev_attr_object.attr,
+        &dev_attr_update_fw.attr,
+        NULL
+};
+
+static const struct attribute_group mxt_attr_group = {
+        .attrs = mxt_attrs,
+};
+
+static void mxt_start(struct mxt_data *data)
+{
+        /* Touch enable */
+        mxt_write_object(data,
+                        MXT_TOUCH_MULTI, MXT_TOUCH_CTRL, 0x83);
+}
+
+static void mxt_stop(struct mxt_data *data)
+{
+        /* Touch disable */
+        mxt_write_object(data,
+                        MXT_TOUCH_MULTI, MXT_TOUCH_CTRL, 0);
+}
+
+static int mxt_input_open(struct input_dev *dev)
+{
+        struct mxt_data *data = input_get_drvdata(dev);
+
+        mxt_start(data);
+
+        return 0;
+}
+
+static void mxt_input_close(struct input_dev *dev)
+{
+        struct mxt_data *data = input_get_drvdata(dev);
+
+        mxt_stop(data);
+}
+
+static int __devinit mxt_probe(struct i2c_client *client,
+                const struct i2c_device_id *id)
+{
+        const struct mxt_platform_data *pdata = client->dev.platform_data;
+        struct mxt_data *data;
+        struct input_dev *input_dev;
+        int error;
+
+        if (!pdata)
+                return -EINVAL;
+
+        data = kzalloc(sizeof(struct mxt_data), GFP_KERNEL);
+        input_dev = input_allocate_device();
+        if (!data || !input_dev) {
+                dev_err(&client->dev, "Failed to allocate memory\n");
+                error = -ENOMEM;
+                goto err_free_mem;
+        }
+
+        input_dev->name = "Atmel maXTouch Touchscreen";
+        input_dev->id.bustype = BUS_I2C;
+        input_dev->dev.parent = &client->dev;
+        input_dev->open = mxt_input_open;
+        input_dev->close = mxt_input_close;
+
+        data->client = client;
+        data->input_dev = input_dev;
+        data->pdata = pdata;
+        data->irq = client->irq;
+
+        mxt_calc_resolution(data);
+
+        __set_bit(EV_ABS, input_dev->evbit);
+        __set_bit(EV_KEY, input_dev->evbit);
+        __set_bit(BTN_TOUCH, input_dev->keybit);
+
+        /* For single touch */
+        input_set_abs_params(input_dev, ABS_X,
+                             0, data->max_x, 0, 0);
+        input_set_abs_params(input_dev, ABS_Y,
+                             0, data->max_y, 0, 0);
+
+        /* For multi touch */
+        input_mt_init_slots(input_dev, MXT_MAX_FINGER);
+        input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR,
+                             0, MXT_MAX_AREA, 0, 0);
+        input_set_abs_params(input_dev, ABS_MT_POSITION_X,
+                             0, data->max_x, 0, 0);
+        input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
+                             0, data->max_y, 0, 0);
+
+        input_set_drvdata(input_dev, data);
+        i2c_set_clientdata(client, data);
+
+        error = mxt_initialize(data);
+        if (error)
+                goto err_free_object;
+
+        error = request_threaded_irq(client->irq, NULL, mxt_interrupt,
+                        pdata->irqflags, client->dev.driver->name, data);
+        if (error) {
+                dev_err(&client->dev, "Failed to register interrupt\n");
+                goto err_free_object;
+        }
+
+        error = mxt_make_highchg(data);
+        if (error)
+                goto err_free_irq;
+
+        error = input_register_device(input_dev);
+        if (error)
+                goto err_free_irq;
+
+        error = sysfs_create_group(&client->dev.kobj, &mxt_attr_group);
+        if (error)
+                goto err_unregister_device;
+
+        return 0;
+
+err_unregister_device:
+        input_unregister_device(input_dev);
+        input_dev = NULL;
+err_free_irq:
+        free_irq(client->irq, data);
+err_free_object:
+        kfree(data->object_table);
+err_free_mem:
+        input_free_device(input_dev);
+        kfree(data);
+        return error;
+}
+
+static int __devexit mxt_remove(struct i2c_client *client)
+{
+        struct mxt_data *data = i2c_get_clientdata(client);
+
+        sysfs_remove_group(&client->dev.kobj, &mxt_attr_group);
+        free_irq(data->irq, data);
+        input_unregister_device(data->input_dev);
+        kfree(data->object_table);
+        kfree(data);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int mxt_suspend(struct device *dev)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct mxt_data *data = i2c_get_clientdata(client);
+        struct input_dev *input_dev = data->input_dev;
+
+        mutex_lock(&input_dev->mutex);
+
+        if (input_dev->users)
+                mxt_stop(data);
+
+        mutex_unlock(&input_dev->mutex);
+
+        return 0;
+}
+
+static int mxt_resume(struct device *dev)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct mxt_data *data = i2c_get_clientdata(client);
+        struct input_dev *input_dev = data->input_dev;
+
+        /* Soft reset */
+        mxt_write_object(data, MXT_GEN_COMMAND,
+                        MXT_COMMAND_RESET, 1);
+
+        msleep(MXT_RESET_TIME);
+
+        mutex_lock(&input_dev->mutex);
+
+        if (input_dev->users)
+                mxt_start(data);
+
+        mutex_unlock(&input_dev->mutex);
+
+        return 0;
+}
+
+static const struct dev_pm_ops mxt_pm_ops = {
+        .suspend        = mxt_suspend,
+        .resume         = mxt_resume,
+};
+#endif
+
+static const struct i2c_device_id mxt_id[] = {
+        { "qt602240_ts", 0 },
+        { "atmel_mxt_ts", 0 },
+        { "mXT224", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, mxt_id);
+
+static struct i2c_driver mxt_driver = {
+        .driver = {
+                .name   = "atmel_mxt_ts",
+                .owner  = THIS_MODULE,
+#ifdef CONFIG_PM
+                .pm     = &mxt_pm_ops,
+#endif
+        },
+        .probe          = mxt_probe,
+        .remove         = __devexit_p(mxt_remove),
+        .id_table       = mxt_id,
+};
+
+static int __init mxt_init(void)
+{
+        return i2c_add_driver(&mxt_driver);
+}
+
+static void __exit mxt_exit(void)
+{
+        i2c_del_driver(&mxt_driver);
+}
+
+module_init(mxt_init);
+module_exit(mxt_exit);
+
+/* Module information */
+MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
+MODULE_DESCRIPTION("Atmel maXTouch Touchscreen driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/touchscreen/atmel_tsadcc.c b/drivers/input/touchscreen/atmel_tsadcc.c
index 3d9b5166ebe9..432c69be6ac6 100644
--- a/drivers/input/touchscreen/atmel_tsadcc.c
+++ b/drivers/input/touchscreen/atmel_tsadcc.c
@@ -317,7 +317,7 @@ err_unmap_regs:
 err_release_mem:
         release_mem_region(res->start, resource_size(res));
 err_free_dev:
-        input_free_device(ts_dev->input);
+        input_free_device(input_dev);
 err_free_mem:
         kfree(ts_dev);
         return err;
diff --git a/drivers/input/touchscreen/bu21013_ts.c b/drivers/input/touchscreen/bu21013_ts.c
new file mode 100644
index 000000000000..1507ce108d5b
--- /dev/null
+++ b/drivers/input/touchscreen/bu21013_ts.c
@@ -0,0 +1,681 @@
+/*
+ * Copyright (C) ST-Ericsson SA 2010
+ * Author: Naveen Kumar G <naveen.gaddipati@stericsson.com> for ST-Ericsson
+ * License terms:GNU General Public License (GPL) version 2
+ */
+
+#include <linux/kernel.h>
+#include <linux/delay.h>
+#include <linux/interrupt.h>
+#include <linux/i2c.h>
+#include <linux/workqueue.h>
+#include <linux/input.h>
+#include <linux/input/bu21013.h>
+#include <linux/slab.h>
+#include <linux/regulator/consumer.h>
+
+#define PEN_DOWN_INTR   0
+#define MAX_FINGERS     2
+#define RESET_DELAY     30
+#define PENUP_TIMEOUT   (10)
+#define DELTA_MIN       16
+#define MASK_BITS       0x03
+#define SHIFT_8         8
+#define SHIFT_2         2
+#define LENGTH_OF_BUFFER        11
+#define I2C_RETRY_COUNT 5
+
+#define BU21013_SENSORS_BTN_0_7_REG     0x70
+#define BU21013_SENSORS_BTN_8_15_REG    0x71
+#define BU21013_SENSORS_BTN_16_23_REG   0x72
+#define BU21013_X1_POS_MSB_REG          0x73
+#define BU21013_X1_POS_LSB_REG          0x74
+#define BU21013_Y1_POS_MSB_REG          0x75
+#define BU21013_Y1_POS_LSB_REG          0x76
+#define BU21013_X2_POS_MSB_REG          0x77
+#define BU21013_X2_POS_LSB_REG          0x78
+#define BU21013_Y2_POS_MSB_REG          0x79
+#define BU21013_Y2_POS_LSB_REG          0x7A
+#define BU21013_INT_CLR_REG             0xE8
+#define BU21013_INT_MODE_REG            0xE9
+#define BU21013_GAIN_REG                0xEA
+#define BU21013_OFFSET_MODE_REG         0xEB
+#define BU21013_XY_EDGE_REG             0xEC
+#define BU21013_RESET_REG               0xED
+#define BU21013_CALIB_REG               0xEE
+#define BU21013_DONE_REG                0xEF
+#define BU21013_SENSOR_0_7_REG          0xF0
+#define BU21013_SENSOR_8_15_REG         0xF1
+#define BU21013_SENSOR_16_23_REG        0xF2
+#define BU21013_POS_MODE1_REG           0xF3
+#define BU21013_POS_MODE2_REG           0xF4
+#define BU21013_CLK_MODE_REG            0xF5
+#define BU21013_IDLE_REG                0xFA
+#define BU21013_FILTER_REG              0xFB
+#define BU21013_TH_ON_REG               0xFC
+#define BU21013_TH_OFF_REG              0xFD
+
+
+#define BU21013_RESET_ENABLE            0x01
+
+#define BU21013_SENSORS_EN_0_7          0x3F
+#define BU21013_SENSORS_EN_8_15         0xFC
+#define BU21013_SENSORS_EN_16_23        0x1F
+
+#define BU21013_POS_MODE1_0             0x02
+#define BU21013_POS_MODE1_1             0x04
+#define BU21013_POS_MODE1_2             0x08
+
+#define BU21013_POS_MODE2_ZERO          0x01
+#define BU21013_POS_MODE2_AVG1          0x02
+#define BU21013_POS_MODE2_AVG2          0x04
+#define BU21013_POS_MODE2_EN_XY         0x08
+#define BU21013_POS_MODE2_EN_RAW        0x10
+#define BU21013_POS_MODE2_MULTI         0x80
+
+#define BU21013_CLK_MODE_DIV            0x01
+#define BU21013_CLK_MODE_EXT            0x02
+#define BU21013_CLK_MODE_CALIB          0x80
+
+#define BU21013_IDLET_0                 0x01
+#define BU21013_IDLET_1                 0x02
+#define BU21013_IDLET_2                 0x04
+#define BU21013_IDLET_3                 0x08
+#define BU21013_IDLE_INTERMIT_EN        0x10
+
+#define BU21013_DELTA_0_6       0x7F
+#define BU21013_FILTER_EN       0x80
+
+#define BU21013_INT_MODE_LEVEL  0x00
+#define BU21013_INT_MODE_EDGE   0x01
+
+#define BU21013_GAIN_0          0x01
+#define BU21013_GAIN_1          0x02
+#define BU21013_GAIN_2          0x04
+
+#define BU21013_OFFSET_MODE_DEFAULT     0x00
+#define BU21013_OFFSET_MODE_MOVE        0x01
+#define BU21013_OFFSET_MODE_DISABLE     0x02
+
+#define BU21013_TH_ON_0         0x01
+#define BU21013_TH_ON_1         0x02
+#define BU21013_TH_ON_2         0x04
+#define BU21013_TH_ON_3         0x08
+#define BU21013_TH_ON_4         0x10
+#define BU21013_TH_ON_5         0x20
+#define BU21013_TH_ON_6         0x40
+#define BU21013_TH_ON_7         0x80
+#define BU21013_TH_ON_MAX       0xFF
+
+#define BU21013_TH_OFF_0        0x01
+#define BU21013_TH_OFF_1        0x02
+#define BU21013_TH_OFF_2        0x04
+#define BU21013_TH_OFF_3        0x08
+#define BU21013_TH_OFF_4        0x10
+#define BU21013_TH_OFF_5        0x20
+#define BU21013_TH_OFF_6        0x40
+#define BU21013_TH_OFF_7        0x80
+#define BU21013_TH_OFF_MAX      0xFF
+
+#define BU21013_X_EDGE_0        0x01
+#define BU21013_X_EDGE_1        0x02
+#define BU21013_X_EDGE_2        0x04
+#define BU21013_X_EDGE_3        0x08
+#define BU21013_Y_EDGE_0        0x10
+#define BU21013_Y_EDGE_1        0x20
+#define BU21013_Y_EDGE_2        0x40
+#define BU21013_Y_EDGE_3        0x80
+
+#define BU21013_DONE    0x01
+#define BU21013_NUMBER_OF_X_SENSORS     (6)
+#define BU21013_NUMBER_OF_Y_SENSORS     (11)
+
+#define DRIVER_TP       "bu21013_tp"
+
+/**
+ * struct bu21013_ts_data - touch panel data structure
+ * @client: pointer to the i2c client
+ * @wait: variable to wait_queue_head_t structure
+ * @touch_stopped: touch stop flag
+ * @chip: pointer to the touch panel controller
+ * @in_dev: pointer to the input device structure
+ * @intr_pin: interrupt pin value
+ * @regulator: pointer to the Regulator used for touch screen
+ *
+ * Touch panel device data structure
+ */
+struct bu21013_ts_data {
+        struct i2c_client *client;
+        wait_queue_head_t wait;
+        bool touch_stopped;
+        const struct bu21013_platform_device *chip;
+        struct input_dev *in_dev;
+        unsigned int intr_pin;
+        struct regulator *regulator;
+};
+
+/**
+ * bu21013_read_block_data(): read the touch co-ordinates
+ * @data: bu21013_ts_data structure pointer
+ * @buf: byte pointer
+ *
+ * Read the touch co-ordinates using i2c read block into buffer
+ * and returns integer.
+ */
+static int bu21013_read_block_data(struct bu21013_ts_data *data, u8 *buf)
+{
+        int ret, i;
+
+        for (i = 0; i < I2C_RETRY_COUNT; i++) {
+                ret = i2c_smbus_read_i2c_block_data
+                        (data->client, BU21013_SENSORS_BTN_0_7_REG,
+                                LENGTH_OF_BUFFER, buf);
+                if (ret == LENGTH_OF_BUFFER)
+                        return 0;
+        }
+        return -EINVAL;
+}
+
+/**
+ * bu21013_do_touch_report(): Get the touch co-ordinates
+ * @data: bu21013_ts_data structure pointer
+ *
+ * Get the touch co-ordinates from touch sensor registers and writes
+ * into device structure and returns integer.
+ */
+static int bu21013_do_touch_report(struct bu21013_ts_data *data)
+{
+        u8      buf[LENGTH_OF_BUFFER];
+        unsigned int pos_x[2], pos_y[2];
+        bool    has_x_sensors, has_y_sensors;
+        int     finger_down_count = 0;
+        int     i;
+
+        if (data == NULL)
+                return -EINVAL;
+
+        if (bu21013_read_block_data(data, buf) < 0)
+                return -EINVAL;
+
+        has_x_sensors = hweight32(buf[0] & BU21013_SENSORS_EN_0_7);
+        has_y_sensors = hweight32(((buf[1] & BU21013_SENSORS_EN_8_15) |
+                ((buf[2] & BU21013_SENSORS_EN_16_23) << SHIFT_8)) >> SHIFT_2);
+        if (!has_x_sensors || !has_y_sensors)
+                return 0;
+
+        for (i = 0; i < MAX_FINGERS; i++) {
+                const u8 *p = &buf[4 * i + 3];
+                unsigned int x = p[0] << SHIFT_2 | (p[1] & MASK_BITS);
+                unsigned int y = p[2] << SHIFT_2 | (p[3] & MASK_BITS);
+                if (x == 0 || y == 0)
+                        continue;
+                pos_x[finger_down_count] = x;
+                pos_y[finger_down_count] = y;
+                finger_down_count++;
+        }
+
+        if (finger_down_count) {
+                if (finger_down_count == 2 &&
+                    (abs(pos_x[0] - pos_x[1]) < DELTA_MIN ||
+                     abs(pos_y[0] - pos_y[1]) < DELTA_MIN)) {
+                        return 0;
+                }
+
+                for (i = 0; i < finger_down_count; i++) {
+                        if (data->chip->x_flip)
+                                pos_x[i] = data->chip->touch_x_max - pos_x[i];
+                        if (data->chip->y_flip)
+                                pos_y[i] = data->chip->touch_y_max - pos_y[i];
+
+                        input_report_abs(data->in_dev,
+                                         ABS_MT_POSITION_X, pos_x[i]);
+                        input_report_abs(data->in_dev,
+                                         ABS_MT_POSITION_Y, pos_y[i]);
+                        input_mt_sync(data->in_dev);
+                }
+        } else
+                input_mt_sync(data->in_dev);
+
+        input_sync(data->in_dev);
+
+        return 0;
+}
+/**
+ * bu21013_gpio_irq() - gpio thread function for touch interrupt
+ * @irq: irq value
+ * @device_data: void pointer
+ *
+ * This gpio thread function for touch interrupt
+ * and returns irqreturn_t.
+ */
+static irqreturn_t bu21013_gpio_irq(int irq, void *device_data)
+{
+        struct bu21013_ts_data *data = device_data;
+        struct i2c_client *i2c = data->client;
+        int retval;
+
+        do {
+                retval = bu21013_do_touch_report(data);
+                if (retval < 0) {
+                        dev_err(&i2c->dev, "bu21013_do_touch_report failed\n");
+                        return IRQ_NONE;
+                }
+
+                data->intr_pin = data->chip->irq_read_val();
+                if (data->intr_pin == PEN_DOWN_INTR)
+                        wait_event_timeout(data->wait, data->touch_stopped,
+                                           msecs_to_jiffies(2));
+        } while (!data->intr_pin && !data->touch_stopped);
+
+        return IRQ_HANDLED;
+}
+
+/**
+ * bu21013_init_chip() - power on sequence for the bu21013 controller
+ * @data: device structure pointer
+ *
+ * This function is used to power on
+ * the bu21013 controller and returns integer.
+ */
+static int bu21013_init_chip(struct bu21013_ts_data *data)
+{
+        int retval;
+        struct i2c_client *i2c = data->client;
+
+        retval = i2c_smbus_write_byte_data(i2c, BU21013_RESET_REG,
+                                        BU21013_RESET_ENABLE);
+        if (retval < 0) {
+                dev_err(&i2c->dev, "BU21013_RESET reg write failed\n");
+                return retval;
+        }
+        msleep(RESET_DELAY);
+
+        retval = i2c_smbus_write_byte_data(i2c, BU21013_SENSOR_0_7_REG,
+                                        BU21013_SENSORS_EN_0_7);
+        if (retval < 0) {
+                dev_err(&i2c->dev, "BU21013_SENSOR_0_7 reg write failed\n");
+                return retval;
+        }
+
+        retval = i2c_smbus_write_byte_data(i2c, BU21013_SENSOR_8_15_REG,
+                                                BU21013_SENSORS_EN_8_15);
+        if (retval < 0) {
+                dev_err(&i2c->dev, "BU21013_SENSOR_8_15 reg write failed\n");
+                return retval;
+        }
+
+        retval = i2c_smbus_write_byte_data(i2c, BU21013_SENSOR_16_23_REG,
+                                                BU21013_SENSORS_EN_16_23);
+        if (retval < 0) {
+                dev_err(&i2c->dev, "BU21013_SENSOR_16_23 reg write failed\n");
+                return retval;
+        }
+
+        retval = i2c_smbus_write_byte_data(i2c, BU21013_POS_MODE1_REG,
+                                (BU21013_POS_MODE1_0 | BU21013_POS_MODE1_1));
+        if (retval < 0) {
+                dev_err(&i2c->dev, "BU21013_POS_MODE1 reg write failed\n");
+                return retval;
+        }
+
+        retval = i2c_smbus_write_byte_data(i2c, BU21013_POS_MODE2_REG,
+                        (BU21013_POS_MODE2_ZERO | BU21013_POS_MODE2_AVG1 |
+                        BU21013_POS_MODE2_AVG2 | BU21013_POS_MODE2_EN_RAW |
+                        BU21013_POS_MODE2_MULTI));
+        if (retval < 0) {
+                dev_err(&i2c->dev, "BU21013_POS_MODE2 reg write failed\n");
+                return retval;
+        }
+
+        if (data->chip->ext_clk)
+                retval = i2c_smbus_write_byte_data(i2c, BU21013_CLK_MODE_REG,
+                        (BU21013_CLK_MODE_EXT | BU21013_CLK_MODE_CALIB));
+        else
+                retval = i2c_smbus_write_byte_data(i2c, BU21013_CLK_MODE_REG,
+                        (BU21013_CLK_MODE_DIV | BU21013_CLK_MODE_CALIB));
+        if (retval < 0) {
+                dev_err(&i2c->dev, "BU21013_CLK_MODE reg write failed\n");
+                return retval;
+        }
+
+        retval = i2c_smbus_write_byte_data(i2c, BU21013_IDLE_REG,
+                                (BU21013_IDLET_0 | BU21013_IDLE_INTERMIT_EN));
+        if (retval < 0) {
+                dev_err(&i2c->dev, "BU21013_IDLE reg write failed\n");
+                return retval;
+        }
+
+        retval = i2c_smbus_write_byte_data(i2c, BU21013_INT_MODE_REG,
+                                                BU21013_INT_MODE_LEVEL);
+        if (retval < 0) {
+                dev_err(&i2c->dev, "BU21013_INT_MODE reg write failed\n");
+                return retval;
+        }
+
+        retval = i2c_smbus_write_byte_data(i2c, BU21013_FILTER_REG,
+                                                (BU21013_DELTA_0_6 |
+                                                        BU21013_FILTER_EN));
+        if (retval < 0) {
+                dev_err(&i2c->dev, "BU21013_FILTER reg write failed\n");
+                return retval;
+        }
+
+        retval = i2c_smbus_write_byte_data(i2c, BU21013_TH_ON_REG,
+                                        BU21013_TH_ON_5);
+        if (retval < 0) {
+                dev_err(&i2c->dev, "BU21013_TH_ON reg write failed\n");
+                return retval;
+        }
+
+        retval = i2c_smbus_write_byte_data(i2c, BU21013_TH_OFF_REG,
+                                BU21013_TH_OFF_4 | BU21013_TH_OFF_3);
+        if (retval < 0) {
+                dev_err(&i2c->dev, "BU21013_TH_OFF reg write failed\n");
+                return retval;
+        }
+
+        retval = i2c_smbus_write_byte_data(i2c, BU21013_GAIN_REG,
+                                        (BU21013_GAIN_0 | BU21013_GAIN_1));
+        if (retval < 0) {
+                dev_err(&i2c->dev, "BU21013_GAIN reg write failed\n");
+                return retval;
+        }
+
+        retval = i2c_smbus_write_byte_data(i2c, BU21013_OFFSET_MODE_REG,
+                                        BU21013_OFFSET_MODE_DEFAULT);
+        if (retval < 0) {
+                dev_err(&i2c->dev, "BU21013_OFFSET_MODE reg write failed\n");
+                return retval;
+        }
+
+        retval = i2c_smbus_write_byte_data(i2c, BU21013_XY_EDGE_REG,
+                                (BU21013_X_EDGE_0 | BU21013_X_EDGE_2 |
+                                BU21013_Y_EDGE_1 | BU21013_Y_EDGE_3));
+        if (retval < 0) {
+                dev_err(&i2c->dev, "BU21013_XY_EDGE reg write failed\n");
+                return retval;
+        }
+
+        retval = i2c_smbus_write_byte_data(i2c, BU21013_DONE_REG,
+                                                        BU21013_DONE);
+        if (retval < 0) {
+                dev_err(&i2c->dev, "BU21013_REG_DONE reg write failed\n");
+                return retval;
+        }
+
+        return 0;
+}
+
+/**
+ * bu21013_free_irq() - frees IRQ registered for touchscreen
+ * @bu21013_data: device structure pointer
+ *
+ * This function signals interrupt thread to stop processing and
+ * frees interrupt.
+ */
+static void bu21013_free_irq(struct bu21013_ts_data *bu21013_data)
+{
+        bu21013_data->touch_stopped = true;
+        wake_up(&bu21013_data->wait);
+        free_irq(bu21013_data->chip->irq, bu21013_data);
+}
+
+/**
+ * bu21013_probe() - initializes the i2c-client touchscreen driver
+ * @client: i2c client structure pointer
+ * @id: i2c device id pointer
+ *
+ * This function used to initializes the i2c-client touchscreen
+ * driver and returns integer.
+ */
+static int __devinit bu21013_probe(struct i2c_client *client,
+                                        const struct i2c_device_id *id)
+{
+        struct bu21013_ts_data *bu21013_data;
+        struct input_dev *in_dev;
+        const struct bu21013_platform_device *pdata =
+                                        client->dev.platform_data;
+        int error;
+
+        if (!i2c_check_functionality(client->adapter,
+                                        I2C_FUNC_SMBUS_BYTE_DATA)) {
+                dev_err(&client->dev, "i2c smbus byte data not supported\n");
+                return -EIO;
+        }
+
+        if (!pdata) {
+                dev_err(&client->dev, "platform data not defined\n");
+                return -EINVAL;
+        }
+
+        bu21013_data = kzalloc(sizeof(struct bu21013_ts_data), GFP_KERNEL);
+        in_dev = input_allocate_device();
+        if (!bu21013_data || !in_dev) {
+                dev_err(&client->dev, "device memory alloc failed\n");
+                error = -ENOMEM;
+                goto err_free_mem;
+        }
+
+        bu21013_data->in_dev = in_dev;
+        bu21013_data->chip = pdata;
+        bu21013_data->client = client;
+
+        bu21013_data->regulator = regulator_get(&client->dev, "V-TOUCH");
+        if (IS_ERR(bu21013_data->regulator)) {
+                dev_err(&client->dev, "regulator_get failed\n");
+                error = PTR_ERR(bu21013_data->regulator);
+                goto err_free_mem;
+        }
+
+        error = regulator_enable(bu21013_data->regulator);
+        if (error < 0) {
+                dev_err(&client->dev, "regulator enable failed\n");
+                goto err_put_regulator;
+        }
+
+        bu21013_data->touch_stopped = false;
+        init_waitqueue_head(&bu21013_data->wait);
+
+        /* configure the gpio pins */
+        if (pdata->cs_en) {
+                error = pdata->cs_en(pdata->cs_pin);
+                if (error < 0) {
+                        dev_err(&client->dev, "chip init failed\n");
+                        goto err_disable_regulator;
+                }
+        }
+
+        /* configure the touch panel controller */
+        error = bu21013_init_chip(bu21013_data);
+        if (error) {
+                dev_err(&client->dev, "error in bu21013 config\n");
+                goto err_cs_disable;
+        }
+
+        /* register the device to input subsystem */
+        in_dev->name = DRIVER_TP;
+        in_dev->id.bustype = BUS_I2C;
+        in_dev->dev.parent = &client->dev;
+
+        __set_bit(EV_SYN, in_dev->evbit);
+        __set_bit(EV_KEY, in_dev->evbit);
+        __set_bit(EV_ABS, in_dev->evbit);
+
+        input_set_abs_params(in_dev, ABS_MT_POSITION_X, 0,
+                                                pdata->touch_x_max, 0, 0);
+        input_set_abs_params(in_dev, ABS_MT_POSITION_Y, 0,
+                                                pdata->touch_y_max, 0, 0);
+        input_set_drvdata(in_dev, bu21013_data);
+
+        error = request_threaded_irq(pdata->irq, NULL, bu21013_gpio_irq,
+                                     IRQF_TRIGGER_FALLING | IRQF_SHARED,
+                                     DRIVER_TP, bu21013_data);
+        if (error) {
+                dev_err(&client->dev, "request irq %d failed\n", pdata->irq);
+                goto err_cs_disable;
+        }
+
+        error = input_register_device(in_dev);
+        if (error) {
+                dev_err(&client->dev, "failed to register input device\n");
+                goto err_free_irq;
+        }
+
+        device_init_wakeup(&client->dev, pdata->wakeup);
+        i2c_set_clientdata(client, bu21013_data);
+
+        return 0;
+
+err_free_irq:
+        bu21013_free_irq(bu21013_data);
+err_cs_disable:
+        pdata->cs_dis(pdata->cs_pin);
+err_disable_regulator:
+        regulator_disable(bu21013_data->regulator);
+err_put_regulator:
+        regulator_put(bu21013_data->regulator);
+err_free_mem:
+        input_free_device(in_dev);
+        kfree(bu21013_data);
+
+        return error;
+}
+/**
+ * bu21013_remove() - removes the i2c-client touchscreen driver
+ * @client: i2c client structure pointer
+ *
+ * This function uses to remove the i2c-client
+ * touchscreen driver and returns integer.
+ */
+static int __devexit bu21013_remove(struct i2c_client *client)
+{
+        struct bu21013_ts_data *bu21013_data = i2c_get_clientdata(client);
+
+        bu21013_free_irq(bu21013_data);
+
+        bu21013_data->chip->cs_dis(bu21013_data->chip->cs_pin);
+
+        input_unregister_device(bu21013_data->in_dev);
+
+        regulator_disable(bu21013_data->regulator);
+        regulator_put(bu21013_data->regulator);
+
+        kfree(bu21013_data);
+
+        device_init_wakeup(&client->dev, false);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+/**
+ * bu21013_suspend() - suspend the touch screen controller
+ * @dev: pointer to device structure
+ *
+ * This function is used to suspend the
+ * touch panel controller and returns integer
+ */
+static int bu21013_suspend(struct device *dev)
+{
+        struct bu21013_ts_data *bu21013_data = dev_get_drvdata(dev);
+        struct i2c_client *client = bu21013_data->client;
+
+        bu21013_data->touch_stopped = true;
+        if (device_may_wakeup(&client->dev))
+                enable_irq_wake(bu21013_data->chip->irq);
+        else
+                disable_irq(bu21013_data->chip->irq);
+
+        regulator_disable(bu21013_data->regulator);
+
+        return 0;
+}
+
+/**
+ * bu21013_resume() - resume the touch screen controller
+ * @dev: pointer to device structure
+ *
+ * This function is used to resume the touch panel
+ * controller and returns integer.
+ */
+static int bu21013_resume(struct device *dev)
+{
+        struct bu21013_ts_data *bu21013_data = dev_get_drvdata(dev);
+        struct i2c_client *client = bu21013_data->client;
+        int retval;
+
+        retval = regulator_enable(bu21013_data->regulator);
+        if (retval < 0) {
+                dev_err(&client->dev, "bu21013 regulator enable failed\n");
+                return retval;
+        }
+
+        retval = bu21013_init_chip(bu21013_data);
+        if (retval < 0) {
+                dev_err(&client->dev, "bu21013 controller config failed\n");
+                return retval;
+        }
+
+        bu21013_data->touch_stopped = false;
+
+        if (device_may_wakeup(&client->dev))
+                disable_irq_wake(bu21013_data->chip->irq);
+        else
+                enable_irq(bu21013_data->chip->irq);
+
+        return 0;
+}
+
+static const struct dev_pm_ops bu21013_dev_pm_ops = {
+        .suspend = bu21013_suspend,
+        .resume  = bu21013_resume,
+};
+#endif
+
+static const struct i2c_device_id bu21013_id[] = {
+        { DRIVER_TP, 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, bu21013_id);
+
+static struct i2c_driver bu21013_driver = {
+        .driver = {
+                .name   =       DRIVER_TP,
+                .owner  =       THIS_MODULE,
+#ifdef CONFIG_PM
+                .pm     =       &bu21013_dev_pm_ops,
+#endif
+        },
+        .probe          =       bu21013_probe,
+        .remove         =       __devexit_p(bu21013_remove),
+        .id_table       =       bu21013_id,
+};
+
+/**
+ * bu21013_init() - initializes the bu21013 touchscreen driver
+ *
+ * This function used to initializes the bu21013
+ * touchscreen driver and returns integer.
+ */
+static int __init bu21013_init(void)
+{
+        return i2c_add_driver(&bu21013_driver);
+}
+
+/**
+ * bu21013_exit() - de-initializes the bu21013 touchscreen driver
+ *
+ * This function uses to de-initializes the bu21013
+ * touchscreen driver and returns none.
+ */
+static void __exit bu21013_exit(void)
+{
+        i2c_del_driver(&bu21013_driver);
+}
+
+module_init(bu21013_init);
+module_exit(bu21013_exit);
+
+MODULE_LICENSE("GPL v2");
+MODULE_AUTHOR("Naveen Kumar G <naveen.gaddipati@stericsson.com>");
+MODULE_DESCRIPTION("bu21013 touch screen controller driver");
diff --git a/drivers/input/touchscreen/cy8ctmg110_ts.c b/drivers/input/touchscreen/cy8ctmg110_ts.c
index 5ec0946938fe..a93c5c26ab3f 100644
--- a/drivers/input/touchscreen/cy8ctmg110_ts.c
+++ b/drivers/input/touchscreen/cy8ctmg110_ts.c
@@ -206,9 +206,9 @@ static int __devinit cy8ctmg110_probe(struct i2c_client *client,
         input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
 
         input_set_abs_params(input_dev, ABS_X,
-                        CY8CTMG110_X_MIN, CY8CTMG110_X_MAX, 0, 0);
+                        CY8CTMG110_X_MIN, CY8CTMG110_X_MAX, 4, 0);
         input_set_abs_params(input_dev, ABS_Y,
-                        CY8CTMG110_Y_MIN, CY8CTMG110_Y_MAX, 0, 0);
+                        CY8CTMG110_Y_MIN, CY8CTMG110_Y_MAX, 4, 0);
 
         if (ts->reset_pin) {
                 err = gpio_request(ts->reset_pin, NULL);
@@ -280,8 +280,9 @@ err_free_mem:
 }
 
 #ifdef CONFIG_PM
-static int cy8ctmg110_suspend(struct i2c_client *client, pm_message_t mesg)
+static int cy8ctmg110_suspend(struct device *dev)
 {
+        struct i2c_client *client = to_i2c_client(dev);
         struct cy8ctmg110 *ts = i2c_get_clientdata(client);
 
         if (device_may_wakeup(&client->dev))
@@ -293,8 +294,9 @@ static int cy8ctmg110_suspend(struct i2c_client *client, pm_message_t mesg)
         return 0;
 }
 
-static int cy8ctmg110_resume(struct i2c_client *client)
+static int cy8ctmg110_resume(struct device *dev)
 {
+        struct i2c_client *client = to_i2c_client(dev);
         struct cy8ctmg110 *ts = i2c_get_clientdata(client);
 
         if (device_may_wakeup(&client->dev))
@@ -305,6 +307,8 @@ static int cy8ctmg110_resume(struct i2c_client *client)
         }
         return 0;
 }
+
+static SIMPLE_DEV_PM_OPS(cy8ctmg110_pm, cy8ctmg110_suspend, cy8ctmg110_resume);
 #endif
 
 static int __devexit cy8ctmg110_remove(struct i2c_client *client)
@@ -335,14 +339,13 @@ static struct i2c_driver cy8ctmg110_driver = {
         .driver         = {
                 .owner  = THIS_MODULE,
                 .name   = CY8CTMG110_DRIVER_NAME,
+#ifdef CONFIG_PM
+                .pm     = &cy8ctmg110_pm,
+#endif
         },
         .id_table       = cy8ctmg110_idtable,
         .probe          = cy8ctmg110_probe,
         .remove         = __devexit_p(cy8ctmg110_remove),
-#ifdef CONFIG_PM
-        .suspend        = cy8ctmg110_suspend,
-        .resume         = cy8ctmg110_resume,
-#endif
 };
 
 static int __init cy8ctmg110_init(void)
diff --git a/drivers/input/touchscreen/eeti_ts.c b/drivers/input/touchscreen/eeti_ts.c
index 7a3a916f84a8..7f8f538a9806 100644
--- a/drivers/input/touchscreen/eeti_ts.c
+++ b/drivers/input/touchscreen/eeti_ts.c
@@ -261,8 +261,9 @@ static int __devexit eeti_ts_remove(struct i2c_client *client)
 }
 
 #ifdef CONFIG_PM
-static int eeti_ts_suspend(struct i2c_client *client, pm_message_t mesg)
+static int eeti_ts_suspend(struct device *dev)
 {
+        struct i2c_client *client = to_i2c_client(dev);
         struct eeti_ts_priv *priv = i2c_get_clientdata(client);
         struct input_dev *input_dev = priv->input;
 
@@ -279,8 +280,9 @@ static int eeti_ts_suspend(struct i2c_client *client, pm_message_t mesg)
         return 0;
 }
 
-static int eeti_ts_resume(struct i2c_client *client)
+static int eeti_ts_resume(struct device *dev)
 {
+        struct i2c_client *client = to_i2c_client(dev);
         struct eeti_ts_priv *priv = i2c_get_clientdata(client);
         struct input_dev *input_dev = priv->input;
 
@@ -296,9 +298,8 @@ static int eeti_ts_resume(struct i2c_client *client)
 
         return 0;
 }
-#else
-#define eeti_ts_suspend NULL
-#define eeti_ts_resume NULL
+
+static SIMPLE_DEV_PM_OPS(eeti_ts_pm, eeti_ts_suspend, eeti_ts_resume);
 #endif
 
 static const struct i2c_device_id eeti_ts_id[] = {
@@ -310,11 +311,12 @@ MODULE_DEVICE_TABLE(i2c, eeti_ts_id);
 static struct i2c_driver eeti_ts_driver = {
         .driver = {
                 .name = "eeti_ts",
+#ifdef CONFIG_PM
+                .pm = &eeti_ts_pm,
+#endif
         },
         .probe = eeti_ts_probe,
         .remove = __devexit_p(eeti_ts_remove),
-        .suspend = eeti_ts_suspend,
-        .resume = eeti_ts_resume,
         .id_table = eeti_ts_id,
 };
 
diff --git a/drivers/input/touchscreen/h3600_ts_input.c b/drivers/input/touchscreen/h3600_ts_input.c
index b4d7f63deff1..211811ae5525 100644
--- a/drivers/input/touchscreen/h3600_ts_input.c
+++ b/drivers/input/touchscreen/h3600_ts_input.c
@@ -62,7 +62,7 @@ MODULE_LICENSE("GPL");
         Programmer has no control over these numbers.
         TODO there are holes - specifically  1,7,0x0a
 */
-#define VERSION_ID              0       /* Get Version (request/respose) */
+#define VERSION_ID              0       /* Get Version (request/response) */
 #define KEYBD_ID                2       /* Keyboard (event) */
 #define TOUCHS_ID               3       /* Touch Screen (event)*/
 #define EEPROM_READ_ID          4       /* (request/response) */
@@ -396,34 +396,37 @@ static int h3600ts_connect(struct serio *serio, struct serio_driver *drv)
         set_GPIO_IRQ_edge(GPIO_BITSY_NPOWER_BUTTON, GPIO_RISING_EDGE);
 
         if (request_irq(IRQ_GPIO_BITSY_ACTION_BUTTON, action_button_handler,
-                        IRQF_SHARED | IRQF_DISABLED, "h3600_action", &ts->dev)) {
+                        IRQF_SHARED | IRQF_DISABLED, "h3600_action", ts->dev)) {
                 printk(KERN_ERR "h3600ts.c: Could not allocate Action Button IRQ!\n");
                 err = -EBUSY;
-                goto fail2;
+                goto fail1;
         }
 
         if (request_irq(IRQ_GPIO_BITSY_NPOWER_BUTTON, npower_button_handler,
-                        IRQF_SHARED | IRQF_DISABLED, "h3600_suspend", &ts->dev)) {
+                        IRQF_SHARED | IRQF_DISABLED, "h3600_suspend", ts->dev)) {
                 printk(KERN_ERR "h3600ts.c: Could not allocate Power Button IRQ!\n");
                 err = -EBUSY;
-                goto fail3;
+                goto fail2;
         }
 
         serio_set_drvdata(serio, ts);
 
         err = serio_open(serio, drv);
         if (err)
-                return err;
+                goto fail3;
 
         //h3600_flite_control(1, 25);     /* default brightness */
-        input_register_device(ts->dev);
+        err = input_register_device(ts->dev);
+        if (err)
+                goto fail4;
 
         return 0;
 
-fail3:  free_irq(IRQ_GPIO_BITSY_NPOWER_BUTTON, ts->dev);
+fail4:  serio_close(serio);
+fail3:  serio_set_drvdata(serio, NULL);
+        free_irq(IRQ_GPIO_BITSY_NPOWER_BUTTON, ts->dev);
 fail2:  free_irq(IRQ_GPIO_BITSY_ACTION_BUTTON, ts->dev);
-fail1:  serio_set_drvdata(serio, NULL);
-        input_free_device(input_dev);
+fail1:  input_free_device(input_dev);
         kfree(ts);
         return err;
 }
@@ -436,8 +439,8 @@ static void h3600ts_disconnect(struct serio *serio)
 {
         struct h3600_dev *ts = serio_get_drvdata(serio);
 
-        free_irq(IRQ_GPIO_BITSY_ACTION_BUTTON, &ts->dev);
-        free_irq(IRQ_GPIO_BITSY_NPOWER_BUTTON, &ts->dev);
+        free_irq(IRQ_GPIO_BITSY_ACTION_BUTTON, ts->dev);
+        free_irq(IRQ_GPIO_BITSY_NPOWER_BUTTON, ts->dev);
         input_get_device(ts->dev);
         input_unregister_device(ts->dev);
         serio_close(serio);
diff --git a/drivers/input/touchscreen/hp680_ts_input.c b/drivers/input/touchscreen/hp680_ts_input.c
index a89700e7ace4..dd4e8f020b99 100644
--- a/drivers/input/touchscreen/hp680_ts_input.c
+++ b/drivers/input/touchscreen/hp680_ts_input.c
@@ -28,29 +28,29 @@ static void do_softint(struct work_struct *work)
         u8 scpdr;
         int touched = 0;
 
-        if (ctrl_inb(PHDR) & PHDR_TS_PEN_DOWN) {
-                scpdr = ctrl_inb(SCPDR);
+        if (__raw_readb(PHDR) & PHDR_TS_PEN_DOWN) {
+                scpdr = __raw_readb(SCPDR);
                 scpdr |= SCPDR_TS_SCAN_ENABLE;
                 scpdr &= ~SCPDR_TS_SCAN_Y;
-                ctrl_outb(scpdr, SCPDR);
+                __raw_writeb(scpdr, SCPDR);
                 udelay(30);
 
                 absy = adc_single(ADC_CHANNEL_TS_Y);
 
-                scpdr = ctrl_inb(SCPDR);
+                scpdr = __raw_readb(SCPDR);
                 scpdr |= SCPDR_TS_SCAN_Y;
                 scpdr &= ~SCPDR_TS_SCAN_X;
-                ctrl_outb(scpdr, SCPDR);
+                __raw_writeb(scpdr, SCPDR);
                 udelay(30);
 
                 absx = adc_single(ADC_CHANNEL_TS_X);
 
-                scpdr = ctrl_inb(SCPDR);
+                scpdr = __raw_readb(SCPDR);
                 scpdr |= SCPDR_TS_SCAN_X;
                 scpdr &= ~SCPDR_TS_SCAN_ENABLE;
-                ctrl_outb(scpdr, SCPDR);
+                __raw_writeb(scpdr, SCPDR);
                 udelay(100);
-                touched = ctrl_inb(PHDR) & PHDR_TS_PEN_DOWN;
+                touched = __raw_readb(PHDR) & PHDR_TS_PEN_DOWN;
         }
 
         if (touched) {
@@ -107,8 +107,7 @@ static int __init hp680_ts_init(void)
         return 0;
 
  fail2: free_irq(HP680_TS_IRQ, NULL);
-        cancel_delayed_work(&work);
-        flush_scheduled_work();
+        cancel_delayed_work_sync(&work);
  fail1: input_free_device(hp680_ts_dev);
         return err;
 }
@@ -116,8 +115,7 @@ static int __init hp680_ts_init(void)
 static void __exit hp680_ts_exit(void)
 {
         free_irq(HP680_TS_IRQ, NULL);
-        cancel_delayed_work(&work);
-        flush_scheduled_work();
+        cancel_delayed_work_sync(&work);
         input_unregister_device(hp680_ts_dev);
 }
 
diff --git a/drivers/input/touchscreen/intel-mid-touch.c b/drivers/input/touchscreen/intel-mid-touch.c
new file mode 100644
index 000000000000..66c96bfc5522
--- /dev/null
+++ b/drivers/input/touchscreen/intel-mid-touch.c
@@ -0,0 +1,687 @@
+/*
+ * Intel MID Resistive Touch Screen Driver
+ *
+ * Copyright (C) 2008 Intel Corp
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ *
+ * Questions/Comments/Bug fixes to Sreedhara (sreedhara.ds@intel.com)
+ *                          Ramesh Agarwal (ramesh.agarwal@intel.com)
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ * TODO:
+ *      review conversion of r/m/w sequences
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/input.h>
+#include <linux/interrupt.h>
+#include <linux/err.h>
+#include <linux/param.h>
+#include <linux/slab.h>
+#include <linux/platform_device.h>
+#include <linux/irq.h>
+#include <linux/delay.h>
+#include <asm/intel_scu_ipc.h>
+
+/* PMIC Interrupt registers */
+#define PMIC_REG_ID1            0x00 /* PMIC ID1 register */
+
+/* PMIC Interrupt registers */
+#define PMIC_REG_INT            0x04 /* PMIC interrupt register */
+#define PMIC_REG_MINT           0x05 /* PMIC interrupt mask register */
+
+/* ADC Interrupt registers */
+#define PMIC_REG_ADCINT         0x5F /* ADC interrupt register */
+#define PMIC_REG_MADCINT        0x60 /* ADC interrupt mask register */
+
+/* ADC Control registers */
+#define PMIC_REG_ADCCNTL1       0x61 /* ADC control register */
+
+/* ADC Channel Selection registers */
+#define PMICADDR0               0xA4
+#define END_OF_CHANNEL          0x1F
+
+/* ADC Result register */
+#define PMIC_REG_ADCSNS0H       0x64
+
+/* ADC channels for touch screen */
+#define MRST_TS_CHAN10          0xA /* Touch screen X+ connection */
+#define MRST_TS_CHAN11          0xB /* Touch screen X- connection */
+#define MRST_TS_CHAN12          0xC /* Touch screen Y+ connection */
+#define MRST_TS_CHAN13          0xD /* Touch screen Y- connection */
+
+/* Touch screen channel BIAS constants */
+#define MRST_XBIAS              0x20
+#define MRST_YBIAS              0x40
+#define MRST_ZBIAS              0x80
+
+/* Touch screen coordinates */
+#define MRST_X_MIN              10
+#define MRST_X_MAX              1024
+#define MRST_X_FUZZ             5
+#define MRST_Y_MIN              10
+#define MRST_Y_MAX              1024
+#define MRST_Y_FUZZ             5
+#define MRST_PRESSURE_MIN       0
+#define MRST_PRESSURE_NOMINAL   50
+#define MRST_PRESSURE_MAX       100
+
+#define WAIT_ADC_COMPLETION     10 /* msec */
+
+/* PMIC ADC round robin delays */
+#define ADC_LOOP_DELAY0         0x0 /* Continuous loop */
+#define ADC_LOOP_DELAY1         0x1 /* 4.5  ms approximate */
+
+/* PMIC Vendor Identifiers */
+#define PMIC_VENDOR_FS          0 /* PMIC vendor FreeScale */
+#define PMIC_VENDOR_MAXIM       1 /* PMIC vendor MAXIM */
+#define PMIC_VENDOR_NEC         2 /* PMIC vendor NEC */
+#define MRSTOUCH_MAX_CHANNELS   32 /* Maximum ADC channels */
+
+/* Touch screen device structure */
+struct mrstouch_dev {
+        struct device *dev; /* device associated with touch screen */
+        struct input_dev *input;
+        char phys[32];
+        u16 asr;                /* Address selection register */
+        int irq;
+        unsigned int vendor;    /* PMIC vendor */
+        unsigned int rev;       /* PMIC revision */
+
+        int (*read_prepare)(struct mrstouch_dev *tsdev);
+        int (*read)(struct mrstouch_dev *tsdev, u16 *x, u16 *y, u16 *z);
+        int (*read_finish)(struct mrstouch_dev *tsdev);
+};
+
+
+/*************************** NEC and Maxim Interface ************************/
+
+static int mrstouch_nec_adc_read_prepare(struct mrstouch_dev *tsdev)
+{
+        return intel_scu_ipc_update_register(PMIC_REG_MADCINT, 0, 0x20);
+}
+
+/*
+ * Enables PENDET interrupt.
+ */
+static int mrstouch_nec_adc_read_finish(struct mrstouch_dev *tsdev)
+{
+        int err;
+
+        err = intel_scu_ipc_update_register(PMIC_REG_MADCINT, 0x20, 0x20);
+        if (!err)
+                err = intel_scu_ipc_update_register(PMIC_REG_ADCCNTL1, 0, 0x05);
+
+        return err;
+}
+
+/*
+ * Reads PMIC ADC touch screen result
+ * Reads ADC storage registers for higher 7 and lower 3 bits and
+ * converts the two readings into a single value and turns off gain bit
+ */
+static int mrstouch_ts_chan_read(u16 offset, u16 chan, u16 *vp, u16 *vm)
+{
+        int err;
+        u16 result;
+        u32 res;
+
+        result = PMIC_REG_ADCSNS0H + offset;
+
+        if (chan == MRST_TS_CHAN12)
+                result += 4;
+
+        err = intel_scu_ipc_ioread32(result, &res);
+        if (err)
+                return err;
+
+        /* Mash the bits up */
+
+        *vp = (res & 0xFF) << 3;        /* Highest 7 bits */
+        *vp |= (res >> 8) & 0x07;       /* Lower 3 bits */
+        *vp &= 0x3FF;
+
+        res >>= 16;
+
+        *vm = (res & 0xFF) << 3;        /* Highest 7 bits */
+        *vm |= (res >> 8) & 0x07;       /* Lower 3 bits */
+        *vm &= 0x3FF;
+
+        return 0;
+}
+
+/*
+ * Enables X, Y and Z bias values
+ * Enables YPYM for X channels and XPXM for Y channels
+ */
+static int mrstouch_ts_bias_set(uint offset, uint bias)
+{
+        int count;
+        u16 chan, start;
+        u16 reg[4];
+        u8 data[4];
+
+        chan = PMICADDR0 + offset;
+        start = MRST_TS_CHAN10;
+
+        for (count = 0; count <= 3; count++) {
+                reg[count] = chan++;
+                data[count] = bias | (start + count);
+        }
+
+        return intel_scu_ipc_writev(reg, data, 4);
+}
+
+/* To read touch screen channel values */
+static int mrstouch_nec_adc_read(struct mrstouch_dev *tsdev,
+                                 u16 *x, u16 *y, u16 *z)
+{
+        int err;
+        u16 xm, ym, zm;
+
+        /* configure Y bias for X channels */
+        err = mrstouch_ts_bias_set(tsdev->asr, MRST_YBIAS);
+        if (err)
+                goto ipc_error;
+
+        msleep(WAIT_ADC_COMPLETION);
+
+        /* read x+ and x- channels */
+        err = mrstouch_ts_chan_read(tsdev->asr, MRST_TS_CHAN10, x, &xm);
+        if (err)
+                goto ipc_error;
+
+        /* configure x bias for y channels */
+        err = mrstouch_ts_bias_set(tsdev->asr, MRST_XBIAS);
+        if (err)
+                goto ipc_error;
+
+        msleep(WAIT_ADC_COMPLETION);
+
+        /* read y+ and y- channels */
+        err = mrstouch_ts_chan_read(tsdev->asr, MRST_TS_CHAN12, y, &ym);
+        if (err)
+                goto ipc_error;
+
+        /* configure z bias for x and y channels */
+        err = mrstouch_ts_bias_set(tsdev->asr, MRST_ZBIAS);
+        if (err)
+                goto ipc_error;
+
+        msleep(WAIT_ADC_COMPLETION);
+
+        /* read z+ and z- channels */
+        err = mrstouch_ts_chan_read(tsdev->asr, MRST_TS_CHAN10, z, &zm);
+        if (err)
+                goto ipc_error;
+
+        return 0;
+
+ipc_error:
+        dev_err(tsdev->dev, "ipc error during adc read\n");
+        return err;
+}
+
+
+/*************************** Freescale Interface ************************/
+
+static int mrstouch_fs_adc_read_prepare(struct mrstouch_dev *tsdev)
+{
+        int err, count;
+        u16 chan;
+        u16 reg[5];
+        u8 data[5];
+
+        /* Stop the ADC */
+        err = intel_scu_ipc_update_register(PMIC_REG_MADCINT, 0x00, 0x02);
+        if (err)
+                goto ipc_error;
+
+        chan = PMICADDR0 + tsdev->asr;
+
+        /* Set X BIAS */
+        for (count = 0; count <= 3; count++) {
+                reg[count] = chan++;
+                data[count] = 0x2A;
+        }
+        reg[count] =  chan++; /* Dummy */
+        data[count] = 0;
+
+        err = intel_scu_ipc_writev(reg, data, 5);
+        if (err)
+                goto ipc_error;
+
+        msleep(WAIT_ADC_COMPLETION);
+
+        /* Set Y BIAS */
+        for (count = 0; count <= 3; count++) {
+                reg[count] = chan++;
+                data[count] = 0x4A;
+        }
+        reg[count] = chan++; /* Dummy */
+        data[count] = 0;
+
+        err = intel_scu_ipc_writev(reg, data, 5);
+        if (err)
+                goto ipc_error;
+
+        msleep(WAIT_ADC_COMPLETION);
+
+        /* Set Z BIAS */
+        err = intel_scu_ipc_iowrite32(chan + 2, 0x8A8A8A8A);
+        if (err)
+                goto ipc_error;
+
+        msleep(WAIT_ADC_COMPLETION);
+
+        return 0;
+
+ipc_error:
+        dev_err(tsdev->dev, "ipc error during %s\n", __func__);
+        return err;
+}
+
+static int mrstouch_fs_adc_read(struct mrstouch_dev *tsdev,
+                                u16 *x, u16 *y, u16 *z)
+{
+        int err;
+        u16 result;
+        u16 reg[4];
+        u8 data[4];
+
+        result = PMIC_REG_ADCSNS0H + tsdev->asr;
+
+        reg[0] = result + 4;
+        reg[1] = result + 5;
+        reg[2] = result + 16;
+        reg[3] = result + 17;
+
+        err = intel_scu_ipc_readv(reg, data, 4);
+        if (err)
+                goto ipc_error;
+
+        *x = data[0] << 3; /* Higher 7 bits */
+        *x |= data[1] & 0x7; /* Lower 3 bits */
+        *x &= 0x3FF;
+
+        *y = data[2] << 3; /* Higher 7 bits */
+        *y |= data[3] & 0x7; /* Lower 3 bits */
+        *y &= 0x3FF;
+
+        /* Read Z value */
+        reg[0] = result + 28;
+        reg[1] = result + 29;
+
+        err = intel_scu_ipc_readv(reg, data, 4);
+        if (err)
+                goto ipc_error;
+
+        *z = data[0] << 3; /* Higher 7 bits */
+        *z |= data[1] & 0x7; /* Lower 3 bits */
+        *z &= 0x3FF;
+
+        return 0;
+
+ipc_error:
+        dev_err(tsdev->dev, "ipc error during %s\n", __func__);
+        return err;
+}
+
+static int mrstouch_fs_adc_read_finish(struct mrstouch_dev *tsdev)
+{
+        int err, count;
+        u16 chan;
+        u16 reg[5];
+        u8 data[5];
+
+        /* Clear all TS channels */
+        chan = PMICADDR0 + tsdev->asr;
+        for (count = 0; count <= 4; count++) {
+                reg[count] = chan++;
+                data[count] = 0;
+        }
+        err = intel_scu_ipc_writev(reg, data, 5);
+        if (err)
+                goto ipc_error;
+
+        for (count = 0; count <= 4; count++) {
+                reg[count] = chan++;
+                data[count] = 0;
+        }
+        err = intel_scu_ipc_writev(reg, data, 5);
+        if (err)
+                goto ipc_error;
+
+        err = intel_scu_ipc_iowrite32(chan + 2, 0x00000000);
+        if (err)
+                goto ipc_error;
+
+        /* Start ADC */
+        err = intel_scu_ipc_update_register(PMIC_REG_MADCINT, 0x02, 0x02);
+        if (err)
+                goto ipc_error;
+
+        return 0;
+
+ipc_error:
+        dev_err(tsdev->dev, "ipc error during %s\n", __func__);
+        return err;
+}
+
+static void mrstouch_report_event(struct input_dev *input,
+                        unsigned int x, unsigned int y, unsigned int z)
+{
+        if (z > MRST_PRESSURE_NOMINAL) {
+                /* Pen touched, report button touch and coordinates */
+                input_report_key(input, BTN_TOUCH, 1);
+                input_report_abs(input, ABS_X, x);
+                input_report_abs(input, ABS_Y, y);
+        } else {
+                input_report_key(input, BTN_TOUCH, 0);
+        }
+
+        input_report_abs(input, ABS_PRESSURE, z);
+        input_sync(input);
+}
+
+/* PENDET interrupt handler */
+static irqreturn_t mrstouch_pendet_irq(int irq, void *dev_id)
+{
+        struct mrstouch_dev *tsdev = dev_id;
+        u16 x, y, z;
+
+        /*
+         * Should we lower thread priority? Probably not, since we are
+         * not spinning but sleeping...
+         */
+
+        if (tsdev->read_prepare(tsdev))
+                goto out;
+
+        do {
+                if (tsdev->read(tsdev, &x, &y, &z))
+                        break;
+
+                mrstouch_report_event(tsdev->input, x, y, z);
+        } while (z > MRST_PRESSURE_NOMINAL);
+
+        tsdev->read_finish(tsdev);
+
+out:
+        return IRQ_HANDLED;
+}
+
+/* Utility to read PMIC ID */
+static int __devinit mrstouch_read_pmic_id(uint *vendor, uint *rev)
+{
+        int err;
+        u8 r;
+
+        err = intel_scu_ipc_ioread8(PMIC_REG_ID1, &r);
+        if (err)
+                return err;
+
+        *vendor = r & 0x7;
+        *rev = (r >> 3) & 0x7;
+
+        return 0;
+}
+
+/*
+ * Parse ADC channels to find end of the channel configured by other ADC user
+ * NEC and MAXIM requires 4 channels and FreeScale needs 18 channels
+ */
+static int __devinit mrstouch_chan_parse(struct mrstouch_dev *tsdev)
+{
+        int err, i, found;
+        u8 r8;
+
+        found = -1;
+
+        for (i = 0; i < MRSTOUCH_MAX_CHANNELS; i++) {
+                if (found >= 0)
+                        break;
+
+                err = intel_scu_ipc_ioread8(PMICADDR0 + i, &r8);
+                if (err)
+                        return err;
+
+                if (r8 == END_OF_CHANNEL) {
+                        found = i;
+                        break;
+                }
+        }
+        if (found < 0)
+                return 0;
+
+        if (tsdev->vendor == PMIC_VENDOR_FS) {
+                if (found && found > (MRSTOUCH_MAX_CHANNELS - 18))
+                        return -ENOSPC;
+        } else {
+                if (found && found > (MRSTOUCH_MAX_CHANNELS - 4))
+                        return -ENOSPC;
+        }
+        return found;
+}
+
+
+/*
+ * Writes touch screen channels to ADC address selection registers
+ */
+static int __devinit mrstouch_ts_chan_set(uint offset)
+{
+        u16 chan;
+
+        int ret, count;
+
+        chan = PMICADDR0 + offset;
+        for (count = 0; count <= 3; count++) {
+                ret = intel_scu_ipc_iowrite8(chan++, MRST_TS_CHAN10 + count);
+                if (ret)
+                        return ret;
+        }
+        return intel_scu_ipc_iowrite8(chan++, END_OF_CHANNEL);
+}
+
+/* Initialize ADC */
+static int __devinit mrstouch_adc_init(struct mrstouch_dev *tsdev)
+{
+        int err, start;
+        u8 ra, rm;
+
+        err = mrstouch_read_pmic_id(&tsdev->vendor, &tsdev->rev);
+        if (err) {
+                dev_err(tsdev->dev, "Unable to read PMIC id\n");
+                return err;
+        }
+
+        switch (tsdev->vendor) {
+        case PMIC_VENDOR_NEC:
+        case PMIC_VENDOR_MAXIM:
+                tsdev->read_prepare = mrstouch_nec_adc_read_prepare;
+                tsdev->read = mrstouch_nec_adc_read;
+                tsdev->read_finish = mrstouch_nec_adc_read_finish;
+                break;
+
+        case PMIC_VENDOR_FS:
+                tsdev->read_prepare = mrstouch_fs_adc_read_prepare;
+                tsdev->read = mrstouch_fs_adc_read;
+                tsdev->read_finish = mrstouch_fs_adc_read_finish;
+                break;
+
+        default:
+                dev_err(tsdev->dev,
+                        "Unsupported touchscreen: %d\n", tsdev->vendor);
+                return -ENXIO;
+        }
+
+        start = mrstouch_chan_parse(tsdev);
+        if (start < 0) {
+                dev_err(tsdev->dev, "Unable to parse channels\n");
+                return start;
+        }
+
+        tsdev->asr = start;
+
+        /*
+         * ADC power on, start, enable PENDET and set loop delay
+         * ADC loop delay is set to 4.5 ms approximately
+         * Loop delay more than this results in jitter in adc readings
+         * Setting loop delay to 0 (continuous loop) in MAXIM stops PENDET
+         * interrupt generation sometimes.
+         */
+
+        if (tsdev->vendor == PMIC_VENDOR_FS) {
+                ra = 0xE0 | ADC_LOOP_DELAY0;
+                rm = 0x5;
+        } else {
+                /* NEC and MAXIm not consistent with loop delay 0 */
+                ra = 0xE0 | ADC_LOOP_DELAY1;
+                rm = 0x0;
+
+                /* configure touch screen channels */
+                err = mrstouch_ts_chan_set(tsdev->asr);
+                if (err)
+                        return err;
+        }
+
+        err = intel_scu_ipc_update_register(PMIC_REG_ADCCNTL1, ra, 0xE7);
+        if (err)
+                return err;
+
+        err = intel_scu_ipc_update_register(PMIC_REG_MADCINT, rm, 0x03);
+        if (err)
+                return err;
+
+        return 0;
+}
+
+
+/* Probe function for touch screen driver */
+static int __devinit mrstouch_probe(struct platform_device *pdev)
+{
+        struct mrstouch_dev *tsdev;
+        struct input_dev *input;
+        int err;
+        int irq;
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0) {
+                dev_err(&pdev->dev, "no interrupt assigned\n");
+                return -EINVAL;
+        }
+
+        tsdev = kzalloc(sizeof(struct mrstouch_dev), GFP_KERNEL);
+        input = input_allocate_device();
+        if (!tsdev || !input) {
+                dev_err(&pdev->dev, "unable to allocate memory\n");
+                err = -ENOMEM;
+                goto err_free_mem;
+        }
+
+        tsdev->dev = &pdev->dev;
+        tsdev->input = input;
+        tsdev->irq = irq;
+
+        snprintf(tsdev->phys, sizeof(tsdev->phys),
+                 "%s/input0", dev_name(tsdev->dev));
+
+        err = mrstouch_adc_init(tsdev);
+        if (err) {
+                dev_err(&pdev->dev, "ADC initialization failed\n");
+                goto err_free_mem;
+        }
+
+        input->name = "mrst_touchscreen";
+        input->phys = tsdev->phys;
+        input->dev.parent = tsdev->dev;
+
+        input->id.vendor = tsdev->vendor;
+        input->id.version = tsdev->rev;
+
+        input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
+        input->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
+
+        input_set_abs_params(tsdev->input, ABS_X,
+                             MRST_X_MIN, MRST_X_MAX, MRST_X_FUZZ, 0);
+        input_set_abs_params(tsdev->input, ABS_Y,
+                             MRST_Y_MIN, MRST_Y_MAX, MRST_Y_FUZZ, 0);
+        input_set_abs_params(tsdev->input, ABS_PRESSURE,
+                             MRST_PRESSURE_MIN, MRST_PRESSURE_MAX, 0, 0);
+
+        err = request_threaded_irq(tsdev->irq, NULL, mrstouch_pendet_irq,
+                                   0, "mrstouch", tsdev);
+        if (err) {
+                dev_err(tsdev->dev, "unable to allocate irq\n");
+                goto err_free_mem;
+        }
+
+        err = input_register_device(tsdev->input);
+        if (err) {
+                dev_err(tsdev->dev, "unable to register input device\n");
+                goto err_free_irq;
+        }
+
+        platform_set_drvdata(pdev, tsdev);
+        return 0;
+
+err_free_irq:
+        free_irq(tsdev->irq, tsdev);
+err_free_mem:
+        input_free_device(input);
+        kfree(tsdev);
+        return err;
+}
+
+static int __devexit mrstouch_remove(struct platform_device *pdev)
+{
+        struct mrstouch_dev *tsdev = platform_get_drvdata(pdev);
+
+        free_irq(tsdev->irq, tsdev);
+        input_unregister_device(tsdev->input);
+        kfree(tsdev);
+
+        platform_set_drvdata(pdev, NULL);
+
+        return 0;
+}
+
+static struct platform_driver mrstouch_driver = {
+        .driver = {
+                .name   = "pmic_touch",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = mrstouch_probe,
+        .remove         = __devexit_p(mrstouch_remove),
+};
+
+static int __init mrstouch_init(void)
+{
+        return platform_driver_register(&mrstouch_driver);
+}
+module_init(mrstouch_init);
+
+static void __exit mrstouch_exit(void)
+{
+        platform_driver_unregister(&mrstouch_driver);
+}
+module_exit(mrstouch_exit);
+
+MODULE_AUTHOR("Sreedhara Murthy. D.S, sreedhara.ds@intel.com");
+MODULE_DESCRIPTION("Intel Moorestown Resistive Touch Screen Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/touchscreen/lpc32xx_ts.c b/drivers/input/touchscreen/lpc32xx_ts.c
new file mode 100644
index 000000000000..dcf803f5a1f7
--- /dev/null
+++ b/drivers/input/touchscreen/lpc32xx_ts.c
@@ -0,0 +1,411 @@
+/*
+ * LPC32xx built-in touchscreen driver
+ *
+ * Copyright (C) 2010 NXP Semiconductors
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/platform_device.h>
+#include <linux/init.h>
+#include <linux/input.h>
+#include <linux/interrupt.h>
+#include <linux/module.h>
+#include <linux/clk.h>
+#include <linux/io.h>
+#include <linux/slab.h>
+
+/*
+ * Touchscreen controller register offsets
+ */
+#define LPC32XX_TSC_STAT                        0x00
+#define LPC32XX_TSC_SEL                         0x04
+#define LPC32XX_TSC_CON                         0x08
+#define LPC32XX_TSC_FIFO                        0x0C
+#define LPC32XX_TSC_DTR                         0x10
+#define LPC32XX_TSC_RTR                         0x14
+#define LPC32XX_TSC_UTR                         0x18
+#define LPC32XX_TSC_TTR                         0x1C
+#define LPC32XX_TSC_DXP                         0x20
+#define LPC32XX_TSC_MIN_X                       0x24
+#define LPC32XX_TSC_MAX_X                       0x28
+#define LPC32XX_TSC_MIN_Y                       0x2C
+#define LPC32XX_TSC_MAX_Y                       0x30
+#define LPC32XX_TSC_AUX_UTR                     0x34
+#define LPC32XX_TSC_AUX_MIN                     0x38
+#define LPC32XX_TSC_AUX_MAX                     0x3C
+
+#define LPC32XX_TSC_STAT_FIFO_OVRRN             (1 << 8)
+#define LPC32XX_TSC_STAT_FIFO_EMPTY             (1 << 7)
+
+#define LPC32XX_TSC_SEL_DEFVAL                  0x0284
+
+#define LPC32XX_TSC_ADCCON_IRQ_TO_FIFO_4        (0x1 << 11)
+#define LPC32XX_TSC_ADCCON_X_SAMPLE_SIZE(s)     ((10 - (s)) << 7)
+#define LPC32XX_TSC_ADCCON_Y_SAMPLE_SIZE(s)     ((10 - (s)) << 4)
+#define LPC32XX_TSC_ADCCON_POWER_UP             (1 << 2)
+#define LPC32XX_TSC_ADCCON_AUTO_EN              (1 << 0)
+
+#define LPC32XX_TSC_FIFO_TS_P_LEVEL             (1 << 31)
+#define LPC32XX_TSC_FIFO_NORMALIZE_X_VAL(x)     (((x) & 0x03FF0000) >> 16)
+#define LPC32XX_TSC_FIFO_NORMALIZE_Y_VAL(y)     ((y) & 0x000003FF)
+
+#define LPC32XX_TSC_ADCDAT_VALUE_MASK           0x000003FF
+
+#define LPC32XX_TSC_MIN_XY_VAL                  0x0
+#define LPC32XX_TSC_MAX_XY_VAL                  0x3FF
+
+#define MOD_NAME "ts-lpc32xx"
+
+#define tsc_readl(dev, reg) \
+        __raw_readl((dev)->tsc_base + (reg))
+#define tsc_writel(dev, reg, val) \
+        __raw_writel((val), (dev)->tsc_base + (reg))
+
+struct lpc32xx_tsc {
+        struct input_dev *dev;
+        void __iomem *tsc_base;
+        int irq;
+        struct clk *clk;
+};
+
+static void lpc32xx_fifo_clear(struct lpc32xx_tsc *tsc)
+{
+        while (!(tsc_readl(tsc, LPC32XX_TSC_STAT) &
+                        LPC32XX_TSC_STAT_FIFO_EMPTY))
+                tsc_readl(tsc, LPC32XX_TSC_FIFO);
+}
+
+static irqreturn_t lpc32xx_ts_interrupt(int irq, void *dev_id)
+{
+        u32 tmp, rv[4], xs[4], ys[4];
+        int idx;
+        struct lpc32xx_tsc *tsc = dev_id;
+        struct input_dev *input = tsc->dev;
+
+        tmp = tsc_readl(tsc, LPC32XX_TSC_STAT);
+
+        if (tmp & LPC32XX_TSC_STAT_FIFO_OVRRN) {
+                /* FIFO overflow - throw away samples */
+                lpc32xx_fifo_clear(tsc);
+                return IRQ_HANDLED;
+        }
+
+        /*
+         * Gather and normalize 4 samples. Pen-up events may have less
+         * than 4 samples, but its ok to pop 4 and let the last sample
+         * pen status check drop the samples.
+         */
+        idx = 0;
+        while (idx < 4 &&
+               !(tsc_readl(tsc, LPC32XX_TSC_STAT) &
+                        LPC32XX_TSC_STAT_FIFO_EMPTY)) {
+                tmp = tsc_readl(tsc, LPC32XX_TSC_FIFO);
+                xs[idx] = LPC32XX_TSC_ADCDAT_VALUE_MASK -
+                        LPC32XX_TSC_FIFO_NORMALIZE_X_VAL(tmp);
+                ys[idx] = LPC32XX_TSC_ADCDAT_VALUE_MASK -
+                        LPC32XX_TSC_FIFO_NORMALIZE_Y_VAL(tmp);
+                rv[idx] = tmp;
+                idx++;
+        }
+
+        /* Data is only valid if pen is still down in last sample */
+        if (!(rv[3] & LPC32XX_TSC_FIFO_TS_P_LEVEL) && idx == 4) {
+                /* Use average of 2nd and 3rd sample for position */
+                input_report_abs(input, ABS_X, (xs[1] + xs[2]) / 2);
+                input_report_abs(input, ABS_Y, (ys[1] + ys[2]) / 2);
+                input_report_key(input, BTN_TOUCH, 1);
+        } else {
+                input_report_key(input, BTN_TOUCH, 0);
+        }
+
+        input_sync(input);
+
+        return IRQ_HANDLED;
+}
+
+static void lpc32xx_stop_tsc(struct lpc32xx_tsc *tsc)
+{
+        /* Disable auto mode */
+        tsc_writel(tsc, LPC32XX_TSC_CON,
+                   tsc_readl(tsc, LPC32XX_TSC_CON) &
+                             ~LPC32XX_TSC_ADCCON_AUTO_EN);
+
+        clk_disable(tsc->clk);
+}
+
+static void lpc32xx_setup_tsc(struct lpc32xx_tsc *tsc)
+{
+        u32 tmp;
+
+        clk_enable(tsc->clk);
+
+        tmp = tsc_readl(tsc, LPC32XX_TSC_CON) & ~LPC32XX_TSC_ADCCON_POWER_UP;
+
+        /* Set the TSC FIFO depth to 4 samples @ 10-bits per sample (max) */
+        tmp = LPC32XX_TSC_ADCCON_IRQ_TO_FIFO_4 |
+              LPC32XX_TSC_ADCCON_X_SAMPLE_SIZE(10) |
+              LPC32XX_TSC_ADCCON_Y_SAMPLE_SIZE(10);
+        tsc_writel(tsc, LPC32XX_TSC_CON, tmp);
+
+        /* These values are all preset */
+        tsc_writel(tsc, LPC32XX_TSC_SEL, LPC32XX_TSC_SEL_DEFVAL);
+        tsc_writel(tsc, LPC32XX_TSC_MIN_X, LPC32XX_TSC_MIN_XY_VAL);
+        tsc_writel(tsc, LPC32XX_TSC_MAX_X, LPC32XX_TSC_MAX_XY_VAL);
+        tsc_writel(tsc, LPC32XX_TSC_MIN_Y, LPC32XX_TSC_MIN_XY_VAL);
+        tsc_writel(tsc, LPC32XX_TSC_MAX_Y, LPC32XX_TSC_MAX_XY_VAL);
+
+        /* Aux support is not used */
+        tsc_writel(tsc, LPC32XX_TSC_AUX_UTR, 0);
+        tsc_writel(tsc, LPC32XX_TSC_AUX_MIN, 0);
+        tsc_writel(tsc, LPC32XX_TSC_AUX_MAX, 0);
+
+        /*
+         * Set sample rate to about 240Hz per X/Y pair. A single measurement
+         * consists of 4 pairs which gives about a 60Hz sample rate based on
+         * a stable 32768Hz clock source. Values are in clocks.
+         * Rate is (32768 / (RTR + XCONV + RTR + YCONV + DXP + TTR + UTR) / 4
+         */
+        tsc_writel(tsc, LPC32XX_TSC_RTR, 0x2);
+        tsc_writel(tsc, LPC32XX_TSC_DTR, 0x2);
+        tsc_writel(tsc, LPC32XX_TSC_TTR, 0x10);
+        tsc_writel(tsc, LPC32XX_TSC_DXP, 0x4);
+        tsc_writel(tsc, LPC32XX_TSC_UTR, 88);
+
+        lpc32xx_fifo_clear(tsc);
+
+        /* Enable automatic ts event capture */
+        tsc_writel(tsc, LPC32XX_TSC_CON, tmp | LPC32XX_TSC_ADCCON_AUTO_EN);
+}
+
+static int lpc32xx_ts_open(struct input_dev *dev)
+{
+        struct lpc32xx_tsc *tsc = input_get_drvdata(dev);
+
+        lpc32xx_setup_tsc(tsc);
+
+        return 0;
+}
+
+static void lpc32xx_ts_close(struct input_dev *dev)
+{
+        struct lpc32xx_tsc *tsc = input_get_drvdata(dev);
+
+        lpc32xx_stop_tsc(tsc);
+}
+
+static int __devinit lpc32xx_ts_probe(struct platform_device *pdev)
+{
+        struct lpc32xx_tsc *tsc;
+        struct input_dev *input;
+        struct resource *res;
+        resource_size_t size;
+        int irq;
+        int error;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(&pdev->dev, "Can't get memory resource\n");
+                return -ENOENT;
+        }
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0) {
+                dev_err(&pdev->dev, "Can't get interrupt resource\n");
+                return irq;
+        }
+
+        tsc = kzalloc(sizeof(*tsc), GFP_KERNEL);
+        input = input_allocate_device();
+        if (!tsc || !input) {
+                dev_err(&pdev->dev, "failed allocating memory\n");
+                error = -ENOMEM;
+                goto err_free_mem;
+        }
+
+        tsc->dev = input;
+        tsc->irq = irq;
+
+        size = resource_size(res);
+
+        if (!request_mem_region(res->start, size, pdev->name)) {
+                dev_err(&pdev->dev, "TSC registers are not free\n");
+                error = -EBUSY;
+                goto err_free_mem;
+        }
+
+        tsc->tsc_base = ioremap(res->start, size);
+        if (!tsc->tsc_base) {
+                dev_err(&pdev->dev, "Can't map memory\n");
+                error = -ENOMEM;
+                goto err_release_mem;
+        }
+
+        tsc->clk = clk_get(&pdev->dev, NULL);
+        if (IS_ERR(tsc->clk)) {
+                dev_err(&pdev->dev, "failed getting clock\n");
+                error = PTR_ERR(tsc->clk);
+                goto err_unmap;
+        }
+
+        input->name = MOD_NAME;
+        input->phys = "lpc32xx/input0";
+        input->id.bustype = BUS_HOST;
+        input->id.vendor = 0x0001;
+        input->id.product = 0x0002;
+        input->id.version = 0x0100;
+        input->dev.parent = &pdev->dev;
+        input->open = lpc32xx_ts_open;
+        input->close = lpc32xx_ts_close;
+
+        input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
+        input->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
+        input_set_abs_params(input, ABS_X, LPC32XX_TSC_MIN_XY_VAL,
+                             LPC32XX_TSC_MAX_XY_VAL, 0, 0);
+        input_set_abs_params(input, ABS_Y, LPC32XX_TSC_MIN_XY_VAL,
+                             LPC32XX_TSC_MAX_XY_VAL, 0, 0);
+
+        input_set_drvdata(input, tsc);
+
+        error = request_irq(tsc->irq, lpc32xx_ts_interrupt,
+                            IRQF_DISABLED, pdev->name, tsc);
+        if (error) {
+                dev_err(&pdev->dev, "failed requesting interrupt\n");
+                goto err_put_clock;
+        }
+
+        error = input_register_device(input);
+        if (error) {
+                dev_err(&pdev->dev, "failed registering input device\n");
+                goto err_free_irq;
+        }
+
+        platform_set_drvdata(pdev, tsc);
+        device_init_wakeup(&pdev->dev, 1);
+
+        return 0;
+
+err_free_irq:
+        free_irq(tsc->irq, tsc);
+err_put_clock:
+        clk_put(tsc->clk);
+err_unmap:
+        iounmap(tsc->tsc_base);
+err_release_mem:
+        release_mem_region(res->start, size);
+err_free_mem:
+        input_free_device(input);
+        kfree(tsc);
+
+        return error;
+}
+
+static int __devexit lpc32xx_ts_remove(struct platform_device *pdev)
+{
+        struct lpc32xx_tsc *tsc = platform_get_drvdata(pdev);
+        struct resource *res;
+
+        device_init_wakeup(&pdev->dev, 0);
+        free_irq(tsc->irq, tsc);
+
+        input_unregister_device(tsc->dev);
+
+        clk_put(tsc->clk);
+
+        iounmap(tsc->tsc_base);
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        release_mem_region(res->start, resource_size(res));
+
+        kfree(tsc);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int lpc32xx_ts_suspend(struct device *dev)
+{
+        struct lpc32xx_tsc *tsc = dev_get_drvdata(dev);
+        struct input_dev *input = tsc->dev;
+
+        /*
+         * Suspend and resume can be called when the device hasn't been
+         * enabled. If there are no users that have the device open, then
+         * avoid calling the TSC stop and start functions as the TSC
+         * isn't yet clocked.
+         */
+        mutex_lock(&input->mutex);
+
+        if (input->users) {
+                if (device_may_wakeup(dev))
+                        enable_irq_wake(tsc->irq);
+                else
+                        lpc32xx_stop_tsc(tsc);
+        }
+
+        mutex_unlock(&input->mutex);
+
+        return 0;
+}
+
+static int lpc32xx_ts_resume(struct device *dev)
+{
+        struct lpc32xx_tsc *tsc = dev_get_drvdata(dev);
+        struct input_dev *input = tsc->dev;
+
+        mutex_lock(&input->mutex);
+
+        if (input->users) {
+                if (device_may_wakeup(dev))
+                        disable_irq_wake(tsc->irq);
+                else
+                        lpc32xx_setup_tsc(tsc);
+        }
+
+        mutex_unlock(&input->mutex);
+
+        return 0;
+}
+
+static const struct dev_pm_ops lpc32xx_ts_pm_ops = {
+        .suspend        = lpc32xx_ts_suspend,
+        .resume         = lpc32xx_ts_resume,
+};
+#define LPC32XX_TS_PM_OPS (&lpc32xx_ts_pm_ops)
+#else
+#define LPC32XX_TS_PM_OPS NULL
+#endif
+
+static struct platform_driver lpc32xx_ts_driver = {
+        .probe          = lpc32xx_ts_probe,
+        .remove         = __devexit_p(lpc32xx_ts_remove),
+        .driver         = {
+                .name   = MOD_NAME,
+                .owner  = THIS_MODULE,
+                .pm     = LPC32XX_TS_PM_OPS,
+        },
+};
+
+static int __init lpc32xx_ts_init(void)
+{
+        return platform_driver_register(&lpc32xx_ts_driver);
+}
+module_init(lpc32xx_ts_init);
+
+static void __exit lpc32xx_ts_exit(void)
+{
+        platform_driver_unregister(&lpc32xx_ts_driver);
+}
+module_exit(lpc32xx_ts_exit);
+
+MODULE_AUTHOR("Kevin Wells <kevin.wells@nxp.com");
+MODULE_DESCRIPTION("LPC32XX TSC Driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:lpc32xx_ts");
diff --git a/drivers/input/touchscreen/mainstone-wm97xx.c b/drivers/input/touchscreen/mainstone-wm97xx.c
index b6b8b1c7ecea..3242e7076258 100644
--- a/drivers/input/touchscreen/mainstone-wm97xx.c
+++ b/drivers/input/touchscreen/mainstone-wm97xx.c
@@ -219,7 +219,7 @@ static int wm97xx_acc_startup(struct wm97xx *wm)
                 }
 
                 wm->pen_irq = gpio_to_irq(irq);
-                set_irq_type(wm->pen_irq, IRQ_TYPE_EDGE_BOTH);
+                irq_set_irq_type(wm->pen_irq, IRQ_TYPE_EDGE_BOTH);
         } else /* pen irq not supported */
                 pen_int = 0;
 
diff --git a/drivers/input/touchscreen/max11801_ts.c b/drivers/input/touchscreen/max11801_ts.c
new file mode 100644
index 000000000000..4f2713d92791
--- /dev/null
+++ b/drivers/input/touchscreen/max11801_ts.c
@@ -0,0 +1,272 @@
+/*
+ * Driver for MAXI MAX11801 - A Resistive touch screen controller with
+ * i2c interface
+ *
+ * Copyright (C) 2011 Freescale Semiconductor, Inc.
+ * Author: Zhang Jiejing <jiejing.zhang@freescale.com>
+ *
+ * Based on mcs5000_ts.c
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License.
+ */
+
+/*
+ * This driver aims to support the series of MAXI touch chips max11801
+ * through max11803. The main difference between these 4 chips can be
+ * found in the table below:
+ * -----------------------------------------------------
+ * | CHIP     |  AUTO MODE SUPPORT(FIFO) | INTERFACE    |
+ * |----------------------------------------------------|
+ * | max11800 |  YES                     |   SPI        |
+ * | max11801 |  YES                     |   I2C        |
+ * | max11802 |  NO                      |   SPI        |
+ * | max11803 |  NO                      |   I2C        |
+ * ------------------------------------------------------
+ *
+ * Currently, this driver only supports max11801.
+ *
+ * Data Sheet:
+ * http://www.maxim-ic.com/datasheet/index.mvp/id/5943
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/i2c.h>
+#include <linux/interrupt.h>
+#include <linux/input.h>
+#include <linux/slab.h>
+#include <linux/bitops.h>
+
+/* Register Address define */
+#define GENERNAL_STATUS_REG             0x00
+#define GENERNAL_CONF_REG               0x01
+#define MESURE_RES_CONF_REG             0x02
+#define MESURE_AVER_CONF_REG            0x03
+#define ADC_SAMPLE_TIME_CONF_REG        0x04
+#define PANEL_SETUPTIME_CONF_REG        0x05
+#define DELAY_CONVERSION_CONF_REG       0x06
+#define TOUCH_DETECT_PULLUP_CONF_REG    0x07
+#define AUTO_MODE_TIME_CONF_REG         0x08 /* only for max11800/max11801 */
+#define APERTURE_CONF_REG               0x09 /* only for max11800/max11801 */
+#define AUX_MESURE_CONF_REG             0x0a
+#define OP_MODE_CONF_REG                0x0b
+
+/* FIFO is found only in max11800 and max11801 */
+#define FIFO_RD_CMD                     (0x50 << 1)
+#define MAX11801_FIFO_INT               (1 << 2)
+#define MAX11801_FIFO_OVERFLOW          (1 << 3)
+
+#define XY_BUFSIZE                      4
+#define XY_BUF_OFFSET                   4
+
+#define MAX11801_MAX_X                  0xfff
+#define MAX11801_MAX_Y                  0xfff
+
+#define MEASURE_TAG_OFFSET              2
+#define MEASURE_TAG_MASK                (3 << MEASURE_TAG_OFFSET)
+#define EVENT_TAG_OFFSET                0
+#define EVENT_TAG_MASK                  (3 << EVENT_TAG_OFFSET)
+#define MEASURE_X_TAG                   (0 << MEASURE_TAG_OFFSET)
+#define MEASURE_Y_TAG                   (1 << MEASURE_TAG_OFFSET)
+
+/* These are the state of touch event state machine */
+enum {
+        EVENT_INIT,
+        EVENT_MIDDLE,
+        EVENT_RELEASE,
+        EVENT_FIFO_END
+};
+
+struct max11801_data {
+        struct i2c_client               *client;
+        struct input_dev                *input_dev;
+};
+
+static u8 read_register(struct i2c_client *client, int addr)
+{
+        /* XXX: The chip ignores LSB of register address */
+        return i2c_smbus_read_byte_data(client, addr << 1);
+}
+
+static int max11801_write_reg(struct i2c_client *client, int addr, int data)
+{
+        /* XXX: The chip ignores LSB of register address */
+        return i2c_smbus_write_byte_data(client, addr << 1, data);
+}
+
+static irqreturn_t max11801_ts_interrupt(int irq, void *dev_id)
+{
+        struct max11801_data *data = dev_id;
+        struct i2c_client *client = data->client;
+        int status, i, ret;
+        u8 buf[XY_BUFSIZE];
+        int x = -1;
+        int y = -1;
+
+        status = read_register(data->client, GENERNAL_STATUS_REG);
+
+        if (status & (MAX11801_FIFO_INT | MAX11801_FIFO_OVERFLOW)) {
+                status = read_register(data->client, GENERNAL_STATUS_REG);
+
+                ret = i2c_smbus_read_i2c_block_data(client, FIFO_RD_CMD,
+                                                    XY_BUFSIZE, buf);
+
+                /*
+                 * We should get 4 bytes buffer that contains X,Y
+                 * and event tag
+                 */
+                if (ret < XY_BUFSIZE)
+                        goto out;
+
+                for (i = 0; i < XY_BUFSIZE; i += XY_BUFSIZE / 2) {
+                        if ((buf[i + 1] & MEASURE_TAG_MASK) == MEASURE_X_TAG)
+                                x = (buf[i] << XY_BUF_OFFSET) +
+                                    (buf[i + 1] >> XY_BUF_OFFSET);
+                        else if ((buf[i + 1] & MEASURE_TAG_MASK) == MEASURE_Y_TAG)
+                                y = (buf[i] << XY_BUF_OFFSET) +
+                                    (buf[i + 1] >> XY_BUF_OFFSET);
+                }
+
+                if ((buf[1] & EVENT_TAG_MASK) != (buf[3] & EVENT_TAG_MASK))
+                        goto out;
+
+                switch (buf[1] & EVENT_TAG_MASK) {
+                case EVENT_INIT:
+                        /* fall through */
+                case EVENT_MIDDLE:
+                        input_report_abs(data->input_dev, ABS_X, x);
+                        input_report_abs(data->input_dev, ABS_Y, y);
+                        input_event(data->input_dev, EV_KEY, BTN_TOUCH, 1);
+                        input_sync(data->input_dev);
+                        break;
+
+                case EVENT_RELEASE:
+                        input_event(data->input_dev, EV_KEY, BTN_TOUCH, 0);
+                        input_sync(data->input_dev);
+                        break;
+
+                case EVENT_FIFO_END:
+                        break;
+                }
+        }
+out:
+        return IRQ_HANDLED;
+}
+
+static void __devinit max11801_ts_phy_init(struct max11801_data *data)
+{
+        struct i2c_client *client = data->client;
+
+        /* Average X,Y, take 16 samples, average eight media sample */
+        max11801_write_reg(client, MESURE_AVER_CONF_REG, 0xff);
+        /* X,Y panel setup time set to 20us */
+        max11801_write_reg(client, PANEL_SETUPTIME_CONF_REG, 0x11);
+        /* Rough pullup time (2uS), Fine pullup time (10us)  */
+        max11801_write_reg(client, TOUCH_DETECT_PULLUP_CONF_REG, 0x10);
+        /* Auto mode init period = 5ms , scan period = 5ms*/
+        max11801_write_reg(client, AUTO_MODE_TIME_CONF_REG, 0xaa);
+        /* Aperture X,Y set to +- 4LSB */
+        max11801_write_reg(client, APERTURE_CONF_REG, 0x33);
+        /* Enable Power, enable Automode, enable Aperture, enable Average X,Y */
+        max11801_write_reg(client, OP_MODE_CONF_REG, 0x36);
+}
+
+static int __devinit max11801_ts_probe(struct i2c_client *client,
+                                       const struct i2c_device_id *id)
+{
+        struct max11801_data *data;
+        struct input_dev *input_dev;
+        int error;
+
+        data = kzalloc(sizeof(struct max11801_data), GFP_KERNEL);
+        input_dev = input_allocate_device();
+        if (!data || !input_dev) {
+                dev_err(&client->dev, "Failed to allocate memory\n");
+                error = -ENOMEM;
+                goto err_free_mem;
+        }
+
+        data->client = client;
+        data->input_dev = input_dev;
+
+        input_dev->name = "max11801_ts";
+        input_dev->id.bustype = BUS_I2C;
+        input_dev->dev.parent = &client->dev;
+
+        __set_bit(EV_ABS, input_dev->evbit);
+        __set_bit(EV_KEY, input_dev->evbit);
+        __set_bit(BTN_TOUCH, input_dev->keybit);
+        input_set_abs_params(input_dev, ABS_X, 0, MAX11801_MAX_X, 0, 0);
+        input_set_abs_params(input_dev, ABS_Y, 0, MAX11801_MAX_Y, 0, 0);
+        input_set_drvdata(input_dev, data);
+
+        max11801_ts_phy_init(data);
+
+        error = request_threaded_irq(client->irq, NULL, max11801_ts_interrupt,
+                                     IRQF_TRIGGER_LOW | IRQF_ONESHOT,
+                                     "max11801_ts", data);
+        if (error) {
+                dev_err(&client->dev, "Failed to register interrupt\n");
+                goto err_free_mem;
+        }
+
+        error = input_register_device(data->input_dev);
+        if (error)
+                goto err_free_irq;
+
+        i2c_set_clientdata(client, data);
+        return 0;
+
+err_free_irq:
+        free_irq(client->irq, data);
+err_free_mem:
+        input_free_device(input_dev);
+        kfree(data);
+        return error;
+}
+
+static __devexit int max11801_ts_remove(struct i2c_client *client)
+{
+        struct max11801_data *data = i2c_get_clientdata(client);
+
+        free_irq(client->irq, data);
+        input_unregister_device(data->input_dev);
+        kfree(data);
+
+        return 0;
+}
+
+static const struct i2c_device_id max11801_ts_id[] = {
+        {"max11801", 0},
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, max11801_ts_id);
+
+static struct i2c_driver max11801_ts_driver = {
+        .driver = {
+                .name   = "max11801_ts",
+                .owner  = THIS_MODULE,
+        },
+        .id_table       = max11801_ts_id,
+        .probe          = max11801_ts_probe,
+        .remove         = __devexit_p(max11801_ts_remove),
+};
+
+static int __init max11801_ts_init(void)
+{
+        return i2c_add_driver(&max11801_ts_driver);
+}
+
+static void __exit max11801_ts_exit(void)
+{
+        i2c_del_driver(&max11801_ts_driver);
+}
+
+module_init(max11801_ts_init);
+module_exit(max11801_ts_exit);
+
+MODULE_AUTHOR("Zhang Jiejing <jiejing.zhang@freescale.com>");
+MODULE_DESCRIPTION("Touchscreen driver for MAXI MAX11801 controller");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/touchscreen/mcs5000_ts.c b/drivers/input/touchscreen/mcs5000_ts.c
index 6ee9940aaf5b..2d84c80ceb66 100644
--- a/drivers/input/touchscreen/mcs5000_ts.c
+++ b/drivers/input/touchscreen/mcs5000_ts.c
@@ -261,25 +261,27 @@ static int __devexit mcs5000_ts_remove(struct i2c_client *client)
 }
 
 #ifdef CONFIG_PM
-static int mcs5000_ts_suspend(struct i2c_client *client, pm_message_t mesg)
+static int mcs5000_ts_suspend(struct device *dev)
 {
+        struct i2c_client *client = to_i2c_client(dev);
+
         /* Touch sleep mode */
         i2c_smbus_write_byte_data(client, MCS5000_TS_OP_MODE, OP_MODE_SLEEP);
 
         return 0;
 }
 
-static int mcs5000_ts_resume(struct i2c_client *client)
+static int mcs5000_ts_resume(struct device *dev)
 {
+        struct i2c_client *client = to_i2c_client(dev);
         struct mcs5000_ts_data *data = i2c_get_clientdata(client);
 
         mcs5000_ts_phys_init(data);
 
         return 0;
 }
-#else
-#define mcs5000_ts_suspend      NULL
-#define mcs5000_ts_resume       NULL
+
+static SIMPLE_DEV_PM_OPS(mcs5000_ts_pm, mcs5000_ts_suspend, mcs5000_ts_resume);
 #endif
 
 static const struct i2c_device_id mcs5000_ts_id[] = {
@@ -291,10 +293,11 @@ MODULE_DEVICE_TABLE(i2c, mcs5000_ts_id);
 static struct i2c_driver mcs5000_ts_driver = {
         .probe          = mcs5000_ts_probe,
         .remove         = __devexit_p(mcs5000_ts_remove),
-        .suspend        = mcs5000_ts_suspend,
-        .resume         = mcs5000_ts_resume,
         .driver = {
                 .name = "mcs5000_ts",
+#ifdef CONFIG_PM
+                .pm   = &mcs5000_ts_pm,
+#endif
         },
         .id_table       = mcs5000_ts_id,
 };
diff --git a/drivers/input/touchscreen/migor_ts.c b/drivers/input/touchscreen/migor_ts.c
index defe5dd3627c..5803bd0c1cca 100644
--- a/drivers/input/touchscreen/migor_ts.c
+++ b/drivers/input/touchscreen/migor_ts.c
@@ -23,6 +23,7 @@
 #include <linux/kernel.h>
 #include <linux/input.h>
 #include <linux/interrupt.h>
+#include <linux/pm.h>
 #include <linux/slab.h>
 #include <asm/io.h>
 #include <linux/i2c.h>
@@ -226,8 +227,9 @@ static int migor_ts_remove(struct i2c_client *client)
         return 0;
 }
 
-static int migor_ts_suspend(struct i2c_client *client, pm_message_t mesg)
+static int migor_ts_suspend(struct device *dev)
 {
+        struct i2c_client *client = to_i2c_client(dev);
         struct migor_ts_priv *priv = dev_get_drvdata(&client->dev);
 
         if (device_may_wakeup(&client->dev))
@@ -236,8 +238,9 @@ static int migor_ts_suspend(struct i2c_client *client, pm_message_t mesg)
         return 0;
 }
 
-static int migor_ts_resume(struct i2c_client *client)
+static int migor_ts_resume(struct device *dev)
 {
+        struct i2c_client *client = to_i2c_client(dev);
         struct migor_ts_priv *priv = dev_get_drvdata(&client->dev);
 
         if (device_may_wakeup(&client->dev))
@@ -246,6 +249,8 @@ static int migor_ts_resume(struct i2c_client *client)
         return 0;
 }
 
+static SIMPLE_DEV_PM_OPS(migor_ts_pm, migor_ts_suspend, migor_ts_resume);
+
 static const struct i2c_device_id migor_ts_id[] = {
         { "migor_ts", 0 },
         { }
@@ -255,11 +260,10 @@ MODULE_DEVICE_TABLE(i2c, migor_ts);
 static struct i2c_driver migor_ts_driver = {
         .driver = {
                 .name = "migor_ts",
+                .pm = &migor_ts_pm,
         },
         .probe = migor_ts_probe,
         .remove = migor_ts_remove,
-        .suspend = migor_ts_suspend,
-        .resume = migor_ts_resume,
         .id_table = migor_ts_id,
 };
 
diff --git a/drivers/input/touchscreen/mk712.c b/drivers/input/touchscreen/mk712.c
index efd3aebaba5f..36e57deacd03 100644
--- a/drivers/input/touchscreen/mk712.c
+++ b/drivers/input/touchscreen/mk712.c
@@ -17,7 +17,7 @@
  * found in Gateway AOL Connected Touchpad computers.
  *
  * Documentation for ICS MK712 can be found at:
- *      http://www.icst.com/pdf/mk712.pdf
+ *      http://www.idt.com/products/getDoc.cfm?docID=18713923
  */
 
 /*
diff --git a/drivers/input/touchscreen/qt602240_ts.c b/drivers/input/touchscreen/qt602240_ts.c
deleted file mode 100644
index 66b26ad3032a..000000000000
--- a/drivers/input/touchscreen/qt602240_ts.c
+++ /dev/null
@@ -1,1401 +0,0 @@
-/*
- * AT42QT602240/ATMXT224 Touchscreen driver
- *
- * Copyright (C) 2010 Samsung Electronics Co.Ltd
- * Author: Joonyoung Shim <jy0922.shim@samsung.com>
- *
- * This program is free software; you can redistribute  it and/or modify it
- * under  the terms of  the GNU General  Public License as published by the
- * Free Software Foundation;  either version 2 of the  License, or (at your
- * option) any later version.
- *
- */
-
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/delay.h>
-#include <linux/firmware.h>
-#include <linux/i2c.h>
-#include <linux/i2c/qt602240_ts.h>
-#include <linux/input.h>
-#include <linux/interrupt.h>
-#include <linux/slab.h>
-
-/* Version */
-#define QT602240_VER_20                 20
-#define QT602240_VER_21                 21
-#define QT602240_VER_22                 22
-
-/* Slave addresses */
-#define QT602240_APP_LOW                0x4a
-#define QT602240_APP_HIGH               0x4b
-#define QT602240_BOOT_LOW               0x24
-#define QT602240_BOOT_HIGH              0x25
-
-/* Firmware */
-#define QT602240_FW_NAME                "qt602240.fw"
-
-/* Registers */
-#define QT602240_FAMILY_ID              0x00
-#define QT602240_VARIANT_ID             0x01
-#define QT602240_VERSION                0x02
-#define QT602240_BUILD                  0x03
-#define QT602240_MATRIX_X_SIZE          0x04
-#define QT602240_MATRIX_Y_SIZE          0x05
-#define QT602240_OBJECT_NUM             0x06
-#define QT602240_OBJECT_START           0x07
-
-#define QT602240_OBJECT_SIZE            6
-
-/* Object types */
-#define QT602240_DEBUG_DIAGNOSTIC       37
-#define QT602240_GEN_MESSAGE            5
-#define QT602240_GEN_COMMAND            6
-#define QT602240_GEN_POWER              7
-#define QT602240_GEN_ACQUIRE            8
-#define QT602240_TOUCH_MULTI            9
-#define QT602240_TOUCH_KEYARRAY         15
-#define QT602240_TOUCH_PROXIMITY        23
-#define QT602240_PROCI_GRIPFACE         20
-#define QT602240_PROCG_NOISE            22
-#define QT602240_PROCI_ONETOUCH         24
-#define QT602240_PROCI_TWOTOUCH         27
-#define QT602240_SPT_COMMSCONFIG        18      /* firmware ver 21 over */
-#define QT602240_SPT_GPIOPWM            19
-#define QT602240_SPT_SELFTEST           25
-#define QT602240_SPT_CTECONFIG          28
-#define QT602240_SPT_USERDATA           38      /* firmware ver 21 over */
-
-/* QT602240_GEN_COMMAND field */
-#define QT602240_COMMAND_RESET          0
-#define QT602240_COMMAND_BACKUPNV       1
-#define QT602240_COMMAND_CALIBRATE      2
-#define QT602240_COMMAND_REPORTALL      3
-#define QT602240_COMMAND_DIAGNOSTIC     5
-
-/* QT602240_GEN_POWER field */
-#define QT602240_POWER_IDLEACQINT       0
-#define QT602240_POWER_ACTVACQINT       1
-#define QT602240_POWER_ACTV2IDLETO      2
-
-/* QT602240_GEN_ACQUIRE field */
-#define QT602240_ACQUIRE_CHRGTIME       0
-#define QT602240_ACQUIRE_TCHDRIFT       2
-#define QT602240_ACQUIRE_DRIFTST        3
-#define QT602240_ACQUIRE_TCHAUTOCAL     4
-#define QT602240_ACQUIRE_SYNC           5
-#define QT602240_ACQUIRE_ATCHCALST      6
-#define QT602240_ACQUIRE_ATCHCALSTHR    7
-
-/* QT602240_TOUCH_MULTI field */
-#define QT602240_TOUCH_CTRL             0
-#define QT602240_TOUCH_XORIGIN          1
-#define QT602240_TOUCH_YORIGIN          2
-#define QT602240_TOUCH_XSIZE            3
-#define QT602240_TOUCH_YSIZE            4
-#define QT602240_TOUCH_BLEN             6
-#define QT602240_TOUCH_TCHTHR           7
-#define QT602240_TOUCH_TCHDI            8
-#define QT602240_TOUCH_ORIENT           9
-#define QT602240_TOUCH_MOVHYSTI         11
-#define QT602240_TOUCH_MOVHYSTN         12
-#define QT602240_TOUCH_NUMTOUCH         14
-#define QT602240_TOUCH_MRGHYST          15
-#define QT602240_TOUCH_MRGTHR           16
-#define QT602240_TOUCH_AMPHYST          17
-#define QT602240_TOUCH_XRANGE_LSB       18
-#define QT602240_TOUCH_XRANGE_MSB       19
-#define QT602240_TOUCH_YRANGE_LSB       20
-#define QT602240_TOUCH_YRANGE_MSB       21
-#define QT602240_TOUCH_XLOCLIP          22
-#define QT602240_TOUCH_XHICLIP          23
-#define QT602240_TOUCH_YLOCLIP          24
-#define QT602240_TOUCH_YHICLIP          25
-#define QT602240_TOUCH_XEDGECTRL        26
-#define QT602240_TOUCH_XEDGEDIST        27
-#define QT602240_TOUCH_YEDGECTRL        28
-#define QT602240_TOUCH_YEDGEDIST        29
-#define QT602240_TOUCH_JUMPLIMIT        30      /* firmware ver 22 over */
-
-/* QT602240_PROCI_GRIPFACE field */
-#define QT602240_GRIPFACE_CTRL          0
-#define QT602240_GRIPFACE_XLOGRIP       1
-#define QT602240_GRIPFACE_XHIGRIP       2
-#define QT602240_GRIPFACE_YLOGRIP       3
-#define QT602240_GRIPFACE_YHIGRIP       4
-#define QT602240_GRIPFACE_MAXTCHS       5
-#define QT602240_GRIPFACE_SZTHR1        7
-#define QT602240_GRIPFACE_SZTHR2        8
-#define QT602240_GRIPFACE_SHPTHR1       9
-#define QT602240_GRIPFACE_SHPTHR2       10
-#define QT602240_GRIPFACE_SUPEXTTO      11
-
-/* QT602240_PROCI_NOISE field */
-#define QT602240_NOISE_CTRL             0
-#define QT602240_NOISE_OUTFLEN          1
-#define QT602240_NOISE_GCAFUL_LSB       3
-#define QT602240_NOISE_GCAFUL_MSB       4
-#define QT602240_NOISE_GCAFLL_LSB       5
-#define QT602240_NOISE_GCAFLL_MSB       6
-#define QT602240_NOISE_ACTVGCAFVALID    7
-#define QT602240_NOISE_NOISETHR         8
-#define QT602240_NOISE_FREQHOPSCALE     10
-#define QT602240_NOISE_FREQ0            11
-#define QT602240_NOISE_FREQ1            12
-#define QT602240_NOISE_FREQ2            13
-#define QT602240_NOISE_FREQ3            14
-#define QT602240_NOISE_FREQ4            15
-#define QT602240_NOISE_IDLEGCAFVALID    16
-
-/* QT602240_SPT_COMMSCONFIG */
-#define QT602240_COMMS_CTRL             0
-#define QT602240_COMMS_CMD              1
-
-/* QT602240_SPT_CTECONFIG field */
-#define QT602240_CTE_CTRL               0
-#define QT602240_CTE_CMD                1
-#define QT602240_CTE_MODE               2
-#define QT602240_CTE_IDLEGCAFDEPTH      3
-#define QT602240_CTE_ACTVGCAFDEPTH      4
-#define QT602240_CTE_VOLTAGE            5       /* firmware ver 21 over */
-
-#define QT602240_VOLTAGE_DEFAULT        2700000
-#define QT602240_VOLTAGE_STEP           10000
-
-/* Define for QT602240_GEN_COMMAND */
-#define QT602240_BOOT_VALUE             0xa5
-#define QT602240_BACKUP_VALUE           0x55
-#define QT602240_BACKUP_TIME            25      /* msec */
-#define QT602240_RESET_TIME             65      /* msec */
-
-#define QT602240_FWRESET_TIME           175     /* msec */
-
-/* Command to unlock bootloader */
-#define QT602240_UNLOCK_CMD_MSB         0xaa
-#define QT602240_UNLOCK_CMD_LSB         0xdc
-
-/* Bootloader mode status */
-#define QT602240_WAITING_BOOTLOAD_CMD   0xc0    /* valid 7 6 bit only */
-#define QT602240_WAITING_FRAME_DATA     0x80    /* valid 7 6 bit only */
-#define QT602240_FRAME_CRC_CHECK        0x02
-#define QT602240_FRAME_CRC_FAIL         0x03
-#define QT602240_FRAME_CRC_PASS         0x04
-#define QT602240_APP_CRC_FAIL           0x40    /* valid 7 8 bit only */
-#define QT602240_BOOT_STATUS_MASK       0x3f
-
-/* Touch status */
-#define QT602240_SUPPRESS               (1 << 1)
-#define QT602240_AMP                    (1 << 2)
-#define QT602240_VECTOR                 (1 << 3)
-#define QT602240_MOVE                   (1 << 4)
-#define QT602240_RELEASE                (1 << 5)
-#define QT602240_PRESS                  (1 << 6)
-#define QT602240_DETECT                 (1 << 7)
-
-/* Touchscreen absolute values */
-#define QT602240_MAX_XC                 0x3ff
-#define QT602240_MAX_YC                 0x3ff
-#define QT602240_MAX_AREA               0xff
-
-#define QT602240_MAX_FINGER             10
-
-/* Initial register values recommended from chip vendor */
-static const u8 init_vals_ver_20[] = {
-        /* QT602240_GEN_COMMAND(6) */
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        /* QT602240_GEN_POWER(7) */
-        0x20, 0xff, 0x32,
-        /* QT602240_GEN_ACQUIRE(8) */
-        0x08, 0x05, 0x05, 0x00, 0x00, 0x00, 0x05, 0x14,
-        /* QT602240_TOUCH_MULTI(9) */
-        0x00, 0x00, 0x00, 0x11, 0x0a, 0x00, 0x00, 0x00, 0x02, 0x00,
-        0x00, 0x01, 0x01, 0x0e, 0x0a, 0x0a, 0x0a, 0x0a, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x88, 0x64,
-        /* QT602240_TOUCH_KEYARRAY(15) */
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00,
-        /* QT602240_SPT_GPIOPWM(19) */
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00,
-        /* QT602240_PROCI_GRIPFACE(20) */
-        0x00, 0x64, 0x64, 0x64, 0x64, 0x00, 0x00, 0x1e, 0x14, 0x04,
-        0x1e, 0x00,
-        /* QT602240_PROCG_NOISE(22) */
-        0x05, 0x00, 0x00, 0x19, 0x00, 0xe7, 0xff, 0x04, 0x32, 0x00,
-        0x01, 0x0a, 0x0f, 0x14, 0x00, 0x00, 0xe8,
-        /* QT602240_TOUCH_PROXIMITY(23) */
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00,
-        /* QT602240_PROCI_ONETOUCH(24) */
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        /* QT602240_SPT_SELFTEST(25) */
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        /* QT602240_PROCI_TWOTOUCH(27) */
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        /* QT602240_SPT_CTECONFIG(28) */
-        0x00, 0x00, 0x00, 0x04, 0x08,
-};
-
-static const u8 init_vals_ver_21[] = {
-        /* QT602240_GEN_COMMAND(6) */
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        /* QT602240_GEN_POWER(7) */
-        0x20, 0xff, 0x32,
-        /* QT602240_GEN_ACQUIRE(8) */
-        0x0a, 0x00, 0x05, 0x00, 0x00, 0x00, 0x09, 0x23,
-        /* QT602240_TOUCH_MULTI(9) */
-        0x00, 0x00, 0x00, 0x13, 0x0b, 0x00, 0x00, 0x00, 0x02, 0x00,
-        0x00, 0x01, 0x01, 0x0e, 0x0a, 0x0a, 0x0a, 0x0a, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        /* QT602240_TOUCH_KEYARRAY(15) */
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00,
-        /* QT602240_SPT_GPIOPWM(19) */
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        /* QT602240_PROCI_GRIPFACE(20) */
-        0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x28, 0x04,
-        0x0f, 0x0a,
-        /* QT602240_PROCG_NOISE(22) */
-        0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x23, 0x00,
-        0x00, 0x05, 0x0f, 0x19, 0x23, 0x2d, 0x03,
-        /* QT602240_TOUCH_PROXIMITY(23) */
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00,
-        /* QT602240_PROCI_ONETOUCH(24) */
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        /* QT602240_SPT_SELFTEST(25) */
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        /* QT602240_PROCI_TWOTOUCH(27) */
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        /* QT602240_SPT_CTECONFIG(28) */
-        0x00, 0x00, 0x00, 0x08, 0x10, 0x00,
-};
-
-static const u8 init_vals_ver_22[] = {
-        /* QT602240_GEN_COMMAND(6) */
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        /* QT602240_GEN_POWER(7) */
-        0x20, 0xff, 0x32,
-        /* QT602240_GEN_ACQUIRE(8) */
-        0x0a, 0x00, 0x05, 0x00, 0x00, 0x00, 0x09, 0x23,
-        /* QT602240_TOUCH_MULTI(9) */
-        0x00, 0x00, 0x00, 0x13, 0x0b, 0x00, 0x00, 0x00, 0x02, 0x00,
-        0x00, 0x01, 0x01, 0x0e, 0x0a, 0x0a, 0x0a, 0x0a, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00,
-        /* QT602240_TOUCH_KEYARRAY(15) */
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00,
-        /* QT602240_SPT_GPIOPWM(19) */
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        /* QT602240_PROCI_GRIPFACE(20) */
-        0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x28, 0x04,
-        0x0f, 0x0a,
-        /* QT602240_PROCG_NOISE(22) */
-        0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x23, 0x00,
-        0x00, 0x05, 0x0f, 0x19, 0x23, 0x2d, 0x03,
-        /* QT602240_TOUCH_PROXIMITY(23) */
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00,
-        /* QT602240_PROCI_ONETOUCH(24) */
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        /* QT602240_SPT_SELFTEST(25) */
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        /* QT602240_PROCI_TWOTOUCH(27) */
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        /* QT602240_SPT_CTECONFIG(28) */
-        0x00, 0x00, 0x00, 0x08, 0x10, 0x00,
-};
-
-struct qt602240_info {
-        u8 family_id;
-        u8 variant_id;
-        u8 version;
-        u8 build;
-        u8 matrix_xsize;
-        u8 matrix_ysize;
-        u8 object_num;
-};
-
-struct qt602240_object {
-        u8 type;
-        u16 start_address;
-        u8 size;
-        u8 instances;
-        u8 num_report_ids;
-
-        /* to map object and message */
-        u8 max_reportid;
-};
-
-struct qt602240_message {
-        u8 reportid;
-        u8 message[7];
-        u8 checksum;
-};
-
-struct qt602240_finger {
-        int status;
-        int x;
-        int y;
-        int area;
-};
-
-/* Each client has this additional data */
-struct qt602240_data {
-        struct i2c_client *client;
-        struct input_dev *input_dev;
-        const struct qt602240_platform_data *pdata;
-        struct qt602240_object *object_table;
-        struct qt602240_info info;
-        struct qt602240_finger finger[QT602240_MAX_FINGER];
-        unsigned int irq;
-};
-
-static bool qt602240_object_readable(unsigned int type)
-{
-        switch (type) {
-        case QT602240_GEN_MESSAGE:
-        case QT602240_GEN_COMMAND:
-        case QT602240_GEN_POWER:
-        case QT602240_GEN_ACQUIRE:
-        case QT602240_TOUCH_MULTI:
-        case QT602240_TOUCH_KEYARRAY:
-        case QT602240_TOUCH_PROXIMITY:
-        case QT602240_PROCI_GRIPFACE:
-        case QT602240_PROCG_NOISE:
-        case QT602240_PROCI_ONETOUCH:
-        case QT602240_PROCI_TWOTOUCH:
-        case QT602240_SPT_COMMSCONFIG:
-        case QT602240_SPT_GPIOPWM:
-        case QT602240_SPT_SELFTEST:
-        case QT602240_SPT_CTECONFIG:
-        case QT602240_SPT_USERDATA:
-                return true;
-        default:
-                return false;
-        }
-}
-
-static bool qt602240_object_writable(unsigned int type)
-{
-        switch (type) {
-        case QT602240_GEN_COMMAND:
-        case QT602240_GEN_POWER:
-        case QT602240_GEN_ACQUIRE:
-        case QT602240_TOUCH_MULTI:
-        case QT602240_TOUCH_KEYARRAY:
-        case QT602240_TOUCH_PROXIMITY:
-        case QT602240_PROCI_GRIPFACE:
-        case QT602240_PROCG_NOISE:
-        case QT602240_PROCI_ONETOUCH:
-        case QT602240_PROCI_TWOTOUCH:
-        case QT602240_SPT_GPIOPWM:
-        case QT602240_SPT_SELFTEST:
-        case QT602240_SPT_CTECONFIG:
-                return true;
-        default:
-                return false;
-        }
-}
-
-static void qt602240_dump_message(struct device *dev,
-                                  struct qt602240_message *message)
-{
-        dev_dbg(dev, "reportid:\t0x%x\n", message->reportid);
-        dev_dbg(dev, "message1:\t0x%x\n", message->message[0]);
-        dev_dbg(dev, "message2:\t0x%x\n", message->message[1]);
-        dev_dbg(dev, "message3:\t0x%x\n", message->message[2]);
-        dev_dbg(dev, "message4:\t0x%x\n", message->message[3]);
-        dev_dbg(dev, "message5:\t0x%x\n", message->message[4]);
-        dev_dbg(dev, "message6:\t0x%x\n", message->message[5]);
-        dev_dbg(dev, "message7:\t0x%x\n", message->message[6]);
-        dev_dbg(dev, "checksum:\t0x%x\n", message->checksum);
-}
-
-static int qt602240_check_bootloader(struct i2c_client *client,
-                                     unsigned int state)
-{
-        u8 val;
-
-recheck:
-        if (i2c_master_recv(client, &val, 1) != 1) {
-                dev_err(&client->dev, "%s: i2c recv failed\n", __func__);
-                return -EIO;
-        }
-
-        switch (state) {
-        case QT602240_WAITING_BOOTLOAD_CMD:
-        case QT602240_WAITING_FRAME_DATA:
-                val &= ~QT602240_BOOT_STATUS_MASK;
-                break;
-        case QT602240_FRAME_CRC_PASS:
-                if (val == QT602240_FRAME_CRC_CHECK)
-                        goto recheck;
-                break;
-        default:
-                return -EINVAL;
-        }
-
-        if (val != state) {
-                dev_err(&client->dev, "Unvalid bootloader mode state\n");
-                return -EINVAL;
-        }
-
-        return 0;
-}
-
-static int qt602240_unlock_bootloader(struct i2c_client *client)
-{
-        u8 buf[2];
-
-        buf[0] = QT602240_UNLOCK_CMD_LSB;
-        buf[1] = QT602240_UNLOCK_CMD_MSB;
-
-        if (i2c_master_send(client, buf, 2) != 2) {
-                dev_err(&client->dev, "%s: i2c send failed\n", __func__);
-                return -EIO;
-        }
-
-        return 0;
-}
-
-static int qt602240_fw_write(struct i2c_client *client,
-                             const u8 *data, unsigned int frame_size)
-{
-        if (i2c_master_send(client, data, frame_size) != frame_size) {
-                dev_err(&client->dev, "%s: i2c send failed\n", __func__);
-                return -EIO;
-        }
-
-        return 0;
-}
-
-static int __qt602240_read_reg(struct i2c_client *client,
-                               u16 reg, u16 len, void *val)
-{
-        struct i2c_msg xfer[2];
-        u8 buf[2];
-
-        buf[0] = reg & 0xff;
-        buf[1] = (reg >> 8) & 0xff;
-
-        /* Write register */
-        xfer[0].addr = client->addr;
-        xfer[0].flags = 0;
-        xfer[0].len = 2;
-        xfer[0].buf = buf;
-
-        /* Read data */
-        xfer[1].addr = client->addr;
-        xfer[1].flags = I2C_M_RD;
-        xfer[1].len = len;
-        xfer[1].buf = val;
-
-        if (i2c_transfer(client->adapter, xfer, 2) != 2) {
-                dev_err(&client->dev, "%s: i2c transfer failed\n", __func__);
-                return -EIO;
-        }
-
-        return 0;
-}
-
-static int qt602240_read_reg(struct i2c_client *client, u16 reg, u8 *val)
-{
-        return __qt602240_read_reg(client, reg, 1, val);
-}
-
-static int qt602240_write_reg(struct i2c_client *client, u16 reg, u8 val)
-{
-        u8 buf[3];
-
-        buf[0] = reg & 0xff;
-        buf[1] = (reg >> 8) & 0xff;
-        buf[2] = val;
-
-        if (i2c_master_send(client, buf, 3) != 3) {
-                dev_err(&client->dev, "%s: i2c send failed\n", __func__);
-                return -EIO;
-        }
-
-        return 0;
-}
-
-static int qt602240_read_object_table(struct i2c_client *client,
-                                      u16 reg, u8 *object_buf)
-{
-        return __qt602240_read_reg(client, reg, QT602240_OBJECT_SIZE,
-                                   object_buf);
-}
-
-static struct qt602240_object *
-qt602240_get_object(struct qt602240_data *data, u8 type)
-{
-        struct qt602240_object *object;
-        int i;
-
-        for (i = 0; i < data->info.object_num; i++) {
-                object = data->object_table + i;
-                if (object->type == type)
-                        return object;
-        }
-
-        dev_err(&data->client->dev, "Invalid object type\n");
-        return NULL;
-}
-
-static int qt602240_read_message(struct qt602240_data *data,
-                                 struct qt602240_message *message)
-{
-        struct qt602240_object *object;
-        u16 reg;
-
-        object = qt602240_get_object(data, QT602240_GEN_MESSAGE);
-        if (!object)
-                return -EINVAL;
-
-        reg = object->start_address;
-        return __qt602240_read_reg(data->client, reg,
-                        sizeof(struct qt602240_message), message);
-}
-
-static int qt602240_read_object(struct qt602240_data *data,
-                                u8 type, u8 offset, u8 *val)
-{
-        struct qt602240_object *object;
-        u16 reg;
-
-        object = qt602240_get_object(data, type);
-        if (!object)
-                return -EINVAL;
-
-        reg = object->start_address;
-        return __qt602240_read_reg(data->client, reg + offset, 1, val);
-}
-
-static int qt602240_write_object(struct qt602240_data *data,
-                                 u8 type, u8 offset, u8 val)
-{
-        struct qt602240_object *object;
-        u16 reg;
-
-        object = qt602240_get_object(data, type);
-        if (!object)
-                return -EINVAL;
-
-        reg = object->start_address;
-        return qt602240_write_reg(data->client, reg + offset, val);
-}
-
-static void qt602240_input_report(struct qt602240_data *data, int single_id)
-{
-        struct qt602240_finger *finger = data->finger;
-        struct input_dev *input_dev = data->input_dev;
-        int status = finger[single_id].status;
-        int finger_num = 0;
-        int id;
-
-        for (id = 0; id < QT602240_MAX_FINGER; id++) {
-                if (!finger[id].status)
-                        continue;
-
-                input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR,
-                                finger[id].status != QT602240_RELEASE ?
-                                finger[id].area : 0);
-                input_report_abs(input_dev, ABS_MT_POSITION_X,
-                                finger[id].x);
-                input_report_abs(input_dev, ABS_MT_POSITION_Y,
-                                finger[id].y);
-                input_mt_sync(input_dev);
-
-                if (finger[id].status == QT602240_RELEASE)
-                        finger[id].status = 0;
-                else
-                        finger_num++;
-        }
-
-        input_report_key(input_dev, BTN_TOUCH, finger_num > 0);
-
-        if (status != QT602240_RELEASE) {
-                input_report_abs(input_dev, ABS_X, finger[single_id].x);
-                input_report_abs(input_dev, ABS_Y, finger[single_id].y);
-        }
-
-        input_sync(input_dev);
-}
-
-static void qt602240_input_touchevent(struct qt602240_data *data,
-                                      struct qt602240_message *message, int id)
-{
-        struct qt602240_finger *finger = data->finger;
-        struct device *dev = &data->client->dev;
-        u8 status = message->message[0];
-        int x;
-        int y;
-        int area;
-
-        /* Check the touch is present on the screen */
-        if (!(status & QT602240_DETECT)) {
-                if (status & QT602240_RELEASE) {
-                        dev_dbg(dev, "[%d] released\n", id);
-
-                        finger[id].status = QT602240_RELEASE;
-                        qt602240_input_report(data, id);
-                }
-                return;
-        }
-
-        /* Check only AMP detection */
-        if (!(status & (QT602240_PRESS | QT602240_MOVE)))
-                return;
-
-        x = (message->message[1] << 2) | ((message->message[3] & ~0x3f) >> 6);
-        y = (message->message[2] << 2) | ((message->message[3] & ~0xf3) >> 2);
-        area = message->message[4];
-
-        dev_dbg(dev, "[%d] %s x: %d, y: %d, area: %d\n", id,
-                status & QT602240_MOVE ? "moved" : "pressed",
-                x, y, area);
-
-        finger[id].status = status & QT602240_MOVE ?
-                                QT602240_MOVE : QT602240_PRESS;
-        finger[id].x = x;
-        finger[id].y = y;
-        finger[id].area = area;
-
-        qt602240_input_report(data, id);
-}
-
-static irqreturn_t qt602240_interrupt(int irq, void *dev_id)
-{
-        struct qt602240_data *data = dev_id;
-        struct qt602240_message message;
-        struct qt602240_object *object;
-        struct device *dev = &data->client->dev;
-        int id;
-        u8 reportid;
-        u8 max_reportid;
-        u8 min_reportid;
-
-        do {
-                if (qt602240_read_message(data, &message)) {
-                        dev_err(dev, "Failed to read message\n");
-                        goto end;
-                }
-
-                reportid = message.reportid;
-
-                /* whether reportid is thing of QT602240_TOUCH_MULTI */
-                object = qt602240_get_object(data, QT602240_TOUCH_MULTI);
-                if (!object)
-                        goto end;
-
-                max_reportid = object->max_reportid;
-                min_reportid = max_reportid - object->num_report_ids + 1;
-                id = reportid - min_reportid;
-
-                if (reportid >= min_reportid && reportid <= max_reportid)
-                        qt602240_input_touchevent(data, &message, id);
-                else
-                        qt602240_dump_message(dev, &message);
-        } while (reportid != 0xff);
-
-end:
-        return IRQ_HANDLED;
-}
-
-static int qt602240_check_reg_init(struct qt602240_data *data)
-{
-        struct qt602240_object *object;
-        struct device *dev = &data->client->dev;
-        int index = 0;
-        int i, j;
-        u8 version = data->info.version;
-        u8 *init_vals;
-
-        switch (version) {
-        case QT602240_VER_20:
-                init_vals = (u8 *)init_vals_ver_20;
-                break;
-        case QT602240_VER_21:
-                init_vals = (u8 *)init_vals_ver_21;
-                break;
-        case QT602240_VER_22:
-                init_vals = (u8 *)init_vals_ver_22;
-                break;
-        default:
-                dev_err(dev, "Firmware version %d doesn't support\n", version);
-                return -EINVAL;
-        }
-
-        for (i = 0; i < data->info.object_num; i++) {
-                object = data->object_table + i;
-
-                if (!qt602240_object_writable(object->type))
-                        continue;
-
-                for (j = 0; j < object->size + 1; j++)
-                        qt602240_write_object(data, object->type, j,
-                                        init_vals[index + j]);
-
-                index += object->size + 1;
-        }
-
-        return 0;
-}
-
-static int qt602240_check_matrix_size(struct qt602240_data *data)
-{
-        const struct qt602240_platform_data *pdata = data->pdata;
-        struct device *dev = &data->client->dev;
-        int mode = -1;
-        int error;
-        u8 val;
-
-        dev_dbg(dev, "Number of X lines: %d\n", pdata->x_line);
-        dev_dbg(dev, "Number of Y lines: %d\n", pdata->y_line);
-
-        switch (pdata->x_line) {
-        case 0 ... 15:
-                if (pdata->y_line <= 14)
-                        mode = 0;
-                break;
-        case 16:
-                if (pdata->y_line <= 12)
-                        mode = 1;
-                if (pdata->y_line == 13 || pdata->y_line == 14)
-                        mode = 0;
-                break;
-        case 17:
-                if (pdata->y_line <= 11)
-                        mode = 2;
-                if (pdata->y_line == 12 || pdata->y_line == 13)
-                        mode = 1;
-                break;
-        case 18:
-                if (pdata->y_line <= 10)
-                        mode = 3;
-                if (pdata->y_line == 11 || pdata->y_line == 12)
-                        mode = 2;
-                break;
-        case 19:
-                if (pdata->y_line <= 9)
-                        mode = 4;
-                if (pdata->y_line == 10 || pdata->y_line == 11)
-                        mode = 3;
-                break;
-        case 20:
-                mode = 4;
-        }
-
-        if (mode < 0) {
-                dev_err(dev, "Invalid X/Y lines\n");
-                return -EINVAL;
-        }
-
-        error = qt602240_read_object(data, QT602240_SPT_CTECONFIG,
-                                QT602240_CTE_MODE, &val);
-        if (error)
-                return error;
-
-        if (mode == val)
-                return 0;
-
-        /* Change the CTE configuration */
-        qt602240_write_object(data, QT602240_SPT_CTECONFIG,
-                        QT602240_CTE_CTRL, 1);
-        qt602240_write_object(data, QT602240_SPT_CTECONFIG,
-                        QT602240_CTE_MODE, mode);
-        qt602240_write_object(data, QT602240_SPT_CTECONFIG,
-                        QT602240_CTE_CTRL, 0);
-
-        return 0;
-}
-
-static int qt602240_make_highchg(struct qt602240_data *data)
-{
-        struct device *dev = &data->client->dev;
-        int count = 10;
-        int error;
-        u8 val;
-
-        /* Read dummy message to make high CHG pin */
-        do {
-                error = qt602240_read_object(data, QT602240_GEN_MESSAGE, 0, &val);
-                if (error)
-                        return error;
-        } while ((val != 0xff) && --count);
-
-        if (!count) {
-                dev_err(dev, "CHG pin isn't cleared\n");
-                return -EBUSY;
-        }
-
-        return 0;
-}
-
-static void qt602240_handle_pdata(struct qt602240_data *data)
-{
-        const struct qt602240_platform_data *pdata = data->pdata;
-        u8 voltage;
-
-        /* Set touchscreen lines */
-        qt602240_write_object(data, QT602240_TOUCH_MULTI, QT602240_TOUCH_XSIZE,
-                        pdata->x_line);
-        qt602240_write_object(data, QT602240_TOUCH_MULTI, QT602240_TOUCH_YSIZE,
-                        pdata->y_line);
-
-        /* Set touchscreen orient */
-        qt602240_write_object(data, QT602240_TOUCH_MULTI, QT602240_TOUCH_ORIENT,
-                        pdata->orient);
-
-        /* Set touchscreen burst length */
-        qt602240_write_object(data, QT602240_TOUCH_MULTI,
-                        QT602240_TOUCH_BLEN, pdata->blen);
-
-        /* Set touchscreen threshold */
-        qt602240_write_object(data, QT602240_TOUCH_MULTI,
-                        QT602240_TOUCH_TCHTHR, pdata->threshold);
-
-        /* Set touchscreen resolution */
-        qt602240_write_object(data, QT602240_TOUCH_MULTI,
-                        QT602240_TOUCH_XRANGE_LSB, (pdata->x_size - 1) & 0xff);
-        qt602240_write_object(data, QT602240_TOUCH_MULTI,
-                        QT602240_TOUCH_XRANGE_MSB, (pdata->x_size - 1) >> 8);
-        qt602240_write_object(data, QT602240_TOUCH_MULTI,
-                        QT602240_TOUCH_YRANGE_LSB, (pdata->y_size - 1) & 0xff);
-        qt602240_write_object(data, QT602240_TOUCH_MULTI,
-                        QT602240_TOUCH_YRANGE_MSB, (pdata->y_size - 1) >> 8);
-
-        /* Set touchscreen voltage */
-        if (data->info.version >= QT602240_VER_21 && pdata->voltage) {
-                if (pdata->voltage < QT602240_VOLTAGE_DEFAULT) {
-                        voltage = (QT602240_VOLTAGE_DEFAULT - pdata->voltage) /
-                                QT602240_VOLTAGE_STEP;
-                        voltage = 0xff - voltage + 1;
-                } else
-                        voltage = (pdata->voltage - QT602240_VOLTAGE_DEFAULT) /
-                                QT602240_VOLTAGE_STEP;
-
-                qt602240_write_object(data, QT602240_SPT_CTECONFIG,
-                                QT602240_CTE_VOLTAGE, voltage);
-        }
-}
-
-static int qt602240_get_info(struct qt602240_data *data)
-{
-        struct i2c_client *client = data->client;
-        struct qt602240_info *info = &data->info;
-        int error;
-        u8 val;
-
-        error = qt602240_read_reg(client, QT602240_FAMILY_ID, &val);
-        if (error)
-                return error;
-        info->family_id = val;
-
-        error = qt602240_read_reg(client, QT602240_VARIANT_ID, &val);
-        if (error)
-                return error;
-        info->variant_id = val;
-
-        error = qt602240_read_reg(client, QT602240_VERSION, &val);
-        if (error)
-                return error;
-        info->version = val;
-
-        error = qt602240_read_reg(client, QT602240_BUILD, &val);
-        if (error)
-                return error;
-        info->build = val;
-
-        error = qt602240_read_reg(client, QT602240_OBJECT_NUM, &val);
-        if (error)
-                return error;
-        info->object_num = val;
-
-        return 0;
-}
-
-static int qt602240_get_object_table(struct qt602240_data *data)
-{
-        int error;
-        int i;
-        u16 reg;
-        u8 reportid = 0;
-        u8 buf[QT602240_OBJECT_SIZE];
-
-        for (i = 0; i < data->info.object_num; i++) {
-                struct qt602240_object *object = data->object_table + i;
-
-                reg = QT602240_OBJECT_START + QT602240_OBJECT_SIZE * i;
-                error = qt602240_read_object_table(data->client, reg, buf);
-                if (error)
-                        return error;
-
-                object->type = buf[0];
-                object->start_address = (buf[2] << 8) | buf[1];
-                object->size = buf[3];
-                object->instances = buf[4];
-                object->num_report_ids = buf[5];
-
-                if (object->num_report_ids) {
-                        reportid += object->num_report_ids *
-                                        (object->instances + 1);
-                        object->max_reportid = reportid;
-                }
-        }
-
-        return 0;
-}
-
-static int qt602240_initialize(struct qt602240_data *data)
-{
-        struct i2c_client *client = data->client;
-        struct qt602240_info *info = &data->info;
-        int error;
-        u8 val;
-
-        error = qt602240_get_info(data);
-        if (error)
-                return error;
-
-        data->object_table = kcalloc(info->object_num,
-                                     sizeof(struct qt602240_data),
-                                     GFP_KERNEL);
-        if (!data->object_table) {
-                dev_err(&client->dev, "Failed to allocate memory\n");
-                return -ENOMEM;
-        }
-
-        /* Get object table information */
-        error = qt602240_get_object_table(data);
-        if (error)
-                return error;
-
-        /* Check register init values */
-        error = qt602240_check_reg_init(data);
-        if (error)
-                return error;
-
-        /* Check X/Y matrix size */
-        error = qt602240_check_matrix_size(data);
-        if (error)
-                return error;
-
-        error = qt602240_make_highchg(data);
-        if (error)
-                return error;
-
-        qt602240_handle_pdata(data);
-
-        /* Backup to memory */
-        qt602240_write_object(data, QT602240_GEN_COMMAND,
-                        QT602240_COMMAND_BACKUPNV,
-                        QT602240_BACKUP_VALUE);
-        msleep(QT602240_BACKUP_TIME);
-
-        /* Soft reset */
-        qt602240_write_object(data, QT602240_GEN_COMMAND,
-                        QT602240_COMMAND_RESET, 1);
-        msleep(QT602240_RESET_TIME);
-
-        /* Update matrix size at info struct */
-        error = qt602240_read_reg(client, QT602240_MATRIX_X_SIZE, &val);
-        if (error)
-                return error;
-        info->matrix_xsize = val;
-
-        error = qt602240_read_reg(client, QT602240_MATRIX_Y_SIZE, &val);
-        if (error)
-                return error;
-        info->matrix_ysize = val;
-
-        dev_info(&client->dev,
-                        "Family ID: %d Variant ID: %d Version: %d Build: %d\n",
-                        info->family_id, info->variant_id, info->version,
-                        info->build);
-
-        dev_info(&client->dev,
-                        "Matrix X Size: %d Matrix Y Size: %d Object Num: %d\n",
-                        info->matrix_xsize, info->matrix_ysize,
-                        info->object_num);
-
-        return 0;
-}
-
-static ssize_t qt602240_object_show(struct device *dev,
-                                    struct device_attribute *attr, char *buf)
-{
-        struct qt602240_data *data = dev_get_drvdata(dev);
-        struct qt602240_object *object;
-        int count = 0;
-        int i, j;
-        int error;
-        u8 val;
-
-        for (i = 0; i < data->info.object_num; i++) {
-                object = data->object_table + i;
-
-                count += sprintf(buf + count,
-                                "Object Table Element %d(Type %d)\n",
-                                i + 1, object->type);
-
-                if (!qt602240_object_readable(object->type)) {
-                        count += sprintf(buf + count, "\n");
-                        continue;
-                }
-
-                for (j = 0; j < object->size + 1; j++) {
-                        error = qt602240_read_object(data,
-                                                object->type, j, &val);
-                        if (error)
-                                return error;
-
-                        count += sprintf(buf + count,
-                                        "  Byte %d: 0x%x (%d)\n", j, val, val);
-                }
-
-                count += sprintf(buf + count, "\n");
-        }
-
-        return count;
-}
-
-static int qt602240_load_fw(struct device *dev, const char *fn)
-{
-        struct qt602240_data *data = dev_get_drvdata(dev);
-        struct i2c_client *client = data->client;
-        const struct firmware *fw = NULL;
-        unsigned int frame_size;
-        unsigned int pos = 0;
-        int ret;
-
-        ret = request_firmware(&fw, fn, dev);
-        if (ret) {
-                dev_err(dev, "Unable to open firmware %s\n", fn);
-                return ret;
-        }
-
-        /* Change to the bootloader mode */
-        qt602240_write_object(data, QT602240_GEN_COMMAND,
-                        QT602240_COMMAND_RESET, QT602240_BOOT_VALUE);
-        msleep(QT602240_RESET_TIME);
-
-        /* Change to slave address of bootloader */
-        if (client->addr == QT602240_APP_LOW)
-                client->addr = QT602240_BOOT_LOW;
-        else
-                client->addr = QT602240_BOOT_HIGH;
-
-        ret = qt602240_check_bootloader(client, QT602240_WAITING_BOOTLOAD_CMD);
-        if (ret)
-                goto out;
-
-        /* Unlock bootloader */
-        qt602240_unlock_bootloader(client);
-
-        while (pos < fw->size) {
-                ret = qt602240_check_bootloader(client,
-                                                QT602240_WAITING_FRAME_DATA);
-                if (ret)
-                        goto out;
-
-                frame_size = ((*(fw->data + pos) << 8) | *(fw->data + pos + 1));
-
-                /* We should add 2 at frame size as the the firmware data is not
-                 * included the CRC bytes.
-                 */
-                frame_size += 2;
-
-                /* Write one frame to device */
-                qt602240_fw_write(client, fw->data + pos, frame_size);
-
-                ret = qt602240_check_bootloader(client,
-                                                QT602240_FRAME_CRC_PASS);
-                if (ret)
-                        goto out;
-
-                pos += frame_size;
-
-                dev_dbg(dev, "Updated %d bytes / %zd bytes\n", pos, fw->size);
-        }
-
-out:
-        release_firmware(fw);
-
-        /* Change to slave address of application */
-        if (client->addr == QT602240_BOOT_LOW)
-                client->addr = QT602240_APP_LOW;
-        else
-                client->addr = QT602240_APP_HIGH;
-
-        return ret;
-}
-
-static ssize_t qt602240_update_fw_store(struct device *dev,
-                                        struct device_attribute *attr,
-                                        const char *buf, size_t count)
-{
-        struct qt602240_data *data = dev_get_drvdata(dev);
-        unsigned int version;
-        int error;
-
-        if (sscanf(buf, "%u", &version) != 1) {
-                dev_err(dev, "Invalid values\n");
-                return -EINVAL;
-        }
-
-        if (data->info.version < QT602240_VER_21 || version < QT602240_VER_21) {
-                dev_err(dev, "FW update supported starting with version 21\n");
-                return -EINVAL;
-        }
-
-        disable_irq(data->irq);
-
-        error = qt602240_load_fw(dev, QT602240_FW_NAME);
-        if (error) {
-                dev_err(dev, "The firmware update failed(%d)\n", error);
-                count = error;
-        } else {
-                dev_dbg(dev, "The firmware update succeeded\n");
-
-                /* Wait for reset */
-                msleep(QT602240_FWRESET_TIME);
-
-                kfree(data->object_table);
-                data->object_table = NULL;
-
-                qt602240_initialize(data);
-        }
-
-        enable_irq(data->irq);
-
-        return count;
-}
-
-static DEVICE_ATTR(object, 0444, qt602240_object_show, NULL);
-static DEVICE_ATTR(update_fw, 0664, NULL, qt602240_update_fw_store);
-
-static struct attribute *qt602240_attrs[] = {
-        &dev_attr_object.attr,
-        &dev_attr_update_fw.attr,
-        NULL
-};
-
-static const struct attribute_group qt602240_attr_group = {
-        .attrs = qt602240_attrs,
-};
-
-static void qt602240_start(struct qt602240_data *data)
-{
-        /* Touch enable */
-        qt602240_write_object(data,
-                        QT602240_TOUCH_MULTI, QT602240_TOUCH_CTRL, 0x83);
-}
-
-static void qt602240_stop(struct qt602240_data *data)
-{
-        /* Touch disable */
-        qt602240_write_object(data,
-                        QT602240_TOUCH_MULTI, QT602240_TOUCH_CTRL, 0);
-}
-
-static int qt602240_input_open(struct input_dev *dev)
-{
-        struct qt602240_data *data = input_get_drvdata(dev);
-
-        qt602240_start(data);
-
-        return 0;
-}
-
-static void qt602240_input_close(struct input_dev *dev)
-{
-        struct qt602240_data *data = input_get_drvdata(dev);
-
-        qt602240_stop(data);
-}
-
-static int __devinit qt602240_probe(struct i2c_client *client,
-                const struct i2c_device_id *id)
-{
-        struct qt602240_data *data;
-        struct input_dev *input_dev;
-        int error;
-
-        if (!client->dev.platform_data)
-                return -EINVAL;
-
-        data = kzalloc(sizeof(struct qt602240_data), GFP_KERNEL);
-        input_dev = input_allocate_device();
-        if (!data || !input_dev) {
-                dev_err(&client->dev, "Failed to allocate memory\n");
-                error = -ENOMEM;
-                goto err_free_mem;
-        }
-
-        input_dev->name = "AT42QT602240/ATMXT224 Touchscreen";
-        input_dev->id.bustype = BUS_I2C;
-        input_dev->dev.parent = &client->dev;
-        input_dev->open = qt602240_input_open;
-        input_dev->close = qt602240_input_close;
-
-        __set_bit(EV_ABS, input_dev->evbit);
-        __set_bit(EV_KEY, input_dev->evbit);
-        __set_bit(BTN_TOUCH, input_dev->keybit);
-
-        /* For single touch */
-        input_set_abs_params(input_dev, ABS_X,
-                             0, QT602240_MAX_XC, 0, 0);
-        input_set_abs_params(input_dev, ABS_Y,
-                             0, QT602240_MAX_YC, 0, 0);
-
-        /* For multi touch */
-        input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR,
-                             0, QT602240_MAX_AREA, 0, 0);
-        input_set_abs_params(input_dev, ABS_MT_POSITION_X,
-                             0, QT602240_MAX_XC, 0, 0);
-        input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
-                             0, QT602240_MAX_YC, 0, 0);
-
-        input_set_drvdata(input_dev, data);
-
-        data->client = client;
-        data->input_dev = input_dev;
-        data->pdata = client->dev.platform_data;
-        data->irq = client->irq;
-
-        i2c_set_clientdata(client, data);
-
-        error = qt602240_initialize(data);
-        if (error)
-                goto err_free_object;
-
-        error = request_threaded_irq(client->irq, NULL, qt602240_interrupt,
-                        IRQF_TRIGGER_FALLING, client->dev.driver->name, data);
-        if (error) {
-                dev_err(&client->dev, "Failed to register interrupt\n");
-                goto err_free_object;
-        }
-
-        error = input_register_device(input_dev);
-        if (error)
-                goto err_free_irq;
-
-        error = sysfs_create_group(&client->dev.kobj, &qt602240_attr_group);
-        if (error)
-                goto err_unregister_device;
-
-        return 0;
-
-err_unregister_device:
-        input_unregister_device(input_dev);
-        input_dev = NULL;
-err_free_irq:
-        free_irq(client->irq, data);
-err_free_object:
-        kfree(data->object_table);
-err_free_mem:
-        input_free_device(input_dev);
-        kfree(data);
-        return error;
-}
-
-static int __devexit qt602240_remove(struct i2c_client *client)
-{
-        struct qt602240_data *data = i2c_get_clientdata(client);
-
-        sysfs_remove_group(&client->dev.kobj, &qt602240_attr_group);
-        free_irq(data->irq, data);
-        input_unregister_device(data->input_dev);
-        kfree(data->object_table);
-        kfree(data);
-
-        return 0;
-}
-
-#ifdef CONFIG_PM
-static int qt602240_suspend(struct i2c_client *client, pm_message_t mesg)
-{
-        struct qt602240_data *data = i2c_get_clientdata(client);
-        struct input_dev *input_dev = data->input_dev;
-
-        mutex_lock(&input_dev->mutex);
-
-        if (input_dev->users)
-                qt602240_stop(data);
-
-        mutex_unlock(&input_dev->mutex);
-
-        return 0;
-}
-
-static int qt602240_resume(struct i2c_client *client)
-{
-        struct qt602240_data *data = i2c_get_clientdata(client);
-        struct input_dev *input_dev = data->input_dev;
-
-        /* Soft reset */
-        qt602240_write_object(data, QT602240_GEN_COMMAND,
-                        QT602240_COMMAND_RESET, 1);
-
-        msleep(QT602240_RESET_TIME);
-
-        mutex_lock(&input_dev->mutex);
-
-        if (input_dev->users)
-                qt602240_start(data);
-
-        mutex_unlock(&input_dev->mutex);
-
-        return 0;
-}
-#else
-#define qt602240_suspend        NULL
-#define qt602240_resume         NULL
-#endif
-
-static const struct i2c_device_id qt602240_id[] = {
-        { "qt602240_ts", 0 },
-        { }
-};
-MODULE_DEVICE_TABLE(i2c, qt602240_id);
-
-static struct i2c_driver qt602240_driver = {
-        .driver = {
-                .name   = "qt602240_ts",
-                .owner  = THIS_MODULE,
-        },
-        .probe          = qt602240_probe,
-        .remove         = __devexit_p(qt602240_remove),
-        .suspend        = qt602240_suspend,
-        .resume         = qt602240_resume,
-        .id_table       = qt602240_id,
-};
-
-static int __init qt602240_init(void)
-{
-        return i2c_add_driver(&qt602240_driver);
-}
-
-static void __exit qt602240_exit(void)
-{
-        i2c_del_driver(&qt602240_driver);
-}
-
-module_init(qt602240_init);
-module_exit(qt602240_exit);
-
-/* Module information */
-MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
-MODULE_DESCRIPTION("AT42QT602240/ATMXT224 Touchscreen driver");
-MODULE_LICENSE("GPL");
diff --git a/drivers/input/touchscreen/s3c2410_ts.c b/drivers/input/touchscreen/s3c2410_ts.c
index 6085d12fd561..8feb7f3c8be1 100644
--- a/drivers/input/touchscreen/s3c2410_ts.c
+++ b/drivers/input/touchscreen/s3c2410_ts.c
@@ -350,7 +350,7 @@ static int __devinit s3c2410ts_probe(struct platform_device *pdev)
  err_tcirq:
         free_irq(ts.irq_tc, ts.input);
  err_inputdev:
-        input_unregister_device(ts.input);
+        input_free_device(ts.input);
  err_iomap:
         iounmap(ts.io);
  err_clk:
diff --git a/drivers/input/touchscreen/st1232.c b/drivers/input/touchscreen/st1232.c
new file mode 100644
index 000000000000..4ab371358b33
--- /dev/null
+++ b/drivers/input/touchscreen/st1232.c
@@ -0,0 +1,274 @@
+/*
+ * ST1232 Touchscreen Controller Driver
+ *
+ * Copyright (C) 2010 Renesas Solutions Corp.
+ *      Tony SIM <chinyeow.sim.xt@renesas.com>
+ *
+ * Using code from:
+ *  - android.git.kernel.org: projects/kernel/common.git: synaptics_i2c_rmi.c
+ *      Copyright (C) 2007 Google, Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * 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.
+ */
+
+#include <linux/delay.h>
+#include <linux/i2c.h>
+#include <linux/input.h>
+#include <linux/interrupt.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/types.h>
+
+#define ST1232_TS_NAME  "st1232-ts"
+
+#define MIN_X           0x00
+#define MIN_Y           0x00
+#define MAX_X           0x31f   /* (800 - 1) */
+#define MAX_Y           0x1df   /* (480 - 1) */
+#define MAX_AREA        0xff
+#define MAX_FINGERS     2
+
+struct st1232_ts_finger {
+        u16 x;
+        u16 y;
+        u8 t;
+        bool is_valid;
+};
+
+struct st1232_ts_data {
+        struct i2c_client *client;
+        struct input_dev *input_dev;
+        struct st1232_ts_finger finger[MAX_FINGERS];
+};
+
+static int st1232_ts_read_data(struct st1232_ts_data *ts)
+{
+        struct st1232_ts_finger *finger = ts->finger;
+        struct i2c_client *client = ts->client;
+        struct i2c_msg msg[2];
+        int error;
+        u8 start_reg;
+        u8 buf[10];
+
+        /* read touchscreen data from ST1232 */
+        msg[0].addr = client->addr;
+        msg[0].flags = 0;
+        msg[0].len = 1;
+        msg[0].buf = &start_reg;
+        start_reg = 0x10;
+
+        msg[1].addr = ts->client->addr;
+        msg[1].flags = I2C_M_RD;
+        msg[1].len = sizeof(buf);
+        msg[1].buf = buf;
+
+        error = i2c_transfer(client->adapter, msg, 2);
+        if (error < 0)
+                return error;
+
+        /* get "valid" bits */
+        finger[0].is_valid = buf[2] >> 7;
+        finger[1].is_valid = buf[5] >> 7;
+
+        /* get xy coordinate */
+        if (finger[0].is_valid) {
+                finger[0].x = ((buf[2] & 0x0070) << 4) | buf[3];
+                finger[0].y = ((buf[2] & 0x0007) << 8) | buf[4];
+                finger[0].t = buf[8];
+        }
+
+        if (finger[1].is_valid) {
+                finger[1].x = ((buf[5] & 0x0070) << 4) | buf[6];
+                finger[1].y = ((buf[5] & 0x0007) << 8) | buf[7];
+                finger[1].t = buf[9];
+        }
+
+        return 0;
+}
+
+static irqreturn_t st1232_ts_irq_handler(int irq, void *dev_id)
+{
+        struct st1232_ts_data *ts = dev_id;
+        struct st1232_ts_finger *finger = ts->finger;
+        struct input_dev *input_dev = ts->input_dev;
+        int count = 0;
+        int i, ret;
+
+        ret = st1232_ts_read_data(ts);
+        if (ret < 0)
+                goto end;
+
+        /* multi touch protocol */
+        for (i = 0; i < MAX_FINGERS; i++) {
+                if (!finger[i].is_valid)
+                        continue;
+
+                input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR, finger[i].t);
+                input_report_abs(input_dev, ABS_MT_POSITION_X, finger[i].x);
+                input_report_abs(input_dev, ABS_MT_POSITION_Y, finger[i].y);
+                input_mt_sync(input_dev);
+                count++;
+        }
+
+        /* SYN_MT_REPORT only if no contact */
+        if (!count)
+                input_mt_sync(input_dev);
+
+        /* SYN_REPORT */
+        input_sync(input_dev);
+
+end:
+        return IRQ_HANDLED;
+}
+
+static int __devinit st1232_ts_probe(struct i2c_client *client,
+                                        const struct i2c_device_id *id)
+{
+        struct st1232_ts_data *ts;
+        struct input_dev *input_dev;
+        int error;
+
+        if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
+                dev_err(&client->dev, "need I2C_FUNC_I2C\n");
+                return -EIO;
+        }
+
+        if (!client->irq) {
+                dev_err(&client->dev, "no IRQ?\n");
+                return -EINVAL;
+        }
+
+
+        ts = kzalloc(sizeof(struct st1232_ts_data), GFP_KERNEL);
+        input_dev = input_allocate_device();
+        if (!ts || !input_dev) {
+                error = -ENOMEM;
+                goto err_free_mem;
+        }
+
+        ts->client = client;
+        ts->input_dev = input_dev;
+
+        input_dev->name = "st1232-touchscreen";
+        input_dev->id.bustype = BUS_I2C;
+        input_dev->dev.parent = &client->dev;
+
+        __set_bit(EV_SYN, input_dev->evbit);
+        __set_bit(EV_KEY, input_dev->evbit);
+        __set_bit(EV_ABS, input_dev->evbit);
+
+        input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, MAX_AREA, 0, 0);
+        input_set_abs_params(input_dev, ABS_MT_POSITION_X, MIN_X, MAX_X, 0, 0);
+        input_set_abs_params(input_dev, ABS_MT_POSITION_Y, MIN_Y, MAX_Y, 0, 0);
+
+        error = request_threaded_irq(client->irq, NULL, st1232_ts_irq_handler,
+                                     IRQF_ONESHOT, client->name, ts);
+        if (error) {
+                dev_err(&client->dev, "Failed to register interrupt\n");
+                goto err_free_mem;
+        }
+
+        error = input_register_device(ts->input_dev);
+        if (error) {
+                dev_err(&client->dev, "Unable to register %s input device\n",
+                        input_dev->name);
+                goto err_free_irq;
+        }
+
+        i2c_set_clientdata(client, ts);
+        device_init_wakeup(&client->dev, 1);
+
+        return 0;
+
+err_free_irq:
+        free_irq(client->irq, ts);
+err_free_mem:
+        input_free_device(input_dev);
+        kfree(ts);
+        return error;
+}
+
+static int __devexit st1232_ts_remove(struct i2c_client *client)
+{
+        struct st1232_ts_data *ts = i2c_get_clientdata(client);
+
+        device_init_wakeup(&client->dev, 0);
+        free_irq(client->irq, ts);
+        input_unregister_device(ts->input_dev);
+        kfree(ts);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int st1232_ts_suspend(struct device *dev)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+
+        if (device_may_wakeup(&client->dev))
+                enable_irq_wake(client->irq);
+        else
+                disable_irq(client->irq);
+
+        return 0;
+}
+
+static int st1232_ts_resume(struct device *dev)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+
+        if (device_may_wakeup(&client->dev))
+                disable_irq_wake(client->irq);
+        else
+                enable_irq(client->irq);
+
+        return 0;
+}
+
+static const struct dev_pm_ops st1232_ts_pm_ops = {
+        .suspend        = st1232_ts_suspend,
+        .resume         = st1232_ts_resume,
+};
+#endif
+
+static const struct i2c_device_id st1232_ts_id[] = {
+        { ST1232_TS_NAME, 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, st1232_ts_id);
+
+static struct i2c_driver st1232_ts_driver = {
+        .probe          = st1232_ts_probe,
+        .remove         = __devexit_p(st1232_ts_remove),
+        .id_table       = st1232_ts_id,
+        .driver = {
+                .name   = ST1232_TS_NAME,
+                .owner  = THIS_MODULE,
+#ifdef CONFIG_PM
+                .pm     = &st1232_ts_pm_ops,
+#endif
+        },
+};
+
+static int __init st1232_ts_init(void)
+{
+        return i2c_add_driver(&st1232_ts_driver);
+}
+module_init(st1232_ts_init);
+
+static void __exit st1232_ts_exit(void)
+{
+        i2c_del_driver(&st1232_ts_driver);
+}
+module_exit(st1232_ts_exit);
+
+MODULE_AUTHOR("Tony SIM <chinyeow.sim.xt@renesas.com>");
+MODULE_DESCRIPTION("SITRONIX ST1232 Touchscreen Controller Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/touchscreen/stmpe-ts.c b/drivers/input/touchscreen/stmpe-ts.c
index 656148ec0027..ae88e13c99ff 100644
--- a/drivers/input/touchscreen/stmpe-ts.c
+++ b/drivers/input/touchscreen/stmpe-ts.c
@@ -268,7 +268,7 @@ static int __devinit stmpe_input_probe(struct platform_device *pdev)
         struct stmpe_touch *ts;
         struct input_dev *idev;
         struct stmpe_ts_platform_data *ts_pdata = NULL;
-        int ret = 0;
+        int ret;
         int ts_irq;
 
         ts_irq = platform_get_irq_byname(pdev, "FIFO_TH");
@@ -276,12 +276,16 @@ static int __devinit stmpe_input_probe(struct platform_device *pdev)
                 return ts_irq;
 
         ts = kzalloc(sizeof(*ts), GFP_KERNEL);
-        if (!ts)
+        if (!ts) {
+                ret = -ENOMEM;
                 goto err_out;
+        }
 
         idev = input_allocate_device();
-        if (!idev)
+        if (!idev) {
+                ret = -ENOMEM;
                 goto err_free_ts;
+        }
 
         platform_set_drvdata(pdev, ts);
         ts->stmpe = stmpe;
@@ -361,7 +365,6 @@ static int __devexit stmpe_ts_remove(struct platform_device *pdev)
         platform_set_drvdata(pdev, NULL);
 
         input_unregister_device(ts->idev);
-        input_free_device(ts->idev);
 
         kfree(ts);
 
diff --git a/drivers/input/touchscreen/tnetv107x-ts.c b/drivers/input/touchscreen/tnetv107x-ts.c
new file mode 100644
index 000000000000..22a3411e93c5
--- /dev/null
+++ b/drivers/input/touchscreen/tnetv107x-ts.c
@@ -0,0 +1,397 @@
+/*
+ * Texas Instruments TNETV107X Touchscreen Driver
+ *
+ * Copyright (C) 2010 Texas Instruments
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation version 2.
+ *
+ * This program is distributed "as is" WITHOUT ANY WARRANTY of any
+ * kind, whether express or implied; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/kernel.h>
+#include <linux/err.h>
+#include <linux/errno.h>
+#include <linux/input.h>
+#include <linux/platform_device.h>
+#include <linux/interrupt.h>
+#include <linux/slab.h>
+#include <linux/delay.h>
+#include <linux/ctype.h>
+#include <linux/io.h>
+#include <linux/clk.h>
+
+#include <mach/tnetv107x.h>
+
+#define TSC_PENUP_POLL          (HZ / 5)
+#define IDLE_TIMEOUT            100 /* msec */
+
+/*
+ * The first and last samples of a touch interval are usually garbage and need
+ * to be filtered out with these devices.  The following definitions control
+ * the number of samples skipped.
+ */
+#define TSC_HEAD_SKIP           1
+#define TSC_TAIL_SKIP           1
+#define TSC_SKIP                (TSC_HEAD_SKIP + TSC_TAIL_SKIP + 1)
+#define TSC_SAMPLES             (TSC_SKIP + 1)
+
+/* Register Offsets */
+struct tsc_regs {
+        u32     rev;
+        u32     tscm;
+        u32     bwcm;
+        u32     swc;
+        u32     adcchnl;
+        u32     adcdata;
+        u32     chval[4];
+};
+
+/* TSC Mode Configuration Register (tscm) bits */
+#define WMODE           BIT(0)
+#define TSKIND          BIT(1)
+#define ZMEASURE_EN     BIT(2)
+#define IDLE            BIT(3)
+#define TSC_EN          BIT(4)
+#define STOP            BIT(5)
+#define ONE_SHOT        BIT(6)
+#define SINGLE          BIT(7)
+#define AVG             BIT(8)
+#define AVGNUM(x)       (((x) & 0x03) <<  9)
+#define PVSTC(x)        (((x) & 0x07) << 11)
+#define PON             BIT(14)
+#define PONBG           BIT(15)
+#define AFERST          BIT(16)
+
+/* ADC DATA Capture Register bits */
+#define DATA_VALID      BIT(16)
+
+/* Register Access Macros */
+#define tsc_read(ts, reg)               __raw_readl(&(ts)->regs->reg)
+#define tsc_write(ts, reg, val)         __raw_writel(val, &(ts)->regs->reg);
+#define tsc_set_bits(ts, reg, val)      \
+        tsc_write(ts, reg, tsc_read(ts, reg) | (val))
+#define tsc_clr_bits(ts, reg, val)      \
+        tsc_write(ts, reg, tsc_read(ts, reg) & ~(val))
+
+struct sample {
+        int x, y, p;
+};
+
+struct tsc_data {
+        struct input_dev                *input_dev;
+        struct resource                 *res;
+        struct tsc_regs __iomem         *regs;
+        struct timer_list               timer;
+        spinlock_t                      lock;
+        struct clk                      *clk;
+        struct device                   *dev;
+        int                             sample_count;
+        struct sample                   samples[TSC_SAMPLES];
+        int                             tsc_irq;
+};
+
+static int tsc_read_sample(struct tsc_data *ts, struct sample* sample)
+{
+        int     x, y, z1, z2, t, p = 0;
+        u32     val;
+
+        val = tsc_read(ts, chval[0]);
+        if (val & DATA_VALID)
+                x = val & 0xffff;
+        else
+                return -EINVAL;
+
+        y  = tsc_read(ts, chval[1]) & 0xffff;
+        z1 = tsc_read(ts, chval[2]) & 0xffff;
+        z2 = tsc_read(ts, chval[3]) & 0xffff;
+
+        if (z1) {
+                t = ((600 * x) * (z2 - z1));
+                p = t / (u32) (z1 << 12);
+                if (p < 0)
+                        p = 0;
+        }
+
+        sample->x  = x;
+        sample->y  = y;
+        sample->p  = p;
+
+        return 0;
+}
+
+static void tsc_poll(unsigned long data)
+{
+        struct tsc_data *ts = (struct tsc_data *)data;
+        unsigned long flags;
+        int i, val, x, y, p;
+
+        spin_lock_irqsave(&ts->lock, flags);
+
+        if (ts->sample_count >= TSC_SKIP) {
+                input_report_abs(ts->input_dev, ABS_PRESSURE, 0);
+                input_report_key(ts->input_dev, BTN_TOUCH, 0);
+                input_sync(ts->input_dev);
+        } else if (ts->sample_count > 0) {
+                /*
+                 * A touch event lasted less than our skip count.  Salvage and
+                 * report anyway.
+                 */
+                for (i = 0, val = 0; i < ts->sample_count; i++)
+                        val += ts->samples[i].x;
+                x = val / ts->sample_count;
+
+                for (i = 0, val = 0; i < ts->sample_count; i++)
+                        val += ts->samples[i].y;
+                y = val / ts->sample_count;
+
+                for (i = 0, val = 0; i < ts->sample_count; i++)
+                        val += ts->samples[i].p;
+                p = val / ts->sample_count;
+
+                input_report_abs(ts->input_dev, ABS_X, x);
+                input_report_abs(ts->input_dev, ABS_Y, y);
+                input_report_abs(ts->input_dev, ABS_PRESSURE, p);
+                input_report_key(ts->input_dev, BTN_TOUCH, 1);
+                input_sync(ts->input_dev);
+        }
+
+        ts->sample_count = 0;
+
+        spin_unlock_irqrestore(&ts->lock, flags);
+}
+
+static irqreturn_t tsc_irq(int irq, void *dev_id)
+{
+        struct tsc_data *ts = (struct tsc_data *)dev_id;
+        struct sample *sample;
+        int index;
+
+        spin_lock(&ts->lock);
+
+        index = ts->sample_count % TSC_SAMPLES;
+        sample = &ts->samples[index];
+        if (tsc_read_sample(ts, sample) < 0)
+                goto out;
+
+        if (++ts->sample_count >= TSC_SKIP) {
+                index = (ts->sample_count - TSC_TAIL_SKIP - 1) % TSC_SAMPLES;
+                sample = &ts->samples[index];
+
+                input_report_abs(ts->input_dev, ABS_X, sample->x);
+                input_report_abs(ts->input_dev, ABS_Y, sample->y);
+                input_report_abs(ts->input_dev, ABS_PRESSURE, sample->p);
+                if (ts->sample_count == TSC_SKIP)
+                        input_report_key(ts->input_dev, BTN_TOUCH, 1);
+                input_sync(ts->input_dev);
+        }
+        mod_timer(&ts->timer, jiffies + TSC_PENUP_POLL);
+out:
+        spin_unlock(&ts->lock);
+        return IRQ_HANDLED;
+}
+
+static int tsc_start(struct input_dev *dev)
+{
+        struct tsc_data *ts = input_get_drvdata(dev);
+        unsigned long timeout = jiffies + msecs_to_jiffies(IDLE_TIMEOUT);
+        u32 val;
+
+        clk_enable(ts->clk);
+
+        /* Go to idle mode, before any initialization */
+        while (time_after(timeout, jiffies)) {
+                if (tsc_read(ts, tscm) & IDLE)
+                        break;
+        }
+
+        if (time_before(timeout, jiffies)) {
+                dev_warn(ts->dev, "timeout waiting for idle\n");
+                clk_disable(ts->clk);
+                return -EIO;
+        }
+
+        /* Configure TSC Control register*/
+        val = (PONBG | PON | PVSTC(4) | ONE_SHOT | ZMEASURE_EN);
+        tsc_write(ts, tscm, val);
+
+        /* Bring TSC out of reset: Clear AFE reset bit */
+        val &= ~(AFERST);
+        tsc_write(ts, tscm, val);
+
+        /* Configure all pins for hardware control*/
+        tsc_write(ts, bwcm, 0);
+
+        /* Finally enable the TSC */
+        tsc_set_bits(ts, tscm, TSC_EN);
+
+        return 0;
+}
+
+static void tsc_stop(struct input_dev *dev)
+{
+        struct tsc_data *ts = input_get_drvdata(dev);
+
+        tsc_clr_bits(ts, tscm, TSC_EN);
+        synchronize_irq(ts->tsc_irq);
+        del_timer_sync(&ts->timer);
+        clk_disable(ts->clk);
+}
+
+static int __devinit tsc_probe(struct platform_device *pdev)
+{
+        struct device *dev = &pdev->dev;
+        struct tsc_data *ts;
+        int error = 0;
+        u32 rev = 0;
+
+        ts = kzalloc(sizeof(struct tsc_data), GFP_KERNEL);
+        if (!ts) {
+                dev_err(dev, "cannot allocate device info\n");
+                return -ENOMEM;
+        }
+
+        ts->dev = dev;
+        spin_lock_init(&ts->lock);
+        setup_timer(&ts->timer, tsc_poll, (unsigned long)ts);
+        platform_set_drvdata(pdev, ts);
+
+        ts->tsc_irq = platform_get_irq(pdev, 0);
+        if (ts->tsc_irq < 0) {
+                dev_err(dev, "cannot determine device interrupt\n");
+                error = -ENODEV;
+                goto error_res;
+        }
+
+        ts->res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!ts->res) {
+                dev_err(dev, "cannot determine register area\n");
+                error = -ENODEV;
+                goto error_res;
+        }
+
+        if (!request_mem_region(ts->res->start, resource_size(ts->res),
+                                pdev->name)) {
+                dev_err(dev, "cannot claim register memory\n");
+                ts->res = NULL;
+                error = -EINVAL;
+                goto error_res;
+        }
+
+        ts->regs = ioremap(ts->res->start, resource_size(ts->res));
+        if (!ts->regs) {
+                dev_err(dev, "cannot map register memory\n");
+                error = -ENOMEM;
+                goto error_map;
+        }
+
+        ts->clk = clk_get(dev, NULL);
+        if (IS_ERR(ts->clk)) {
+                dev_err(dev, "cannot claim device clock\n");
+                error = PTR_ERR(ts->clk);
+                goto error_clk;
+        }
+
+        error = request_threaded_irq(ts->tsc_irq, NULL, tsc_irq, 0,
+                                     dev_name(dev), ts);
+        if (error < 0) {
+                dev_err(ts->dev, "Could not allocate ts irq\n");
+                goto error_irq;
+        }
+
+        ts->input_dev = input_allocate_device();
+        if (!ts->input_dev) {
+                dev_err(dev, "cannot allocate input device\n");
+                error = -ENOMEM;
+                goto error_input;
+        }
+        input_set_drvdata(ts->input_dev, ts);
+
+        ts->input_dev->name       = pdev->name;
+        ts->input_dev->id.bustype = BUS_HOST;
+        ts->input_dev->dev.parent = &pdev->dev;
+        ts->input_dev->open       = tsc_start;
+        ts->input_dev->close      = tsc_stop;
+
+        clk_enable(ts->clk);
+        rev = tsc_read(ts, rev);
+        ts->input_dev->id.product = ((rev >>  8) & 0x07);
+        ts->input_dev->id.version = ((rev >> 16) & 0xfff);
+        clk_disable(ts->clk);
+
+        __set_bit(EV_KEY,    ts->input_dev->evbit);
+        __set_bit(EV_ABS,    ts->input_dev->evbit);
+        __set_bit(BTN_TOUCH, ts->input_dev->keybit);
+
+        input_set_abs_params(ts->input_dev, ABS_X, 0, 0xffff, 5, 0);
+        input_set_abs_params(ts->input_dev, ABS_Y, 0, 0xffff, 5, 0);
+        input_set_abs_params(ts->input_dev, ABS_PRESSURE, 0, 4095, 128, 0);
+
+        error = input_register_device(ts->input_dev);
+        if (error < 0) {
+                dev_err(dev, "failed input device registration\n");
+                goto error_reg;
+        }
+
+        return 0;
+
+error_reg:
+        input_free_device(ts->input_dev);
+error_input:
+        free_irq(ts->tsc_irq, ts);
+error_irq:
+        clk_put(ts->clk);
+error_clk:
+        iounmap(ts->regs);
+error_map:
+        release_mem_region(ts->res->start, resource_size(ts->res));
+error_res:
+        platform_set_drvdata(pdev, NULL);
+        kfree(ts);
+
+        return error;
+}
+
+static int __devexit tsc_remove(struct platform_device *pdev)
+{
+        struct tsc_data *ts = platform_get_drvdata(pdev);
+
+        input_unregister_device(ts->input_dev);
+        free_irq(ts->tsc_irq, ts);
+        clk_put(ts->clk);
+        iounmap(ts->regs);
+        release_mem_region(ts->res->start, resource_size(ts->res));
+        platform_set_drvdata(pdev, NULL);
+        kfree(ts);
+
+        return 0;
+}
+
+static struct platform_driver tsc_driver = {
+        .probe          = tsc_probe,
+        .remove         = __devexit_p(tsc_remove),
+        .driver.name    = "tnetv107x-ts",
+        .driver.owner   = THIS_MODULE,
+};
+
+static int __init tsc_init(void)
+{
+        return platform_driver_register(&tsc_driver);
+}
+
+static void __exit tsc_exit(void)
+{
+        platform_driver_unregister(&tsc_driver);
+}
+
+module_init(tsc_init);
+module_exit(tsc_exit);
+
+MODULE_AUTHOR("Cyril Chemparathy");
+MODULE_DESCRIPTION("TNETV107X Touchscreen Driver");
+MODULE_ALIAS("platform: tnetv107x-ts");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/touchscreen/tps6507x-ts.c b/drivers/input/touchscreen/tps6507x-ts.c
index a644d18c04dc..43031492d733 100644
--- a/drivers/input/touchscreen/tps6507x-ts.c
+++ b/drivers/input/touchscreen/tps6507x-ts.c
@@ -43,7 +43,6 @@ struct tps6507x_ts {
         struct input_dev        *input_dev;
         struct device           *dev;
         char                    phys[32];
-        struct workqueue_struct *wq;
         struct delayed_work     work;
         unsigned                polling;        /* polling is active */
         struct ts_event         tc;
@@ -220,8 +219,8 @@ done:
         poll = 1;
 
         if (poll) {
-                schd = queue_delayed_work(tsc->wq, &tsc->work,
-                                          msecs_to_jiffies(tsc->poll_period));
+                schd = schedule_delayed_work(&tsc->work,
+                                        msecs_to_jiffies(tsc->poll_period));
                 if (schd)
                         tsc->polling = 1;
                 else {
@@ -303,7 +302,6 @@ static int tps6507x_ts_probe(struct platform_device *pdev)
         tsc->input_dev = input_dev;
 
         INIT_DELAYED_WORK(&tsc->work, tps6507x_ts_handler);
-        tsc->wq = create_workqueue("TPS6507x Touchscreen");
 
         if (init_data) {
                 tsc->poll_period = init_data->poll_period;
@@ -325,8 +323,8 @@ static int tps6507x_ts_probe(struct platform_device *pdev)
         if (error)
                 goto err2;
 
-        schd = queue_delayed_work(tsc->wq, &tsc->work,
-                                  msecs_to_jiffies(tsc->poll_period));
+        schd = schedule_delayed_work(&tsc->work,
+                                     msecs_to_jiffies(tsc->poll_period));
 
         if (schd)
                 tsc->polling = 1;
@@ -335,12 +333,12 @@ static int tps6507x_ts_probe(struct platform_device *pdev)
                 dev_err(tsc->dev, "schedule failed");
                 goto err2;
          }
+        platform_set_drvdata(pdev, tps6507x_dev);
 
         return 0;
 
 err2:
         cancel_delayed_work_sync(&tsc->work);
-        destroy_workqueue(tsc->wq);
         input_free_device(input_dev);
 err1:
         kfree(tsc);
@@ -356,9 +354,8 @@ static int __devexit tps6507x_ts_remove(struct platform_device *pdev)
         struct input_dev *input_dev = tsc->input_dev;
 
         cancel_delayed_work_sync(&tsc->work);
-        destroy_workqueue(tsc->wq);
 
-        input_free_device(input_dev);
+        input_unregister_device(input_dev);
 
         tps6507x_dev->ts = NULL;
         kfree(tsc);
diff --git a/drivers/input/touchscreen/tsc2005.c b/drivers/input/touchscreen/tsc2005.c
new file mode 100644
index 000000000000..cbf0ff322676
--- /dev/null
+++ b/drivers/input/touchscreen/tsc2005.c
@@ -0,0 +1,764 @@
+/*
+ * TSC2005 touchscreen driver
+ *
+ * Copyright (C) 2006-2010 Nokia Corporation
+ *
+ * Author: Lauri Leukkunen <lauri.leukkunen@nokia.com>
+ * based on TSC2301 driver by Klaus K. Pedersen <klaus.k.pedersen@nokia.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/input.h>
+#include <linux/interrupt.h>
+#include <linux/delay.h>
+#include <linux/pm.h>
+#include <linux/spi/spi.h>
+#include <linux/spi/tsc2005.h>
+
+/*
+ * The touchscreen interface operates as follows:
+ *
+ * 1) Pen is pressed against the touchscreen.
+ * 2) TSC2005 performs AD conversion.
+ * 3) After the conversion is done TSC2005 drives DAV line down.
+ * 4) GPIO IRQ is received and tsc2005_irq_thread() is scheduled.
+ * 5) tsc2005_irq_thread() queues up an spi transfer to fetch the x, y, z1, z2
+ *    values.
+ * 6) tsc2005_irq_thread() reports coordinates to input layer and sets up
+ *    tsc2005_penup_timer() to be called after TSC2005_PENUP_TIME_MS (40ms).
+ * 7) When the penup timer expires, there have not been touch or DAV interrupts
+ *    during the last 40ms which means the pen has been lifted.
+ *
+ * ESD recovery via a hardware reset is done if the TSC2005 doesn't respond
+ * after a configurable period (in ms) of activity. If esd_timeout is 0, the
+ * watchdog is disabled.
+ */
+
+/* control byte 1 */
+#define TSC2005_CMD                     0x80
+#define TSC2005_CMD_NORMAL              0x00
+#define TSC2005_CMD_STOP                0x01
+#define TSC2005_CMD_12BIT               0x04
+
+/* control byte 0 */
+#define TSC2005_REG_READ                0x0001
+#define TSC2005_REG_PND0                0x0002
+#define TSC2005_REG_X                   0x0000
+#define TSC2005_REG_Y                   0x0008
+#define TSC2005_REG_Z1                  0x0010
+#define TSC2005_REG_Z2                  0x0018
+#define TSC2005_REG_TEMP_HIGH           0x0050
+#define TSC2005_REG_CFR0                0x0060
+#define TSC2005_REG_CFR1                0x0068
+#define TSC2005_REG_CFR2                0x0070
+
+/* configuration register 0 */
+#define TSC2005_CFR0_PRECHARGE_276US    0x0040
+#define TSC2005_CFR0_STABTIME_1MS       0x0300
+#define TSC2005_CFR0_CLOCK_1MHZ         0x1000
+#define TSC2005_CFR0_RESOLUTION12       0x2000
+#define TSC2005_CFR0_PENMODE            0x8000
+#define TSC2005_CFR0_INITVALUE          (TSC2005_CFR0_STABTIME_1MS    | \
+                                         TSC2005_CFR0_CLOCK_1MHZ      | \
+                                         TSC2005_CFR0_RESOLUTION12    | \
+                                         TSC2005_CFR0_PRECHARGE_276US | \
+                                         TSC2005_CFR0_PENMODE)
+
+/* bits common to both read and write of configuration register 0 */
+#define TSC2005_CFR0_RW_MASK            0x3fff
+
+/* configuration register 1 */
+#define TSC2005_CFR1_BATCHDELAY_4MS     0x0003
+#define TSC2005_CFR1_INITVALUE          TSC2005_CFR1_BATCHDELAY_4MS
+
+/* configuration register 2 */
+#define TSC2005_CFR2_MAVE_Z             0x0004
+#define TSC2005_CFR2_MAVE_Y             0x0008
+#define TSC2005_CFR2_MAVE_X             0x0010
+#define TSC2005_CFR2_AVG_7              0x0800
+#define TSC2005_CFR2_MEDIUM_15          0x3000
+#define TSC2005_CFR2_INITVALUE          (TSC2005_CFR2_MAVE_X    | \
+                                         TSC2005_CFR2_MAVE_Y    | \
+                                         TSC2005_CFR2_MAVE_Z    | \
+                                         TSC2005_CFR2_MEDIUM_15 | \
+                                         TSC2005_CFR2_AVG_7)
+
+#define MAX_12BIT                       0xfff
+#define TSC2005_SPI_MAX_SPEED_HZ        10000000
+#define TSC2005_PENUP_TIME_MS           40
+
+struct tsc2005_spi_rd {
+        struct spi_transfer     spi_xfer;
+        u32                     spi_tx;
+        u32                     spi_rx;
+};
+
+struct tsc2005 {
+        struct spi_device       *spi;
+
+        struct spi_message      spi_read_msg;
+        struct tsc2005_spi_rd   spi_x;
+        struct tsc2005_spi_rd   spi_y;
+        struct tsc2005_spi_rd   spi_z1;
+        struct tsc2005_spi_rd   spi_z2;
+
+        struct input_dev        *idev;
+        char                    phys[32];
+
+        struct mutex            mutex;
+
+        /* raw copy of previous x,y,z */
+        int                     in_x;
+        int                     in_y;
+        int                     in_z1;
+        int                     in_z2;
+
+        spinlock_t              lock;
+        struct timer_list       penup_timer;
+
+        unsigned int            esd_timeout;
+        struct delayed_work     esd_work;
+        unsigned long           last_valid_interrupt;
+
+        unsigned int            x_plate_ohm;
+
+        bool                    opened;
+        bool                    suspended;
+
+        bool                    pen_down;
+
+        void                    (*set_reset)(bool enable);
+};
+
+static int tsc2005_cmd(struct tsc2005 *ts, u8 cmd)
+{
+        u8 tx = TSC2005_CMD | TSC2005_CMD_12BIT | cmd;
+        struct spi_transfer xfer = {
+                .tx_buf         = &tx,
+                .len            = 1,
+                .bits_per_word  = 8,
+        };
+        struct spi_message msg;
+        int error;
+
+        spi_message_init(&msg);
+        spi_message_add_tail(&xfer, &msg);
+
+        error = spi_sync(ts->spi, &msg);
+        if (error) {
+                dev_err(&ts->spi->dev, "%s: failed, command: %x, error: %d\n",
+                        __func__, cmd, error);
+                return error;
+        }
+
+        return 0;
+}
+
+static int tsc2005_write(struct tsc2005 *ts, u8 reg, u16 value)
+{
+        u32 tx = ((reg | TSC2005_REG_PND0) << 16) | value;
+        struct spi_transfer xfer = {
+                .tx_buf         = &tx,
+                .len            = 4,
+                .bits_per_word  = 24,
+        };
+        struct spi_message msg;
+        int error;
+
+        spi_message_init(&msg);
+        spi_message_add_tail(&xfer, &msg);
+
+        error = spi_sync(ts->spi, &msg);
+        if (error) {
+                dev_err(&ts->spi->dev,
+                        "%s: failed, register: %x, value: %x, error: %d\n",
+                        __func__, reg, value, error);
+                return error;
+        }
+
+        return 0;
+}
+
+static void tsc2005_setup_read(struct tsc2005_spi_rd *rd, u8 reg, bool last)
+{
+        memset(rd, 0, sizeof(*rd));
+
+        rd->spi_tx                 = (reg | TSC2005_REG_READ) << 16;
+        rd->spi_xfer.tx_buf        = &rd->spi_tx;
+        rd->spi_xfer.rx_buf        = &rd->spi_rx;
+        rd->spi_xfer.len           = 4;
+        rd->spi_xfer.bits_per_word = 24;
+        rd->spi_xfer.cs_change     = !last;
+}
+
+static int tsc2005_read(struct tsc2005 *ts, u8 reg, u16 *value)
+{
+        struct tsc2005_spi_rd spi_rd;
+        struct spi_message msg;
+        int error;
+
+        tsc2005_setup_read(&spi_rd, reg, true);
+
+        spi_message_init(&msg);
+        spi_message_add_tail(&spi_rd.spi_xfer, &msg);
+
+        error = spi_sync(ts->spi, &msg);
+        if (error)
+                return error;
+
+        *value = spi_rd.spi_rx;
+        return 0;
+}
+
+static void tsc2005_update_pen_state(struct tsc2005 *ts,
+                                     int x, int y, int pressure)
+{
+        if (pressure) {
+                input_report_abs(ts->idev, ABS_X, x);
+                input_report_abs(ts->idev, ABS_Y, y);
+                input_report_abs(ts->idev, ABS_PRESSURE, pressure);
+                if (!ts->pen_down) {
+                        input_report_key(ts->idev, BTN_TOUCH, !!pressure);
+                        ts->pen_down = true;
+                }
+        } else {
+                input_report_abs(ts->idev, ABS_PRESSURE, 0);
+                if (ts->pen_down) {
+                        input_report_key(ts->idev, BTN_TOUCH, 0);
+                        ts->pen_down = false;
+                }
+        }
+        input_sync(ts->idev);
+        dev_dbg(&ts->spi->dev, "point(%4d,%4d), pressure (%4d)\n", x, y,
+                pressure);
+}
+
+static irqreturn_t tsc2005_irq_thread(int irq, void *_ts)
+{
+        struct tsc2005 *ts = _ts;
+        unsigned long flags;
+        unsigned int pressure;
+        u32 x, y;
+        u32 z1, z2;
+        int error;
+
+        /* read the coordinates */
+        error = spi_sync(ts->spi, &ts->spi_read_msg);
+        if (unlikely(error))
+                goto out;
+
+        x = ts->spi_x.spi_rx;
+        y = ts->spi_y.spi_rx;
+        z1 = ts->spi_z1.spi_rx;
+        z2 = ts->spi_z2.spi_rx;
+
+        /* validate position */
+        if (unlikely(x > MAX_12BIT || y > MAX_12BIT))
+                goto out;
+
+        /* Skip reading if the pressure components are out of range */
+        if (unlikely(z1 == 0 || z2 > MAX_12BIT || z1 >= z2))
+                goto out;
+
+       /*
+        * Skip point if this is a pen down with the exact same values as
+        * the value before pen-up - that implies SPI fed us stale data
+        */
+        if (!ts->pen_down &&
+            ts->in_x == x && ts->in_y == y &&
+            ts->in_z1 == z1 && ts->in_z2 == z2) {
+                goto out;
+        }
+
+        /*
+         * At this point we are happy we have a valid and useful reading.
+         * Remember it for later comparisons. We may now begin downsampling.
+         */
+        ts->in_x = x;
+        ts->in_y = y;
+        ts->in_z1 = z1;
+        ts->in_z2 = z2;
+
+        /* Compute touch pressure resistance using equation #1 */
+        pressure = x * (z2 - z1) / z1;
+        pressure = pressure * ts->x_plate_ohm / 4096;
+        if (unlikely(pressure > MAX_12BIT))
+                goto out;
+
+        spin_lock_irqsave(&ts->lock, flags);
+
+        tsc2005_update_pen_state(ts, x, y, pressure);
+        mod_timer(&ts->penup_timer,
+                  jiffies + msecs_to_jiffies(TSC2005_PENUP_TIME_MS));
+
+        spin_unlock_irqrestore(&ts->lock, flags);
+
+        ts->last_valid_interrupt = jiffies;
+out:
+        return IRQ_HANDLED;
+}
+
+static void tsc2005_penup_timer(unsigned long data)
+{
+        struct tsc2005 *ts = (struct tsc2005 *)data;
+        unsigned long flags;
+
+        spin_lock_irqsave(&ts->lock, flags);
+        tsc2005_update_pen_state(ts, 0, 0, 0);
+        spin_unlock_irqrestore(&ts->lock, flags);
+}
+
+static void tsc2005_start_scan(struct tsc2005 *ts)
+{
+        tsc2005_write(ts, TSC2005_REG_CFR0, TSC2005_CFR0_INITVALUE);
+        tsc2005_write(ts, TSC2005_REG_CFR1, TSC2005_CFR1_INITVALUE);
+        tsc2005_write(ts, TSC2005_REG_CFR2, TSC2005_CFR2_INITVALUE);
+        tsc2005_cmd(ts, TSC2005_CMD_NORMAL);
+}
+
+static void tsc2005_stop_scan(struct tsc2005 *ts)
+{
+        tsc2005_cmd(ts, TSC2005_CMD_STOP);
+}
+
+/* must be called with ts->mutex held */
+static void __tsc2005_disable(struct tsc2005 *ts)
+{
+        tsc2005_stop_scan(ts);
+
+        disable_irq(ts->spi->irq);
+        del_timer_sync(&ts->penup_timer);
+
+        cancel_delayed_work_sync(&ts->esd_work);
+
+        enable_irq(ts->spi->irq);
+}
+
+/* must be called with ts->mutex held */
+static void __tsc2005_enable(struct tsc2005 *ts)
+{
+        tsc2005_start_scan(ts);
+
+        if (ts->esd_timeout && ts->set_reset) {
+                ts->last_valid_interrupt = jiffies;
+                schedule_delayed_work(&ts->esd_work,
+                                round_jiffies_relative(
+                                        msecs_to_jiffies(ts->esd_timeout)));
+        }
+
+}
+
+static ssize_t tsc2005_selftest_show(struct device *dev,
+                                     struct device_attribute *attr,
+                                     char *buf)
+{
+        struct spi_device *spi = to_spi_device(dev);
+        struct tsc2005 *ts = spi_get_drvdata(spi);
+        u16 temp_high;
+        u16 temp_high_orig;
+        u16 temp_high_test;
+        bool success = true;
+        int error;
+
+        mutex_lock(&ts->mutex);
+
+        /*
+         * Test TSC2005 communications via temp high register.
+         */
+        __tsc2005_disable(ts);
+
+        error = tsc2005_read(ts, TSC2005_REG_TEMP_HIGH, &temp_high_orig);
+        if (error) {
+                dev_warn(dev, "selftest failed: read error %d\n", error);
+                success = false;
+                goto out;
+        }
+
+        temp_high_test = (temp_high_orig - 1) & MAX_12BIT;
+
+        error = tsc2005_write(ts, TSC2005_REG_TEMP_HIGH, temp_high_test);
+        if (error) {
+                dev_warn(dev, "selftest failed: write error %d\n", error);
+                success = false;
+                goto out;
+        }
+
+        error = tsc2005_read(ts, TSC2005_REG_TEMP_HIGH, &temp_high);
+        if (error) {
+                dev_warn(dev, "selftest failed: read error %d after write\n",
+                         error);
+                success = false;
+                goto out;
+        }
+
+        if (temp_high != temp_high_test) {
+                dev_warn(dev, "selftest failed: %d != %d\n",
+                         temp_high, temp_high_test);
+                success = false;
+        }
+
+        /* hardware reset */
+        ts->set_reset(false);
+        usleep_range(100, 500); /* only 10us required */
+        ts->set_reset(true);
+
+        if (!success)
+                goto out;
+
+        /* test that the reset really happened */
+        error = tsc2005_read(ts, TSC2005_REG_TEMP_HIGH, &temp_high);
+        if (error) {
+                dev_warn(dev, "selftest failed: read error %d after reset\n",
+                         error);
+                success = false;
+                goto out;
+        }
+
+        if (temp_high != temp_high_orig) {
+                dev_warn(dev, "selftest failed after reset: %d != %d\n",
+                         temp_high, temp_high_orig);
+                success = false;
+        }
+
+out:
+        __tsc2005_enable(ts);
+        mutex_unlock(&ts->mutex);
+
+        return sprintf(buf, "%d\n", success);
+}
+
+static DEVICE_ATTR(selftest, S_IRUGO, tsc2005_selftest_show, NULL);
+
+static struct attribute *tsc2005_attrs[] = {
+        &dev_attr_selftest.attr,
+        NULL
+};
+
+static mode_t tsc2005_attr_is_visible(struct kobject *kobj,
+                                      struct attribute *attr, int n)
+{
+        struct device *dev = container_of(kobj, struct device, kobj);
+        struct spi_device *spi = to_spi_device(dev);
+        struct tsc2005 *ts = spi_get_drvdata(spi);
+        mode_t mode = attr->mode;
+
+        if (attr == &dev_attr_selftest.attr) {
+                if (!ts->set_reset)
+                        mode = 0;
+        }
+
+        return mode;
+}
+
+static const struct attribute_group tsc2005_attr_group = {
+        .is_visible     = tsc2005_attr_is_visible,
+        .attrs          = tsc2005_attrs,
+};
+
+static void tsc2005_esd_work(struct work_struct *work)
+{
+        struct tsc2005 *ts = container_of(work, struct tsc2005, esd_work.work);
+        int error;
+        u16 r;
+
+        if (!mutex_trylock(&ts->mutex)) {
+                /*
+                 * If the mutex is taken, it means that disable or enable is in
+                 * progress. In that case just reschedule the work. If the work
+                 * is not needed, it will be canceled by disable.
+                 */
+                goto reschedule;
+        }
+
+        if (time_is_after_jiffies(ts->last_valid_interrupt +
+                                  msecs_to_jiffies(ts->esd_timeout)))
+                goto out;
+
+        /* We should be able to read register without disabling interrupts. */
+        error = tsc2005_read(ts, TSC2005_REG_CFR0, &r);
+        if (!error &&
+            !((r ^ TSC2005_CFR0_INITVALUE) & TSC2005_CFR0_RW_MASK)) {
+                goto out;
+        }
+
+        /*
+         * If we could not read our known value from configuration register 0
+         * then we should reset the controller as if from power-up and start
+         * scanning again.
+         */
+        dev_info(&ts->spi->dev, "TSC2005 not responding - resetting\n");
+
+        disable_irq(ts->spi->irq);
+        del_timer_sync(&ts->penup_timer);
+
+        tsc2005_update_pen_state(ts, 0, 0, 0);
+
+        ts->set_reset(false);
+        usleep_range(100, 500); /* only 10us required */
+        ts->set_reset(true);
+
+        enable_irq(ts->spi->irq);
+        tsc2005_start_scan(ts);
+
+out:
+        mutex_unlock(&ts->mutex);
+reschedule:
+        /* re-arm the watchdog */
+        schedule_delayed_work(&ts->esd_work,
+                              round_jiffies_relative(
+                                        msecs_to_jiffies(ts->esd_timeout)));
+}
+
+static int tsc2005_open(struct input_dev *input)
+{
+        struct tsc2005 *ts = input_get_drvdata(input);
+
+        mutex_lock(&ts->mutex);
+
+        if (!ts->suspended)
+                __tsc2005_enable(ts);
+
+        ts->opened = true;
+
+        mutex_unlock(&ts->mutex);
+
+        return 0;
+}
+
+static void tsc2005_close(struct input_dev *input)
+{
+        struct tsc2005 *ts = input_get_drvdata(input);
+
+        mutex_lock(&ts->mutex);
+
+        if (!ts->suspended)
+                __tsc2005_disable(ts);
+
+        ts->opened = false;
+
+        mutex_unlock(&ts->mutex);
+}
+
+static void __devinit tsc2005_setup_spi_xfer(struct tsc2005 *ts)
+{
+        tsc2005_setup_read(&ts->spi_x, TSC2005_REG_X, false);
+        tsc2005_setup_read(&ts->spi_y, TSC2005_REG_Y, false);
+        tsc2005_setup_read(&ts->spi_z1, TSC2005_REG_Z1, false);
+        tsc2005_setup_read(&ts->spi_z2, TSC2005_REG_Z2, true);
+
+        spi_message_init(&ts->spi_read_msg);
+        spi_message_add_tail(&ts->spi_x.spi_xfer, &ts->spi_read_msg);
+        spi_message_add_tail(&ts->spi_y.spi_xfer, &ts->spi_read_msg);
+        spi_message_add_tail(&ts->spi_z1.spi_xfer, &ts->spi_read_msg);
+        spi_message_add_tail(&ts->spi_z2.spi_xfer, &ts->spi_read_msg);
+}
+
+static int __devinit tsc2005_probe(struct spi_device *spi)
+{
+        const struct tsc2005_platform_data *pdata = spi->dev.platform_data;
+        struct tsc2005 *ts;
+        struct input_dev *input_dev;
+        unsigned int max_x, max_y, max_p;
+        unsigned int fudge_x, fudge_y, fudge_p;
+        int error;
+
+        if (!pdata) {
+                dev_dbg(&spi->dev, "no platform data\n");
+                return -ENODEV;
+        }
+
+        fudge_x = pdata->ts_x_fudge        ? : 4;
+        fudge_y = pdata->ts_y_fudge        ? : 8;
+        fudge_p = pdata->ts_pressure_fudge ? : 2;
+        max_x   = pdata->ts_x_max          ? : MAX_12BIT;
+        max_y   = pdata->ts_y_max          ? : MAX_12BIT;
+        max_p   = pdata->ts_pressure_max   ? : MAX_12BIT;
+
+        if (spi->irq <= 0) {
+                dev_dbg(&spi->dev, "no irq\n");
+                return -ENODEV;
+        }
+
+        spi->mode = SPI_MODE_0;
+        spi->bits_per_word = 8;
+        if (!spi->max_speed_hz)
+                spi->max_speed_hz = TSC2005_SPI_MAX_SPEED_HZ;
+
+        error = spi_setup(spi);
+        if (error)
+                return error;
+
+        ts = kzalloc(sizeof(*ts), GFP_KERNEL);
+        input_dev = input_allocate_device();
+        if (!ts || !input_dev) {
+                error = -ENOMEM;
+                goto err_free_mem;
+        }
+
+        ts->spi = spi;
+        ts->idev = input_dev;
+
+        ts->x_plate_ohm = pdata->ts_x_plate_ohm ? : 280;
+        ts->esd_timeout = pdata->esd_timeout_ms;
+        ts->set_reset   = pdata->set_reset;
+
+        mutex_init(&ts->mutex);
+
+        spin_lock_init(&ts->lock);
+        setup_timer(&ts->penup_timer, tsc2005_penup_timer, (unsigned long)ts);
+
+        INIT_DELAYED_WORK(&ts->esd_work, tsc2005_esd_work);
+
+        tsc2005_setup_spi_xfer(ts);
+
+        snprintf(ts->phys, sizeof(ts->phys),
+                 "%s/input-ts", dev_name(&spi->dev));
+
+        input_dev->name = "TSC2005 touchscreen";
+        input_dev->phys = ts->phys;
+        input_dev->id.bustype = BUS_SPI;
+        input_dev->dev.parent = &spi->dev;
+        input_dev->evbit[0] = BIT(EV_ABS) | BIT(EV_KEY);
+        input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
+
+        input_set_abs_params(input_dev, ABS_X, 0, max_x, fudge_x, 0);
+        input_set_abs_params(input_dev, ABS_Y, 0, max_y, fudge_y, 0);
+        input_set_abs_params(input_dev, ABS_PRESSURE, 0, max_p, fudge_p, 0);
+
+        input_dev->open = tsc2005_open;
+        input_dev->close = tsc2005_close;
+
+        input_set_drvdata(input_dev, ts);
+
+        /* Ensure the touchscreen is off */
+        tsc2005_stop_scan(ts);
+
+        error = request_threaded_irq(spi->irq, NULL, tsc2005_irq_thread,
+                                     IRQF_TRIGGER_RISING, "tsc2005", ts);
+        if (error) {
+                dev_err(&spi->dev, "Failed to request irq, err: %d\n", error);
+                goto err_free_mem;
+        }
+
+        spi_set_drvdata(spi, ts);
+        error = sysfs_create_group(&spi->dev.kobj, &tsc2005_attr_group);
+        if (error) {
+                dev_err(&spi->dev,
+                        "Failed to create sysfs attributes, err: %d\n", error);
+                goto err_clear_drvdata;
+        }
+
+        error = input_register_device(ts->idev);
+        if (error) {
+                dev_err(&spi->dev,
+                        "Failed to register input device, err: %d\n", error);
+                goto err_remove_sysfs;
+        }
+
+        irq_set_irq_wake(spi->irq, 1);
+        return 0;
+
+err_remove_sysfs:
+        sysfs_remove_group(&spi->dev.kobj, &tsc2005_attr_group);
+err_clear_drvdata:
+        spi_set_drvdata(spi, NULL);
+        free_irq(spi->irq, ts);
+err_free_mem:
+        input_free_device(input_dev);
+        kfree(ts);
+        return error;
+}
+
+static int __devexit tsc2005_remove(struct spi_device *spi)
+{
+        struct tsc2005 *ts = spi_get_drvdata(spi);
+
+        sysfs_remove_group(&ts->spi->dev.kobj, &tsc2005_attr_group);
+
+        free_irq(ts->spi->irq, ts);
+        input_unregister_device(ts->idev);
+        kfree(ts);
+
+        spi_set_drvdata(spi, NULL);
+        return 0;
+}
+
+#ifdef CONFIG_PM_SLEEP
+static int tsc2005_suspend(struct device *dev)
+{
+        struct spi_device *spi = to_spi_device(dev);
+        struct tsc2005 *ts = spi_get_drvdata(spi);
+
+        mutex_lock(&ts->mutex);
+
+        if (!ts->suspended && ts->opened)
+                __tsc2005_disable(ts);
+
+        ts->suspended = true;
+
+        mutex_unlock(&ts->mutex);
+
+        return 0;
+}
+
+static int tsc2005_resume(struct device *dev)
+{
+        struct spi_device *spi = to_spi_device(dev);
+        struct tsc2005 *ts = spi_get_drvdata(spi);
+
+        mutex_lock(&ts->mutex);
+
+        if (ts->suspended && ts->opened)
+                __tsc2005_enable(ts);
+
+        ts->suspended = false;
+
+        mutex_unlock(&ts->mutex);
+
+        return 0;
+}
+#endif
+
+static SIMPLE_DEV_PM_OPS(tsc2005_pm_ops, tsc2005_suspend, tsc2005_resume);
+
+static struct spi_driver tsc2005_driver = {
+        .driver = {
+                .name   = "tsc2005",
+                .owner  = THIS_MODULE,
+                .pm     = &tsc2005_pm_ops,
+        },
+        .probe  = tsc2005_probe,
+        .remove = __devexit_p(tsc2005_remove),
+};
+
+static int __init tsc2005_init(void)
+{
+        return spi_register_driver(&tsc2005_driver);
+}
+module_init(tsc2005_init);
+
+static void __exit tsc2005_exit(void)
+{
+        spi_unregister_driver(&tsc2005_driver);
+}
+module_exit(tsc2005_exit);
+
+MODULE_AUTHOR("Lauri Leukkunen <lauri.leukkunen@nokia.com>");
+MODULE_DESCRIPTION("TSC2005 Touchscreen Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/touchscreen/tsc2007.c b/drivers/input/touchscreen/tsc2007.c
index be23780e8a3e..fadc11545b1e 100644
--- a/drivers/input/touchscreen/tsc2007.c
+++ b/drivers/input/touchscreen/tsc2007.c
@@ -27,9 +27,6 @@
 #include <linux/i2c.h>
 #include <linux/i2c/tsc2007.h>
 
-#define TS_POLL_DELAY                   1 /* ms delay between samples */
-#define TS_POLL_PERIOD                  1 /* ms delay between samples */
-
 #define TSC2007_MEASURE_TEMP0           (0x0 << 4)
 #define TSC2007_MEASURE_AUX             (0x2 << 4)
 #define TSC2007_MEASURE_TEMP1           (0x4 << 4)
@@ -75,6 +72,9 @@ struct tsc2007 {
 
         u16                     model;
         u16                     x_plate_ohms;
+        u16                     max_rt;
+        unsigned long           poll_delay;
+        unsigned long           poll_period;
 
         bool                    pendown;
         int                     irq;
@@ -156,6 +156,7 @@ static void tsc2007_work(struct work_struct *work)
 {
         struct tsc2007 *ts =
                 container_of(to_delayed_work(work), struct tsc2007, work);
+        bool debounced = false;
         struct ts_event tc;
         u32 rt;
 
@@ -184,13 +185,14 @@ static void tsc2007_work(struct work_struct *work)
         tsc2007_read_values(ts, &tc);
 
         rt = tsc2007_calculate_pressure(ts, &tc);
-        if (rt > MAX_12BIT) {
+        if (rt > ts->max_rt) {
                 /*
                  * Sample found inconsistent by debouncing or pressure is
                  * beyond the maximum. Don't report it to user space,
                  * repeat at least once more the measurement.
                  */
                 dev_dbg(&ts->client->dev, "ignored pressure %d\n", rt);
+                debounced = true;
                 goto out;
 
         }
@@ -225,9 +227,9 @@ static void tsc2007_work(struct work_struct *work)
         }
 
  out:
-        if (ts->pendown)
+        if (ts->pendown || debounced)
                 schedule_delayed_work(&ts->work,
-                                      msecs_to_jiffies(TS_POLL_PERIOD));
+                                      msecs_to_jiffies(ts->poll_period));
         else
                 enable_irq(ts->irq);
 }
@@ -239,7 +241,7 @@ static irqreturn_t tsc2007_irq(int irq, void *handle)
         if (!ts->get_pendown_state || likely(ts->get_pendown_state())) {
                 disable_irq_nosync(ts->irq);
                 schedule_delayed_work(&ts->work,
-                                      msecs_to_jiffies(TS_POLL_DELAY));
+                                      msecs_to_jiffies(ts->poll_delay));
         }
 
         if (ts->clear_penirq)
@@ -265,7 +267,7 @@ static int __devinit tsc2007_probe(struct i2c_client *client,
                                    const struct i2c_device_id *id)
 {
         struct tsc2007 *ts;
-        struct tsc2007_platform_data *pdata = pdata = client->dev.platform_data;
+        struct tsc2007_platform_data *pdata = client->dev.platform_data;
         struct input_dev *input_dev;
         int err;
 
@@ -292,6 +294,9 @@ static int __devinit tsc2007_probe(struct i2c_client *client,
 
         ts->model             = pdata->model;
         ts->x_plate_ohms      = pdata->x_plate_ohms;
+        ts->max_rt            = pdata->max_rt ? : MAX_12BIT;
+        ts->poll_delay        = pdata->poll_delay ? : 1;
+        ts->poll_period       = pdata->poll_period ? : 1;
         ts->get_pendown_state = pdata->get_pendown_state;
         ts->clear_penirq      = pdata->clear_penirq;
 
@@ -305,9 +310,10 @@ static int __devinit tsc2007_probe(struct i2c_client *client,
         input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
         input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
 
-        input_set_abs_params(input_dev, ABS_X, 0, MAX_12BIT, 0, 0);
-        input_set_abs_params(input_dev, ABS_Y, 0, MAX_12BIT, 0, 0);
-        input_set_abs_params(input_dev, ABS_PRESSURE, 0, MAX_12BIT, 0, 0);
+        input_set_abs_params(input_dev, ABS_X, 0, MAX_12BIT, pdata->fuzzx, 0);
+        input_set_abs_params(input_dev, ABS_Y, 0, MAX_12BIT, pdata->fuzzy, 0);
+        input_set_abs_params(input_dev, ABS_PRESSURE, 0, MAX_12BIT,
+                        pdata->fuzzz, 0);
 
         if (pdata->init_platform_hw)
                 pdata->init_platform_hw();
diff --git a/drivers/input/touchscreen/ucb1400_ts.c b/drivers/input/touchscreen/ucb1400_ts.c
index 028a5363eea1..3b5b5df04dd6 100644
--- a/drivers/input/touchscreen/ucb1400_ts.c
+++ b/drivers/input/touchscreen/ucb1400_ts.c
@@ -6,7 +6,7 @@
  *  Copyright:  MontaVista Software, Inc.
  *
  * Spliting done by: Marek Vasut <marek.vasut@gmail.com>
- * If something doesnt work and it worked before spliting, e-mail me,
+ * If something doesn't work and it worked before spliting, e-mail me,
  * dont bother Nicolas please ;-)
  *
  * This program is free software; you can redistribute it and/or modify
diff --git a/drivers/input/touchscreen/usbtouchscreen.c b/drivers/input/touchscreen/usbtouchscreen.c
index f45f80f6d336..73fd6642b681 100644
--- a/drivers/input/touchscreen/usbtouchscreen.c
+++ b/drivers/input/touchscreen/usbtouchscreen.c
@@ -178,6 +178,7 @@ static const struct usb_device_id usbtouch_devices[] = {
 
 #ifdef CONFIG_TOUCHSCREEN_USB_ITM
         {USB_DEVICE(0x0403, 0xf9e9), .driver_info = DEVTYPE_ITM},
+        {USB_DEVICE(0x16e3, 0xf9e9), .driver_info = DEVTYPE_ITM},
 #endif
 
 #ifdef CONFIG_TOUCHSCREEN_USB_ETURBO
diff --git a/drivers/input/touchscreen/wacom_w8001.c b/drivers/input/touchscreen/wacom_w8001.c
index 56dc35c94bb1..c14412ef4648 100644
--- a/drivers/input/touchscreen/wacom_w8001.c
+++ b/drivers/input/touchscreen/wacom_w8001.c
@@ -2,6 +2,8 @@
  * Wacom W8001 penabled serial touchscreen driver
  *
  * Copyright (c) 2008 Jaya Kumar
+ * Copyright (c) 2010 Red Hat, Inc.
+ * Copyright (c) 2010 - 2011 Ping Cheng, Wacom. <pingc@wacom.com>
  *
  * This file is subject to the terms and conditions of the GNU General Public
  * License. See the file COPYING in the main directory of this archive for
@@ -14,10 +16,11 @@
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/slab.h>
-#include <linux/input.h>
+#include <linux/input/mt.h>
 #include <linux/serio.h>
 #include <linux/init.h>
 #include <linux/ctype.h>
+#include <linux/delay.h>
 
 #define DRIVER_DESC     "Wacom W8001 serial touchscreen driver"
 
@@ -30,11 +33,27 @@ MODULE_LICENSE("GPL");
 #define W8001_LEAD_BYTE         0x80
 #define W8001_TAB_MASK          0x40
 #define W8001_TAB_BYTE          0x40
+/* set in first byte of touch data packets */
+#define W8001_TOUCH_MASK        (0x10 | W8001_LEAD_MASK)
+#define W8001_TOUCH_BYTE        (0x10 | W8001_LEAD_BYTE)
 
 #define W8001_QUERY_PACKET      0x20
 
+#define W8001_CMD_STOP          '0'
 #define W8001_CMD_START         '1'
 #define W8001_CMD_QUERY         '*'
+#define W8001_CMD_TOUCHQUERY    '%'
+
+/* length of data packets in bytes, depends on device. */
+#define W8001_PKTLEN_TOUCH93    5
+#define W8001_PKTLEN_TOUCH9A    7
+#define W8001_PKTLEN_TPCPEN     9
+#define W8001_PKTLEN_TPCCTL     11      /* control packet */
+#define W8001_PKTLEN_TOUCH2FG   13
+
+/* resolution in points/mm */
+#define W8001_PEN_RESOLUTION    100
+#define W8001_TOUCH_RESOLUTION  10
 
 struct w8001_coord {
         u8 rdy;
@@ -48,6 +67,15 @@ struct w8001_coord {
         u8 tilt_y;
 };
 
+/* touch query reply packet */
+struct w8001_touch_query {
+        u16 x;
+        u16 y;
+        u8 panel_res;
+        u8 capacity_res;
+        u8 sensor_id;
+};
+
 /*
  * Per-touchscreen data.
  */
@@ -62,9 +90,16 @@ struct w8001 {
         unsigned char response[W8001_MAX_LENGTH];
         unsigned char data[W8001_MAX_LENGTH];
         char phys[32];
+        int type;
+        unsigned int pktlen;
+        u16 max_touch_x;
+        u16 max_touch_y;
+        u16 max_pen_x;
+        u16 max_pen_y;
+        char name[64];
 };
 
-static void parse_data(u8 *data, struct w8001_coord *coord)
+static void parse_pen_data(u8 *data, struct w8001_coord *coord)
 {
         memset(coord, 0, sizeof(*coord));
 
@@ -88,11 +123,166 @@ static void parse_data(u8 *data, struct w8001_coord *coord)
         coord->tilt_y = data[8] & 0x7F;
 }
 
+static void parse_single_touch(u8 *data, struct w8001_coord *coord)
+{
+        coord->x = (data[1] << 7) | data[2];
+        coord->y = (data[3] << 7) | data[4];
+        coord->tsw = data[0] & 0x01;
+}
+
+static void scale_touch_coordinates(struct w8001 *w8001,
+                                    unsigned int *x, unsigned int *y)
+{
+        if (w8001->max_pen_x && w8001->max_touch_x)
+                *x = *x * w8001->max_pen_x / w8001->max_touch_x;
+
+        if (w8001->max_pen_y && w8001->max_touch_y)
+                *y = *y * w8001->max_pen_y / w8001->max_touch_y;
+}
+
+static void parse_multi_touch(struct w8001 *w8001)
+{
+        struct input_dev *dev = w8001->dev;
+        unsigned char *data = w8001->data;
+        unsigned int x, y;
+        int i;
+        int count = 0;
+
+        for (i = 0; i < 2; i++) {
+                bool touch = data[0] & (1 << i);
+
+                input_mt_slot(dev, i);
+                input_mt_report_slot_state(dev, MT_TOOL_FINGER, touch);
+                if (touch) {
+                        x = (data[6 * i + 1] << 7) | data[6 * i + 2];
+                        y = (data[6 * i + 3] << 7) | data[6 * i + 4];
+                        /* data[5,6] and [11,12] is finger capacity */
+
+                        /* scale to pen maximum */
+                        scale_touch_coordinates(w8001, &x, &y);
+
+                        input_report_abs(dev, ABS_MT_POSITION_X, x);
+                        input_report_abs(dev, ABS_MT_POSITION_Y, y);
+                        count++;
+                }
+        }
+
+        /* emulate single touch events when stylus is out of proximity.
+         * This is to make single touch backward support consistent
+         * across all Wacom single touch devices.
+         */
+        if (w8001->type != BTN_TOOL_PEN &&
+                            w8001->type != BTN_TOOL_RUBBER) {
+                w8001->type = count == 1 ? BTN_TOOL_FINGER : KEY_RESERVED;
+                input_mt_report_pointer_emulation(dev, true);
+        }
+
+        input_sync(dev);
+}
+
+static void parse_touchquery(u8 *data, struct w8001_touch_query *query)
+{
+        memset(query, 0, sizeof(*query));
+
+        query->panel_res = data[1];
+        query->sensor_id = data[2] & 0x7;
+        query->capacity_res = data[7];
+
+        query->x = data[3] << 9;
+        query->x |= data[4] << 2;
+        query->x |= (data[2] >> 5) & 0x3;
+
+        query->y = data[5] << 9;
+        query->y |= data[6] << 2;
+        query->y |= (data[2] >> 3) & 0x3;
+
+        /* Early days' single-finger touch models need the following defaults */
+        if (!query->x && !query->y) {
+                query->x = 1024;
+                query->y = 1024;
+                if (query->panel_res)
+                        query->x = query->y = (1 << query->panel_res);
+                query->panel_res = W8001_TOUCH_RESOLUTION;
+        }
+}
+
+static void report_pen_events(struct w8001 *w8001, struct w8001_coord *coord)
+{
+        struct input_dev *dev = w8001->dev;
+
+        /*
+         * We have 1 bit for proximity (rdy) and 3 bits for tip, side,
+         * side2/eraser. If rdy && f2 are set, this can be either pen + side2,
+         * or eraser. Assume:
+         * - if dev is already in proximity and f2 is toggled → pen + side2
+         * - if dev comes into proximity with f2 set → eraser
+         * If f2 disappears after assuming eraser, fake proximity out for
+         * eraser and in for pen.
+         */
+
+        switch (w8001->type) {
+        case BTN_TOOL_RUBBER:
+                if (!coord->f2) {
+                        input_report_abs(dev, ABS_PRESSURE, 0);
+                        input_report_key(dev, BTN_TOUCH, 0);
+                        input_report_key(dev, BTN_STYLUS, 0);
+                        input_report_key(dev, BTN_STYLUS2, 0);
+                        input_report_key(dev, BTN_TOOL_RUBBER, 0);
+                        input_sync(dev);
+                        w8001->type = BTN_TOOL_PEN;
+                }
+                break;
+
+        case BTN_TOOL_FINGER:
+                input_report_key(dev, BTN_TOUCH, 0);
+                input_report_key(dev, BTN_TOOL_FINGER, 0);
+                input_sync(dev);
+                /* fall through */
+
+        case KEY_RESERVED:
+                w8001->type = coord->f2 ? BTN_TOOL_RUBBER : BTN_TOOL_PEN;
+                break;
+
+        default:
+                input_report_key(dev, BTN_STYLUS2, coord->f2);
+                break;
+        }
+
+        input_report_abs(dev, ABS_X, coord->x);
+        input_report_abs(dev, ABS_Y, coord->y);
+        input_report_abs(dev, ABS_PRESSURE, coord->pen_pressure);
+        input_report_key(dev, BTN_TOUCH, coord->tsw);
+        input_report_key(dev, BTN_STYLUS, coord->f1);
+        input_report_key(dev, w8001->type, coord->rdy);
+        input_sync(dev);
+
+        if (!coord->rdy)
+                w8001->type = KEY_RESERVED;
+}
+
+static void report_single_touch(struct w8001 *w8001, struct w8001_coord *coord)
+{
+        struct input_dev *dev = w8001->dev;
+        unsigned int x = coord->x;
+        unsigned int y = coord->y;
+
+        /* scale to pen maximum */
+        scale_touch_coordinates(w8001, &x, &y);
+
+        input_report_abs(dev, ABS_X, x);
+        input_report_abs(dev, ABS_Y, y);
+        input_report_key(dev, BTN_TOUCH, coord->tsw);
+        input_report_key(dev, BTN_TOOL_FINGER, coord->tsw);
+
+        input_sync(dev);
+
+        w8001->type = coord->tsw ? BTN_TOOL_FINGER : KEY_RESERVED;
+}
+
 static irqreturn_t w8001_interrupt(struct serio *serio,
                                    unsigned char data, unsigned int flags)
 {
         struct w8001 *w8001 = serio_get_drvdata(serio);
-        struct input_dev *dev = w8001->dev;
         struct w8001_coord coord;
         unsigned char tmp;
 
@@ -105,26 +295,54 @@ static irqreturn_t w8001_interrupt(struct serio *serio,
                 }
                 break;
 
-        case 8:
+        case W8001_PKTLEN_TOUCH93 - 1:
+        case W8001_PKTLEN_TOUCH9A - 1:
+                tmp = w8001->data[0] & W8001_TOUCH_BYTE;
+                if (tmp != W8001_TOUCH_BYTE)
+                        break;
+
+                if (w8001->pktlen == w8001->idx) {
+                        w8001->idx = 0;
+                        if (w8001->type != BTN_TOOL_PEN &&
+                            w8001->type != BTN_TOOL_RUBBER) {
+                                parse_single_touch(w8001->data, &coord);
+                                report_single_touch(w8001, &coord);
+                        }
+                }
+                break;
+
+        /* Pen coordinates packet */
+        case W8001_PKTLEN_TPCPEN - 1:
                 tmp = w8001->data[0] & W8001_TAB_MASK;
                 if (unlikely(tmp == W8001_TAB_BYTE))
                         break;
 
+                tmp = w8001->data[0] & W8001_TOUCH_BYTE;
+                if (tmp == W8001_TOUCH_BYTE)
+                        break;
+
                 w8001->idx = 0;
-                parse_data(w8001->data, &coord);
-                input_report_abs(dev, ABS_X, coord.x);
-                input_report_abs(dev, ABS_Y, coord.y);
-                input_report_abs(dev, ABS_PRESSURE, coord.pen_pressure);
-                input_report_key(dev, BTN_TOUCH, coord.tsw);
-                input_sync(dev);
+                parse_pen_data(w8001->data, &coord);
+                report_pen_events(w8001, &coord);
                 break;
 
-        case 10:
+        /* control packet */
+        case W8001_PKTLEN_TPCCTL - 1:
+                tmp = w8001->data[0] & W8001_TOUCH_MASK;
+                if (tmp == W8001_TOUCH_BYTE)
+                        break;
+
                 w8001->idx = 0;
                 memcpy(w8001->response, w8001->data, W8001_MAX_LENGTH);
                 w8001->response_type = W8001_QUERY_PACKET;
                 complete(&w8001->cmd_done);
                 break;
+
+        /* 2 finger touch packet */
+        case W8001_PKTLEN_TOUCH2FG - 1:
+                w8001->idx = 0;
+                parse_multi_touch(w8001);
+                break;
         }
 
         return IRQ_HANDLED;
@@ -153,19 +371,108 @@ static int w8001_setup(struct w8001 *w8001)
 {
         struct input_dev *dev = w8001->dev;
         struct w8001_coord coord;
+        struct w8001_touch_query touch;
         int error;
 
-        error = w8001_command(w8001, W8001_CMD_QUERY, true);
+        error = w8001_command(w8001, W8001_CMD_STOP, false);
         if (error)
                 return error;
 
-        parse_data(w8001->response, &coord);
+        msleep(250);    /* wait 250ms before querying the device */
+
+        dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
+        strlcat(w8001->name, "Wacom Serial", sizeof(w8001->name));
 
-        input_set_abs_params(dev, ABS_X, 0, coord.x, 0, 0);
-        input_set_abs_params(dev, ABS_Y, 0, coord.y, 0, 0);
-        input_set_abs_params(dev, ABS_PRESSURE, 0, coord.pen_pressure, 0, 0);
-        input_set_abs_params(dev, ABS_TILT_X, 0, coord.tilt_x, 0, 0);
-        input_set_abs_params(dev, ABS_TILT_Y, 0, coord.tilt_y, 0, 0);
+        /* penabled? */
+        error = w8001_command(w8001, W8001_CMD_QUERY, true);
+        if (!error) {
+                __set_bit(BTN_TOUCH, dev->keybit);
+                __set_bit(BTN_TOOL_PEN, dev->keybit);
+                __set_bit(BTN_TOOL_RUBBER, dev->keybit);
+                __set_bit(BTN_STYLUS, dev->keybit);
+                __set_bit(BTN_STYLUS2, dev->keybit);
+
+                parse_pen_data(w8001->response, &coord);
+                w8001->max_pen_x = coord.x;
+                w8001->max_pen_y = coord.y;
+
+                input_set_abs_params(dev, ABS_X, 0, coord.x, 0, 0);
+                input_set_abs_params(dev, ABS_Y, 0, coord.y, 0, 0);
+                input_abs_set_res(dev, ABS_X, W8001_PEN_RESOLUTION);
+                input_abs_set_res(dev, ABS_Y, W8001_PEN_RESOLUTION);
+                input_set_abs_params(dev, ABS_PRESSURE, 0, coord.pen_pressure, 0, 0);
+                if (coord.tilt_x && coord.tilt_y) {
+                        input_set_abs_params(dev, ABS_TILT_X, 0, coord.tilt_x, 0, 0);
+                        input_set_abs_params(dev, ABS_TILT_Y, 0, coord.tilt_y, 0, 0);
+                }
+                w8001->id = 0x90;
+                strlcat(w8001->name, " Penabled", sizeof(w8001->name));
+        }
+
+        /* Touch enabled? */
+        error = w8001_command(w8001, W8001_CMD_TOUCHQUERY, true);
+
+        /*
+         * Some non-touch devices may reply to the touch query. But their
+         * second byte is empty, which indicates touch is not supported.
+         */
+        if (!error && w8001->response[1]) {
+                __set_bit(BTN_TOUCH, dev->keybit);
+                __set_bit(BTN_TOOL_FINGER, dev->keybit);
+
+                parse_touchquery(w8001->response, &touch);
+                w8001->max_touch_x = touch.x;
+                w8001->max_touch_y = touch.y;
+
+                if (w8001->max_pen_x && w8001->max_pen_y) {
+                        /* if pen is supported scale to pen maximum */
+                        touch.x = w8001->max_pen_x;
+                        touch.y = w8001->max_pen_y;
+                        touch.panel_res = W8001_PEN_RESOLUTION;
+                }
+
+                input_set_abs_params(dev, ABS_X, 0, touch.x, 0, 0);
+                input_set_abs_params(dev, ABS_Y, 0, touch.y, 0, 0);
+                input_abs_set_res(dev, ABS_X, touch.panel_res);
+                input_abs_set_res(dev, ABS_Y, touch.panel_res);
+
+                switch (touch.sensor_id) {
+                case 0:
+                case 2:
+                        w8001->pktlen = W8001_PKTLEN_TOUCH93;
+                        w8001->id = 0x93;
+                        strlcat(w8001->name, " 1FG", sizeof(w8001->name));
+                        break;
+
+                case 1:
+                case 3:
+                case 4:
+                        w8001->pktlen = W8001_PKTLEN_TOUCH9A;
+                        strlcat(w8001->name, " 1FG", sizeof(w8001->name));
+                        w8001->id = 0x9a;
+                        break;
+
+                case 5:
+                        w8001->pktlen = W8001_PKTLEN_TOUCH2FG;
+
+                        input_mt_init_slots(dev, 2);
+                        input_set_abs_params(dev, ABS_MT_POSITION_X,
+                                                0, touch.x, 0, 0);
+                        input_set_abs_params(dev, ABS_MT_POSITION_Y,
+                                                0, touch.y, 0, 0);
+                        input_set_abs_params(dev, ABS_MT_TOOL_TYPE,
+                                                0, MT_TOOL_MAX, 0, 0);
+
+                        strlcat(w8001->name, " 2FG", sizeof(w8001->name));
+                        if (w8001->max_pen_x && w8001->max_pen_y)
+                                w8001->id = 0xE3;
+                        else
+                                w8001->id = 0xE2;
+                        break;
+                }
+        }
+
+        strlcat(w8001->name, " Touchscreen", sizeof(w8001->name));
 
         return w8001_command(w8001, W8001_CMD_START, false);
 }
@@ -206,22 +513,10 @@ static int w8001_connect(struct serio *serio, struct serio_driver *drv)
         }
 
         w8001->serio = serio;
-        w8001->id = serio->id.id;
         w8001->dev = input_dev;
         init_completion(&w8001->cmd_done);
         snprintf(w8001->phys, sizeof(w8001->phys), "%s/input0", serio->phys);
 
-        input_dev->name = "Wacom W8001 Penabled Serial TouchScreen";
-        input_dev->phys = w8001->phys;
-        input_dev->id.bustype = BUS_RS232;
-        input_dev->id.vendor = SERIO_W8001;
-        input_dev->id.product = w8001->id;
-        input_dev->id.version = 0x0100;
-        input_dev->dev.parent = &serio->dev;
-
-        input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
-        input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
-
         serio_set_drvdata(serio, w8001);
         err = serio_open(serio, drv);
         if (err)
@@ -231,6 +526,14 @@ static int w8001_connect(struct serio *serio, struct serio_driver *drv)
         if (err)
                 goto fail3;
 
+        input_dev->name = w8001->name;
+        input_dev->phys = w8001->phys;
+        input_dev->id.product = w8001->id;
+        input_dev->id.bustype = BUS_RS232;
+        input_dev->id.vendor = 0x056a;
+        input_dev->id.version = 0x0100;
+        input_dev->dev.parent = &serio->dev;
+
         err = input_register_device(w8001->dev);
         if (err)
                 goto fail3;
diff --git a/drivers/input/touchscreen/wm831x-ts.c b/drivers/input/touchscreen/wm831x-ts.c
new file mode 100644
index 000000000000..9175d49d2546
--- /dev/null
+++ b/drivers/input/touchscreen/wm831x-ts.c
@@ -0,0 +1,421 @@
+/*
+ * Touchscreen driver for WM831x PMICs
+ *
+ * Copyright 2011 Wolfson Microelectronics plc.
+ * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ */
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/string.h>
+#include <linux/pm.h>
+#include <linux/input.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/mfd/wm831x/core.h>
+#include <linux/mfd/wm831x/irq.h>
+#include <linux/mfd/wm831x/pdata.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/types.h>
+
+/*
+ * R16424 (0x4028) - Touch Control 1
+ */
+#define WM831X_TCH_ENA                          0x8000  /* TCH_ENA */
+#define WM831X_TCH_CVT_ENA                      0x4000  /* TCH_CVT_ENA */
+#define WM831X_TCH_SLPENA                       0x1000  /* TCH_SLPENA */
+#define WM831X_TCH_Z_ENA                        0x0400  /* TCH_Z_ENA */
+#define WM831X_TCH_Y_ENA                        0x0200  /* TCH_Y_ENA */
+#define WM831X_TCH_X_ENA                        0x0100  /* TCH_X_ENA */
+#define WM831X_TCH_DELAY_MASK                   0x00E0  /* TCH_DELAY - [7:5] */
+#define WM831X_TCH_DELAY_SHIFT                       5  /* TCH_DELAY - [7:5] */
+#define WM831X_TCH_DELAY_WIDTH                       3  /* TCH_DELAY - [7:5] */
+#define WM831X_TCH_RATE_MASK                    0x001F  /* TCH_RATE - [4:0] */
+#define WM831X_TCH_RATE_SHIFT                        0  /* TCH_RATE - [4:0] */
+#define WM831X_TCH_RATE_WIDTH                        5  /* TCH_RATE - [4:0] */
+
+/*
+ * R16425 (0x4029) - Touch Control 2
+ */
+#define WM831X_TCH_PD_WK                        0x2000  /* TCH_PD_WK */
+#define WM831X_TCH_5WIRE                        0x1000  /* TCH_5WIRE */
+#define WM831X_TCH_PDONLY                       0x0800  /* TCH_PDONLY */
+#define WM831X_TCH_ISEL                         0x0100  /* TCH_ISEL */
+#define WM831X_TCH_RPU_MASK                     0x000F  /* TCH_RPU - [3:0] */
+#define WM831X_TCH_RPU_SHIFT                         0  /* TCH_RPU - [3:0] */
+#define WM831X_TCH_RPU_WIDTH                         4  /* TCH_RPU - [3:0] */
+
+/*
+ * R16426-8 (0x402A-C) - Touch Data X/Y/X
+ */
+#define WM831X_TCH_PD                           0x8000  /* TCH_PD1 */
+#define WM831X_TCH_DATA_MASK                    0x0FFF  /* TCH_DATA - [11:0] */
+#define WM831X_TCH_DATA_SHIFT                        0  /* TCH_DATA - [11:0] */
+#define WM831X_TCH_DATA_WIDTH                       12  /* TCH_DATA - [11:0] */
+
+struct wm831x_ts {
+        struct input_dev *input_dev;
+        struct wm831x *wm831x;
+        unsigned int data_irq;
+        unsigned int pd_irq;
+        bool pressure;
+        bool pen_down;
+        struct work_struct pd_data_work;
+};
+
+static void wm831x_pd_data_work(struct work_struct *work)
+{
+        struct wm831x_ts *wm831x_ts =
+                container_of(work, struct wm831x_ts, pd_data_work);
+
+        if (wm831x_ts->pen_down) {
+                enable_irq(wm831x_ts->data_irq);
+                dev_dbg(wm831x_ts->wm831x->dev, "IRQ PD->DATA done\n");
+        } else {
+                enable_irq(wm831x_ts->pd_irq);
+                dev_dbg(wm831x_ts->wm831x->dev, "IRQ DATA->PD done\n");
+        }
+}
+
+static irqreturn_t wm831x_ts_data_irq(int irq, void *irq_data)
+{
+        struct wm831x_ts *wm831x_ts = irq_data;
+        struct wm831x *wm831x = wm831x_ts->wm831x;
+        static int data_types[] = { ABS_X, ABS_Y, ABS_PRESSURE };
+        u16 data[3];
+        int count;
+        int i, ret;
+
+        if (wm831x_ts->pressure)
+                count = 3;
+        else
+                count = 2;
+
+        wm831x_set_bits(wm831x, WM831X_INTERRUPT_STATUS_1,
+                        WM831X_TCHDATA_EINT, WM831X_TCHDATA_EINT);
+
+        ret = wm831x_bulk_read(wm831x, WM831X_TOUCH_DATA_X, count,
+                               data);
+        if (ret != 0) {
+                dev_err(wm831x->dev, "Failed to read touch data: %d\n",
+                        ret);
+                return IRQ_NONE;
+        }
+
+        /*
+         * We get a pen down reading on every reading, report pen up if any
+         * individual reading does so.
+         */
+        wm831x_ts->pen_down = true;
+        for (i = 0; i < count; i++) {
+                if (!(data[i] & WM831X_TCH_PD)) {
+                        wm831x_ts->pen_down = false;
+                        continue;
+                }
+                input_report_abs(wm831x_ts->input_dev, data_types[i],
+                                 data[i] & WM831X_TCH_DATA_MASK);
+        }
+
+        if (!wm831x_ts->pen_down) {
+                /* Switch from data to pen down */
+                dev_dbg(wm831x->dev, "IRQ DATA->PD\n");
+
+                disable_irq_nosync(wm831x_ts->data_irq);
+
+                /* Don't need data any more */
+                wm831x_set_bits(wm831x, WM831X_TOUCH_CONTROL_1,
+                                WM831X_TCH_X_ENA | WM831X_TCH_Y_ENA |
+                                WM831X_TCH_Z_ENA, 0);
+
+                /* Flush any final samples that arrived while reading */
+                wm831x_set_bits(wm831x, WM831X_INTERRUPT_STATUS_1,
+                                WM831X_TCHDATA_EINT, WM831X_TCHDATA_EINT);
+
+                wm831x_bulk_read(wm831x, WM831X_TOUCH_DATA_X, count, data);
+
+                if (wm831x_ts->pressure)
+                        input_report_abs(wm831x_ts->input_dev,
+                                         ABS_PRESSURE, 0);
+
+                input_report_key(wm831x_ts->input_dev, BTN_TOUCH, 0);
+
+                schedule_work(&wm831x_ts->pd_data_work);
+        } else {
+                input_report_key(wm831x_ts->input_dev, BTN_TOUCH, 1);
+        }
+
+        input_sync(wm831x_ts->input_dev);
+
+        return IRQ_HANDLED;
+}
+
+static irqreturn_t wm831x_ts_pen_down_irq(int irq, void *irq_data)
+{
+        struct wm831x_ts *wm831x_ts = irq_data;
+        struct wm831x *wm831x = wm831x_ts->wm831x;
+        int ena = 0;
+
+        if (wm831x_ts->pen_down)
+                return IRQ_HANDLED;
+
+        disable_irq_nosync(wm831x_ts->pd_irq);
+
+        /* Start collecting data */
+        if (wm831x_ts->pressure)
+                ena |= WM831X_TCH_Z_ENA;
+
+        wm831x_set_bits(wm831x, WM831X_TOUCH_CONTROL_1,
+                        WM831X_TCH_X_ENA | WM831X_TCH_Y_ENA | WM831X_TCH_Z_ENA,
+                        WM831X_TCH_X_ENA | WM831X_TCH_Y_ENA | ena);
+
+        wm831x_set_bits(wm831x, WM831X_INTERRUPT_STATUS_1,
+                        WM831X_TCHPD_EINT, WM831X_TCHPD_EINT);
+
+        wm831x_ts->pen_down = true;
+
+        /* Switch from pen down to data */
+        dev_dbg(wm831x->dev, "IRQ PD->DATA\n");
+        schedule_work(&wm831x_ts->pd_data_work);
+
+        return IRQ_HANDLED;
+}
+
+static int wm831x_ts_input_open(struct input_dev *idev)
+{
+        struct wm831x_ts *wm831x_ts = input_get_drvdata(idev);
+        struct wm831x *wm831x = wm831x_ts->wm831x;
+
+        wm831x_set_bits(wm831x, WM831X_TOUCH_CONTROL_1,
+                        WM831X_TCH_ENA | WM831X_TCH_CVT_ENA |
+                        WM831X_TCH_X_ENA | WM831X_TCH_Y_ENA |
+                        WM831X_TCH_Z_ENA, WM831X_TCH_ENA);
+
+        wm831x_set_bits(wm831x, WM831X_TOUCH_CONTROL_1,
+                        WM831X_TCH_CVT_ENA, WM831X_TCH_CVT_ENA);
+
+        return 0;
+}
+
+static void wm831x_ts_input_close(struct input_dev *idev)
+{
+        struct wm831x_ts *wm831x_ts = input_get_drvdata(idev);
+        struct wm831x *wm831x = wm831x_ts->wm831x;
+
+        /* Shut the controller down, disabling all other functionality too */
+        wm831x_set_bits(wm831x, WM831X_TOUCH_CONTROL_1,
+                        WM831X_TCH_ENA | WM831X_TCH_X_ENA |
+                        WM831X_TCH_Y_ENA | WM831X_TCH_Z_ENA, 0);
+
+        /* Make sure any pending IRQs are done, the above will prevent
+         * new ones firing.
+         */
+        synchronize_irq(wm831x_ts->data_irq);
+        synchronize_irq(wm831x_ts->pd_irq);
+
+        /* Make sure the IRQ completion work is quiesced */
+        flush_work_sync(&wm831x_ts->pd_data_work);
+
+        /* If we ended up with the pen down then make sure we revert back
+         * to pen detection state for the next time we start up.
+         */
+        if (wm831x_ts->pen_down) {
+                disable_irq(wm831x_ts->data_irq);
+                enable_irq(wm831x_ts->pd_irq);
+                wm831x_ts->pen_down = false;
+        }
+}
+
+static __devinit int wm831x_ts_probe(struct platform_device *pdev)
+{
+        struct wm831x_ts *wm831x_ts;
+        struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
+        struct wm831x_pdata *core_pdata = dev_get_platdata(pdev->dev.parent);
+        struct wm831x_touch_pdata *pdata = NULL;
+        struct input_dev *input_dev;
+        int error, irqf;
+
+        if (core_pdata)
+                pdata = core_pdata->touch;
+
+        wm831x_ts = kzalloc(sizeof(struct wm831x_ts), GFP_KERNEL);
+        input_dev = input_allocate_device();
+        if (!wm831x_ts || !input_dev) {
+                error = -ENOMEM;
+                goto err_alloc;
+        }
+
+        wm831x_ts->wm831x = wm831x;
+        wm831x_ts->input_dev = input_dev;
+        INIT_WORK(&wm831x_ts->pd_data_work, wm831x_pd_data_work);
+
+        /*
+         * If we have a direct IRQ use it, otherwise use the interrupt
+         * from the WM831x IRQ controller.
+         */
+        if (pdata && pdata->data_irq)
+                wm831x_ts->data_irq = pdata->data_irq;
+        else
+                wm831x_ts->data_irq = platform_get_irq_byname(pdev, "TCHDATA");
+
+        if (pdata && pdata->pd_irq)
+                wm831x_ts->pd_irq = pdata->pd_irq;
+        else
+                wm831x_ts->pd_irq = platform_get_irq_byname(pdev, "TCHPD");
+
+        if (pdata)
+                wm831x_ts->pressure = pdata->pressure;
+        else
+                wm831x_ts->pressure = true;
+
+        /* Five wire touchscreens can't report pressure */
+        if (pdata && pdata->fivewire) {
+                wm831x_set_bits(wm831x, WM831X_TOUCH_CONTROL_2,
+                                WM831X_TCH_5WIRE, WM831X_TCH_5WIRE);
+
+                /* Pressure measurements are not possible for five wire mode */
+                WARN_ON(pdata->pressure && pdata->fivewire);
+                wm831x_ts->pressure = false;
+        } else {
+                wm831x_set_bits(wm831x, WM831X_TOUCH_CONTROL_2,
+                                WM831X_TCH_5WIRE, 0);
+        }
+
+        if (pdata) {
+                switch (pdata->isel) {
+                default:
+                        dev_err(&pdev->dev, "Unsupported ISEL setting: %d\n",
+                                pdata->isel);
+                        /* Fall through */
+                case 200:
+                case 0:
+                        wm831x_set_bits(wm831x, WM831X_TOUCH_CONTROL_2,
+                                        WM831X_TCH_ISEL, 0);
+                        break;
+                case 400:
+                        wm831x_set_bits(wm831x, WM831X_TOUCH_CONTROL_2,
+                                        WM831X_TCH_ISEL, WM831X_TCH_ISEL);
+                        break;
+                }
+        }
+
+        wm831x_set_bits(wm831x, WM831X_TOUCH_CONTROL_2,
+                        WM831X_TCH_PDONLY, 0);
+
+        /* Default to 96 samples/sec */
+        wm831x_set_bits(wm831x, WM831X_TOUCH_CONTROL_1,
+                        WM831X_TCH_RATE_MASK, 6);
+
+        if (pdata && pdata->data_irqf)
+                irqf = pdata->data_irqf;
+        else
+                irqf = IRQF_TRIGGER_HIGH;
+
+        error = request_threaded_irq(wm831x_ts->data_irq,
+                                     NULL, wm831x_ts_data_irq,
+                                     irqf | IRQF_ONESHOT,
+                                     "Touchscreen data", wm831x_ts);
+        if (error) {
+                dev_err(&pdev->dev, "Failed to request data IRQ %d: %d\n",
+                        wm831x_ts->data_irq, error);
+                goto err_alloc;
+        }
+        disable_irq(wm831x_ts->data_irq);
+
+        if (pdata && pdata->pd_irqf)
+                irqf = pdata->pd_irqf;
+        else
+                irqf = IRQF_TRIGGER_HIGH;
+
+        error = request_threaded_irq(wm831x_ts->pd_irq,
+                                     NULL, wm831x_ts_pen_down_irq,
+                                     irqf | IRQF_ONESHOT,
+                                     "Touchscreen pen down", wm831x_ts);
+        if (error) {
+                dev_err(&pdev->dev, "Failed to request pen down IRQ %d: %d\n",
+                        wm831x_ts->pd_irq, error);
+                goto err_data_irq;
+        }
+
+        /* set up touch configuration */
+        input_dev->name = "WM831x touchscreen";
+        input_dev->phys = "wm831x";
+        input_dev->open = wm831x_ts_input_open;
+        input_dev->close = wm831x_ts_input_close;
+
+        __set_bit(EV_ABS, input_dev->evbit);
+        __set_bit(EV_KEY, input_dev->evbit);
+        __set_bit(BTN_TOUCH, input_dev->keybit);
+
+        input_set_abs_params(input_dev, ABS_X, 0, 4095, 5, 0);
+        input_set_abs_params(input_dev, ABS_Y, 0, 4095, 5, 0);
+        if (wm831x_ts->pressure)
+                input_set_abs_params(input_dev, ABS_PRESSURE, 0, 4095, 5, 0);
+
+        input_set_drvdata(input_dev, wm831x_ts);
+        input_dev->dev.parent = &pdev->dev;
+
+        error = input_register_device(input_dev);
+        if (error)
+                goto err_pd_irq;
+
+        platform_set_drvdata(pdev, wm831x_ts);
+        return 0;
+
+err_pd_irq:
+        free_irq(wm831x_ts->pd_irq, wm831x_ts);
+err_data_irq:
+        free_irq(wm831x_ts->data_irq, wm831x_ts);
+err_alloc:
+        input_free_device(input_dev);
+        kfree(wm831x_ts);
+
+        return error;
+}
+
+static __devexit int wm831x_ts_remove(struct platform_device *pdev)
+{
+        struct wm831x_ts *wm831x_ts = platform_get_drvdata(pdev);
+
+        free_irq(wm831x_ts->pd_irq, wm831x_ts);
+        free_irq(wm831x_ts->data_irq, wm831x_ts);
+        input_unregister_device(wm831x_ts->input_dev);
+        kfree(wm831x_ts);
+
+        platform_set_drvdata(pdev, NULL);
+        return 0;
+}
+
+static struct platform_driver wm831x_ts_driver = {
+        .driver = {
+                .name = "wm831x-touch",
+                .owner = THIS_MODULE,
+        },
+        .probe = wm831x_ts_probe,
+        .remove = __devexit_p(wm831x_ts_remove),
+};
+
+static int __init wm831x_ts_init(void)
+{
+        return platform_driver_register(&wm831x_ts_driver);
+}
+module_init(wm831x_ts_init);
+
+static void __exit wm831x_ts_exit(void)
+{
+        platform_driver_unregister(&wm831x_ts_driver);
+}
+module_exit(wm831x_ts_exit);
+
+/* Module information */
+MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
+MODULE_DESCRIPTION("WM831x PMIC touchscreen driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:wm831x-touch");
diff --git a/drivers/input/touchscreen/wm9705.c b/drivers/input/touchscreen/wm9705.c
index 6b5be742c27d..98e61175d3f5 100644
--- a/drivers/input/touchscreen/wm9705.c
+++ b/drivers/input/touchscreen/wm9705.c
@@ -306,7 +306,7 @@ static int wm9705_acc_enable(struct wm97xx *wm, int enable)
         dig2 = wm->dig[2];
 
         if (enable) {
-                /* continous mode */
+                /* continuous mode */
                 if (wm->mach_ops->acc_startup &&
                     (ret = wm->mach_ops->acc_startup(wm)) < 0)
                         return ret;
diff --git a/drivers/input/touchscreen/wm9712.c b/drivers/input/touchscreen/wm9712.c
index 7490b05c3566..2bc2fb801009 100644
--- a/drivers/input/touchscreen/wm9712.c
+++ b/drivers/input/touchscreen/wm9712.c
@@ -419,7 +419,7 @@ static int wm9712_acc_enable(struct wm97xx *wm, int enable)
         dig2 = wm->dig[2];
 
         if (enable) {
-                /* continous mode */
+                /* continuous mode */
                 if (wm->mach_ops->acc_startup) {
                         ret = wm->mach_ops->acc_startup(wm);
                         if (ret < 0)
diff --git a/drivers/input/touchscreen/wm9713.c b/drivers/input/touchscreen/wm9713.c
index 238b5132712e..73ec99568f12 100644
--- a/drivers/input/touchscreen/wm9713.c
+++ b/drivers/input/touchscreen/wm9713.c
@@ -431,7 +431,7 @@ static int wm9713_acc_enable(struct wm97xx *wm, int enable)
         dig3 = wm->dig[2];
 
         if (enable) {
-                /* continous mode */
+                /* continuous mode */
                 if (wm->mach_ops->acc_startup &&
                         (ret = wm->mach_ops->acc_startup(wm)) < 0)
                         return ret;
diff --git a/drivers/input/touchscreen/wm97xx-core.c b/drivers/input/touchscreen/wm97xx-core.c
index cbfef1ea7e30..5dbe73af2f8f 100644
--- a/drivers/input/touchscreen/wm97xx-core.c
+++ b/drivers/input/touchscreen/wm97xx-core.c
@@ -125,6 +125,8 @@ int wm97xx_read_aux_adc(struct wm97xx *wm, u16 adcsel)
 {
         int power_adc = 0, auxval;
         u16 power = 0;
+        int rc = 0;
+        int timeout = 0;
 
         /* get codec */
         mutex_lock(&wm->codec_mutex);
@@ -143,7 +145,9 @@ int wm97xx_read_aux_adc(struct wm97xx *wm, u16 adcsel)
 
         /* Turn polling mode on to read AUX ADC */
         wm->pen_probably_down = 1;
-        wm->codec->poll_sample(wm, adcsel, &auxval);
+
+        while (rc != RC_VALID && timeout++ < 5)
+                rc = wm->codec->poll_sample(wm, adcsel, &auxval);
 
         if (power_adc)
                 wm97xx_reg_write(wm, AC97_EXTENDED_MID, power | 0x8000);
@@ -152,8 +156,15 @@ int wm97xx_read_aux_adc(struct wm97xx *wm, u16 adcsel)
 
         wm->pen_probably_down = 0;
 
+        if (timeout >= 5) {
+                dev_err(wm->dev,
+                        "timeout reading auxadc %d, disabling digitiser\n",
+                        adcsel);
+                wm->codec->dig_enable(wm, false);
+        }
+
         mutex_unlock(&wm->codec_mutex);
-        return auxval & 0xfff;
+        return (rc == RC_VALID ? auxval & 0xfff : -EBUSY);
 }
 EXPORT_SYMBOL_GPL(wm97xx_read_aux_adc);
 
@@ -324,7 +335,7 @@ static void wm97xx_pen_irq_worker(struct work_struct *work)
          */
         if (!wm->mach_ops->acc_enabled || wm->mach_ops->acc_pen_down) {
                 if (wm->pen_is_down && !pen_was_down) {
-                        /* Data is not availiable immediately on pen down */
+                        /* Data is not available immediately on pen down */
                         queue_delayed_work(wm->ts_workq, &wm->ts_reader, 1);
                 }
 
@@ -343,7 +354,7 @@ static void wm97xx_pen_irq_worker(struct work_struct *work)
  * Codec PENDOWN irq handler
  *
  * We have to disable the codec interrupt in the handler because it
- * can take upto 1ms to clear the interrupt source. We schedule a task
+ * can take up to 1ms to clear the interrupt source. We schedule a task
  * in a work queue to do the actual interaction with the chip.  The
  * interrupt is then enabled again in the slow handler when the source
  * has been cleared.
@@ -684,8 +695,7 @@ static int wm97xx_probe(struct device *dev)
  touch_reg_err:
         platform_device_put(wm->touch_dev);
  touch_err:
-        platform_device_unregister(wm->battery_dev);
-        wm->battery_dev = NULL;
+        platform_device_del(wm->battery_dev);
  batt_reg_err:
         platform_device_put(wm->battery_dev);
  batt_err:
diff --git a/drivers/input/touchscreen/zylonite-wm97xx.c b/drivers/input/touchscreen/zylonite-wm97xx.c
index 048849867643..5b0f15ec874a 100644
--- a/drivers/input/touchscreen/zylonite-wm97xx.c
+++ b/drivers/input/touchscreen/zylonite-wm97xx.c
@@ -193,7 +193,7 @@ static int zylonite_wm97xx_probe(struct platform_device *pdev)
                 gpio_touch_irq = mfp_to_gpio(MFP_PIN_GPIO26);
 
         wm->pen_irq = IRQ_GPIO(gpio_touch_irq);
-        set_irq_type(IRQ_GPIO(gpio_touch_irq), IRQ_TYPE_EDGE_BOTH);
+        irq_set_irq_type(IRQ_GPIO(gpio_touch_irq), IRQ_TYPE_EDGE_BOTH);
 
         wm97xx_config_gpio(wm, WM97XX_GPIO_13, WM97XX_GPIO_IN,
                            WM97XX_GPIO_POL_HIGH,