200 files changed, 21353 insertions, 6216 deletions

diff --git a/drivers/input/evdev.c b/drivers/input/evdev.c
index 258c639571b5..e3f7fc6f9565 100644
--- a/drivers/input/evdev.c
+++ b/drivers/input/evdev.c
@@ -10,7 +10,8 @@
 
 #define EVDEV_MINOR_BASE        64
 #define EVDEV_MINORS            32
-#define EVDEV_BUFFER_SIZE       64
+#define EVDEV_MIN_BUFFER_SIZE   64U
+#define EVDEV_BUF_PACKETS       8
 
 #include <linux/poll.h>
 #include <linux/sched.h>
@@ -23,26 +24,27 @@
 #include "input-compat.h"
 
 struct evdev {
-        int exist;
         int open;
         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;
         struct device dev;
+        bool exist;
 };
 
 struct evdev_client {
-        struct input_event buffer[EVDEV_BUFFER_SIZE];
         int head;
         int tail;
         spinlock_t buffer_lock; /* protects access to buffer, head and tail */
         struct fasync_struct *fasync;
         struct evdev *evdev;
         struct list_head node;
+        int bufsize;
+        struct input_event buffer[];
 };
 
 static struct evdev *evdev_table[EVDEV_MINORS];
@@ -52,11 +54,15 @@ static void evdev_pass_event(struct evdev_client *client,
                              struct input_event *event)
 {
         /*
-         * Interrupts are disabled, just acquire the lock
+         * Interrupts are disabled, just acquire the lock.
+         * Make sure we don't leave with the client buffer
+         * "empty" by having client->head == client->tail.
          */
         spin_lock(&client->buffer_lock);
-        client->buffer[client->head++] = *event;
-        client->head &= EVDEV_BUFFER_SIZE - 1;
+        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)
@@ -242,11 +248,21 @@ static int evdev_release(struct inode *inode, struct file *file)
         return 0;
 }
 
+static unsigned int evdev_compute_buffer_size(struct input_dev *dev)
+{
+        unsigned int n_events =
+                max(dev->hint_events_per_packet * EVDEV_BUF_PACKETS,
+                    EVDEV_MIN_BUFFER_SIZE);
+
+        return roundup_pow_of_two(n_events);
+}
+
 static int evdev_open(struct inode *inode, struct file *file)
 {
         struct evdev *evdev;
         struct evdev_client *client;
         int i = iminor(inode) - EVDEV_MINOR_BASE;
+        unsigned int bufsize;
         int error;
 
         if (i >= EVDEV_MINORS)
@@ -263,12 +279,17 @@ static int evdev_open(struct inode *inode, struct file *file)
         if (!evdev)
                 return -ENODEV;
 
-        client = kzalloc(sizeof(struct evdev_client), GFP_KERNEL);
+        bufsize = evdev_compute_buffer_size(evdev->handle.dev);
+
+        client = kzalloc(sizeof(struct evdev_client) +
+                                bufsize * sizeof(struct input_event),
+                         GFP_KERNEL);
         if (!client) {
                 error = -ENOMEM;
                 goto err_put_evdev;
         }
 
+        client->bufsize = bufsize;
         spin_lock_init(&client->buffer_lock);
         client->evdev = evdev;
         evdev_attach_client(evdev, client);
@@ -278,6 +299,8 @@ static int evdev_open(struct inode *inode, struct file *file)
                 goto err_free_client;
 
         file->private_data = client;
+        nonseekable_open(inode, file);
+
         return 0;
 
  err_free_client:
@@ -332,7 +355,7 @@ static int evdev_fetch_next_event(struct evdev_client *client,
         have_event = client->head != client->tail;
         if (have_event) {
                 *event = client->buffer[client->tail++];
-                client->tail &= EVDEV_BUFFER_SIZE - 1;
+                client->tail &= client->bufsize - 1;
         }
 
         spin_unlock_irq(&client->buffer_lock);
@@ -380,10 +403,15 @@ static unsigned int evdev_poll(struct file *file, poll_table *wait)
 {
         struct evdev_client *client = file->private_data;
         struct evdev *evdev = client->evdev;
+        unsigned int mask;
 
         poll_wait(file, &evdev->wait, wait);
-        return ((client->head == client->tail) ? 0 : (POLLIN | POLLRDNORM)) |
-                (evdev->exist ? 0 : (POLLHUP | POLLERR));
+
+        mask = evdev->exist ? POLLOUT | POLLWRNORM : POLLHUP | POLLERR;
+        if (client->head != client->tail)
+                mask |= POLLIN | POLLRDNORM;
+
+        return mask;
 }
 
 #ifdef CONFIG_COMPAT
@@ -464,13 +492,15 @@ static int str_to_user(const char *str, unsigned int maxlen, void __user *p)
 }
 
 #define OLD_KEY_MAX     0x1ff
-static int handle_eviocgbit(struct input_dev *dev, unsigned int cmd, void __user *p, int compat_mode)
+static int handle_eviocgbit(struct input_dev *dev,
+                            unsigned int type, unsigned int size,
+                            void __user *p, int compat_mode)
 {
         static unsigned long keymax_warn_time;
         unsigned long *bits;
         int len;
 
-        switch (_IOC_NR(cmd) & EV_MAX) {
+        switch (type) {
 
         case      0: bits = dev->evbit;  len = EV_MAX;  break;
         case EV_KEY: bits = dev->keybit; len = KEY_MAX; break;
@@ -489,7 +519,7 @@ static int handle_eviocgbit(struct input_dev *dev, unsigned int cmd, void __user
          * EVIOCGBIT(EV_KEY, KEY_MAX) and not realize that 'len'
          * should be in bytes, not in bits.
          */
-        if ((_IOC_NR(cmd) & EV_MAX) == EV_KEY && _IOC_SIZE(cmd) == OLD_KEY_MAX) {
+        if (type == EV_KEY && size == OLD_KEY_MAX) {
                 len = OLD_KEY_MAX;
                 if (printk_timed_ratelimit(&keymax_warn_time, 10 * 1000))
                         printk(KERN_WARNING
@@ -500,10 +530,84 @@ static int handle_eviocgbit(struct input_dev *dev, unsigned int cmd, void __user
                                 BITS_TO_LONGS(OLD_KEY_MAX) * sizeof(long));
         }
 
-        return bits_to_user(bits, len, _IOC_SIZE(cmd), p, compat_mode);
+        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, size_t size)
+{
+        struct input_keymap_entry ke;
+        int error;
+
+        memset(&ke, 0, sizeof(ke));
+
+        if (size == sizeof(unsigned int[2])) {
+                /* legacy case */
+                int __user *ip = (int __user *)p;
+
+                if (copy_from_user(ke.scancode, p, sizeof(unsigned int)))
+                        return -EFAULT;
+
+                ke.len = sizeof(unsigned int);
+                ke.flags = 0;
+
+                error = input_get_keycode(dev, &ke);
+                if (error)
+                        return error;
+
+                if (put_user(ke.keycode, ip + 1))
+                        return -EFAULT;
+
+        } else {
+                size = min(size, sizeof(ke));
+
+                if (copy_from_user(&ke, p, size))
+                        return -EFAULT;
+
+                error = input_get_keycode(dev, &ke);
+                if (error)
+                        return error;
+
+                if (copy_to_user(p, &ke, size))
+                        return -EFAULT;
+        }
+        return 0;
+}
+
+static int evdev_handle_set_keycode(struct input_dev *dev,
+                                    void __user *p, size_t size)
+{
+        struct input_keymap_entry ke;
+
+        memset(&ke, 0, sizeof(ke));
+
+        if (size == sizeof(unsigned int[2])) {
+                /* legacy case */
+                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;
+
+                ke.len = sizeof(unsigned int);
+                ke.flags = 0;
+
+        } else {
+                size = min(size, sizeof(ke));
+
+                if (copy_from_user(&ke, p, size))
+                        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)
 {
@@ -513,9 +617,11 @@ static long evdev_do_ioctl(struct file *file, unsigned int cmd,
         struct input_absinfo abs;
         struct ff_effect effect;
         int __user *ip = (int __user *)p;
-        int i, t, u, v;
+        unsigned int i, t, u, v;
+        unsigned int size;
         int error;
 
+        /* First we check for fixed-length commands */
         switch (cmd) {
 
         case EVIOCGVERSION:
@@ -548,25 +654,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);
 
@@ -582,108 +669,113 @@ static long evdev_do_ioctl(struct file *file, unsigned int cmd,
                         return evdev_grab(evdev, client);
                 else
                         return evdev_ungrab(evdev, client);
+        }
 
-        default:
+        size = _IOC_SIZE(cmd);
 
-                if (_IOC_TYPE(cmd) != 'E')
-                        return -EINVAL;
+        /* Now check variable-length commands */
+#define EVIOC_MASK_SIZE(nr)     ((nr) & ~(_IOC_SIZEMASK << _IOC_SIZESHIFT))
+        switch (EVIOC_MASK_SIZE(cmd)) {
 
-                if (_IOC_DIR(cmd) == _IOC_READ) {
+        case EVIOCGKEY(0):
+                return bits_to_user(dev->key, KEY_MAX, size, p, compat_mode);
 
-                        if ((_IOC_NR(cmd) & ~EV_MAX) == _IOC_NR(EVIOCGBIT(0, 0)))
-                                return handle_eviocgbit(dev, cmd, p, compat_mode);
+        case EVIOCGLED(0):
+                return bits_to_user(dev->led, LED_MAX, size, p, compat_mode);
 
-                        if (_IOC_NR(cmd) == _IOC_NR(EVIOCGKEY(0)))
-                                return bits_to_user(dev->key, KEY_MAX, _IOC_SIZE(cmd),
-                                                    p, compat_mode);
+        case EVIOCGSND(0):
+                return bits_to_user(dev->snd, SND_MAX, size, p, compat_mode);
 
-                        if (_IOC_NR(cmd) == _IOC_NR(EVIOCGLED(0)))
-                                return bits_to_user(dev->led, LED_MAX, _IOC_SIZE(cmd),
-                                                    p, compat_mode);
+        case EVIOCGSW(0):
+                return bits_to_user(dev->sw, SW_MAX, size, p, compat_mode);
 
-                        if (_IOC_NR(cmd) == _IOC_NR(EVIOCGSND(0)))
-                                return bits_to_user(dev->snd, SND_MAX, _IOC_SIZE(cmd),
-                                                    p, compat_mode);
+        case EVIOCGNAME(0):
+                return str_to_user(dev->name, size, p);
 
-                        if (_IOC_NR(cmd) == _IOC_NR(EVIOCGSW(0)))
-                                return bits_to_user(dev->sw, SW_MAX, _IOC_SIZE(cmd),
-                                                    p, compat_mode);
+        case EVIOCGPHYS(0):
+                return str_to_user(dev->phys, size, p);
 
-                        if (_IOC_NR(cmd) == _IOC_NR(EVIOCGNAME(0)))
-                                return str_to_user(dev->name, _IOC_SIZE(cmd), p);
+        case EVIOCGUNIQ(0):
+                return str_to_user(dev->uniq, size, p);
 
-                        if (_IOC_NR(cmd) == _IOC_NR(EVIOCGPHYS(0)))
-                                return str_to_user(dev->phys, _IOC_SIZE(cmd), p);
+        case EVIOC_MASK_SIZE(EVIOCSFF):
+                if (input_ff_effect_from_user(p, size, &effect))
+                        return -EFAULT;
 
-                        if (_IOC_NR(cmd) == _IOC_NR(EVIOCGUNIQ(0)))
-                                return str_to_user(dev->uniq, _IOC_SIZE(cmd), p);
+                error = input_ff_upload(dev, &effect, file);
 
-                        if ((_IOC_NR(cmd) & ~ABS_MAX) == _IOC_NR(EVIOCGABS(0))) {
+                if (put_user(effect.id, &(((struct ff_effect __user *)p)->id)))
+                        return -EFAULT;
 
-                                t = _IOC_NR(cmd) & ABS_MAX;
+                return error;
 
-                                abs.value = dev->abs[t];
-                                abs.minimum = dev->absmin[t];
-                                abs.maximum = dev->absmax[t];
-                                abs.fuzz = dev->absfuzz[t];
-                                abs.flat = dev->absflat[t];
-                                abs.resolution = dev->absres[t];
+        case EVIOC_MASK_SIZE(EVIOCGKEYCODE):
+                return evdev_handle_get_keycode(dev, p, size);
 
-                                if (copy_to_user(p, &abs, min_t(size_t,
-                                                                _IOC_SIZE(cmd),
-                                                                sizeof(struct input_absinfo))))
-                                        return -EFAULT;
+        case EVIOC_MASK_SIZE(EVIOCSKEYCODE):
+                return evdev_handle_set_keycode(dev, p, size);
+        }
 
-                                return 0;
-                        }
+        /* Multi-number variable-length handlers */
+        if (_IOC_TYPE(cmd) != 'E')
+                return -EINVAL;
 
-                }
+        if (_IOC_DIR(cmd) == _IOC_READ) {
 
-                if (_IOC_DIR(cmd) == _IOC_WRITE) {
+                if ((_IOC_NR(cmd) & ~EV_MAX) == _IOC_NR(EVIOCGBIT(0, 0)))
+                        return handle_eviocgbit(dev,
+                                                _IOC_NR(cmd) & EV_MAX, size,
+                                                p, compat_mode);
 
-                        if (_IOC_NR(cmd) == _IOC_NR(EVIOCSFF)) {
+                if ((_IOC_NR(cmd) & ~ABS_MAX) == _IOC_NR(EVIOCGABS(0))) {
 
-                                if (input_ff_effect_from_user(p, _IOC_SIZE(cmd), &effect))
-                                        return -EFAULT;
+                        if (!dev->absinfo)
+                                return -EINVAL;
 
-                                error = input_ff_upload(dev, &effect, file);
+                        t = _IOC_NR(cmd) & ABS_MAX;
+                        abs = dev->absinfo[t];
 
-                                if (put_user(effect.id, &(((struct ff_effect __user *)p)->id)))
-                                        return -EFAULT;
+                        if (copy_to_user(p, &abs, min_t(size_t,
+                                        size, sizeof(struct input_absinfo))))
+                                return -EFAULT;
 
-                                return error;
-                        }
+                        return 0;
+                }
+        }
 
-                        if ((_IOC_NR(cmd) & ~ABS_MAX) == _IOC_NR(EVIOCSABS(0))) {
+        if (_IOC_DIR(cmd) == _IOC_WRITE) {
 
-                                t = _IOC_NR(cmd) & ABS_MAX;
+                if ((_IOC_NR(cmd) & ~ABS_MAX) == _IOC_NR(EVIOCSABS(0))) {
 
-                                if (copy_from_user(&abs, p, min_t(size_t,
-                                                                  _IOC_SIZE(cmd),
-                                                                  sizeof(struct input_absinfo))))
-                                        return -EFAULT;
+                        if (!dev->absinfo)
+                                return -EINVAL;
 
-                                /*
-                                 * Take event lock to ensure that we are not
-                                 * changing device parameters in the middle
-                                 * of event.
-                                 */
-                                spin_lock_irq(&dev->event_lock);
+                        t = _IOC_NR(cmd) & ABS_MAX;
 
-                                dev->abs[t] = abs.value;
-                                dev->absmin[t] = abs.minimum;
-                                dev->absmax[t] = abs.maximum;
-                                dev->absfuzz[t] = abs.fuzz;
-                                dev->absflat[t] = abs.flat;
-                                dev->absres[t] = _IOC_SIZE(cmd) < sizeof(struct input_absinfo) ?
-                                                        0 : abs.resolution;
+                        if (copy_from_user(&abs, p, min_t(size_t,
+                                        size, sizeof(struct input_absinfo))))
+                                return -EFAULT;
+
+                        if (size < sizeof(struct input_absinfo))
+                                abs.resolution = 0;
 
-                                spin_unlock_irq(&dev->event_lock);
+                        /* We can't change number of reserved MT slots */
+                        if (t == ABS_MT_SLOT)
+                                return -EINVAL;
 
-                                return 0;
-                        }
+                        /*
+                         * Take event lock to ensure that we are not
+                         * changing device parameters in the middle
+                         * of event.
+                         */
+                        spin_lock_irq(&dev->event_lock);
+                        dev->absinfo[t] = abs;
+                        spin_unlock_irq(&dev->event_lock);
+
+                        return 0;
                 }
         }
+
         return -EINVAL;
 }
 
@@ -735,7 +827,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)
@@ -766,7 +859,7 @@ static void evdev_remove_chrdev(struct evdev *evdev)
 static void evdev_mark_dead(struct evdev *evdev)
 {
         mutex_lock(&evdev->mutex);
-        evdev->exist = 0;
+        evdev->exist = false;
         mutex_unlock(&evdev->mutex);
 }
 
@@ -815,7 +908,7 @@ static int evdev_connect(struct input_handler *handler, struct input_dev *dev,
         init_waitqueue_head(&evdev->wait);
 
         dev_set_name(&evdev->dev, "event%d", minor);
-        evdev->exist = 1;
+        evdev->exist = true;
         evdev->minor = minor;
 
         evdev->handle.dev = input_get_device(dev);
diff --git a/drivers/input/ff-core.c b/drivers/input/ff-core.c
index b2f07aa1604b..03078c08309a 100644
--- a/drivers/input/ff-core.c
+++ b/drivers/input/ff-core.c
@@ -29,6 +29,7 @@
 #include <linux/module.h>
 #include <linux/mutex.h>
 #include <linux/sched.h>
+#include <linux/slab.h>
 
 /*
  * Check that the effect_id is a valid effect and whether the user
diff --git a/drivers/input/ff-memless.c b/drivers/input/ff-memless.c
index f967008f332e..1d881c96ba8f 100644
--- a/drivers/input/ff-memless.c
+++ b/drivers/input/ff-memless.c
@@ -25,6 +25,7 @@
 
 #define debug(format, arg...) pr_debug("ff-memless: " format "\n", ## arg)
 
+#include <linux/slab.h>
 #include <linux/input.h>
 #include <linux/module.h>
 #include <linux/mutex.h>
diff --git a/drivers/input/gameport/emu10k1-gp.c b/drivers/input/gameport/emu10k1-gp.c
index b04930f7ea7d..422aa0a6b77f 100644
--- a/drivers/input/gameport/emu10k1-gp.c
+++ b/drivers/input/gameport/emu10k1-gp.c
@@ -46,7 +46,7 @@ struct emu {
         int size;
 };
 
-static struct pci_device_id emu_tbl[] = {
+static const struct pci_device_id emu_tbl[] = {
 
         { 0x1102, 0x7002, PCI_ANY_ID, PCI_ANY_ID }, /* SB Live gameport */
         { 0x1102, 0x7003, PCI_ANY_ID, PCI_ANY_ID }, /* Audigy gameport */
@@ -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 8a1810f88b9e..a3b70ff21018 100644
--- a/drivers/input/gameport/fm801-gp.c
+++ b/drivers/input/gameport/fm801-gp.c
@@ -133,14 +133,14 @@ 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 struct pci_device_id fm801_gp_id_table[] = {
+static const struct pci_device_id fm801_gp_id_table[] = {
         { PCI_VENDOR_ID_FORTEMEDIA, PCI_DEVICE_ID_FM801_GP, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0  },
         { 0 }
 };
diff --git a/drivers/input/gameport/gameport.c b/drivers/input/gameport/gameport.c
index ac11be08585e..46239e47a260 100644
--- a/drivers/input/gameport/gameport.c
+++ b/drivers/input/gameport/gameport.c
@@ -11,6 +11,8 @@
  * the Free Software Foundation.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/stddef.h>
 #include <linux/module.h>
 #include <linux/ioport.h>
@@ -57,11 +59,11 @@ static unsigned int get_time_pit(void)
         unsigned long flags;
         unsigned int count;
 
-        spin_lock_irqsave(&i8253_lock, flags);
+        raw_spin_lock_irqsave(&i8253_lock, flags);
         outb_p(0x00, 0x43);
         count = inb_p(0x40);
         count |= inb_p(0x40) << 8;
-        spin_unlock_irqrestore(&i8253_lock, flags);
+        raw_spin_unlock_irqrestore(&i8253_lock, flags);
 
         return count;
 }
@@ -190,9 +192,8 @@ static int gameport_bind_driver(struct gameport *gameport, struct gameport_drive
 
         error = device_bind_driver(&gameport->dev);
         if (error) {
-                printk(KERN_WARNING
-                        "gameport: device_bind_driver() failed "
-                        "for %s (%s) and %s, error: %d\n",
+                dev_warn(&gameport->dev,
+                         "device_bind_driver() failed for %s (%s) and %s, error: %d\n",
                         gameport->phys, gameport->name,
                         drv->description, error);
                 drv->disconnect(gameport);
@@ -209,9 +210,9 @@ static void gameport_find_driver(struct gameport *gameport)
 
         error = device_attach(&gameport->dev);
         if (error < 0)
-                printk(KERN_WARNING
-                        "gameport: device_attach() failed for %s (%s), error: %d\n",
-                        gameport->phys, gameport->name, error);
+                dev_warn(&gameport->dev,
+                         "device_attach() failed for %s (%s), error: %d\n",
+                         gameport->phys, gameport->name, error);
 }
 
 
@@ -262,17 +263,14 @@ static int gameport_queue_event(void *object, struct module *owner,
 
         event = kmalloc(sizeof(struct gameport_event), GFP_ATOMIC);
         if (!event) {
-                printk(KERN_ERR
-                        "gameport: Not enough memory to queue event %d\n",
-                        event_type);
+                pr_err("Not enough memory to queue event %d\n", event_type);
                 retval = -ENOMEM;
                 goto out;
         }
 
         if (!try_module_get(owner)) {
-                printk(KERN_WARNING
-                        "gameport: Can't get module reference, dropping event %d\n",
-                        event_type);
+                pr_warning("Can't get module reference, dropping event %d\n",
+                           event_type);
                 kfree(event);
                 retval = -EINVAL;
                 goto out;
@@ -298,14 +296,12 @@ static void gameport_free_event(struct gameport_event *event)
 
 static void gameport_remove_duplicate_events(struct gameport_event *event)
 {
-        struct list_head *node, *next;
-        struct gameport_event *e;
+        struct gameport_event *e, *next;
         unsigned long flags;
 
         spin_lock_irqsave(&gameport_event_lock, flags);
 
-        list_for_each_safe(node, next, &gameport_event_list) {
-                e = list_entry(node, struct gameport_event, node);
+        list_for_each_entry_safe(e, next, &gameport_event_list, node) {
                 if (event->object == e->object) {
                         /*
                          * If this event is of different type we should not
@@ -315,7 +311,7 @@ static void gameport_remove_duplicate_events(struct gameport_event *event)
                         if (event->type != e->type)
                                 break;
 
-                        list_del_init(node);
+                        list_del_init(&e->node);
                         gameport_free_event(e);
                 }
         }
@@ -325,23 +321,18 @@ static void gameport_remove_duplicate_events(struct gameport_event *event)
 
 static struct gameport_event *gameport_get_event(void)
 {
-        struct gameport_event *event;
-        struct list_head *node;
+        struct gameport_event *event = NULL;
         unsigned long flags;
 
         spin_lock_irqsave(&gameport_event_lock, flags);
 
-        if (list_empty(&gameport_event_list)) {
-                spin_unlock_irqrestore(&gameport_event_lock, flags);
-                return NULL;
+        if (!list_empty(&gameport_event_list)) {
+                event = list_first_entry(&gameport_event_list,
+                                         struct gameport_event, node);
+                list_del_init(&event->node);
         }
 
-        node = gameport_event_list.next;
-        event = list_entry(node, struct gameport_event, node);
-        list_del_init(node);
-
         spin_unlock_irqrestore(&gameport_event_lock, flags);
-
         return event;
 }
 
@@ -360,16 +351,14 @@ static void gameport_handle_event(void)
         if ((event = gameport_get_event())) {
 
                 switch (event->type) {
-                        case GAMEPORT_REGISTER_PORT:
-                                gameport_add_port(event->object);
-                                break;
 
-                        case GAMEPORT_ATTACH_DRIVER:
-                                gameport_attach_driver(event->object);
-                                break;
+                case GAMEPORT_REGISTER_PORT:
+                        gameport_add_port(event->object);
+                        break;
 
-                        default:
-                                break;
+                case GAMEPORT_ATTACH_DRIVER:
+                        gameport_attach_driver(event->object);
+                        break;
                 }
 
                 gameport_remove_duplicate_events(event);
@@ -385,16 +374,14 @@ static void gameport_handle_event(void)
  */
 static void gameport_remove_pending_events(void *object)
 {
-        struct list_head *node, *next;
-        struct gameport_event *event;
+        struct gameport_event *event, *next;
         unsigned long flags;
 
         spin_lock_irqsave(&gameport_event_lock, flags);
 
-        list_for_each_safe(node, next, &gameport_event_list) {
-                event = list_entry(node, struct gameport_event, node);
+        list_for_each_entry_safe(event, next, &gameport_event_list, node) {
                 if (event->object == object) {
-                        list_del_init(node);
+                        list_del_init(&event->node);
                         gameport_free_event(event);
                 }
         }
@@ -441,7 +428,6 @@ static int gameport_thread(void *nothing)
                         kthread_should_stop() || !list_empty(&gameport_event_list));
         } while (!kthread_should_stop());
 
-        printk(KERN_DEBUG "gameport: kgameportd exiting\n");
         return 0;
 }
 
@@ -453,6 +439,7 @@ static int gameport_thread(void *nothing)
 static ssize_t gameport_show_description(struct device *dev, struct device_attribute *attr, char *buf)
 {
         struct gameport *gameport = to_gameport_port(dev);
+
         return sprintf(buf, "%s\n", gameport->name);
 }
 
@@ -521,7 +508,8 @@ static void gameport_init_port(struct gameport *gameport)
 
         mutex_init(&gameport->drv_mutex);
         device_initialize(&gameport->dev);
-        dev_set_name(&gameport->dev, "gameport%lu", (unsigned long)atomic_inc_return(&gameport_no) - 1);
+        dev_set_name(&gameport->dev, "gameport%lu",
+                        (unsigned long)atomic_inc_return(&gameport_no) - 1);
         gameport->dev.bus = &gameport_bus;
         gameport->dev.release = gameport_release_port;
         if (gameport->parent)
@@ -550,19 +538,17 @@ static void gameport_add_port(struct gameport *gameport)
         list_add_tail(&gameport->node, &gameport_list);
 
         if (gameport->io)
-                printk(KERN_INFO "gameport: %s is %s, io %#x, speed %dkHz\n",
-                        gameport->name, gameport->phys, gameport->io, gameport->speed);
+                dev_info(&gameport->dev, "%s is %s, io %#x, speed %dkHz\n",
+                         gameport->name, gameport->phys, gameport->io, gameport->speed);
         else
-                printk(KERN_INFO "gameport: %s is %s, speed %dkHz\n",
+                dev_info(&gameport->dev, "%s is %s, speed %dkHz\n",
                         gameport->name, gameport->phys, gameport->speed);
 
         error = device_add(&gameport->dev);
         if (error)
-                printk(KERN_ERR
-                        "gameport: device_add() failed for %s (%s), error: %d\n",
+                dev_err(&gameport->dev,
+                        "device_add() failed for %s (%s), error: %d\n",
                         gameport->phys, gameport->name, error);
-        else
-                gameport->registered = 1;
 }
 
 /*
@@ -584,10 +570,8 @@ static void gameport_destroy_port(struct gameport *gameport)
                 gameport->parent = NULL;
         }
 
-        if (gameport->registered) {
+        if (device_is_registered(&gameport->dev))
                 device_del(&gameport->dev);
-                gameport->registered = 0;
-        }
 
         list_del_init(&gameport->node);
 
@@ -705,8 +689,7 @@ static void gameport_attach_driver(struct gameport_driver *drv)
 
         error = driver_attach(&drv->driver);
         if (error)
-                printk(KERN_ERR
-                        "gameport: driver_attach() failed for %s, error: %d\n",
+                pr_err("driver_attach() failed for %s, error: %d\n",
                         drv->driver.name, error);
 }
 
@@ -727,8 +710,7 @@ int __gameport_register_driver(struct gameport_driver *drv, struct module *owner
 
         error = driver_register(&drv->driver);
         if (error) {
-                printk(KERN_ERR
-                        "gameport: driver_register() failed for %s, error: %d\n",
+                pr_err("driver_register() failed for %s, error: %d\n",
                         drv->driver.name, error);
                 return error;
         }
@@ -828,7 +810,7 @@ static int __init gameport_init(void)
 
         error = bus_register(&gameport_bus);
         if (error) {
-                printk(KERN_ERR "gameport: failed to register gameport bus, error: %d\n", error);
+                pr_err("failed to register gameport bus, error: %d\n", error);
                 return error;
         }
 
@@ -836,7 +818,7 @@ static int __init gameport_init(void)
         if (IS_ERR(gameport_task)) {
                 bus_unregister(&gameport_bus);
                 error = PTR_ERR(gameport_task);
-                printk(KERN_ERR "gameport: Failed to start kgameportd, error: %d\n", error);
+                pr_err("Failed to start kgameportd, error: %d\n", error);
                 return error;
         }
 
diff --git a/drivers/input/gameport/lightning.c b/drivers/input/gameport/lightning.c
index 06ad36ed3483..85d6ee09f11f 100644
--- a/drivers/input/gameport/lightning.c
+++ b/drivers/input/gameport/lightning.c
@@ -34,7 +34,6 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/gameport.h>
-#include <linux/slab.h>
 
 #define L4_PORT                 0x201
 #define L4_SELECT_ANALOG        0xa4
diff --git a/drivers/input/gameport/ns558.c b/drivers/input/gameport/ns558.c
index db556b71ddda..7c217848613e 100644
--- a/drivers/input/gameport/ns558.c
+++ b/drivers/input/gameport/ns558.c
@@ -166,7 +166,7 @@ static int ns558_isa_probe(int io)
 
 #ifdef CONFIG_PNP
 
-static struct pnp_device_id pnp_devids[] = {
+static const struct pnp_device_id pnp_devids[] = {
         { .id = "@P@0001", .driver_data = 0 }, /* ALS 100 */
         { .id = "@P@0020", .driver_data = 0 }, /* ALS 200 */
         { .id = "@P@1001", .driver_data = 0 }, /* ALS 100+ */
diff --git a/drivers/input/input-compat.h b/drivers/input/input-compat.h
index 47cd9eaee66a..4d8ea32e8a00 100644
--- a/drivers/input/input-compat.h
+++ b/drivers/input/input-compat.h
@@ -21,8 +21,6 @@
    you why the ifdefs are needed? Think about it again. -AK */
 #ifdef CONFIG_X86_64
 #  define INPUT_COMPAT_TEST is_compat_task()
-#elif defined(CONFIG_IA64)
-#  define INPUT_COMPAT_TEST IS_IA32_PROCESS(task_pt_regs(current))
 #elif defined(CONFIG_S390)
 #  define INPUT_COMPAT_TEST test_thread_flag(TIF_31BIT)
 #elif defined(CONFIG_MIPS)
diff --git a/drivers/input/input-polldev.c b/drivers/input/input-polldev.c
index aa6713b4a988..10c9b0a845f0 100644
--- a/drivers/input/input-polldev.c
+++ b/drivers/input/input-polldev.c
@@ -9,6 +9,7 @@
  */
 
 #include <linux/jiffies.h>
+#include <linux/slab.h>
 #include <linux/mutex.h>
 #include <linux/input-polldev.h>
 
@@ -100,6 +101,12 @@ 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)
diff --git a/drivers/input/input.c b/drivers/input/input.c
index 86cb2d2196ff..d092ef9291da 100644
--- a/drivers/input/input.c
+++ b/drivers/input/input.c
@@ -14,6 +14,7 @@
 #include <linux/types.h>
 #include <linux/input.h>
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/random.h>
 #include <linux/major.h>
 #include <linux/proc_fs.h>
@@ -32,25 +33,6 @@ MODULE_LICENSE("GPL");
 
 #define INPUT_DEVICES   256
 
-/*
- * EV_ABS events which should not be cached are listed here.
- */
-static unsigned int input_abs_bypass_init_data[] __initdata = {
-        ABS_MT_TOUCH_MAJOR,
-        ABS_MT_TOUCH_MINOR,
-        ABS_MT_WIDTH_MAJOR,
-        ABS_MT_WIDTH_MINOR,
-        ABS_MT_ORIENTATION,
-        ABS_MT_POSITION_X,
-        ABS_MT_POSITION_Y,
-        ABS_MT_TOOL_TYPE,
-        ABS_MT_BLOB_ID,
-        ABS_MT_TRACKING_ID,
-        ABS_MT_PRESSURE,
-        0
-};
-static unsigned long input_abs_bypass[BITS_TO_LONGS(ABS_CNT)];
-
 static LIST_HEAD(input_dev_list);
 static LIST_HEAD(input_handler_list);
 
@@ -87,12 +69,14 @@ static int input_defuzz_abs_event(int value, int old_val, int fuzz)
 }
 
 /*
- * Pass event through all open handles. This function is called with
+ * Pass event first through all filters and then, if event has not been
+ * filtered out, through all open handles. This function is called with
  * dev->event_lock held and interrupts disabled.
  */
 static void input_pass_event(struct input_dev *dev,
                              unsigned int type, unsigned int code, int value)
 {
+        struct input_handler *handler;
         struct input_handle *handle;
 
         rcu_read_lock();
@@ -100,11 +84,25 @@ static void input_pass_event(struct input_dev *dev,
         handle = rcu_dereference(dev->grab);
         if (handle)
                 handle->handler->event(handle, type, code, value);
-        else
-                list_for_each_entry_rcu(handle, &dev->h_list, d_node)
-                        if (handle->open)
-                                handle->handler->event(handle,
-                                                        type, code, value);
+        else {
+                bool filtered = false;
+
+                list_for_each_entry_rcu(handle, &dev->h_list, d_node) {
+                        if (!handle->open)
+                                continue;
+
+                        handler = handle->handler;
+                        if (!handler->filter) {
+                                if (filtered)
+                                        break;
+
+                                handler->event(handle, type, code, value);
+
+                        } else if (handler->filter(handle, type, code, value))
+                                filtered = true;
+                }
+        }
+
         rcu_read_unlock();
 }
 
@@ -164,6 +162,56 @@ static void input_stop_autorepeat(struct input_dev *dev)
 #define INPUT_PASS_TO_DEVICE    2
 #define INPUT_PASS_TO_ALL       (INPUT_PASS_TO_HANDLERS | INPUT_PASS_TO_DEVICE)
 
+static int input_handle_abs_event(struct input_dev *dev,
+                                  unsigned int code, int *pval)
+{
+        bool is_mt_event;
+        int *pold;
+
+        if (code == ABS_MT_SLOT) {
+                /*
+                 * "Stage" the event; we'll flush it later, when we
+                 * get actual touch data.
+                 */
+                if (*pval >= 0 && *pval < dev->mtsize)
+                        dev->slot = *pval;
+
+                return INPUT_IGNORE_EVENT;
+        }
+
+        is_mt_event = code >= ABS_MT_FIRST && code <= ABS_MT_LAST;
+
+        if (!is_mt_event) {
+                pold = &dev->absinfo[code].value;
+        } else if (dev->mt) {
+                struct input_mt_slot *mtslot = &dev->mt[dev->slot];
+                pold = &mtslot->abs[code - ABS_MT_FIRST];
+        } else {
+                /*
+                 * Bypass filtering for multi-touch events when
+                 * not employing slots.
+                 */
+                pold = NULL;
+        }
+
+        if (pold) {
+                *pval = input_defuzz_abs_event(*pval, *pold,
+                                                dev->absinfo[code].fuzz);
+                if (*pold == *pval)
+                        return INPUT_IGNORE_EVENT;
+
+                *pold = *pval;
+        }
+
+        /* Flush pending "slot" event */
+        if (is_mt_event && dev->slot != input_abs_get_val(dev, ABS_MT_SLOT)) {
+                input_abs_set_val(dev, ABS_MT_SLOT, dev->slot);
+                input_pass_event(dev, EV_ABS, ABS_MT_SLOT, dev->slot);
+        }
+
+        return INPUT_PASS_TO_HANDLERS;
+}
+
 static void input_handle_event(struct input_dev *dev,
                                unsigned int type, unsigned int code, int value)
 {
@@ -179,12 +227,12 @@ static void input_handle_event(struct input_dev *dev,
 
                 case SYN_REPORT:
                         if (!dev->sync) {
-                                dev->sync = 1;
+                                dev->sync = true;
                                 disposition = INPUT_PASS_TO_HANDLERS;
                         }
                         break;
                 case SYN_MT_REPORT:
-                        dev->sync = 0;
+                        dev->sync = false;
                         disposition = INPUT_PASS_TO_HANDLERS;
                         break;
                 }
@@ -216,21 +264,9 @@ static void input_handle_event(struct input_dev *dev,
                 break;
 
         case EV_ABS:
-                if (is_event_supported(code, dev->absbit, ABS_MAX)) {
-
-                        if (test_bit(code, input_abs_bypass)) {
-                                disposition = INPUT_PASS_TO_HANDLERS;
-                                break;
-                        }
-
-                        value = input_defuzz_abs_event(value,
-                                        dev->abs[code], dev->absfuzz[code]);
+                if (is_event_supported(code, dev->absbit, ABS_MAX))
+                        disposition = input_handle_abs_event(dev, code, &value);
 
-                        if (dev->abs[code] != value) {
-                                dev->abs[code] = value;
-                                disposition = INPUT_PASS_TO_HANDLERS;
-                        }
-                }
                 break;
 
         case EV_REL:
@@ -281,7 +317,7 @@ static void input_handle_event(struct input_dev *dev,
         }
 
         if (disposition != INPUT_IGNORE_EVENT && type != EV_SYN)
-                dev->sync = 0;
+                dev->sync = false;
 
         if ((disposition & INPUT_PASS_TO_DEVICE) && dev->event)
                 dev->event(dev, type, code, value);
@@ -355,6 +391,43 @@ void input_inject_event(struct input_handle *handle,
 EXPORT_SYMBOL(input_inject_event);
 
 /**
+ * input_alloc_absinfo - allocates array of input_absinfo structs
+ * @dev: the input device emitting absolute events
+ *
+ * If the absinfo struct the caller asked for is already allocated, this
+ * functions will not do anything.
+ */
+void input_alloc_absinfo(struct input_dev *dev)
+{
+        if (!dev->absinfo)
+                dev->absinfo = kcalloc(ABS_CNT, sizeof(struct input_absinfo),
+                                        GFP_KERNEL);
+
+        WARN(!dev->absinfo, "%s(): kcalloc() failed?\n", __func__);
+}
+EXPORT_SYMBOL(input_alloc_absinfo);
+
+void input_set_abs_params(struct input_dev *dev, unsigned int axis,
+                          int min, int max, int fuzz, int flat)
+{
+        struct input_absinfo *absinfo;
+
+        input_alloc_absinfo(dev);
+        if (!dev->absinfo)
+                return;
+
+        absinfo = &dev->absinfo[axis];
+        absinfo->minimum = min;
+        absinfo->maximum = max;
+        absinfo->fuzz = fuzz;
+        absinfo->flat = flat;
+
+        dev->absbit[BIT_WORD(axis)] |= BIT_MASK(axis);
+}
+EXPORT_SYMBOL(input_set_abs_params);
+
+
+/**
  * input_grab_device - grabs device for exclusive use
  * @handle: input handle that wants to own the device
  *
@@ -511,12 +584,30 @@ void input_close_device(struct input_handle *handle)
 EXPORT_SYMBOL(input_close_device);
 
 /*
+ * Simulate keyup events for all keys that are marked as pressed.
+ * The function must be called with dev->event_lock held.
+ */
+static void input_dev_release_keys(struct input_dev *dev)
+{
+        int code;
+
+        if (is_event_supported(EV_KEY, dev->evbit, EV_MAX)) {
+                for (code = 0; code <= KEY_MAX; code++) {
+                        if (is_event_supported(code, dev->keybit, KEY_MAX) &&
+                            __test_and_clear_bit(code, dev->key)) {
+                                input_pass_event(dev, EV_KEY, code, 0);
+                        }
+                }
+                input_pass_event(dev, EV_SYN, SYN_REPORT, 1);
+        }
+}
+
+/*
  * Prepare device for unregistering
  */
 static void input_disconnect_device(struct input_dev *dev)
 {
         struct input_handle *handle;
-        int code;
 
         /*
          * Mark device as going away. Note that we take dev->mutex here
@@ -535,15 +626,7 @@ static void input_disconnect_device(struct input_dev *dev)
          * generate events even after we done here but they will not
          * reach any handlers.
          */
-        if (is_event_supported(EV_KEY, dev->evbit, EV_MAX)) {
-                for (code = 0; code <= KEY_MAX; code++) {
-                        if (is_event_supported(code, dev->keybit, KEY_MAX) &&
-                            __test_and_clear_bit(code, dev->key)) {
-                                input_pass_event(dev, EV_KEY, code, 0);
-                        }
-                }
-                input_pass_event(dev, EV_SYN, SYN_REPORT, 1);
-        }
+        input_dev_release_keys(dev);
 
         list_for_each_entry(handle, &dev->h_list, d_node)
                 handle->open = 0;
@@ -551,76 +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,
-                                    int scancode, 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,
-                                    int scancode, 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(dev->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 */
                 }
         }
@@ -631,53 +779,92 @@ 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, int scancode, int *keycode)
+int input_get_keycode(struct input_dev *dev, struct input_keymap_entry *ke)
 {
-        if (scancode < 0)
-                return -EINVAL;
+        unsigned long flags;
+        int retval;
+
+        spin_lock_irqsave(&dev->event_lock, flags);
 
-        return dev->getkeycode(dev, scancode, keycode);
+        if (dev->getkeycode) {
+                /*
+                 * Support for legacy drivers, that don't implement the new
+                 * ioctls
+                 */
+                u32 scancode = ke->index;
+
+                memcpy(ke->scancode, &scancode, sizeof(scancode));
+                ke->len = sizeof(scancode);
+                retval = dev->getkeycode(dev, scancode, &ke->keycode);
+        } else {
+                retval = dev->getkeycode_new(dev, ke);
+        }
+
+        spin_unlock_irqrestore(&dev->event_lock, flags);
+        return retval;
 }
 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, int scancode, int keycode)
+int input_set_keycode(struct input_dev *dev,
+                      const struct input_keymap_entry *ke)
 {
         unsigned long flags;
-        int old_keycode;
+        unsigned int old_keycode;
         int retval;
 
-        if (scancode < 0)
-                return -EINVAL;
-
-        if (keycode < 0 || 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;
+        if (dev->setkeycode) {
+                /*
+                 * Support for legacy drivers, that don't implement the new
+                 * ioctls
+                 */
+                unsigned int scancode;
+
+                retval = input_scancode_to_scalar(ke, &scancode);
+                if (retval)
+                        goto out;
+
+                /*
+                 * We need to know the old scancode, in order to generate a
+                 * keyup effect, if the set operation happens successfully
+                 */
+                if (!dev->getkeycode) {
+                        retval = -EINVAL;
+                        goto out;
+                }
+
+                retval = dev->getkeycode(dev, scancode, &old_keycode);
+                if (retval)
+                        goto out;
+
+                retval = dev->setkeycode(dev, scancode, ke->keycode);
+        } else {
+                retval = dev->setkeycode_new(dev, ke, &old_keycode);
+        }
 
-        retval = dev->setkeycode(dev, scancode, keycode);
         if (retval)
                 goto out;
 
+        /* Make sure KEY_RESERVED did not get enabled. */
+        __clear_bit(KEY_RESERVED, dev->keybit);
+
         /*
          * Simulate keyup event if keycode is not present
          * in the keymap anymore
@@ -705,12 +892,13 @@ EXPORT_SYMBOL(input_set_keycode);
                 if (i != BITS_TO_LONGS(max)) \
                         continue;
 
-static const struct input_device_id *input_match_device(const struct input_device_id *id,
+static const struct input_device_id *input_match_device(struct input_handler *handler,
                                                         struct input_dev *dev)
 {
+        const struct input_device_id *id;
         int i;
 
-        for (; id->flags || id->driver_info; id++) {
+        for (id = handler->id_table; id->flags || id->driver_info; id++) {
 
                 if (id->flags & INPUT_DEVICE_ID_MATCH_BUS)
                         if (id->bustype != dev->id.bustype)
@@ -738,7 +926,8 @@ static const struct input_device_id *input_match_device(const struct input_devic
                 MATCH_BIT(ffbit,  FF_MAX);
                 MATCH_BIT(swbit,  SW_MAX);
 
-                return id;
+                if (!handler->match || handler->match(handler, dev))
+                        return id;
         }
 
         return NULL;
@@ -749,10 +938,7 @@ static int input_attach_handler(struct input_dev *dev, struct input_handler *han
         const struct input_device_id *id;
         int error;
 
-        if (handler->blacklist && input_match_device(handler->blacklist, dev))
-                return -ENODEV;
-
-        id = input_match_device(handler->id_table, dev);
+        id = input_match_device(handler, dev);
         if (!id)
                 return -ENODEV;
 
@@ -988,6 +1174,8 @@ static int input_handlers_seq_show(struct seq_file *seq, void *v)
         union input_seq_state *state = (union input_seq_state *)&seq->private;
 
         seq_printf(seq, "N: Number=%u Name=%s", state->pos, handler->name);
+        if (handler->filter)
+                seq_puts(seq, " (filter)");
         if (handler->fops)
                 seq_printf(seq, " Minor=%d", handler->minor);
         seq_putc(seq, '\n');
@@ -1252,6 +1440,8 @@ static void input_dev_release(struct device *device)
         struct input_dev *dev = to_input_dev(device);
 
         input_ff_destroy(dev);
+        input_mt_destroy_slots(dev);
+        kfree(dev->absinfo);
         kfree(dev);
 
         module_put(THIS_MODULE);
@@ -1407,6 +1597,15 @@ static int input_dev_resume(struct device *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);
 
         return 0;
@@ -1492,6 +1691,52 @@ 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 by 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...)
@@ -1551,6 +1796,25 @@ void input_set_capability(struct input_dev *dev, unsigned int type, unsigned int
 }
 EXPORT_SYMBOL(input_set_capability);
 
+#define INPUT_CLEANSE_BITMASK(dev, type, bits)                          \
+        do {                                                            \
+                if (!test_bit(EV_##type, dev->evbit))                   \
+                        memset(dev->bits##bit, 0,                       \
+                                sizeof(dev->bits##bit));                \
+        } while (0)
+
+static void input_cleanse_bitmasks(struct input_dev *dev)
+{
+        INPUT_CLEANSE_BITMASK(dev, KEY, key);
+        INPUT_CLEANSE_BITMASK(dev, REL, rel);
+        INPUT_CLEANSE_BITMASK(dev, ABS, abs);
+        INPUT_CLEANSE_BITMASK(dev, MSC, msc);
+        INPUT_CLEANSE_BITMASK(dev, LED, led);
+        INPUT_CLEANSE_BITMASK(dev, SND, snd);
+        INPUT_CLEANSE_BITMASK(dev, FF, ff);
+        INPUT_CLEANSE_BITMASK(dev, SW, sw);
+}
+
 /**
  * input_register_device - register device with input core
  * @dev: device to be registered
@@ -1570,13 +1834,19 @@ int input_register_device(struct input_dev *dev)
         const char *path;
         int error;
 
+        /* Every input device generates EV_SYN/SYN_REPORT events. */
         __set_bit(EV_SYN, dev->evbit);
 
+        /* KEY_RESERVED is not supposed to be transmitted to userspace. */
+        __clear_bit(KEY_RESERVED, dev->keybit);
+
+        /* Make sure that bitmasks not mentioned in dev->evbit are clean. */
+        input_cleanse_bitmasks(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.
          */
-
         init_timer(&dev->timer);
         if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD]) {
                 dev->timer.data = (long) dev;
@@ -1585,11 +1855,11 @@ int input_register_device(struct input_dev *dev)
                 dev->rep[REP_PERIOD] = 33;
         }
 
-        if (!dev->getkeycode)
-                dev->getkeycode = input_default_getkeycode;
+        if (!dev->getkeycode && !dev->getkeycode_new)
+                dev->getkeycode_new = input_default_getkeycode;
 
-        if (!dev->setkeycode)
-                dev->setkeycode = input_default_setkeycode;
+        if (!dev->setkeycode && !dev->setkeycode_new)
+                dev->setkeycode_new = input_default_setkeycode;
 
         dev_set_name(&dev->dev, "input%ld",
                      (unsigned long) atomic_inc_return(&input_no) - 1);
@@ -1776,7 +2046,16 @@ int input_register_handle(struct input_handle *handle)
         error = mutex_lock_interruptible(&dev->mutex);
         if (error)
                 return error;
-        list_add_tail_rcu(&handle->d_node, &dev->h_list);
+
+        /*
+         * Filters go to the head of the list, normal handlers
+         * to the tail.
+         */
+        if (handler->filter)
+                list_add_rcu(&handle->d_node, &dev->h_list);
+        else
+                list_add_tail_rcu(&handle->d_node, &dev->h_list);
+
         mutex_unlock(&dev->mutex);
 
         /*
@@ -1827,57 +2106,50 @@ static int input_open_file(struct inode *inode, struct file *file)
         const struct file_operations *old_fops, *new_fops = NULL;
         int err;
 
-        lock_kernel();
+        err = mutex_lock_interruptible(&input_mutex);
+        if (err)
+                return err;
+
         /* No load-on-demand here? */
         handler = input_table[iminor(inode) >> 5];
-        if (!handler || !(new_fops = fops_get(handler->fops))) {
-                err = -ENODEV;
-                goto out;
-        }
+        if (handler)
+                new_fops = fops_get(handler->fops);
+
+        mutex_unlock(&input_mutex);
 
         /*
          * That's _really_ odd. Usually NULL ->open means "nothing special",
          * not "no device". Oh, well...
          */
-        if (!new_fops->open) {
+        if (!new_fops || !new_fops->open) {
                 fops_put(new_fops);
                 err = -ENODEV;
                 goto out;
         }
+
         old_fops = file->f_op;
         file->f_op = new_fops;
 
         err = new_fops->open(inode, file);
-
         if (err) {
                 fops_put(file->f_op);
                 file->f_op = fops_get(old_fops);
         }
         fops_put(old_fops);
 out:
-        unlock_kernel();
         return err;
 }
 
 static const struct file_operations input_fops = {
         .owner = THIS_MODULE,
         .open = input_open_file,
+        .llseek = noop_llseek,
 };
 
-static void __init input_init_abs_bypass(void)
-{
-        const unsigned int *p;
-
-        for (p = input_abs_bypass_init_data; *p; p++)
-                input_abs_bypass[BIT_WORD(*p)] |= BIT_MASK(*p);
-}
-
 static int __init input_init(void)
 {
         int err;
 
-        input_init_abs_bypass();
-
         err = class_register(&input_class);
         if (err) {
                 printk(KERN_ERR "input: unable to register input_dev class\n");
diff --git a/drivers/input/joydev.c b/drivers/input/joydev.c
index b1bd6dd32286..9d424cebfd2c 100644
--- a/drivers/input/joydev.c
+++ b/drivers/input/joydev.c
@@ -37,7 +37,6 @@ MODULE_LICENSE("GPL");
 #define JOYDEV_BUFFER_SIZE      64
 
 struct joydev {
-        int exist;
         int open;
         int minor;
         struct input_handle handle;
@@ -46,16 +45,17 @@ struct joydev {
         spinlock_t client_lock; /* protects client_list */
         struct mutex mutex;
         struct device dev;
+        bool exist;
 
-        struct js_corr corr[ABS_MAX + 1];
+        struct js_corr corr[ABS_CNT];
         struct JS_DATA_SAVE_TYPE glue;
         int nabs;
         int nkey;
         __u16 keymap[KEY_MAX - BTN_MISC + 1];
         __u16 keypam[KEY_MAX - BTN_MISC + 1];
-        __u8 absmap[ABS_MAX + 1];
-        __u8 abspam[ABS_MAX + 1];
-        __s16 abs[ABS_MAX + 1];
+        __u8 absmap[ABS_CNT];
+        __u8 abspam[ABS_CNT];
+        __s16 abs[ABS_CNT];
 };
 
 struct joydev_client {
@@ -286,6 +286,8 @@ static int joydev_open(struct inode *inode, struct file *file)
                 goto err_free_client;
 
         file->private_data = client;
+        nonseekable_open(inode, file);
+
         return 0;
 
  err_free_client:
@@ -481,6 +483,9 @@ static int joydev_handle_JSIOCSAXMAP(struct joydev *joydev,
 
         memcpy(joydev->abspam, abspam, len);
 
+        for (i = 0; i < joydev->nabs; i++)
+                joydev->absmap[joydev->abspam[i]] = i;
+
  out:
         kfree(abspam);
         return retval;
@@ -528,7 +533,7 @@ static int joydev_ioctl_common(struct joydev *joydev,
 {
         struct input_dev *dev = joydev->handle.dev;
         size_t len;
-        int i, j;
+        int i;
         const char *name;
 
         /* Process fixed-sized commands. */
@@ -560,12 +565,11 @@ static int joydev_ioctl_common(struct joydev *joydev,
         case JSIOCSCORR:
                 if (copy_from_user(joydev->corr, argp,
                               sizeof(joydev->corr[0]) * joydev->nabs))
-                    return -EFAULT;
+                        return -EFAULT;
 
                 for (i = 0; i < joydev->nabs; i++) {
-                        j = joydev->abspam[i];
-                        joydev->abs[i] = joydev_correct(dev->abs[j],
-                                                        &joydev->corr[i]);
+                        int val = input_abs_get_val(dev, joydev->abspam[i]);
+                        joydev->abs[i] = joydev_correct(val, &joydev->corr[i]);
                 }
                 return 0;
 
@@ -735,6 +739,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)
@@ -758,7 +763,7 @@ static void joydev_remove_chrdev(struct joydev *joydev)
 static void joydev_mark_dead(struct joydev *joydev)
 {
         mutex_lock(&joydev->mutex);
-        joydev->exist = 0;
+        joydev->exist = false;
         mutex_unlock(&joydev->mutex);
 }
 
@@ -775,6 +780,20 @@ static void joydev_cleanup(struct joydev *joydev)
                 input_close_device(handle);
 }
 
+
+static bool joydev_match(struct input_handler *handler, struct input_dev *dev)
+{
+        /* Avoid touchpads and touchscreens */
+        if (test_bit(EV_KEY, dev->evbit) && test_bit(BTN_TOUCH, dev->keybit))
+                return false;
+
+        /* Avoid tablets, digitisers and similar devices */
+        if (test_bit(EV_KEY, dev->evbit) && test_bit(BTN_DIGI, dev->keybit))
+                return false;
+
+        return true;
+}
+
 static int joydev_connect(struct input_handler *handler, struct input_dev *dev,
                           const struct input_device_id *id)
 {
@@ -801,16 +820,15 @@ static int joydev_connect(struct input_handler *handler, struct input_dev *dev,
         init_waitqueue_head(&joydev->wait);
 
         dev_set_name(&joydev->dev, "js%d", minor);
-        joydev->exist = 1;
+        joydev->exist = true;
         joydev->minor = minor;
 
-        joydev->exist = 1;
         joydev->handle.dev = input_get_device(dev);
         joydev->handle.name = dev_name(&joydev->dev);
         joydev->handle.handler = handler;
         joydev->handle.private = joydev;
 
-        for (i = 0; i < ABS_MAX + 1; i++)
+        for (i = 0; i < ABS_CNT; i++)
                 if (test_bit(i, dev->absbit)) {
                         joydev->absmap[i] = joydev->nabs;
                         joydev->abspam[joydev->nabs] = i;
@@ -833,25 +851,27 @@ static int joydev_connect(struct input_handler *handler, struct input_dev *dev,
 
         for (i = 0; i < joydev->nabs; i++) {
                 j = joydev->abspam[i];
-                if (dev->absmax[j] == dev->absmin[j]) {
+                if (input_abs_get_max(dev, j) == input_abs_get_min(dev, j)) {
                         joydev->corr[i].type = JS_CORR_NONE;
-                        joydev->abs[i] = dev->abs[j];
+                        joydev->abs[i] = input_abs_get_val(dev, j);
                         continue;
                 }
                 joydev->corr[i].type = JS_CORR_BROKEN;
-                joydev->corr[i].prec = dev->absfuzz[j];
-                joydev->corr[i].coef[0] =
-                        (dev->absmax[j] + dev->absmin[j]) / 2 - dev->absflat[j];
-                joydev->corr[i].coef[1] =
-                        (dev->absmax[j] + dev->absmin[j]) / 2 + dev->absflat[j];
+                joydev->corr[i].prec = input_abs_get_fuzz(dev, j);
 
-                t = (dev->absmax[j] - dev->absmin[j]) / 2 - 2 * dev->absflat[j];
+                t = (input_abs_get_max(dev, j) + input_abs_get_min(dev, j)) / 2;
+                joydev->corr[i].coef[0] = t - input_abs_get_flat(dev, j);
+                joydev->corr[i].coef[1] = t + input_abs_get_flat(dev, j);
+
+                t = (input_abs_get_max(dev, j) - input_abs_get_min(dev, j)) / 2
+                        - 2 * input_abs_get_flat(dev, j);
                 if (t) {
                         joydev->corr[i].coef[2] = (1 << 29) / t;
                         joydev->corr[i].coef[3] = (1 << 29) / t;
 
-                        joydev->abs[i] = joydev_correct(dev->abs[j],
-                                                        joydev->corr + i);
+                        joydev->abs[i] =
+                                joydev_correct(input_abs_get_val(dev, j),
+                                               joydev->corr + i);
                 }
         }
 
@@ -894,22 +914,6 @@ static void joydev_disconnect(struct input_handle *handle)
         put_device(&joydev->dev);
 }
 
-static const struct input_device_id joydev_blacklist[] = {
-        {
-                .flags = INPUT_DEVICE_ID_MATCH_EVBIT |
-                                INPUT_DEVICE_ID_MATCH_KEYBIT,
-                .evbit = { BIT_MASK(EV_KEY) },
-                .keybit = { [BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH) },
-        },      /* Avoid itouchpads and touchscreens */
-        {
-                .flags = INPUT_DEVICE_ID_MATCH_EVBIT |
-                                INPUT_DEVICE_ID_MATCH_KEYBIT,
-                .evbit = { BIT_MASK(EV_KEY) },
-                .keybit = { [BIT_WORD(BTN_DIGI)] = BIT_MASK(BTN_DIGI) },
-        },      /* Avoid tablets, digitisers and similar devices */
-        { }     /* Terminating entry */
-};
-
 static const struct input_device_id joydev_ids[] = {
         {
                 .flags = INPUT_DEVICE_ID_MATCH_EVBIT |
@@ -929,6 +933,24 @@ static const struct input_device_id joydev_ids[] = {
                 .evbit = { BIT_MASK(EV_ABS) },
                 .absbit = { BIT_MASK(ABS_THROTTLE) },
         },
+        {
+                .flags = INPUT_DEVICE_ID_MATCH_EVBIT |
+                                INPUT_DEVICE_ID_MATCH_KEYBIT,
+                .evbit = { BIT_MASK(EV_KEY) },
+                .keybit = {[BIT_WORD(BTN_JOYSTICK)] = BIT_MASK(BTN_JOYSTICK) },
+        },
+        {
+                .flags = INPUT_DEVICE_ID_MATCH_EVBIT |
+                                INPUT_DEVICE_ID_MATCH_KEYBIT,
+                .evbit = { BIT_MASK(EV_KEY) },
+                .keybit = { [BIT_WORD(BTN_GAMEPAD)] = BIT_MASK(BTN_GAMEPAD) },
+        },
+        {
+                .flags = INPUT_DEVICE_ID_MATCH_EVBIT |
+                                INPUT_DEVICE_ID_MATCH_KEYBIT,
+                .evbit = { BIT_MASK(EV_KEY) },
+                .keybit = { [BIT_WORD(BTN_TRIGGER_HAPPY)] = BIT_MASK(BTN_TRIGGER_HAPPY) },
+        },
         { }     /* Terminating entry */
 };
 
@@ -936,13 +958,13 @@ MODULE_DEVICE_TABLE(input, joydev_ids);
 
 static struct input_handler joydev_handler = {
         .event          = joydev_event,
+        .match          = joydev_match,
         .connect        = joydev_connect,
         .disconnect     = joydev_disconnect,
         .fops           = &joydev_fops,
         .minor          = JOYDEV_MINOR_BASE,
         .name           = "joydev",
         .id_table       = joydev_ids,
-        .blacklist      = joydev_blacklist,
 };
 
 static int __init joydev_init(void)
diff --git a/drivers/input/joystick/Kconfig b/drivers/input/joystick/Kconfig
index b11419590cfe..5b596165b571 100644
--- a/drivers/input/joystick/Kconfig
+++ b/drivers/input/joystick/Kconfig
@@ -221,6 +221,7 @@ config JOYSTICK_DB9
 config JOYSTICK_GAMECON
         tristate "Multisystem, NES, SNES, N64, PSX joysticks and gamepads"
         depends on PARPORT
+        select INPUT_FF_MEMLESS
         ---help---
           Say Y here if you have a Nintendo Entertainment System gamepad,
           Super Nintendo Entertainment System gamepad, Nintendo 64 gamepad,
diff --git a/drivers/input/joystick/a3d.c b/drivers/input/joystick/a3d.c
index 6489f4010c4f..d259b41354b8 100644
--- a/drivers/input/joystick/a3d.c
+++ b/drivers/input/joystick/a3d.c
@@ -342,7 +342,8 @@ static int a3d_connect(struct gameport *gameport, struct gameport_driver *drv)
 
                 for (i = 0; i < 4; i++) {
                         if (i < 2)
-                                input_set_abs_params(input_dev, axes[i], 48, input_dev->abs[axes[i]] * 2 - 48, 0, 8);
+                                input_set_abs_params(input_dev, axes[i],
+                                        48, input_abs_get_val(input_dev, axes[i]) * 2 - 48, 0, 8);
                         else
                                 input_set_abs_params(input_dev, axes[i], 2, 253, 0, 0);
                         input_set_abs_params(input_dev, ABS_HAT0X + i, -1, 1, 0, 0);
diff --git a/drivers/input/joystick/adi.c b/drivers/input/joystick/adi.c
index 89c4c084d4ad..b992fbf91f2f 100644
--- a/drivers/input/joystick/adi.c
+++ b/drivers/input/joystick/adi.c
@@ -452,7 +452,7 @@ static void adi_init_center(struct adi *adi)
         for (i = 0; i < adi->axes10 + adi->axes8 + (adi->hats + (adi->pad != -1)) * 2; i++) {
 
                 t = adi->abs[i];
-                x = adi->dev->abs[t];
+                x = input_abs_get_val(adi->dev, t);
 
                 if (t == ABS_THROTTLE || t == ABS_RUDDER || adi->id == ADI_ID_WGPE)
                         x = i < adi->axes10 ? 512 : 128;
diff --git a/drivers/input/joystick/amijoy.c b/drivers/input/joystick/amijoy.c
index 05022f07ec77..0bc86204213e 100644
--- a/drivers/input/joystick/amijoy.c
+++ b/drivers/input/joystick/amijoy.c
@@ -139,8 +139,8 @@ static int __init amijoy_init(void)
                 amijoy_dev[i]->keybit[BIT_WORD(BTN_LEFT)] = BIT_MASK(BTN_LEFT) |
                         BIT_MASK(BTN_MIDDLE) | BIT_MASK(BTN_RIGHT);
                 for (j = 0; j < 2; j++) {
-                        amijoy_dev[i]->absmin[ABS_X + j] = -1;
-                        amijoy_dev[i]->absmax[ABS_X + j] = 1;
+                        input_set_abs_params(amijoy_dev[i], ABS_X + j,
+                                             -1, 1, 0, 0);
                 }
 
                 err = input_register_device(amijoy_dev[i]);
diff --git a/drivers/input/joystick/analog.c b/drivers/input/joystick/analog.c
index 1c0b529c06aa..4afe0a3b4884 100644
--- a/drivers/input/joystick/analog.c
+++ b/drivers/input/joystick/analog.c
@@ -146,11 +146,11 @@ static unsigned int get_time_pit(void)
         unsigned long flags;
         unsigned int count;
 
-        spin_lock_irqsave(&i8253_lock, flags);
+        raw_spin_lock_irqsave(&i8253_lock, flags);
         outb_p(0x00, 0x43);
         count = inb_p(0x40);
         count |= inb_p(0x40) << 8;
-        spin_unlock_irqrestore(&i8253_lock, flags);
+        raw_spin_unlock_irqrestore(&i8253_lock, flags);
 
         return count;
 }
diff --git a/drivers/input/joystick/db9.c b/drivers/input/joystick/db9.c
index 523959484753..8e7de5c7754f 100644
--- a/drivers/input/joystick/db9.c
+++ b/drivers/input/joystick/db9.c
@@ -36,6 +36,7 @@
 #include <linux/parport.h>
 #include <linux/input.h>
 #include <linux/mutex.h>
+#include <linux/slab.h>
 
 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
 MODULE_DESCRIPTION("Atari, Amstrad, Commodore, Amiga, Sega, etc. joystick driver");
diff --git a/drivers/input/joystick/gamecon.c b/drivers/input/joystick/gamecon.c
index 07a32aff5a31..e68e49786483 100644
--- a/drivers/input/joystick/gamecon.c
+++ b/drivers/input/joystick/gamecon.c
@@ -30,6 +30,8 @@
  * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/delay.h>
 #include <linux/module.h>
@@ -37,6 +39,7 @@
 #include <linux/parport.h>
 #include <linux/input.h>
 #include <linux/mutex.h>
+#include <linux/slab.h>
 
 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
 MODULE_DESCRIPTION("NES, SNES, N64, MultiSystem, PSX gamepad driver");
@@ -61,48 +64,72 @@ MODULE_PARM_DESC(map3, "Describes third set of devices");
 
 /* see also gs_psx_delay parameter in PSX support section */
 
-#define GC_SNES         1
-#define GC_NES          2
-#define GC_NES4         3
-#define GC_MULTI        4
-#define GC_MULTI2       5
-#define GC_N64          6
-#define GC_PSX          7
-#define GC_DDR          8
-#define GC_SNESMOUSE    9
-
-#define GC_MAX          9
+enum gc_type {
+        GC_NONE = 0,
+        GC_SNES,
+        GC_NES,
+        GC_NES4,
+        GC_MULTI,
+        GC_MULTI2,
+        GC_N64,
+        GC_PSX,
+        GC_DDR,
+        GC_SNESMOUSE,
+        GC_MAX
+};
 
 #define GC_REFRESH_TIME HZ/100
 
+struct gc_pad {
+        struct input_dev *dev;
+        enum gc_type type;
+        char phys[32];
+};
+
 struct gc {
         struct pardevice *pd;
-        struct input_dev *dev[GC_MAX_DEVICES];
+        struct gc_pad pads[GC_MAX_DEVICES];
         struct timer_list timer;
-        unsigned char pads[GC_MAX + 1];
+        int pad_count[GC_MAX];
         int used;
         struct mutex mutex;
-        char phys[GC_MAX_DEVICES][32];
+};
+
+struct gc_subdev {
+        unsigned int idx;
 };
 
 static struct gc *gc_base[3];
 
-static int gc_status_bit[] = { 0x40, 0x80, 0x20, 0x10, 0x08 };
+static const int gc_status_bit[] = { 0x40, 0x80, 0x20, 0x10, 0x08 };
+
+static const char *gc_names[] = {
+        NULL, "SNES pad", "NES pad", "NES FourPort", "Multisystem joystick",
+        "Multisystem 2-button joystick", "N64 controller", "PSX controller",
+        "PSX DDR controller", "SNES mouse"
+};
 
-static char *gc_names[] = { NULL, "SNES pad", "NES pad", "NES FourPort", "Multisystem joystick",
-                                "Multisystem 2-button joystick", "N64 controller", "PSX controller",
-                                "PSX DDR controller", "SNES mouse" };
 /*
  * N64 support.
  */
 
-static unsigned char gc_n64_bytes[] = { 0, 1, 13, 15, 14, 12, 10, 11, 2, 3 };
-static short gc_n64_btn[] = { BTN_A, BTN_B, BTN_C, BTN_X, BTN_Y, BTN_Z, BTN_TL, BTN_TR, BTN_TRIGGER, BTN_START };
+static const unsigned char gc_n64_bytes[] = { 0, 1, 13, 15, 14, 12, 10, 11, 2, 3 };
+static const short gc_n64_btn[] = {
+        BTN_A, BTN_B, BTN_C, BTN_X, BTN_Y, BTN_Z,
+        BTN_TL, BTN_TR, BTN_TRIGGER, BTN_START
+};
 
 #define GC_N64_LENGTH           32              /* N64 bit length, not including stop bit */
-#define GC_N64_REQUEST_LENGTH   37              /* transmit request sequence is 9 bits long */
+#define GC_N64_STOP_LENGTH      5               /* Length of encoded stop bit */
+#define GC_N64_CMD_00           0x11111111UL
+#define GC_N64_CMD_01           0xd1111111UL
+#define GC_N64_CMD_03           0xdd111111UL
+#define GC_N64_CMD_1b           0xdd1dd111UL
+#define GC_N64_CMD_c0           0x111111ddUL
+#define GC_N64_CMD_80           0x1111111dUL
+#define GC_N64_STOP_BIT         0x1d            /* Encoded stop bit */
+#define GC_N64_REQUEST_DATA     GC_N64_CMD_01   /* the request data command */
 #define GC_N64_DELAY            133             /* delay between transmit request, and response ready (us) */
-#define GC_N64_REQUEST          0x1dd1111111ULL /* the request data command (encoded for 000000011) */
 #define GC_N64_DWS              3               /* delay between write segments (required for sound playback because of ISA DMA) */
                                                 /* GC_N64_DWS > 24 is known to fail */
 #define GC_N64_POWER_W          0xe2            /* power during write (transmit request) */
@@ -114,8 +141,40 @@ static short gc_n64_btn[] = { BTN_A, BTN_B, BTN_C, BTN_X, BTN_Y, BTN_Z, BTN_TL,
 #define GC_N64_CLOCK            0x02            /* clock bits for read */
 
 /*
+ * Used for rumble code.
+ */
+
+/* Send encoded command */
+static void gc_n64_send_command(struct gc *gc, unsigned long cmd,
+                                unsigned char target)
+{
+        struct parport *port = gc->pd->port;
+        int i;
+
+        for (i = 0; i < GC_N64_LENGTH; i++) {
+                unsigned char data = (cmd >> i) & 1 ? target : 0;
+                parport_write_data(port, GC_N64_POWER_W | data);
+                udelay(GC_N64_DWS);
+        }
+}
+
+/* Send stop bit */
+static void gc_n64_send_stop_bit(struct gc *gc, unsigned char target)
+{
+        struct parport *port = gc->pd->port;
+        int i;
+
+        for (i = 0; i < GC_N64_STOP_LENGTH; i++) {
+                unsigned char data = (GC_N64_STOP_BIT >> i) & 1 ? target : 0;
+                parport_write_data(port, GC_N64_POWER_W | data);
+                udelay(GC_N64_DWS);
+        }
+}
+
+/*
  * gc_n64_read_packet() reads an N64 packet.
- * Each pad uses one bit per byte. So all pads connected to this port are read in parallel.
+ * Each pad uses one bit per byte. So all pads connected to this port
+ * are read in parallel.
  */
 
 static void gc_n64_read_packet(struct gc *gc, unsigned char *data)
@@ -128,14 +187,13 @@ static void gc_n64_read_packet(struct gc *gc, unsigned char *data)
  */
 
         local_irq_save(flags);
-        for (i = 0; i < GC_N64_REQUEST_LENGTH; i++) {
-                parport_write_data(gc->pd->port, GC_N64_POWER_W | ((GC_N64_REQUEST >> i) & 1 ? GC_N64_OUT : 0));
-                udelay(GC_N64_DWS);
-        }
+        gc_n64_send_command(gc, GC_N64_REQUEST_DATA, GC_N64_OUT);
+        gc_n64_send_stop_bit(gc, GC_N64_OUT);
         local_irq_restore(flags);
 
 /*
- * Wait for the pad response to be loaded into the 33-bit register of the adapter
+ * Wait for the pad response to be loaded into the 33-bit register
+ * of the adapter.
  */
 
         udelay(GC_N64_DELAY);
@@ -146,13 +204,15 @@ static void gc_n64_read_packet(struct gc *gc, unsigned char *data)
 
         for (i = 0; i < GC_N64_LENGTH; i++) {
                 parport_write_data(gc->pd->port, GC_N64_POWER_R);
+                udelay(2);
                 data[i] = parport_read_status(gc->pd->port);
                 parport_write_data(gc->pd->port, GC_N64_POWER_R | GC_N64_CLOCK);
          }
 
 /*
- * We must wait 200 ms here for the controller to reinitialize before the next read request.
- * No worries as long as gc_read is polled less frequently than this.
+ * We must wait 200 ms here for the controller to reinitialize before
+ * the next read request. No worries as long as gc_read is polled less
+ * frequently than this.
  */
 
 }
@@ -160,45 +220,112 @@ static void gc_n64_read_packet(struct gc *gc, unsigned char *data)
 static void gc_n64_process_packet(struct gc *gc)
 {
         unsigned char data[GC_N64_LENGTH];
-        signed char axes[2];
         struct input_dev *dev;
         int i, j, s;
+        signed char x, y;
 
         gc_n64_read_packet(gc, data);
 
         for (i = 0; i < GC_MAX_DEVICES; i++) {
 
-                dev = gc->dev[i];
-                if (!dev)
+                if (gc->pads[i].type != GC_N64)
                         continue;
 
+                dev = gc->pads[i].dev;
                 s = gc_status_bit[i];
 
-                if (s & gc->pads[GC_N64] & ~(data[8] | data[9])) {
+                if (s & ~(data[8] | data[9])) {
 
-                        axes[0] = axes[1] = 0;
+                        x = y = 0;
 
                         for (j = 0; j < 8; j++) {
                                 if (data[23 - j] & s)
-                                        axes[0] |= 1 << j;
+                                        x |= 1 << j;
                                 if (data[31 - j] & s)
-                                        axes[1] |= 1 << j;
+                                        y |= 1 << j;
                         }
 
-                        input_report_abs(dev, ABS_X,  axes[0]);
-                        input_report_abs(dev, ABS_Y, -axes[1]);
+                        input_report_abs(dev, ABS_X,  x);
+                        input_report_abs(dev, ABS_Y, -y);
 
-                        input_report_abs(dev, ABS_HAT0X, !(s & data[6]) - !(s & data[7]));
-                        input_report_abs(dev, ABS_HAT0Y, !(s & data[4]) - !(s & data[5]));
+                        input_report_abs(dev, ABS_HAT0X,
+                                         !(s & data[6]) - !(s & data[7]));
+                        input_report_abs(dev, ABS_HAT0Y,
+                                         !(s & data[4]) - !(s & data[5]));
 
                         for (j = 0; j < 10; j++)
-                                input_report_key(dev, gc_n64_btn[j], s & data[gc_n64_bytes[j]]);
+                                input_report_key(dev, gc_n64_btn[j],
+                                                 s & data[gc_n64_bytes[j]]);
 
                         input_sync(dev);
                 }
         }
 }
 
+static int gc_n64_play_effect(struct input_dev *dev, void *data,
+                              struct ff_effect *effect)
+{
+        int i;
+        unsigned long flags;
+        struct gc *gc = input_get_drvdata(dev);
+        struct gc_subdev *sdev = data;
+        unsigned char target = 1 << sdev->idx; /* select desired pin */
+
+        if (effect->type == FF_RUMBLE) {
+                struct ff_rumble_effect *rumble = &effect->u.rumble;
+                unsigned int cmd =
+                        rumble->strong_magnitude || rumble->weak_magnitude ?
+                        GC_N64_CMD_01 : GC_N64_CMD_00;
+
+                local_irq_save(flags);
+
+                /* Init Rumble - 0x03, 0x80, 0x01, (34)0x80 */
+                gc_n64_send_command(gc, GC_N64_CMD_03, target);
+                gc_n64_send_command(gc, GC_N64_CMD_80, target);
+                gc_n64_send_command(gc, GC_N64_CMD_01, target);
+                for (i = 0; i < 32; i++)
+                        gc_n64_send_command(gc, GC_N64_CMD_80, target);
+                gc_n64_send_stop_bit(gc, target);
+
+                udelay(GC_N64_DELAY);
+
+                /* Now start or stop it - 0x03, 0xc0, 0zx1b, (32)0x01/0x00 */
+                gc_n64_send_command(gc, GC_N64_CMD_03, target);
+                gc_n64_send_command(gc, GC_N64_CMD_c0, target);
+                gc_n64_send_command(gc, GC_N64_CMD_1b, target);
+                for (i = 0; i < 32; i++)
+                        gc_n64_send_command(gc, cmd, target);
+                gc_n64_send_stop_bit(gc, target);
+
+                local_irq_restore(flags);
+
+        }
+
+        return 0;
+}
+
+static int __init gc_n64_init_ff(struct input_dev *dev, int i)
+{
+        struct gc_subdev *sdev;
+        int err;
+
+        sdev = kmalloc(sizeof(*sdev), GFP_KERNEL);
+        if (!sdev)
+                return -ENOMEM;
+
+        sdev->idx = i;
+
+        input_set_capability(dev, EV_FF, FF_RUMBLE);
+
+        err = input_ff_create_memless(dev, sdev, gc_n64_play_effect);
+        if (err) {
+                kfree(sdev);
+                return err;
+        }
+
+        return 0;
+}
+
 /*
  * NES/SNES support.
  */
@@ -214,9 +341,11 @@ static void gc_n64_process_packet(struct gc *gc)
 #define GC_NES_CLOCK    0x01
 #define GC_NES_LATCH    0x02
 
-static unsigned char gc_nes_bytes[] = { 0, 1, 2, 3 };
-static unsigned char gc_snes_bytes[] = { 8, 0, 2, 3, 9, 1, 10, 11 };
-static short gc_snes_btn[] = { BTN_A, BTN_B, BTN_SELECT, BTN_START, BTN_X, BTN_Y, BTN_TL, BTN_TR };
+static const unsigned char gc_nes_bytes[] = { 0, 1, 2, 3 };
+static const unsigned char gc_snes_bytes[] = { 8, 0, 2, 3, 9, 1, 10, 11 };
+static const short gc_snes_btn[] = {
+        BTN_A, BTN_B, BTN_SELECT, BTN_START, BTN_X, BTN_Y, BTN_TL, BTN_TR
+};
 
 /*
  * gc_nes_read_packet() reads a NES/SNES packet.
@@ -244,40 +373,51 @@ static void gc_nes_read_packet(struct gc *gc, int length, unsigned char *data)
 static void gc_nes_process_packet(struct gc *gc)
 {
         unsigned char data[GC_SNESMOUSE_LENGTH];
+        struct gc_pad *pad;
         struct input_dev *dev;
         int i, j, s, len;
         char x_rel, y_rel;
 
-        len = gc->pads[GC_SNESMOUSE] ? GC_SNESMOUSE_LENGTH :
-                        (gc->pads[GC_SNES] ? GC_SNES_LENGTH : GC_NES_LENGTH);
+        len = gc->pad_count[GC_SNESMOUSE] ? GC_SNESMOUSE_LENGTH :
+                        (gc->pad_count[GC_SNES] ? GC_SNES_LENGTH : GC_NES_LENGTH);
 
         gc_nes_read_packet(gc, len, data);
 
         for (i = 0; i < GC_MAX_DEVICES; i++) {
 
-                dev = gc->dev[i];
-                if (!dev)
-                        continue;
-
+                pad = &gc->pads[i];
+                dev = pad->dev;
                 s = gc_status_bit[i];
 
-                if (s & (gc->pads[GC_NES] | gc->pads[GC_SNES])) {
+                switch (pad->type) {
+
+                case GC_NES:
+
                         input_report_abs(dev, ABS_X, !(s & data[6]) - !(s & data[7]));
                         input_report_abs(dev, ABS_Y, !(s & data[4]) - !(s & data[5]));
-                }
 
-                if (s & gc->pads[GC_NES])
                         for (j = 0; j < 4; j++)
-                                input_report_key(dev, gc_snes_btn[j], s & data[gc_nes_bytes[j]]);
+                                input_report_key(dev, gc_snes_btn[j],
+                                                 s & data[gc_nes_bytes[j]]);
+                        input_sync(dev);
+                        break;
+
+                case GC_SNES:
+
+                        input_report_abs(dev, ABS_X, !(s & data[6]) - !(s & data[7]));
+                        input_report_abs(dev, ABS_Y, !(s & data[4]) - !(s & data[5]));
 
-                if (s & gc->pads[GC_SNES])
                         for (j = 0; j < 8; j++)
-                                input_report_key(dev, gc_snes_btn[j], s & data[gc_snes_bytes[j]]);
+                                input_report_key(dev, gc_snes_btn[j],
+                                                 s & data[gc_snes_bytes[j]]);
+                        input_sync(dev);
+                        break;
 
-                if (s & gc->pads[GC_SNESMOUSE]) {
+                case GC_SNESMOUSE:
                         /*
-                         * The 4 unused bits from SNES controllers appear to be ID bits
-                         * so use them to make sure iwe are dealing with a mouse.
+                         * The 4 unused bits from SNES controllers appear
+                         * to be ID bits so use them to make sure we are
+                         * dealing with a mouse.
                          * gamepad is connected. This is important since
                          * my SNES gamepad sends 1's for bits 16-31, which
                          * cause the mouse pointer to quickly move to the
@@ -310,9 +450,14 @@ static void gc_nes_process_packet(struct gc *gc)
                                                 y_rel = -y_rel;
                                         input_report_rel(dev, REL_Y, y_rel);
                                 }
+
+                                input_sync(dev);
                         }
+                        break;
+
+                default:
+                        break;
                 }
-                input_sync(dev);
         }
 }
 
@@ -340,29 +485,35 @@ static void gc_multi_read_packet(struct gc *gc, int length, unsigned char *data)
 static void gc_multi_process_packet(struct gc *gc)
 {
         unsigned char data[GC_MULTI2_LENGTH];
+        int data_len = gc->pad_count[GC_MULTI2] ? GC_MULTI2_LENGTH : GC_MULTI_LENGTH;
+        struct gc_pad *pad;
         struct input_dev *dev;
         int i, s;
 
-        gc_multi_read_packet(gc, gc->pads[GC_MULTI2] ? GC_MULTI2_LENGTH : GC_MULTI_LENGTH, data);
+        gc_multi_read_packet(gc, data_len, data);
 
         for (i = 0; i < GC_MAX_DEVICES; i++) {
-
-                dev = gc->dev[i];
-                if (!dev)
-                        continue;
-
+                pad = &gc->pads[i];
+                dev = pad->dev;
                 s = gc_status_bit[i];
 
-                if (s & (gc->pads[GC_MULTI] | gc->pads[GC_MULTI2])) {
-                        input_report_abs(dev, ABS_X,  !(s & data[2]) - !(s & data[3]));
-                        input_report_abs(dev, ABS_Y,  !(s & data[0]) - !(s & data[1]));
-                        input_report_key(dev, BTN_TRIGGER, s & data[4]);
-                }
-
-                if (s & gc->pads[GC_MULTI2])
+                switch (pad->type) {
+                case GC_MULTI2:
                         input_report_key(dev, BTN_THUMB, s & data[5]);
+                        /* fall through */
 
-                input_sync(dev);
+                case GC_MULTI:
+                        input_report_abs(dev, ABS_X,
+                                         !(s & data[2]) - !(s & data[3]));
+                        input_report_abs(dev, ABS_Y,
+                                         !(s & data[0]) - !(s & data[1]));
+                        input_report_key(dev, BTN_TRIGGER, s & data[4]);
+                        input_sync(dev);
+                        break;
+
+                default:
+                        break;
+                }
         }
 }
 
@@ -370,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/
  *
  */
 
@@ -398,30 +548,41 @@ static int gc_psx_delay = GC_PSX_DELAY;
 module_param_named(psx_delay, gc_psx_delay, uint, 0);
 MODULE_PARM_DESC(psx_delay, "Delay when accessing Sony PSX controller (usecs)");
 
-static short gc_psx_abs[] = { ABS_X, ABS_Y, ABS_RX, ABS_RY, ABS_HAT0X, ABS_HAT0Y };
-static short gc_psx_btn[] = { BTN_TL, BTN_TR, BTN_TL2, BTN_TR2, BTN_A, BTN_B, BTN_X, BTN_Y,
-                                BTN_START, BTN_SELECT, BTN_THUMBL, BTN_THUMBR };
-static short gc_psx_ddr_btn[] = { BTN_0, BTN_1, BTN_2, BTN_3 };
+static const short gc_psx_abs[] = {
+        ABS_X, ABS_Y, ABS_RX, ABS_RY, ABS_HAT0X, ABS_HAT0Y
+};
+static const short gc_psx_btn[] = {
+        BTN_TL, BTN_TR, BTN_TL2, BTN_TR2, BTN_A, BTN_B, BTN_X, BTN_Y,
+        BTN_START, BTN_SELECT, BTN_THUMBL, BTN_THUMBR
+};
+static const short gc_psx_ddr_btn[] = { BTN_0, BTN_1, BTN_2, BTN_3 };
 
 /*
  * gc_psx_command() writes 8bit command and reads 8bit data from
  * the psx pad.
  */
 
-static void gc_psx_command(struct gc *gc, int b, unsigned char data[GC_MAX_DEVICES])
+static void gc_psx_command(struct gc *gc, int b, unsigned char *data)
 {
+        struct parport *port = gc->pd->port;
         int i, j, cmd, read;
 
-        for (i = 0; i < GC_MAX_DEVICES; i++)
-                data[i] = 0;
+        memset(data, 0, GC_MAX_DEVICES);
 
         for (i = 0; i < GC_PSX_LENGTH; i++, b >>= 1) {
                 cmd = (b & 1) ? GC_PSX_COMMAND : 0;
-                parport_write_data(gc->pd->port, cmd | GC_PSX_POWER);
+                parport_write_data(port, cmd | GC_PSX_POWER);
                 udelay(gc_psx_delay);
-                read = parport_read_status(gc->pd->port) ^ 0x80;
-                for (j = 0; j < GC_MAX_DEVICES; j++)
-                        data[j] |= (read & gc_status_bit[j] & (gc->pads[GC_PSX] | gc->pads[GC_DDR])) ? (1 << i) : 0;
+
+                read = parport_read_status(port) ^ 0x80;
+
+                for (j = 0; j < GC_MAX_DEVICES; j++) {
+                        struct gc_pad *pad = &gc->pads[j];
+
+                        if (pad->type == GC_PSX || pad->type == GC_DDR)
+                                data[j] |= (read & gc_status_bit[j]) ? (1 << i) : 0;
+                }
+
                 parport_write_data(gc->pd->port, cmd | GC_PSX_CLOCK | GC_PSX_POWER);
                 udelay(gc_psx_delay);
         }
@@ -432,31 +593,40 @@ static void gc_psx_command(struct gc *gc, int b, unsigned char data[GC_MAX_DEVIC
  * device identifier code.
  */
 
-static void gc_psx_read_packet(struct gc *gc, unsigned char data[GC_MAX_DEVICES][GC_PSX_BYTES],
+static void gc_psx_read_packet(struct gc *gc,
+                               unsigned char data[GC_MAX_DEVICES][GC_PSX_BYTES],
                                unsigned char id[GC_MAX_DEVICES])
 {
         int i, j, max_len = 0;
         unsigned long flags;
         unsigned char data2[GC_MAX_DEVICES];
 
-        parport_write_data(gc->pd->port, GC_PSX_CLOCK | GC_PSX_SELECT | GC_PSX_POWER);  /* Select pad */
+        /* Select pad */
+        parport_write_data(gc->pd->port, GC_PSX_CLOCK | GC_PSX_SELECT | GC_PSX_POWER);
         udelay(gc_psx_delay);
-        parport_write_data(gc->pd->port, GC_PSX_CLOCK | GC_PSX_POWER);                  /* Deselect, begin command */
+        /* Deselect, begin command */
+        parport_write_data(gc->pd->port, GC_PSX_CLOCK | GC_PSX_POWER);
         udelay(gc_psx_delay);
 
         local_irq_save(flags);
 
-        gc_psx_command(gc, 0x01, data2);                                                /* Access pad */
-        gc_psx_command(gc, 0x42, id);                                                   /* Get device ids */
-        gc_psx_command(gc, 0, data2);                                                   /* Dump status */
+        gc_psx_command(gc, 0x01, data2);        /* Access pad */
+        gc_psx_command(gc, 0x42, id);           /* Get device ids */
+        gc_psx_command(gc, 0, data2);           /* Dump status */
 
-        for (i =0; i < GC_MAX_DEVICES; i++)                                                             /* Find the longest pad */
-                if((gc_status_bit[i] & (gc->pads[GC_PSX] | gc->pads[GC_DDR]))
-                        && (GC_PSX_LEN(id[i]) > max_len)
-                        && (GC_PSX_LEN(id[i]) <= GC_PSX_BYTES))
+        /* Find the longest pad */
+        for (i = 0; i < GC_MAX_DEVICES; i++) {
+                struct gc_pad *pad = &gc->pads[i];
+
+                if ((pad->type == GC_PSX || pad->type == GC_DDR) &&
+                    GC_PSX_LEN(id[i]) > max_len &&
+                    GC_PSX_LEN(id[i]) <= GC_PSX_BYTES) {
                         max_len = GC_PSX_LEN(id[i]);
+                }
+        }
 
-        for (i = 0; i < max_len; i++) {                                         /* Read in all the data */
+        /* Read in all the data */
+        for (i = 0; i < max_len; i++) {
                 gc_psx_command(gc, 0, data2);
                 for (j = 0; j < GC_MAX_DEVICES; j++)
                         data[j][i] = data2[j];
@@ -466,86 +636,104 @@ static void gc_psx_read_packet(struct gc *gc, unsigned char data[GC_MAX_DEVICES]
 
         parport_write_data(gc->pd->port, GC_PSX_CLOCK | GC_PSX_SELECT | GC_PSX_POWER);
 
-        for(i = 0; i < GC_MAX_DEVICES; i++)                                                             /* Set id's to the real value */
+        /* Set id's to the real value */
+        for (i = 0; i < GC_MAX_DEVICES; i++)
                 id[i] = GC_PSX_ID(id[i]);
 }
 
-static void gc_psx_process_packet(struct gc *gc)
+static void gc_psx_report_one(struct gc_pad *pad, unsigned char psx_type,
+                              unsigned char *data)
 {
-        unsigned char data[GC_MAX_DEVICES][GC_PSX_BYTES];
-        unsigned char id[GC_MAX_DEVICES];
-        struct input_dev *dev;
-        int i, j;
+        struct input_dev *dev = pad->dev;
+        int i;
 
-        gc_psx_read_packet(gc, data, id);
+        switch (psx_type) {
 
-        for (i = 0; i < GC_MAX_DEVICES; i++) {
+        case GC_PSX_RUMBLE:
 
-                dev = gc->dev[i];
-                if (!dev)
-                        continue;
+                input_report_key(dev, BTN_THUMBL, ~data[0] & 0x04);
+                input_report_key(dev, BTN_THUMBR, ~data[0] & 0x02);
 
-                switch (id[i]) {
+        case GC_PSX_NEGCON:
+        case GC_PSX_ANALOG:
 
-                        case GC_PSX_RUMBLE:
+                if (pad->type == GC_DDR) {
+                        for (i = 0; i < 4; i++)
+                                input_report_key(dev, gc_psx_ddr_btn[i],
+                                                 ~data[0] & (0x10 << i));
+                } else {
+                        for (i = 0; i < 4; i++)
+                                input_report_abs(dev, gc_psx_abs[i + 2],
+                                                 data[i + 2]);
 
-                                input_report_key(dev, BTN_THUMBL, ~data[i][0] & 0x04);
-                                input_report_key(dev, BTN_THUMBR, ~data[i][0] & 0x02);
+                        input_report_abs(dev, ABS_X,
+                                !!(data[0] & 0x80) * 128 + !(data[0] & 0x20) * 127);
+                        input_report_abs(dev, ABS_Y,
+                                !!(data[0] & 0x10) * 128 + !(data[0] & 0x40) * 127);
+                }
 
-                        case GC_PSX_NEGCON:
-                        case GC_PSX_ANALOG:
+                for (i = 0; i < 8; i++)
+                        input_report_key(dev, gc_psx_btn[i], ~data[1] & (1 << i));
 
-                                if (gc->pads[GC_DDR] & gc_status_bit[i]) {
-                                        for(j = 0; j < 4; j++)
-                                                input_report_key(dev, gc_psx_ddr_btn[j], ~data[i][0] & (0x10 << j));
-                                } else {
-                                        for (j = 0; j < 4; j++)
-                                                input_report_abs(dev, gc_psx_abs[j + 2], data[i][j + 2]);
+                input_report_key(dev, BTN_START,  ~data[0] & 0x08);
+                input_report_key(dev, BTN_SELECT, ~data[0] & 0x01);
 
-                                        input_report_abs(dev, ABS_X, 128 + !(data[i][0] & 0x20) * 127 - !(data[i][0] & 0x80) * 128);
-                                        input_report_abs(dev, ABS_Y, 128 + !(data[i][0] & 0x40) * 127 - !(data[i][0] & 0x10) * 128);
-                                }
+                input_sync(dev);
 
-                                for (j = 0; j < 8; j++)
-                                        input_report_key(dev, gc_psx_btn[j], ~data[i][1] & (1 << j));
+                break;
 
-                                input_report_key(dev, BTN_START,  ~data[i][0] & 0x08);
-                                input_report_key(dev, BTN_SELECT, ~data[i][0] & 0x01);
+        case GC_PSX_NORMAL:
 
-                                input_sync(dev);
+                if (pad->type == GC_DDR) {
+                        for (i = 0; i < 4; i++)
+                                input_report_key(dev, gc_psx_ddr_btn[i],
+                                                 ~data[0] & (0x10 << i));
+                } else {
+                        input_report_abs(dev, ABS_X,
+                                !!(data[0] & 0x80) * 128 + !(data[0] & 0x20) * 127);
+                        input_report_abs(dev, ABS_Y,
+                                !!(data[0] & 0x10) * 128 + !(data[0] & 0x40) * 127);
 
-                                break;
-
-                        case GC_PSX_NORMAL:
-                                if (gc->pads[GC_DDR] & gc_status_bit[i]) {
-                                        for(j = 0; j < 4; j++)
-                                                input_report_key(dev, gc_psx_ddr_btn[j], ~data[i][0] & (0x10 << j));
-                                } else {
-                                        input_report_abs(dev, ABS_X, 128 + !(data[i][0] & 0x20) * 127 - !(data[i][0] & 0x80) * 128);
-                                        input_report_abs(dev, ABS_Y, 128 + !(data[i][0] & 0x40) * 127 - !(data[i][0] & 0x10) * 128);
-
-                                        /* for some reason if the extra axes are left unset they drift */
-                                        /* for (j = 0; j < 4; j++)
-                                                input_report_abs(dev, gc_psx_abs[j + 2], 128);
-                                         * This needs to be debugged properly,
-                                         * maybe fuzz processing needs to be done in input_sync()
-                                         *                               --vojtech
-                                         */
-                                }
+                        /*
+                         * For some reason if the extra axes are left unset
+                         * they drift.
+                         * for (i = 0; i < 4; i++)
+                                input_report_abs(dev, gc_psx_abs[i + 2], 128);
+                         * This needs to be debugged properly,
+                         * maybe fuzz processing needs to be done
+                         * in input_sync()
+                         *                               --vojtech
+                         */
+                }
 
-                                for (j = 0; j < 8; j++)
-                                        input_report_key(dev, gc_psx_btn[j], ~data[i][1] & (1 << j));
+                for (i = 0; i < 8; i++)
+                        input_report_key(dev, gc_psx_btn[i], ~data[1] & (1 << i));
 
-                                input_report_key(dev, BTN_START,  ~data[i][0] & 0x08);
-                                input_report_key(dev, BTN_SELECT, ~data[i][0] & 0x01);
+                input_report_key(dev, BTN_START,  ~data[0] & 0x08);
+                input_report_key(dev, BTN_SELECT, ~data[0] & 0x01);
 
-                                input_sync(dev);
+                input_sync(dev);
 
-                                break;
+                break;
 
-                        case 0: /* not a pad, ignore */
-                                break;
-                }
+        default: /* not a pad, ignore */
+                break;
+        }
+}
+
+static void gc_psx_process_packet(struct gc *gc)
+{
+        unsigned char data[GC_MAX_DEVICES][GC_PSX_BYTES];
+        unsigned char id[GC_MAX_DEVICES];
+        struct gc_pad *pad;
+        int i;
+
+        gc_psx_read_packet(gc, data, id);
+
+        for (i = 0; i < GC_MAX_DEVICES; i++) {
+                pad = &gc->pads[i];
+                if (pad->type == GC_PSX || pad->type == GC_DDR)
+                        gc_psx_report_one(pad, id[i], data[i]);
         }
 }
 
@@ -561,28 +749,31 @@ static void gc_timer(unsigned long private)
  * N64 pads - must be read first, any read confuses them for 200 us
  */
 
-        if (gc->pads[GC_N64])
+        if (gc->pad_count[GC_N64])
                 gc_n64_process_packet(gc);
 
 /*
  * NES and SNES pads or mouse
  */
 
-        if (gc->pads[GC_NES] || gc->pads[GC_SNES] || gc->pads[GC_SNESMOUSE])
+        if (gc->pad_count[GC_NES] ||
+            gc->pad_count[GC_SNES] ||
+            gc->pad_count[GC_SNESMOUSE]) {
                 gc_nes_process_packet(gc);
+        }
 
 /*
  * Multi and Multi2 joysticks
  */
 
-        if (gc->pads[GC_MULTI] || gc->pads[GC_MULTI2])
+        if (gc->pad_count[GC_MULTI] || gc->pad_count[GC_MULTI2])
                 gc_multi_process_packet(gc);
 
 /*
  * PSX controllers
  */
 
-        if (gc->pads[GC_PSX] || gc->pads[GC_DDR])
+        if (gc->pad_count[GC_PSX] || gc->pad_count[GC_DDR])
                 gc_psx_process_packet(gc);
 
         mod_timer(&gc->timer, jiffies + GC_REFRESH_TIME);
@@ -622,25 +813,29 @@ static void gc_close(struct input_dev *dev)
 
 static int __init gc_setup_pad(struct gc *gc, int idx, int pad_type)
 {
+        struct gc_pad *pad = &gc->pads[idx];
         struct input_dev *input_dev;
         int i;
+        int err;
 
-        if (!pad_type)
-                return 0;
-
-        if (pad_type < 1 || pad_type > GC_MAX) {
-                printk(KERN_WARNING "gamecon.c: Pad type %d unknown\n", pad_type);
+        if (pad_type < 1 || pad_type >= GC_MAX) {
+                pr_err("Pad type %d unknown\n", pad_type);
                 return -EINVAL;
         }
 
-        gc->dev[idx] = input_dev = input_allocate_device();
+        pad->dev = input_dev = input_allocate_device();
         if (!input_dev) {
-                printk(KERN_ERR "gamecon.c: Not enough memory for input device\n");
+                pr_err("Not enough memory for input device\n");
                 return -ENOMEM;
         }
 
+        pad->type = pad_type;
+
+        snprintf(pad->phys, sizeof(pad->phys),
+                 "%s/input%d", gc->pd->port->name, idx);
+
         input_dev->name = gc_names[pad_type];
-        input_dev->phys = gc->phys[idx];
+        input_dev->phys = pad->phys;
         input_dev->id.bustype = BUS_PARPORT;
         input_dev->id.vendor = 0x0001;
         input_dev->id.product = pad_type;
@@ -659,61 +854,76 @@ static int __init gc_setup_pad(struct gc *gc, int idx, int pad_type)
         } else
                 input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL);
 
-        gc->pads[0] |= gc_status_bit[idx];
-        gc->pads[pad_type] |= gc_status_bit[idx];
+        gc->pad_count[pad_type]++;
 
         switch (pad_type) {
 
-                case GC_N64:
-                        for (i = 0; i < 10; i++)
-                                set_bit(gc_n64_btn[i], input_dev->keybit);
+        case GC_N64:
+                for (i = 0; i < 10; i++)
+                        __set_bit(gc_n64_btn[i], input_dev->keybit);
 
-                        for (i = 0; i < 2; i++) {
-                                input_set_abs_params(input_dev, ABS_X + i, -127, 126, 0, 2);
-                                input_set_abs_params(input_dev, ABS_HAT0X + i, -1, 1, 0, 0);
-                        }
-
-                        break;
-
-                case GC_SNESMOUSE:
-                        set_bit(BTN_LEFT, input_dev->keybit);
-                        set_bit(BTN_RIGHT, input_dev->keybit);
-                        set_bit(REL_X, input_dev->relbit);
-                        set_bit(REL_Y, input_dev->relbit);
-                        break;
-
-                case GC_SNES:
-                        for (i = 4; i < 8; i++)
-                                set_bit(gc_snes_btn[i], input_dev->keybit);
-                case GC_NES:
-                        for (i = 0; i < 4; i++)
-                                set_bit(gc_snes_btn[i], input_dev->keybit);
-                        break;
-
-                case GC_MULTI2:
-                        set_bit(BTN_THUMB, input_dev->keybit);
-                case GC_MULTI:
-                        set_bit(BTN_TRIGGER, input_dev->keybit);
-                        break;
-
-                case GC_PSX:
-                        for (i = 0; i < 6; i++)
-                                input_set_abs_params(input_dev, gc_psx_abs[i], 4, 252, 0, 2);
-                        for (i = 0; i < 12; i++)
-                                set_bit(gc_psx_btn[i], input_dev->keybit);
-
-                        break;
+                for (i = 0; i < 2; i++) {
+                        input_set_abs_params(input_dev, ABS_X + i, -127, 126, 0, 2);
+                        input_set_abs_params(input_dev, ABS_HAT0X + i, -1, 1, 0, 0);
+                }
 
-                case GC_DDR:
-                        for (i = 0; i < 4; i++)
-                                set_bit(gc_psx_ddr_btn[i], input_dev->keybit);
-                        for (i = 0; i < 12; i++)
-                                set_bit(gc_psx_btn[i], input_dev->keybit);
+                err = gc_n64_init_ff(input_dev, idx);
+                if (err) {
+                        pr_warning("Failed to initiate rumble for N64 device %d\n", idx);
+                        goto err_free_dev;
+                }
 
-                        break;
+                break;
+
+        case GC_SNESMOUSE:
+                __set_bit(BTN_LEFT, input_dev->keybit);
+                __set_bit(BTN_RIGHT, input_dev->keybit);
+                __set_bit(REL_X, input_dev->relbit);
+                __set_bit(REL_Y, input_dev->relbit);
+                break;
+
+        case GC_SNES:
+                for (i = 4; i < 8; i++)
+                        __set_bit(gc_snes_btn[i], input_dev->keybit);
+        case GC_NES:
+                for (i = 0; i < 4; i++)
+                        __set_bit(gc_snes_btn[i], input_dev->keybit);
+                break;
+
+        case GC_MULTI2:
+                __set_bit(BTN_THUMB, input_dev->keybit);
+        case GC_MULTI:
+                __set_bit(BTN_TRIGGER, input_dev->keybit);
+                break;
+
+        case GC_PSX:
+                for (i = 0; i < 6; i++)
+                        input_set_abs_params(input_dev,
+                                             gc_psx_abs[i], 4, 252, 0, 2);
+                for (i = 0; i < 12; i++)
+                        __set_bit(gc_psx_btn[i], input_dev->keybit);
+
+                break;
+
+        case GC_DDR:
+                for (i = 0; i < 4; i++)
+                        __set_bit(gc_psx_ddr_btn[i], input_dev->keybit);
+                for (i = 0; i < 12; i++)
+                        __set_bit(gc_psx_btn[i], input_dev->keybit);
+
+                break;
         }
 
+        err = input_register_device(pad->dev);
+        if (err)
+                goto err_free_dev;
+
         return 0;
+
+err_free_dev:
+        input_free_device(pad->dev);
+        pad->dev = NULL;
+        return err;
 }
 
 static struct gc __init *gc_probe(int parport, int *pads, int n_pads)
@@ -722,52 +932,47 @@ static struct gc __init *gc_probe(int parport, int *pads, int n_pads)
         struct parport *pp;
         struct pardevice *pd;
         int i;
+        int count = 0;
         int err;
 
         pp = parport_find_number(parport);
         if (!pp) {
-                printk(KERN_ERR "gamecon.c: no such parport\n");
+                pr_err("no such parport %d\n", parport);
                 err = -EINVAL;
                 goto err_out;
         }
 
         pd = parport_register_device(pp, "gamecon", NULL, NULL, NULL, PARPORT_DEV_EXCL, NULL);
         if (!pd) {
-                printk(KERN_ERR "gamecon.c: parport busy already - lp.o loaded?\n");
+                pr_err("parport busy already - lp.o loaded?\n");
                 err = -EBUSY;
                 goto err_put_pp;
         }
 
         gc = kzalloc(sizeof(struct gc), GFP_KERNEL);
         if (!gc) {
-                printk(KERN_ERR "gamecon.c: Not enough memory\n");
+                pr_err("Not enough memory\n");
                 err = -ENOMEM;
                 goto err_unreg_pardev;
         }
 
         mutex_init(&gc->mutex);
         gc->pd = pd;
-        init_timer(&gc->timer);
-        gc->timer.data = (long) gc;
-        gc->timer.function = gc_timer;
+        setup_timer(&gc->timer, gc_timer, (long) gc);
 
         for (i = 0; i < n_pads && i < GC_MAX_DEVICES; i++) {
                 if (!pads[i])
                         continue;
 
-                snprintf(gc->phys[i], sizeof(gc->phys[i]),
-                         "%s/input%d", gc->pd->port->name, i);
                 err = gc_setup_pad(gc, i, pads[i]);
                 if (err)
                         goto err_unreg_devs;
 
-                err = input_register_device(gc->dev[i]);
-                if (err)
-                        goto err_free_dev;
+                count++;
         }
 
-        if (!gc->pads[0]) {
-                printk(KERN_ERR "gamecon.c: No valid devices specified\n");
+        if (count == 0) {
+                pr_err("No valid devices specified\n");
                 err = -EINVAL;
                 goto err_free_gc;
         }
@@ -775,12 +980,10 @@ static struct gc __init *gc_probe(int parport, int *pads, int n_pads)
         parport_put_port(pp);
         return gc;
 
- err_free_dev:
-        input_free_device(gc->dev[i]);
  err_unreg_devs:
         while (--i >= 0)
-                if (gc->dev[i])
-                        input_unregister_device(gc->dev[i]);
+                if (gc->pads[i].dev)
+                        input_unregister_device(gc->pads[i].dev);
  err_free_gc:
         kfree(gc);
  err_unreg_pardev:
@@ -796,8 +999,8 @@ static void gc_remove(struct gc *gc)
         int i;
 
         for (i = 0; i < GC_MAX_DEVICES; i++)
-                if (gc->dev[i])
-                        input_unregister_device(gc->dev[i]);
+                if (gc->pads[i].dev)
+                        input_unregister_device(gc->pads[i].dev);
         parport_unregister_device(gc->pd);
         kfree(gc);
 }
@@ -813,7 +1016,7 @@ static int __init gc_init(void)
                         continue;
 
                 if (gc_cfg[i].nargs < 2) {
-                        printk(KERN_ERR "gamecon.c: at least one device must be specified\n");
+                        pr_err("at least one device must be specified\n");
                         err = -EINVAL;
                         break;
                 }
diff --git a/drivers/input/joystick/gf2k.c b/drivers/input/joystick/gf2k.c
index 45ac70eae0aa..0536b1b2f018 100644
--- a/drivers/input/joystick/gf2k.c
+++ b/drivers/input/joystick/gf2k.c
@@ -318,11 +318,8 @@ static int gf2k_connect(struct gameport *gameport, struct gameport_driver *drv)
         for (i = 0; i < gf2k_axes[gf2k->id]; i++)
                 set_bit(gf2k_abs[i], input_dev->absbit);
 
-        for (i = 0; i < gf2k_hats[gf2k->id]; i++) {
-                set_bit(ABS_HAT0X + i, input_dev->absbit);
-                input_dev->absmin[ABS_HAT0X + i] = -1;
-                input_dev->absmax[ABS_HAT0X + i] = 1;
-        }
+        for (i = 0; i < gf2k_hats[gf2k->id]; i++)
+                input_set_abs_params(input_dev, ABS_HAT0X + i, -1, 1, 0, 0);
 
         for (i = 0; i < gf2k_joys[gf2k->id]; i++)
                 set_bit(gf2k_btn_joy[i], input_dev->keybit);
@@ -334,11 +331,14 @@ static int gf2k_connect(struct gameport *gameport, struct gameport_driver *drv)
         gf2k_read(gf2k, data);
 
         for (i = 0; i < gf2k_axes[gf2k->id]; i++) {
-                input_dev->absmax[gf2k_abs[i]] = (i < 2) ? input_dev->abs[gf2k_abs[i]] * 2 - 32 :
-                          input_dev->abs[gf2k_abs[0]] + input_dev->abs[gf2k_abs[1]] - 32;
-                input_dev->absmin[gf2k_abs[i]] = 32;
-                input_dev->absfuzz[gf2k_abs[i]] = 8;
-                input_dev->absflat[gf2k_abs[i]] = (i < 2) ? 24 : 0;
+                int max = i < 2 ?
+                        input_abs_get_val(input_dev, gf2k_abs[i]) * 2 :
+                        input_abs_get_val(input_dev, gf2k_abs[0]) +
+                                input_abs_get_val(input_dev, gf2k_abs[1]);
+                int flat = i < 2 ? 24 : 0;
+
+                input_set_abs_params(input_dev, gf2k_abs[i],
+                                     32, max - 32, 8, flat);
         }
 
         err = input_register_device(gf2k->dev);
diff --git a/drivers/input/joystick/iforce/iforce-main.c b/drivers/input/joystick/iforce/iforce-main.c
index b1edd778639c..405febd94f24 100644
--- a/drivers/input/joystick/iforce/iforce-main.c
+++ b/drivers/input/joystick/iforce/iforce-main.c
@@ -54,6 +54,9 @@ static signed short btn_avb_wheel[] =
 static signed short abs_joystick[] =
 { ABS_X, ABS_Y, ABS_THROTTLE, ABS_HAT0X, ABS_HAT0Y, -1 };
 
+static signed short abs_joystick_rudder[] =
+{ ABS_X, ABS_Y, ABS_THROTTLE, ABS_RUDDER, ABS_HAT0X, ABS_HAT0Y, -1 };
+
 static signed short abs_avb_pegasus[] =
 { ABS_X, ABS_Y, ABS_THROTTLE, ABS_RUDDER, ABS_HAT0X, ABS_HAT0Y,
   ABS_HAT1X, ABS_HAT1Y, -1 };
@@ -76,8 +79,9 @@ static struct iforce_device iforce_device[] = {
         { 0x061c, 0xc0a4, "ACT LABS Force RS",                          btn_wheel, abs_wheel, ff_iforce }, //?
         { 0x061c, 0xc084, "ACT LABS Force RS",                          btn_wheel, abs_wheel, ff_iforce },
         { 0x06f8, 0x0001, "Guillemot Race Leader Force Feedback",       btn_wheel, abs_wheel, ff_iforce }, //?
+        { 0x06f8, 0x0001, "Guillemot Jet Leader Force Feedback",        btn_joystick, abs_joystick_rudder, ff_iforce },
         { 0x06f8, 0x0004, "Guillemot Force Feedback Racing Wheel",      btn_wheel, abs_wheel, ff_iforce }, //?
-        { 0x06f8, 0x0004, "Gullemot Jet Leader 3D",                     btn_joystick, abs_joystick, ff_iforce }, //?
+        { 0x06f8, 0xa302, "Guillemot Jet Leader 3D",                    btn_joystick, abs_joystick, ff_iforce }, //?
         { 0x06d6, 0x29bc, "Trust Force Feedback Race Master",           btn_wheel, abs_wheel, ff_iforce },
         { 0x0000, 0x0000, "Unknown I-Force Device [%04x:%04x]",         btn_joystick, abs_joystick, ff_iforce }
 };
diff --git a/drivers/input/joystick/iforce/iforce-usb.c b/drivers/input/joystick/iforce/iforce-usb.c
index b41303d3ec54..6c96631ae5d9 100644
--- a/drivers/input/joystick/iforce/iforce-usb.c
+++ b/drivers/input/joystick/iforce/iforce-usb.c
@@ -212,6 +212,7 @@ static struct usb_device_id iforce_usb_ids [] = {
         { USB_DEVICE(0x061c, 0xc0a4) },         /* ACT LABS Force RS */
         { USB_DEVICE(0x061c, 0xc084) },         /* ACT LABS Force RS */
         { USB_DEVICE(0x06f8, 0x0001) },         /* Guillemot Race Leader Force Feedback */
+        { USB_DEVICE(0x06f8, 0x0003) },         /* Guillemot Jet Leader Force Feedback */
         { USB_DEVICE(0x06f8, 0x0004) },         /* Guillemot Force Feedback Racing Wheel */
         { USB_DEVICE(0x06f8, 0xa302) },         /* Guillemot Jet Leader 3D */
         { }                                     /* Terminating entry */
diff --git a/drivers/input/joystick/interact.c b/drivers/input/joystick/interact.c
index 2478289aeeea..16fb19d1ca25 100644
--- a/drivers/input/joystick/interact.c
+++ b/drivers/input/joystick/interact.c
@@ -270,18 +270,14 @@ static int interact_connect(struct gameport *gameport, struct gameport_driver *d
         input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
 
         for (i = 0; (t = interact_type[interact->type].abs[i]) >= 0; i++) {
-                set_bit(t, input_dev->absbit);
-                if (i < interact_type[interact->type].b8) {
-                        input_dev->absmin[t] = 0;
-                        input_dev->absmax[t] = 255;
-                } else {
-                        input_dev->absmin[t] = -1;
-                        input_dev->absmax[t] = 1;
-                }
+                if (i < interact_type[interact->type].b8)
+                        input_set_abs_params(input_dev, t, 0, 255, 0, 0);
+                else
+                        input_set_abs_params(input_dev, t, -1, 1, 0, 0);
         }
 
         for (i = 0; (t = interact_type[interact->type].btn[i]) >= 0; i++)
-                set_bit(t, input_dev->keybit);
+                __set_bit(t, input_dev->keybit);
 
         err = input_register_device(interact->dev);
         if (err)
diff --git a/drivers/input/joystick/sidewinder.c b/drivers/input/joystick/sidewinder.c
index ca13a6bec33e..b8d86115644b 100644
--- a/drivers/input/joystick/sidewinder.c
+++ b/drivers/input/joystick/sidewinder.c
@@ -761,17 +761,21 @@ static int sw_connect(struct gameport *gameport, struct gameport_driver *drv)
                 input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
 
                 for (j = 0; (bits = sw_bit[sw->type][j]); j++) {
+                        int min, max, fuzz, flat;
+
                         code = sw_abs[sw->type][j];
-                        set_bit(code, input_dev->absbit);
-                        input_dev->absmax[code] = (1 << bits) - 1;
-                        input_dev->absmin[code] = (bits == 1) ? -1 : 0;
-                        input_dev->absfuzz[code] = ((bits >> 1) >= 2) ? (1 << ((bits >> 1) - 2)) : 0;
-                        if (code != ABS_THROTTLE)
-                                input_dev->absflat[code] = (bits >= 5) ? (1 << (bits - 5)) : 0;
+                        min = bits == 1 ? -1 : 0;
+                        max = (1 << bits) - 1;
+                        fuzz = (bits >> 1) >= 2 ? 1 << ((bits >> 1) - 2) : 0;
+                        flat = code == ABS_THROTTLE || bits < 5 ?
+                                0 : 1 << (bits - 5);
+
+                        input_set_abs_params(input_dev, code,
+                                             min, max, fuzz, flat);
                 }
 
                 for (j = 0; (code = sw_btn[sw->type][j]); j++)
-                        set_bit(code, input_dev->keybit);
+                        __set_bit(code, input_dev->keybit);
 
                 dbg("%s%s [%d-bit id %d data %d]\n", sw->name, comment, m, l, k);
 
diff --git a/drivers/input/joystick/turbografx.c b/drivers/input/joystick/turbografx.c
index b6f859869540..d53b9e900234 100644
--- a/drivers/input/joystick/turbografx.c
+++ b/drivers/input/joystick/turbografx.c
@@ -35,6 +35,7 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/mutex.h>
+#include <linux/slab.h>
 
 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
 MODULE_DESCRIPTION("TurboGraFX parallel port interface driver");
diff --git a/drivers/input/joystick/xpad.c b/drivers/input/joystick/xpad.c
index 8a28fb7846dc..f9fb7fa10af3 100644
--- a/drivers/input/joystick/xpad.c
+++ b/drivers/input/joystick/xpad.c
@@ -9,6 +9,7 @@
  *               2005 Dominic Cerquetti <binary1230@yahoo.com>
  *               2006 Adam Buchbinder <adam.buchbinder@gmail.com>
  *               2007 Jan Kratochvil <honza@jikos.cz>
+ *               2010 Christoph Fritz <chf.fritz@googlemail.com>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
@@ -86,9 +87,11 @@
 
 /* xbox d-pads should map to buttons, as is required for DDR pads
    but we map them to axes when possible to simplify things */
-#define MAP_DPAD_TO_BUTTONS    0
-#define MAP_DPAD_TO_AXES       1
-#define MAP_DPAD_UNKNOWN       2
+#define MAP_DPAD_TO_BUTTONS             (1 << 0)
+#define MAP_TRIGGERS_TO_BUTTONS         (1 << 1)
+#define MAP_STICKS_TO_NULL              (1 << 2)
+#define DANCEPAD_MAP_CONFIG     (MAP_DPAD_TO_BUTTONS |                  \
+                                MAP_TRIGGERS_TO_BUTTONS | MAP_STICKS_TO_NULL)
 
 #define XTYPE_XBOX        0
 #define XTYPE_XBOX360     1
@@ -99,63 +102,73 @@ static int dpad_to_buttons;
 module_param(dpad_to_buttons, bool, S_IRUGO);
 MODULE_PARM_DESC(dpad_to_buttons, "Map D-PAD to buttons rather than axes for unknown pads");
 
+static int triggers_to_buttons;
+module_param(triggers_to_buttons, bool, S_IRUGO);
+MODULE_PARM_DESC(triggers_to_buttons, "Map triggers to buttons rather than axes for unknown pads");
+
+static int sticks_to_null;
+module_param(sticks_to_null, bool, S_IRUGO);
+MODULE_PARM_DESC(sticks_to_null, "Do not map sticks at all for unknown pads");
+
 static const struct xpad_device {
         u16 idVendor;
         u16 idProduct;
         char *name;
-        u8 dpad_mapping;
+        u8 mapping;
         u8 xtype;
 } xpad_device[] = {
-        { 0x045e, 0x0202, "Microsoft X-Box pad v1 (US)", MAP_DPAD_TO_AXES, XTYPE_XBOX },
-        { 0x045e, 0x0289, "Microsoft X-Box pad v2 (US)", MAP_DPAD_TO_AXES, XTYPE_XBOX },
-        { 0x045e, 0x0285, "Microsoft X-Box pad (Japan)", MAP_DPAD_TO_AXES, XTYPE_XBOX },
-        { 0x045e, 0x0287, "Microsoft Xbox Controller S", MAP_DPAD_TO_AXES, XTYPE_XBOX },
+        { 0x045e, 0x0202, "Microsoft X-Box pad v1 (US)", 0, XTYPE_XBOX },
+        { 0x045e, 0x0289, "Microsoft X-Box pad v2 (US)", 0, XTYPE_XBOX },
+        { 0x045e, 0x0285, "Microsoft X-Box pad (Japan)", 0, XTYPE_XBOX },
+        { 0x045e, 0x0287, "Microsoft Xbox Controller S", 0, XTYPE_XBOX },
         { 0x045e, 0x0719, "Xbox 360 Wireless Receiver", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360W },
-        { 0x0c12, 0x8809, "RedOctane Xbox Dance Pad", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
-        { 0x044f, 0x0f07, "Thrustmaster, Inc. Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX },
-        { 0x046d, 0xc242, "Logitech Chillstream Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX360 },
-        { 0x046d, 0xca84, "Logitech Xbox Cordless Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX },
-        { 0x046d, 0xca88, "Logitech Compact Controller for Xbox", MAP_DPAD_TO_AXES, XTYPE_XBOX },
-        { 0x05fd, 0x1007, "Mad Catz Controller (unverified)", MAP_DPAD_TO_AXES, XTYPE_XBOX },
-        { 0x05fd, 0x107a, "InterAct 'PowerPad Pro' X-Box pad (Germany)", MAP_DPAD_TO_AXES, XTYPE_XBOX },
-        { 0x0738, 0x4516, "Mad Catz Control Pad", MAP_DPAD_TO_AXES, XTYPE_XBOX },
-        { 0x0738, 0x4522, "Mad Catz LumiCON", MAP_DPAD_TO_AXES, XTYPE_XBOX },
-        { 0x0738, 0x4526, "Mad Catz Control Pad Pro", MAP_DPAD_TO_AXES, XTYPE_XBOX },
-        { 0x0738, 0x4536, "Mad Catz MicroCON", MAP_DPAD_TO_AXES, XTYPE_XBOX },
+        { 0x0c12, 0x8809, "RedOctane Xbox Dance Pad", DANCEPAD_MAP_CONFIG, XTYPE_XBOX },
+        { 0x044f, 0x0f07, "Thrustmaster, Inc. Controller", 0, XTYPE_XBOX },
+        { 0x046d, 0xc242, "Logitech Chillstream Controller", 0, XTYPE_XBOX360 },
+        { 0x046d, 0xca84, "Logitech Xbox Cordless Controller", 0, XTYPE_XBOX },
+        { 0x046d, 0xca88, "Logitech Compact Controller for Xbox", 0, XTYPE_XBOX },
+        { 0x05fd, 0x1007, "Mad Catz Controller (unverified)", 0, XTYPE_XBOX },
+        { 0x05fd, 0x107a, "InterAct 'PowerPad Pro' X-Box pad (Germany)", 0, XTYPE_XBOX },
+        { 0x0738, 0x4516, "Mad Catz Control Pad", 0, XTYPE_XBOX },
+        { 0x0738, 0x4522, "Mad Catz LumiCON", 0, XTYPE_XBOX },
+        { 0x0738, 0x4526, "Mad Catz Control Pad Pro", 0, XTYPE_XBOX },
+        { 0x0738, 0x4536, "Mad Catz MicroCON", 0, XTYPE_XBOX },
         { 0x0738, 0x4540, "Mad Catz Beat Pad", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
-        { 0x0738, 0x4556, "Mad Catz Lynx Wireless Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX },
-        { 0x0738, 0x4716, "Mad Catz Wired Xbox 360 Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX360 },
-        { 0x0738, 0x4738, "Mad Catz Wired Xbox 360 Controller (SFIV)", MAP_DPAD_TO_AXES, XTYPE_XBOX360 },
+        { 0x0738, 0x4556, "Mad Catz Lynx Wireless Controller", 0, XTYPE_XBOX },
+        { 0x0738, 0x4716, "Mad Catz Wired Xbox 360 Controller", 0, XTYPE_XBOX360 },
+        { 0x0738, 0x4738, "Mad Catz Wired Xbox 360 Controller (SFIV)", MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
         { 0x0738, 0x6040, "Mad Catz Beat Pad Pro", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
-        { 0x0c12, 0x8802, "Zeroplus Xbox Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX },
-        { 0x0c12, 0x880a, "Pelican Eclipse PL-2023", MAP_DPAD_TO_AXES, XTYPE_XBOX },
-        { 0x0c12, 0x8810, "Zeroplus Xbox Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX },
-        { 0x0c12, 0x9902, "HAMA VibraX - *FAULTY HARDWARE*", MAP_DPAD_TO_AXES, XTYPE_XBOX },
-        { 0x0e4c, 0x1097, "Radica Gamester Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX },
-        { 0x0e4c, 0x2390, "Radica Games Jtech Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX },
-        { 0x0e6f, 0x0003, "Logic3 Freebird wireless Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX },
-        { 0x0e6f, 0x0005, "Eclipse wireless Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX },
-        { 0x0e6f, 0x0006, "Edge wireless Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX },
-        { 0x0e6f, 0x0006, "Pelican 'TSZ' Wired Xbox 360 Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX360 },
-        { 0x0e8f, 0x0201, "SmartJoy Frag Xpad/PS2 adaptor", MAP_DPAD_TO_AXES, XTYPE_XBOX },
-        { 0x0f30, 0x0202, "Joytech Advanced Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX },
-        { 0x0f30, 0x8888, "BigBen XBMiniPad Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX },
-        { 0x102c, 0xff0c, "Joytech Wireless Advanced Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX },
+        { 0x0c12, 0x8802, "Zeroplus Xbox Controller", 0, XTYPE_XBOX },
+        { 0x0c12, 0x880a, "Pelican Eclipse PL-2023", 0, XTYPE_XBOX },
+        { 0x0c12, 0x8810, "Zeroplus Xbox Controller", 0, XTYPE_XBOX },
+        { 0x0c12, 0x9902, "HAMA VibraX - *FAULTY HARDWARE*", 0, XTYPE_XBOX },
+        { 0x0e4c, 0x1097, "Radica Gamester Controller", 0, XTYPE_XBOX },
+        { 0x0e4c, 0x2390, "Radica Games Jtech Controller", 0, XTYPE_XBOX },
+        { 0x0e6f, 0x0003, "Logic3 Freebird wireless Controller", 0, XTYPE_XBOX },
+        { 0x0e6f, 0x0005, "Eclipse wireless Controller", 0, XTYPE_XBOX },
+        { 0x0e6f, 0x0006, "Edge wireless Controller", 0, XTYPE_XBOX },
+        { 0x0e6f, 0x0006, "Pelican 'TSZ' Wired Xbox 360 Controller", 0, XTYPE_XBOX360 },
+        { 0x0e6f, 0x0201, "Pelican PL-3601 'TSZ' Wired Xbox 360 Controller", 0, XTYPE_XBOX360 },
+        { 0x0e8f, 0x0201, "SmartJoy Frag Xpad/PS2 adaptor", 0, XTYPE_XBOX },
+        { 0x0f30, 0x0202, "Joytech Advanced Controller", 0, XTYPE_XBOX },
+        { 0x0f30, 0x8888, "BigBen XBMiniPad Controller", 0, XTYPE_XBOX },
+        { 0x102c, 0xff0c, "Joytech Wireless Advanced Controller", 0, XTYPE_XBOX },
         { 0x12ab, 0x8809, "Xbox DDR dancepad", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
-        { 0x1430, 0x4748, "RedOctane Guitar Hero X-plorer", MAP_DPAD_TO_AXES, XTYPE_XBOX360 },
+        { 0x1430, 0x4748, "RedOctane Guitar Hero X-plorer", 0, XTYPE_XBOX360 },
         { 0x1430, 0x8888, "TX6500+ Dance Pad (first generation)", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
-        { 0x146b, 0x0601, "BigBen Interactive XBOX 360 Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX360 },
-        { 0x045e, 0x028e, "Microsoft X-Box 360 pad", MAP_DPAD_TO_AXES, XTYPE_XBOX360 },
+        { 0x146b, 0x0601, "BigBen Interactive XBOX 360 Controller", 0, XTYPE_XBOX360 },
+        { 0x045e, 0x028e, "Microsoft X-Box 360 pad", 0, XTYPE_XBOX360 },
         { 0x1bad, 0x0003, "Harmonix Rock Band Drumkit", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360 },
-        { 0x0f0d, 0x0016, "Hori Real Arcade Pro.EX", MAP_DPAD_TO_AXES, XTYPE_XBOX360 },
-        { 0xffff, 0xffff, "Chinese-made Xbox Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX },
-        { 0x0000, 0x0000, "Generic X-Box pad", MAP_DPAD_UNKNOWN, XTYPE_UNKNOWN }
+        { 0x0f0d, 0x0016, "Hori Real Arcade Pro.EX", MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
+        { 0x0f0d, 0x000d, "Hori Fighting Stick EX2", MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
+        { 0xffff, 0xffff, "Chinese-made Xbox Controller", 0, XTYPE_XBOX },
+        { 0x0000, 0x0000, "Generic X-Box pad", 0, XTYPE_UNKNOWN }
 };
 
 /* buttons shared with xbox and xbox360 */
 static const signed short xpad_common_btn[] = {
         BTN_A, BTN_B, BTN_X, BTN_Y,                     /* "analog" buttons */
-        BTN_START, BTN_BACK, BTN_THUMBL, BTN_THUMBR,    /* start/back/sticks */
+        BTN_START, BTN_SELECT, BTN_THUMBL, BTN_THUMBR,  /* start/back/sticks */
         -1                                              /* terminating entry */
 };
 
@@ -165,13 +178,20 @@ static const signed short xpad_btn[] = {
         -1                      /* terminating entry */
 };
 
-/* only used if MAP_DPAD_TO_BUTTONS */
+/* used when dpad is mapped to buttons */
 static const signed short xpad_btn_pad[] = {
-        BTN_LEFT, BTN_RIGHT,            /* d-pad left, right */
-        BTN_0, BTN_1,                   /* d-pad up, down (XXX names??) */
+        BTN_TRIGGER_HAPPY1, BTN_TRIGGER_HAPPY2,         /* d-pad left, right */
+        BTN_TRIGGER_HAPPY3, BTN_TRIGGER_HAPPY4,         /* d-pad up, down */
         -1                              /* terminating entry */
 };
 
+/* used when triggers are mapped to buttons */
+static const signed short xpad_btn_triggers[] = {
+        BTN_TL2, BTN_TR2,               /* triggers left/right */
+        -1
+};
+
+
 static const signed short xpad360_btn[] = {  /* buttons for x360 controller */
         BTN_TL, BTN_TR,         /* Button LB/RB */
         BTN_MODE,               /* The big X button */
@@ -181,16 +201,21 @@ static const signed short xpad360_btn[] = {  /* buttons for x360 controller */
 static const signed short xpad_abs[] = {
         ABS_X, ABS_Y,           /* left stick */
         ABS_RX, ABS_RY,         /* right stick */
-        ABS_Z, ABS_RZ,          /* triggers left/right */
         -1                      /* terminating entry */
 };
 
-/* only used if MAP_DPAD_TO_AXES */
+/* used when dpad is mapped to axes */
 static const signed short xpad_abs_pad[] = {
         ABS_HAT0X, ABS_HAT0Y,   /* d-pad axes */
         -1                      /* terminating entry */
 };
 
+/* used when triggers are mapped to axes */
+static const signed short xpad_abs_triggers[] = {
+        ABS_Z, ABS_RZ,          /* triggers left/right */
+        -1
+};
+
 /* Xbox 360 has a vendor-specific class, so we cannot match it with only
  * USB_INTERFACE_INFO (also specifically refused by USB subsystem), so we
  * match against vendor id as well. Wired Xbox 360 devices have protocol 1,
@@ -246,7 +271,7 @@ struct usb_xpad {
 
         char phys[64];                  /* physical device path */
 
-        int dpad_mapping;               /* map d-pad to buttons or to axes */
+        int mapping;                    /* map d-pad to buttons or to axes */
         int xtype;                      /* type of xbox device */
 };
 
@@ -264,38 +289,46 @@ static void xpad_process_packet(struct usb_xpad *xpad, u16 cmd, unsigned char *d
 {
         struct input_dev *dev = xpad->dev;
 
-        /* left stick */
-        input_report_abs(dev, ABS_X,
-                         (__s16) le16_to_cpup((__le16 *)(data + 12)));
-        input_report_abs(dev, ABS_Y,
-                         ~(__s16) le16_to_cpup((__le16 *)(data + 14)));
-
-        /* right stick */
-        input_report_abs(dev, ABS_RX,
-                         (__s16) le16_to_cpup((__le16 *)(data + 16)));
-        input_report_abs(dev, ABS_RY,
-                         ~(__s16) le16_to_cpup((__le16 *)(data + 18)));
+        if (!(xpad->mapping & MAP_STICKS_TO_NULL)) {
+                /* left stick */
+                input_report_abs(dev, ABS_X,
+                                 (__s16) le16_to_cpup((__le16 *)(data + 12)));
+                input_report_abs(dev, ABS_Y,
+                                 ~(__s16) le16_to_cpup((__le16 *)(data + 14)));
+
+                /* right stick */
+                input_report_abs(dev, ABS_RX,
+                                 (__s16) le16_to_cpup((__le16 *)(data + 16)));
+                input_report_abs(dev, ABS_RY,
+                                 ~(__s16) le16_to_cpup((__le16 *)(data + 18)));
+        }
 
         /* triggers left/right */
-        input_report_abs(dev, ABS_Z, data[10]);
-        input_report_abs(dev, ABS_RZ, data[11]);
+        if (xpad->mapping & MAP_TRIGGERS_TO_BUTTONS) {
+                input_report_key(dev, BTN_TL2, data[10]);
+                input_report_key(dev, BTN_TR2, data[11]);
+        } else {
+                input_report_abs(dev, ABS_Z, data[10]);
+                input_report_abs(dev, ABS_RZ, data[11]);
+        }
 
         /* digital pad */
-        if (xpad->dpad_mapping == MAP_DPAD_TO_AXES) {
+        if (xpad->mapping & MAP_DPAD_TO_BUTTONS) {
+                /* dpad as buttons (left, right, up, down) */
+                input_report_key(dev, BTN_TRIGGER_HAPPY1, data[2] & 0x04);
+                input_report_key(dev, BTN_TRIGGER_HAPPY2, data[2] & 0x08);
+                input_report_key(dev, BTN_TRIGGER_HAPPY3, data[2] & 0x01);
+                input_report_key(dev, BTN_TRIGGER_HAPPY4, data[2] & 0x02);
+        } else {
                 input_report_abs(dev, ABS_HAT0X,
                                  !!(data[2] & 0x08) - !!(data[2] & 0x04));
                 input_report_abs(dev, ABS_HAT0Y,
                                  !!(data[2] & 0x02) - !!(data[2] & 0x01));
-        } else /* xpad->dpad_mapping == MAP_DPAD_TO_BUTTONS */ {
-                input_report_key(dev, BTN_LEFT,  data[2] & 0x04);
-                input_report_key(dev, BTN_RIGHT, data[2] & 0x08);
-                input_report_key(dev, BTN_0,     data[2] & 0x01); /* up */
-                input_report_key(dev, BTN_1,     data[2] & 0x02); /* down */
         }
 
         /* start/back buttons and stick press left/right */
         input_report_key(dev, BTN_START,  data[2] & 0x10);
-        input_report_key(dev, BTN_BACK,   data[2] & 0x20);
+        input_report_key(dev, BTN_SELECT, data[2] & 0x20);
         input_report_key(dev, BTN_THUMBL, data[2] & 0x40);
         input_report_key(dev, BTN_THUMBR, data[2] & 0x80);
 
@@ -328,22 +361,22 @@ static void xpad360_process_packet(struct usb_xpad *xpad,
         struct input_dev *dev = xpad->dev;
 
         /* digital pad */
-        if (xpad->dpad_mapping == MAP_DPAD_TO_AXES) {
+        if (xpad->mapping & MAP_DPAD_TO_BUTTONS) {
+                /* dpad as buttons (left, right, up, down) */
+                input_report_key(dev, BTN_TRIGGER_HAPPY1, data[2] & 0x04);
+                input_report_key(dev, BTN_TRIGGER_HAPPY2, data[2] & 0x08);
+                input_report_key(dev, BTN_TRIGGER_HAPPY3, data[2] & 0x01);
+                input_report_key(dev, BTN_TRIGGER_HAPPY4, data[2] & 0x02);
+        } else {
                 input_report_abs(dev, ABS_HAT0X,
                                  !!(data[2] & 0x08) - !!(data[2] & 0x04));
                 input_report_abs(dev, ABS_HAT0Y,
                                  !!(data[2] & 0x02) - !!(data[2] & 0x01));
-        } else if (xpad->dpad_mapping == MAP_DPAD_TO_BUTTONS) {
-                /* dpad as buttons (right, left, down, up) */
-                input_report_key(dev, BTN_LEFT, data[2] & 0x04);
-                input_report_key(dev, BTN_RIGHT, data[2] & 0x08);
-                input_report_key(dev, BTN_0, data[2] & 0x01);   /* up */
-                input_report_key(dev, BTN_1, data[2] & 0x02);   /* down */
         }
 
         /* start/back buttons */
         input_report_key(dev, BTN_START,  data[2] & 0x10);
-        input_report_key(dev, BTN_BACK,   data[2] & 0x20);
+        input_report_key(dev, BTN_SELECT, data[2] & 0x20);
 
         /* stick press left/right */
         input_report_key(dev, BTN_THUMBL, data[2] & 0x40);
@@ -358,21 +391,28 @@ static void xpad360_process_packet(struct usb_xpad *xpad,
         input_report_key(dev, BTN_TR,   data[3] & 0x02);
         input_report_key(dev, BTN_MODE, data[3] & 0x04);
 
-        /* left stick */
-        input_report_abs(dev, ABS_X,
-                         (__s16) le16_to_cpup((__le16 *)(data + 6)));
-        input_report_abs(dev, ABS_Y,
-                         ~(__s16) le16_to_cpup((__le16 *)(data + 8)));
-
-        /* right stick */
-        input_report_abs(dev, ABS_RX,
-                         (__s16) le16_to_cpup((__le16 *)(data + 10)));
-        input_report_abs(dev, ABS_RY,
-                         ~(__s16) le16_to_cpup((__le16 *)(data + 12)));
+        if (!(xpad->mapping & MAP_STICKS_TO_NULL)) {
+                /* left stick */
+                input_report_abs(dev, ABS_X,
+                                 (__s16) le16_to_cpup((__le16 *)(data + 6)));
+                input_report_abs(dev, ABS_Y,
+                                 ~(__s16) le16_to_cpup((__le16 *)(data + 8)));
+
+                /* right stick */
+                input_report_abs(dev, ABS_RX,
+                                 (__s16) le16_to_cpup((__le16 *)(data + 10)));
+                input_report_abs(dev, ABS_RY,
+                                 ~(__s16) le16_to_cpup((__le16 *)(data + 12)));
+        }
 
         /* triggers left/right */
-        input_report_abs(dev, ABS_Z, data[4]);
-        input_report_abs(dev, ABS_RZ, data[5]);
+        if (xpad->mapping & MAP_TRIGGERS_TO_BUTTONS) {
+                input_report_key(dev, BTN_TL2, data[4]);
+                input_report_key(dev, BTN_TR2, data[5]);
+        } else {
+                input_report_abs(dev, ABS_Z, data[4]);
+                input_report_abs(dev, ABS_RZ, data[5]);
+        }
 
         input_sync(dev);
 }
@@ -505,11 +545,11 @@ static int xpad_init_output(struct usb_interface *intf, struct usb_xpad *xpad)
         struct usb_endpoint_descriptor *ep_irq_out;
         int error = -ENOMEM;
 
-        if (xpad->xtype != XTYPE_XBOX360)
+        if (xpad->xtype != XTYPE_XBOX360 && xpad->xtype != XTYPE_XBOX)
                 return 0;
 
-        xpad->odata = usb_buffer_alloc(xpad->udev, XPAD_PKT_LEN,
-                                       GFP_KERNEL, &xpad->odata_dma);
+        xpad->odata = usb_alloc_coherent(xpad->udev, XPAD_PKT_LEN,
+                                         GFP_KERNEL, &xpad->odata_dma);
         if (!xpad->odata)
                 goto fail1;
 
@@ -529,21 +569,21 @@ static int xpad_init_output(struct usb_interface *intf, struct usb_xpad *xpad)
 
         return 0;
 
- fail2: usb_buffer_free(xpad->udev, XPAD_PKT_LEN, xpad->odata, xpad->odata_dma);
+ fail2: usb_free_coherent(xpad->udev, XPAD_PKT_LEN, xpad->odata, xpad->odata_dma);
  fail1: return error;
 }
 
 static void xpad_stop_output(struct usb_xpad *xpad)
 {
-        if (xpad->xtype == XTYPE_XBOX360)
+        if (xpad->xtype == XTYPE_XBOX360 || xpad->xtype == XTYPE_XBOX)
                 usb_kill_urb(xpad->irq_out);
 }
 
 static void xpad_deinit_output(struct usb_xpad *xpad)
 {
-        if (xpad->xtype == XTYPE_XBOX360) {
+        if (xpad->xtype == XTYPE_XBOX360 || xpad->xtype == XTYPE_XBOX) {
                 usb_free_urb(xpad->irq_out);
-                usb_buffer_free(xpad->udev, XPAD_PKT_LEN,
+                usb_free_coherent(xpad->udev, XPAD_PKT_LEN,
                                 xpad->odata, xpad->odata_dma);
         }
 }
@@ -554,24 +594,45 @@ static void xpad_stop_output(struct usb_xpad *xpad) {}
 #endif
 
 #ifdef CONFIG_JOYSTICK_XPAD_FF
-static int xpad_play_effect(struct input_dev *dev, void *data,
-                            struct ff_effect *effect)
+static int xpad_play_effect(struct input_dev *dev, void *data, struct ff_effect *effect)
 {
         struct usb_xpad *xpad = input_get_drvdata(dev);
 
         if (effect->type == FF_RUMBLE) {
                 __u16 strong = effect->u.rumble.strong_magnitude;
                 __u16 weak = effect->u.rumble.weak_magnitude;
-                xpad->odata[0] = 0x00;
-                xpad->odata[1] = 0x08;
-                xpad->odata[2] = 0x00;
-                xpad->odata[3] = strong / 256;
-                xpad->odata[4] = weak / 256;
-                xpad->odata[5] = 0x00;
-                xpad->odata[6] = 0x00;
-                xpad->odata[7] = 0x00;
-                xpad->irq_out->transfer_buffer_length = 8;
-                usb_submit_urb(xpad->irq_out, GFP_ATOMIC);
+
+                switch (xpad->xtype) {
+
+                case XTYPE_XBOX:
+                        xpad->odata[0] = 0x00;
+                        xpad->odata[1] = 0x06;
+                        xpad->odata[2] = 0x00;
+                        xpad->odata[3] = strong / 256;  /* left actuator */
+                        xpad->odata[4] = 0x00;
+                        xpad->odata[5] = weak / 256;    /* right actuator */
+                        xpad->irq_out->transfer_buffer_length = 6;
+
+                        return usb_submit_urb(xpad->irq_out, GFP_ATOMIC);
+
+                case XTYPE_XBOX360:
+                        xpad->odata[0] = 0x00;
+                        xpad->odata[1] = 0x08;
+                        xpad->odata[2] = 0x00;
+                        xpad->odata[3] = strong / 256;  /* left actuator? */
+                        xpad->odata[4] = weak / 256;    /* right actuator? */
+                        xpad->odata[5] = 0x00;
+                        xpad->odata[6] = 0x00;
+                        xpad->odata[7] = 0x00;
+                        xpad->irq_out->transfer_buffer_length = 8;
+
+                        return usb_submit_urb(xpad->irq_out, GFP_ATOMIC);
+
+                default:
+                        dbg("%s - rumble command sent to unsupported xpad type: %d",
+                                __func__, xpad->xtype);
+                        return -1;
+                }
         }
 
         return 0;
@@ -579,7 +640,7 @@ static int xpad_play_effect(struct input_dev *dev, void *data,
 
 static int xpad_init_ff(struct usb_xpad *xpad)
 {
-        if (xpad->xtype != XTYPE_XBOX360)
+        if (xpad->xtype != XTYPE_XBOX360 && xpad->xtype != XTYPE_XBOX)
                 return 0;
 
         input_set_capability(xpad->dev, EV_FF, FF_RUMBLE);
@@ -712,11 +773,11 @@ static void xpad_set_up_abs(struct input_dev *input_dev, signed short abs)
                 input_set_abs_params(input_dev, abs, -32768, 32767, 16, 128);
                 break;
         case ABS_Z:
-        case ABS_RZ:    /* the triggers */
+        case ABS_RZ:    /* the triggers (if mapped to axes) */
                 input_set_abs_params(input_dev, abs, 0, 255, 0, 0);
                 break;
         case ABS_HAT0X:
-        case ABS_HAT0Y: /* the d-pad (only if MAP_DPAD_TO_AXES) */
+        case ABS_HAT0Y: /* the d-pad (only if dpad is mapped to axes */
                 input_set_abs_params(input_dev, abs, -1, 1, 0, 0);
                 break;
         }
@@ -742,8 +803,8 @@ static int xpad_probe(struct usb_interface *intf, const struct usb_device_id *id
         if (!xpad || !input_dev)
                 goto fail1;
 
-        xpad->idata = usb_buffer_alloc(udev, XPAD_PKT_LEN,
-                                       GFP_KERNEL, &xpad->idata_dma);
+        xpad->idata = usb_alloc_coherent(udev, XPAD_PKT_LEN,
+                                         GFP_KERNEL, &xpad->idata_dma);
         if (!xpad->idata)
                 goto fail1;
 
@@ -752,10 +813,9 @@ static int xpad_probe(struct usb_interface *intf, const struct usb_device_id *id
                 goto fail2;
 
         xpad->udev = udev;
-        xpad->dpad_mapping = xpad_device[i].dpad_mapping;
+        xpad->mapping = xpad_device[i].mapping;
         xpad->xtype = xpad_device[i].xtype;
-        if (xpad->dpad_mapping == MAP_DPAD_UNKNOWN)
-                xpad->dpad_mapping = !dpad_to_buttons;
+
         if (xpad->xtype == XTYPE_UNKNOWN) {
                 if (intf->cur_altsetting->desc.bInterfaceClass == USB_CLASS_VENDOR_SPEC) {
                         if (intf->cur_altsetting->desc.bInterfaceProtocol == 129)
@@ -764,7 +824,15 @@ static int xpad_probe(struct usb_interface *intf, const struct usb_device_id *id
                                 xpad->xtype = XTYPE_XBOX360;
                 } else
                         xpad->xtype = XTYPE_XBOX;
+
+                if (dpad_to_buttons)
+                        xpad->mapping |= MAP_DPAD_TO_BUTTONS;
+                if (triggers_to_buttons)
+                        xpad->mapping |= MAP_TRIGGERS_TO_BUTTONS;
+                if (sticks_to_null)
+                        xpad->mapping |= MAP_STICKS_TO_NULL;
         }
+
         xpad->dev = input_dev;
         usb_make_path(udev, xpad->phys, sizeof(xpad->phys));
         strlcat(xpad->phys, "/input0", sizeof(xpad->phys));
@@ -779,27 +847,43 @@ static int xpad_probe(struct usb_interface *intf, const struct usb_device_id *id
         input_dev->open = xpad_open;
         input_dev->close = xpad_close;
 
-        input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
+        input_dev->evbit[0] = BIT_MASK(EV_KEY);
+
+        if (!(xpad->mapping & MAP_STICKS_TO_NULL)) {
+                input_dev->evbit[0] |= BIT_MASK(EV_ABS);
+                /* set up axes */
+                for (i = 0; xpad_abs[i] >= 0; i++)
+                        xpad_set_up_abs(input_dev, xpad_abs[i]);
+        }
 
-        /* set up buttons */
+        /* set up standard buttons */
         for (i = 0; xpad_common_btn[i] >= 0; i++)
-                set_bit(xpad_common_btn[i], input_dev->keybit);
-        if ((xpad->xtype == XTYPE_XBOX360) || (xpad->xtype == XTYPE_XBOX360W))
+                __set_bit(xpad_common_btn[i], input_dev->keybit);
+
+        /* set up model-specific ones */
+        if (xpad->xtype == XTYPE_XBOX360 || xpad->xtype == XTYPE_XBOX360W) {
                 for (i = 0; xpad360_btn[i] >= 0; i++)
-                        set_bit(xpad360_btn[i], input_dev->keybit);
-        else
+                        __set_bit(xpad360_btn[i], input_dev->keybit);
+        } else {
                 for (i = 0; xpad_btn[i] >= 0; i++)
-                        set_bit(xpad_btn[i], input_dev->keybit);
-        if (xpad->dpad_mapping == MAP_DPAD_TO_BUTTONS)
-                for (i = 0; xpad_btn_pad[i] >= 0; i++)
-                        set_bit(xpad_btn_pad[i], input_dev->keybit);
+                        __set_bit(xpad_btn[i], input_dev->keybit);
+        }
 
-        /* set up axes */
-        for (i = 0; xpad_abs[i] >= 0; i++)
-                xpad_set_up_abs(input_dev, xpad_abs[i]);
-        if (xpad->dpad_mapping == MAP_DPAD_TO_AXES)
+        if (xpad->mapping & MAP_DPAD_TO_BUTTONS) {
+                for (i = 0; xpad_btn_pad[i] >= 0; i++)
+                        __set_bit(xpad_btn_pad[i], input_dev->keybit);
+        } else {
                 for (i = 0; xpad_abs_pad[i] >= 0; i++)
                     xpad_set_up_abs(input_dev, xpad_abs_pad[i]);
+        }
+
+        if (xpad->mapping & MAP_TRIGGERS_TO_BUTTONS) {
+                for (i = 0; xpad_btn_triggers[i] >= 0; i++)
+                        __set_bit(xpad_btn_triggers[i], input_dev->keybit);
+        } else {
+                for (i = 0; xpad_abs_triggers[i] >= 0; i++)
+                        xpad_set_up_abs(input_dev, xpad_abs_triggers[i]);
+        }
 
         error = xpad_init_output(intf, xpad);
         if (error)
@@ -879,7 +963,7 @@ static int xpad_probe(struct usb_interface *intf, const struct usb_device_id *id
  fail5: usb_kill_urb(xpad->irq_in);
  fail4: usb_free_urb(xpad->irq_in);
  fail3: xpad_deinit_output(xpad);
- fail2: usb_buffer_free(udev, XPAD_PKT_LEN, xpad->idata, xpad->idata_dma);
+ fail2: usb_free_coherent(udev, XPAD_PKT_LEN, xpad->idata, xpad->idata_dma);
  fail1: input_free_device(input_dev);
         kfree(xpad);
         return error;
@@ -901,7 +985,7 @@ static void xpad_disconnect(struct usb_interface *intf)
                         usb_kill_urb(xpad->irq_in);
                 }
                 usb_free_urb(xpad->irq_in);
-                usb_buffer_free(xpad->udev, XPAD_PKT_LEN,
+                usb_free_coherent(xpad->udev, XPAD_PKT_LEN,
                                 xpad->idata, xpad->idata_dma);
                 kfree(xpad);
         }
diff --git a/drivers/input/keyboard/Kconfig b/drivers/input/keyboard/Kconfig
index 02c836e11813..b8c51b9781db 100644
--- a/drivers/input/keyboard/Kconfig
+++ b/drivers/input/keyboard/Kconfig
@@ -35,10 +35,10 @@ config KEYBOARD_ADP5520
           be called adp5520-keys.
 
 config KEYBOARD_ADP5588
-        tristate "ADP5588 I2C QWERTY Keypad and IO Expander"
+        tristate "ADP5588/87 I2C QWERTY Keypad and IO Expander"
         depends on I2C
         help
-          Say Y here if you want to use a ADP5588 attached to your
+          Say Y here if you want to use a ADP5588/87 attached to your
           system I2C bus.
 
           To compile this driver as a module, choose M here: the
@@ -124,7 +124,7 @@ config KEYBOARD_ATKBD_RDI_KEYCODES
           right-hand column will be interpreted as the key shown in the
           left-hand column.
 
-config QT2160
+config KEYBOARD_QT2160
         tristate "Atmel AT42QT2160 Touch Sensor Chip"
         depends on I2C && EXPERIMENTAL
         help
@@ -143,17 +143,6 @@ config KEYBOARD_BFIN
           To compile this driver as a module, choose M here: the
           module will be called bf54x-keys.
 
-config KEYBOARD_CORGI
-        tristate "Corgi keyboard"
-        depends on PXA_SHARPSL
-        default y
-        help
-          Say Y here to enable the keyboard on the Sharp Zaurus SL-C7xx
-          series of PDAs.
-
-          To compile this driver as a module, choose M here: the
-          module will be called corgikbd.
-
 config KEYBOARD_LKKBD
         tristate "DECstation/VAXstation LK201/LK401 keyboard"
         select SERIO
@@ -190,6 +179,22 @@ config KEYBOARD_GPIO
           To compile this driver as a module, choose M here: the
           module will be called gpio_keys.
 
+config KEYBOARD_TCA6416
+        tristate "TCA6416 Keypad Support"
+        depends on I2C
+        help
+          This driver implements basic keypad functionality
+          for keys connected through TCA6416 IO expander
+
+          Say Y here if your device has keys connected to
+          TCA6416 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
+          this driver.
+
+
 config KEYBOARD_MATRIX
         tristate "GPIO driven matrix keypad support"
         depends on GENERIC_GPIO
@@ -292,6 +297,27 @@ config KEYBOARD_MAX7359
           To compile this driver as a module, choose M here: the
           module will be called max7359_keypad.
 
+config KEYBOARD_MCS
+        tristate "MELFAS MCS Touchkey"
+        depends on I2C
+        help
+          Say Y here if you have the MELFAS MCS5000/5080 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 mcs_touchkey.
+
+config KEYBOARD_IMX
+        tristate "IMX keypad support"
+        depends on ARCH_MXC
+        help
+          Enable support for IMX keypad port.
+
+          To compile this driver as a module, choose M here: the
+          module will be called imx_keypad.
+
 config KEYBOARD_NEWTON
         tristate "Newton keyboard"
         select SERIO
@@ -301,6 +327,16 @@ 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_OPENCORES
         tristate "OpenCores Keyboard Controller"
         help
@@ -312,7 +348,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.
 
@@ -328,16 +364,14 @@ config KEYBOARD_PXA930_ROTARY
           To compile this driver as a module, choose M here: the
           module will be called pxa930_rotary.
 
-config KEYBOARD_SPITZ
-        tristate "Spitz keyboard"
-        depends on PXA_SHARPSL
-        default y
+config KEYBOARD_SAMSUNG
+        tristate "Samsung keypad support"
+        depends on SAMSUNG_DEV_KEYPAD
         help
-          Say Y here to enable the keyboard on the Sharp Zaurus SL-C1000,
-          SL-C3000 and Sl-C3100 series of PDAs.
+          Say Y here if you want to use the Samsung keypad.
 
           To compile this driver as a module, choose M here: the
-          module will be called spitzkbd.
+          module will be called samsung-keypad.
 
 config KEYBOARD_STOWAWAY
         tristate "Stowaway keyboard"
@@ -363,7 +397,7 @@ config KEYBOARD_SUNKBD
 
 config KEYBOARD_SH_KEYSC
         tristate "SuperH KEYSC keypad support"
-        depends on SUPERH
+        depends on SUPERH || ARCH_SHMOBILE
         help
           Say Y here if you want to use a keypad attached to the KEYSC block
           on SuperH processors such as sh7722 and sh7343.
@@ -371,6 +405,16 @@ config KEYBOARD_SH_KEYSC
           To compile this driver as a module, choose M here: the
           module will be called sh_keysc.
 
+config KEYBOARD_STMPE
+        tristate "STMPE keypad support"
+        depends on MFD_STMPE
+        help
+          Say Y here if you want to use the keypad controller on STMPE I/O
+          expanders.
+
+          To compile this driver as a module, choose M here: the module will be
+          called stmpe-keypad.
+
 config KEYBOARD_DAVINCI
         tristate "TI DaVinci Key Scan"
         depends on ARCH_DAVINCI_DM365
@@ -390,36 +434,34 @@ config KEYBOARD_OMAP
           To compile this driver as a module, choose M here: the
           module will be called omap-keypad.
 
-config KEYBOARD_TWL4030
-        tristate "TI TWL4030/TWL5030/TPS659x0 keypad support"
-        depends on TWL4030_CORE
+config KEYBOARD_OMAP4
+        tristate "TI OMAP4 keypad support"
+        depends on ARCH_OMAP4
         help
-          Say Y here if your board use the keypad controller on
-          TWL4030 family chips.  It's safe to say enable this
-          even on boards that don't use the keypad controller.
+          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 twl4030_keypad.
+          module will be called omap4-keypad.
 
-config KEYBOARD_TOSA
-        tristate "Tosa keyboard"
-        depends on MACH_TOSA
-        default y
+config KEYBOARD_TNETV107X
+        tristate "TI TNETV107X keypad support"
+        depends on ARCH_DAVINCI_TNETV107X
         help
-          Say Y here to enable the keyboard on the Sharp Zaurus SL-6000x (Tosa)
+          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 tosakbd.
+          module will be called tnetv107x-keypad.
 
-config KEYBOARD_TOSA_USE_EXT_KEYCODES
-        bool "Tosa keyboard: use extended keycodes"
-        depends on KEYBOARD_TOSA
+config KEYBOARD_TWL4030
+        tristate "TI TWL4030/TWL5030/TPS659x0 keypad support"
+        depends on TWL4030_CORE
         help
-          Say Y here to enable the tosa keyboard driver to generate extended
-          (>= 127) keycodes. Be aware, that they can't be correctly interpreted
-          by either console keyboard driver or by Kdrive keybd driver.
+          Say Y here if your board use the keypad controller on
+          TWL4030 family chips.  It's safe to say enable this
+          even on boards that don't use the keypad controller.
 
-          Say Y only if you know, what you are doing!
+          To compile this driver as a module, choose M here: the
+          module will be called twl4030_keypad.
 
 config KEYBOARD_XTKBD
         tristate "XT keyboard"
diff --git a/drivers/input/keyboard/Makefile b/drivers/input/keyboard/Makefile
index 78654ef65206..a34452e8ebe2 100644
--- a/drivers/input/keyboard/Makefile
+++ b/drivers/input/keyboard/Makefile
@@ -11,12 +11,13 @@ obj-$(CONFIG_KEYBOARD_AMIGA)		+= amikbd.o
 obj-$(CONFIG_KEYBOARD_ATARI)            += atakbd.o
 obj-$(CONFIG_KEYBOARD_ATKBD)            += atkbd.o
 obj-$(CONFIG_KEYBOARD_BFIN)             += bf54x-keys.o
-obj-$(CONFIG_KEYBOARD_CORGI)            += corgikbd.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_TCA6416)          += tca6416-keypad.o
 obj-$(CONFIG_KEYBOARD_HIL)              += hil_kbd.o
 obj-$(CONFIG_KEYBOARD_HIL_OLD)          += hilkbd.o
+obj-$(CONFIG_KEYBOARD_IMX)              += imx_keypad.o
 obj-$(CONFIG_KEYBOARD_HP6XX)            += jornada680_kbd.o
 obj-$(CONFIG_KEYBOARD_HP7XX)            += jornada720_kbd.o
 obj-$(CONFIG_KEYBOARD_LKKBD)            += lkkbd.o
@@ -25,17 +26,21 @@ obj-$(CONFIG_KEYBOARD_LOCOMO)		+= locomokbd.o
 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_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_PXA27x)           += pxa27x_keypad.o
 obj-$(CONFIG_KEYBOARD_PXA930_ROTARY)    += pxa930_rotary.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_SPITZ)            += spitzkbd.o
+obj-$(CONFIG_KEYBOARD_STMPE)            += stmpe-keypad.o
 obj-$(CONFIG_KEYBOARD_STOWAWAY)         += stowaway.o
 obj-$(CONFIG_KEYBOARD_SUNKBD)           += sunkbd.o
-obj-$(CONFIG_KEYBOARD_TOSA)             += tosakbd.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/adp5520-keys.c b/drivers/input/keyboard/adp5520-keys.c
index a7ba27fb4109..3db8006dac3a 100644
--- a/drivers/input/keyboard/adp5520-keys.c
+++ b/drivers/input/keyboard/adp5520-keys.c
@@ -12,6 +12,7 @@
 #include <linux/platform_device.h>
 #include <linux/input.h>
 #include <linux/mfd/adp5520.h>
+#include <linux/slab.h>
 
 struct adp5520_keys {
         struct input_dev *input;
diff --git a/drivers/input/keyboard/adp5588-keys.c b/drivers/input/keyboard/adp5588-keys.c
index 1edb596d927b..b92d1cd5cba1 100644
--- a/drivers/input/keyboard/adp5588-keys.c
+++ b/drivers/input/keyboard/adp5588-keys.c
@@ -1,6 +1,7 @@
 /*
  * File: drivers/input/keyboard/adp5588_keys.c
- * Description:  keypad driver for ADP5588 I2C QWERTY Keypad and IO Expander
+ * Description:  keypad driver for ADP5588 and ADP5587
+ *               I2C QWERTY Keypad and IO Expander
  * Bugs: Enter bugs at http://blackfin.uclinux.org/
  *
  * Copyright (C) 2008-2009 Analog Devices Inc.
@@ -18,6 +19,8 @@
 #include <linux/platform_device.h>
 #include <linux/input.h>
 #include <linux/i2c.h>
+#include <linux/gpio.h>
+#include <linux/slab.h>
 
 #include <linux/i2c/adp5588.h>
 
@@ -52,6 +55,10 @@
 
 #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
@@ -65,6 +72,16 @@ struct adp5588_kpad {
         struct delayed_work work;
         unsigned long delay;
         unsigned short keycode[ADP5588_KEYMAPSIZE];
+        const struct adp5588_gpi_map *gpimap;
+        unsigned short gpimapsize;
+#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 adp5588_read(struct i2c_client *client, u8 reg)
@@ -82,12 +99,222 @@ static int adp5588_write(struct i2c_client *client, u8 reg, u8 val)
         return i2c_smbus_write_byte_data(client, reg, val);
 }
 
+#ifdef CONFIG_GPIOLIB
+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]);
+
+        return !!(adp5588_read(kpad->client, GPIO_DAT_STAT1 + bank) & bit);
+}
+
+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]);
+
+        mutex_lock(&kpad->gpio_lock);
+
+        if (val)
+                kpad->dat_out[bank] |= bit;
+        else
+                kpad->dat_out[bank] &= ~bit;
+
+        adp5588_write(kpad->client, GPIO_DAT_OUT1 + bank,
+                           kpad->dat_out[bank]);
+
+        mutex_unlock(&kpad->gpio_lock);
+}
+
+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]);
+        int ret;
+
+        mutex_lock(&kpad->gpio_lock);
+
+        kpad->dir[bank] &= ~bit;
+        ret = adp5588_write(kpad->client, GPIO_DIR1 + bank, kpad->dir[bank]);
+
+        mutex_unlock(&kpad->gpio_lock);
+
+        return ret;
+}
+
+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]);
+        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 = adp5588_write(kpad->client, GPIO_DAT_OUT1 + bank,
+                                 kpad->dat_out[bank]);
+        ret |= adp5588_write(kpad->client, GPIO_DIR1 + bank,
+                                 kpad->dir[bank]);
+
+        mutex_unlock(&kpad->gpio_lock);
+
+        return ret;
+}
+
+static int __devinit adp5588_build_gpiomap(struct adp5588_kpad *kpad,
+                                const struct adp5588_kpad_platform_data *pdata)
+{
+        bool pin_used[MAXGPIO];
+        int n_unused = 0;
+        int i;
+
+        memset(pin_used, 0, sizeof(pin_used));
+
+        for (i = 0; i < pdata->rows; i++)
+                pin_used[i] = true;
+
+        for (i = 0; i < pdata->cols; i++)
+                pin_used[i + GPI_PIN_COL_BASE - GPI_PIN_BASE] = true;
+
+        for (i = 0; i < kpad->gpimapsize; i++)
+                pin_used[kpad->gpimap[i].pin - GPI_PIN_BASE] = true;
+
+        for (i = 0; i < MAXGPIO; i++)
+                if (!pin_used[i])
+                        kpad->gpiomap[n_unused++] = i;
+
+        return n_unused;
+}
+
+static int __devinit adp5588_gpio_add(struct adp5588_kpad *kpad)
+{
+        struct device *dev = &kpad->client->dev;
+        const struct adp5588_kpad_platform_data *pdata = dev->platform_data;
+        const struct adp5588_gpio_platform_data *gpio_data = pdata->gpio_data;
+        int i, error;
+
+        if (!gpio_data)
+                return 0;
+
+        kpad->gc.ngpio = adp5588_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 = adp5588_gpio_direction_input;
+        kpad->gc.direction_output = adp5588_gpio_direction_output;
+        kpad->gc.get = adp5588_gpio_get_value;
+        kpad->gc.set = adp5588_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] = adp5588_read(kpad->client,
+                                                GPIO_DAT_OUT1 + i);
+                kpad->dir[i] = adp5588_read(kpad->client, GPIO_DIR1 + 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 adp5588_gpio_remove(struct adp5588_kpad *kpad)
+{
+        struct device *dev = &kpad->client->dev;
+        const struct adp5588_kpad_platform_data *pdata = dev->platform_data;
+        const struct adp5588_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 adp5588_gpio_add(struct adp5588_kpad *kpad)
+{
+        return 0;
+}
+
+static inline void adp5588_gpio_remove(struct adp5588_kpad *kpad)
+{
+}
+#endif
+
+static void adp5588_report_events(struct adp5588_kpad *kpad, int ev_cnt)
+{
+        int i, j;
+
+        for (i = 0; i < ev_cnt; i++) {
+                int key = adp5588_read(kpad->client, Key_EVENTA + i);
+                int key_val = key & KEY_EV_MASK;
+
+                if (key_val >= GPI_PIN_BASE && key_val <= GPI_PIN_END) {
+                        for (j = 0; j < kpad->gpimapsize; j++) {
+                                if (key_val == kpad->gpimap[j].pin) {
+                                        input_report_switch(kpad->input,
+                                                        kpad->gpimap[j].sw_evt,
+                                                        key & KEY_EV_PRESSED);
+                                        break;
+                                }
+                        }
+                } else {
+                        input_report_key(kpad->input,
+                                         kpad->keycode[key_val - 1],
+                                         key & KEY_EV_PRESSED);
+                }
+        }
+}
+
 static void adp5588_work(struct work_struct *work)
 {
         struct adp5588_kpad *kpad = container_of(work,
                                                 struct adp5588_kpad, work.work);
         struct i2c_client *client = kpad->client;
-        int i, key, status, ev_cnt;
+        int status, ev_cnt;
 
         status = adp5588_read(client, INT_STAT);
 
@@ -97,12 +324,7 @@ static void adp5588_work(struct work_struct *work)
         if (status & KE_INT) {
                 ev_cnt = adp5588_read(client, KEY_LCK_EC_STAT) & KEC;
                 if (ev_cnt) {
-                        for (i = 0; i < ev_cnt; i++) {
-                                key = adp5588_read(client, Key_EVENTA + i);
-                                input_report_key(kpad->input,
-                                        kpad->keycode[(key & KEY_EV_MASK) - 1],
-                                        key & KEY_EV_PRESSED);
-                        }
+                        adp5588_report_events(kpad, ev_cnt);
                         input_sync(kpad->input);
                 }
         }
@@ -126,8 +348,10 @@ static irqreturn_t adp5588_irq(int irq, void *handle)
 
 static int __devinit adp5588_setup(struct i2c_client *client)
 {
-        struct adp5588_kpad_platform_data *pdata = client->dev.platform_data;
+        const struct adp5588_kpad_platform_data *pdata = client->dev.platform_data;
+        const struct adp5588_gpio_platform_data *gpio_data = pdata->gpio_data;
         int i, ret;
+        unsigned char evt_mode1 = 0, evt_mode2 = 0, evt_mode3 = 0;
 
         ret = adp5588_write(client, KP_GPIO1, KP_SEL(pdata->rows));
         ret |= adp5588_write(client, KP_GPIO2, KP_SEL(pdata->cols) & 0xFF);
@@ -142,6 +366,32 @@ static int __devinit adp5588_setup(struct i2c_client *client)
         for (i = 0; i < KEYP_MAX_EVENT; i++)
                 ret |= adp5588_read(client, Key_EVENTA);
 
+        for (i = 0; i < pdata->gpimapsize; i++) {
+                unsigned short pin = pdata->gpimap[i].pin;
+
+                if (pin <= GPI_PIN_ROW_END) {
+                        evt_mode1 |= (1 << (pin - GPI_PIN_ROW_BASE));
+                } else {
+                        evt_mode2 |= ((1 << (pin - GPI_PIN_COL_BASE)) & 0xFF);
+                        evt_mode3 |= ((1 << (pin - GPI_PIN_COL_BASE)) >> 8);
+                }
+        }
+
+        if (pdata->gpimapsize) {
+                ret |= adp5588_write(client, GPI_EM1, evt_mode1);
+                ret |= adp5588_write(client, GPI_EM2, evt_mode2);
+                ret |= adp5588_write(client, GPI_EM3, evt_mode3);
+        }
+
+        if (gpio_data) {
+                for (i = 0; i <= ADP_BANK(MAXGPIO); i++) {
+                        int pull_mask = gpio_data->pullup_dis_mask;
+
+                        ret |= adp5588_write(client, GPIO_PULL1 + i,
+                                (pull_mask >> (8 * i)) & 0xFF);
+                }
+        }
+
         ret |= adp5588_write(client, INT_STAT, CMP2_INT | CMP1_INT |
                                         OVR_FLOW_INT | K_LCK_INT |
                                         GPI_INT | KE_INT); /* Status is W1C */
@@ -156,11 +406,49 @@ static int __devinit adp5588_setup(struct i2c_client *client)
         return 0;
 }
 
+static void __devinit adp5588_report_switch_state(struct adp5588_kpad *kpad)
+{
+        int gpi_stat1 = adp5588_read(kpad->client, GPIO_DAT_STAT1);
+        int gpi_stat2 = adp5588_read(kpad->client, GPIO_DAT_STAT2);
+        int gpi_stat3 = adp5588_read(kpad->client, GPIO_DAT_STAT3);
+        int gpi_stat_tmp, pin_loc;
+        int i;
+
+        for (i = 0; i < kpad->gpimapsize; i++) {
+                unsigned short pin = kpad->gpimap[i].pin;
+
+                if (pin <= GPI_PIN_ROW_END) {
+                        gpi_stat_tmp = gpi_stat1;
+                        pin_loc = pin - GPI_PIN_ROW_BASE;
+                } else if ((pin - GPI_PIN_COL_BASE) < 8) {
+                        gpi_stat_tmp = gpi_stat2;
+                        pin_loc = pin - GPI_PIN_COL_BASE;
+                } else {
+                        gpi_stat_tmp = gpi_stat3;
+                        pin_loc = pin - 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 adp5588_probe(struct i2c_client *client,
                                         const struct i2c_device_id *id)
 {
         struct adp5588_kpad *kpad;
-        struct adp5588_kpad_platform_data *pdata = client->dev.platform_data;
+        const struct adp5588_kpad_platform_data *pdata = client->dev.platform_data;
         struct input_dev *input;
         unsigned int revid;
         int ret, i;
@@ -187,6 +475,37 @@ static int __devinit adp5588_probe(struct i2c_client *client,
                 return -EINVAL;
         }
 
+        if (!pdata->gpimap && pdata->gpimapsize) {
+                dev_err(&client->dev, "invalid gpimap from pdata\n");
+                return -EINVAL;
+        }
+
+        if (pdata->gpimapsize > ADP5588_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 < GPI_PIN_BASE || pin > GPI_PIN_END) {
+                        dev_err(&client->dev, "invalid gpi pin data\n");
+                        return -EINVAL;
+                }
+
+                if (pin <= GPI_PIN_ROW_END) {
+                        if (pin - GPI_PIN_ROW_BASE + 1 <= pdata->rows) {
+                                dev_err(&client->dev, "invalid gpi row data\n");
+                                return -EINVAL;
+                        }
+                } else {
+                        if (pin - GPI_PIN_COL_BASE + 1 <= pdata->cols) {
+                                dev_err(&client->dev, "invalid gpi col data\n");
+                                return -EINVAL;
+                        }
+                }
+        }
+
         if (!client->irq) {
                 dev_err(&client->dev, "no IRQ?\n");
                 return -EINVAL;
@@ -231,6 +550,9 @@ static int __devinit adp5588_probe(struct i2c_client *client,
         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);
 
@@ -241,6 +563,11 @@ static int __devinit adp5588_probe(struct i2c_client *client,
                 __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");
@@ -259,6 +586,13 @@ static int __devinit adp5588_probe(struct i2c_client *client,
         if (error)
                 goto err_free_irq;
 
+        if (kpad->gpimapsize)
+                adp5588_report_switch_state(kpad);
+
+        error = adp5588_gpio_add(kpad);
+        if (error)
+                goto err_free_irq;
+
         device_init_wakeup(&client->dev, 1);
         i2c_set_clientdata(client, kpad);
 
@@ -285,7 +619,7 @@ static int __devexit adp5588_remove(struct i2c_client *client)
         free_irq(client->irq, kpad);
         cancel_delayed_work_sync(&kpad->work);
         input_unregister_device(kpad->input);
-        i2c_set_clientdata(client, NULL);
+        adp5588_gpio_remove(kpad);
         kfree(kpad);
 
         return 0;
@@ -326,7 +660,8 @@ 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 },
         { }
 };
 MODULE_DEVICE_TABLE(i2c, adp5588_id);
@@ -357,5 +692,5 @@ module_exit(adp5588_exit);
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
-MODULE_DESCRIPTION("ADP5588 Keypad driver");
+MODULE_DESCRIPTION("ADP5588/87 Keypad driver");
 MODULE_ALIAS("platform:adp5588-keys");
diff --git a/drivers/input/keyboard/amikbd.c b/drivers/input/keyboard/amikbd.c
index 35149ec455a9..79172af164f2 100644
--- a/drivers/input/keyboard/amikbd.c
+++ b/drivers/input/keyboard/amikbd.c
@@ -35,6 +35,7 @@
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/keyboard.h>
+#include <linux/platform_device.h>
 
 #include <asm/amigaints.h>
 #include <asm/amigahw.h>
@@ -154,10 +155,9 @@ static const char *amikbd_messages[8] = {
         [7] = KERN_WARNING "amikbd: keyboard interrupt\n"
 };
 
-static struct input_dev *amikbd_dev;
-
-static irqreturn_t amikbd_interrupt(int irq, void *dummy)
+static irqreturn_t amikbd_interrupt(int irq, void *data)
 {
+        struct input_dev *dev = data;
         unsigned char scancode, down;
 
         scancode = ~ciaa.sdr;           /* get and invert scancode (keyboard is active low) */
@@ -170,47 +170,42 @@ static irqreturn_t amikbd_interrupt(int irq, void *dummy)
 
         if (scancode < 0x78) {          /* scancodes < 0x78 are keys */
                 if (scancode == 98) {   /* CapsLock is a toggle switch key on Amiga */
-                        input_report_key(amikbd_dev, scancode, 1);
-                        input_report_key(amikbd_dev, scancode, 0);
+                        input_report_key(dev, scancode, 1);
+                        input_report_key(dev, scancode, 0);
                 } else {
-                        input_report_key(amikbd_dev, scancode, down);
+                        input_report_key(dev, scancode, down);
                 }
 
-                input_sync(amikbd_dev);
+                input_sync(dev);
         } else                          /* scancodes >= 0x78 are error codes */
                 printk(amikbd_messages[scancode - 0x78]);
 
         return IRQ_HANDLED;
 }
 
-static int __init amikbd_init(void)
+static int __init amikbd_probe(struct platform_device *pdev)
 {
+        struct input_dev *dev;
         int i, j, err;
 
-        if (!AMIGAHW_PRESENT(AMI_KEYBOARD))
-                return -ENODEV;
-
-        if (!request_mem_region(CIAA_PHYSADDR-1+0xb00, 0x100, "amikeyb"))
-                return -EBUSY;
-
-        amikbd_dev = input_allocate_device();
-        if (!amikbd_dev) {
-                printk(KERN_ERR "amikbd: not enough memory for input device\n");
-                err = -ENOMEM;
-                goto fail1;
+        dev = input_allocate_device();
+        if (!dev) {
+                dev_err(&pdev->dev, "Not enough memory for input device\n");
+                return -ENOMEM;
         }
 
-        amikbd_dev->name = "Amiga Keyboard";
-        amikbd_dev->phys = "amikbd/input0";
-        amikbd_dev->id.bustype = BUS_AMIGA;
-        amikbd_dev->id.vendor = 0x0001;
-        amikbd_dev->id.product = 0x0001;
-        amikbd_dev->id.version = 0x0100;
+        dev->name = pdev->name;
+        dev->phys = "amikbd/input0";
+        dev->id.bustype = BUS_AMIGA;
+        dev->id.vendor = 0x0001;
+        dev->id.product = 0x0001;
+        dev->id.version = 0x0100;
+        dev->dev.parent = &pdev->dev;
 
-        amikbd_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP);
+        dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP);
 
         for (i = 0; i < 0x78; i++)
-                set_bit(i, amikbd_dev->keybit);
+                set_bit(i, dev->keybit);
 
         for (i = 0; i < MAX_NR_KEYMAPS; i++) {
                 static u_short temp_map[NR_KEYS] __initdata;
@@ -229,30 +224,54 @@ static int __init amikbd_init(void)
                 memcpy(key_maps[i], temp_map, sizeof(temp_map));
         }
         ciaa.cra &= ~0x41;       /* serial data in, turn off TA */
-        if (request_irq(IRQ_AMIGA_CIAA_SP, amikbd_interrupt, 0, "amikbd",
-                        amikbd_interrupt)) {
-                err = -EBUSY;
+        err = request_irq(IRQ_AMIGA_CIAA_SP, amikbd_interrupt, 0, "amikbd",
+                          dev);
+        if (err)
                 goto fail2;
-        }
 
-        err = input_register_device(amikbd_dev);
+        err = input_register_device(dev);
         if (err)
                 goto fail3;
 
+        platform_set_drvdata(pdev, dev);
+
         return 0;
 
- fail3: free_irq(IRQ_AMIGA_CIAA_SP, amikbd_interrupt);
- fail2: input_free_device(amikbd_dev);
- fail1: release_mem_region(CIAA_PHYSADDR - 1 + 0xb00, 0x100);
+ fail3: free_irq(IRQ_AMIGA_CIAA_SP, dev);
+ fail2: input_free_device(dev);
         return err;
 }
 
-static void __exit amikbd_exit(void)
+static int __exit amikbd_remove(struct platform_device *pdev)
+{
+        struct input_dev *dev = platform_get_drvdata(pdev);
+
+        platform_set_drvdata(pdev, NULL);
+        free_irq(IRQ_AMIGA_CIAA_SP, dev);
+        input_unregister_device(dev);
+        return 0;
+}
+
+static struct platform_driver amikbd_driver = {
+        .remove = __exit_p(amikbd_remove),
+        .driver   = {
+                .name   = "amiga-keyboard",
+                .owner  = THIS_MODULE,
+        },
+};
+
+static int __init amikbd_init(void)
 {
-        free_irq(IRQ_AMIGA_CIAA_SP, amikbd_interrupt);
-        input_unregister_device(amikbd_dev);
-        release_mem_region(CIAA_PHYSADDR - 1 + 0xb00, 0x100);
+        return platform_driver_probe(&amikbd_driver, amikbd_probe);
 }
 
 module_init(amikbd_init);
+
+static void __exit amikbd_exit(void)
+{
+        platform_driver_unregister(&amikbd_driver);
+}
+
 module_exit(amikbd_exit);
+
+MODULE_ALIAS("platform:amiga-keyboard");
diff --git a/drivers/input/keyboard/atkbd.c b/drivers/input/keyboard/atkbd.c
index 7b4056292eaf..d358ef8623f4 100644
--- a/drivers/input/keyboard/atkbd.c
+++ b/drivers/input/keyboard/atkbd.c
@@ -40,26 +40,26 @@ module_param_named(set, atkbd_set, int, 0);
 MODULE_PARM_DESC(set, "Select keyboard code set (2 = default, 3 = PS/2 native)");
 
 #if defined(__i386__) || defined(__x86_64__) || defined(__hppa__)
-static int atkbd_reset;
+static bool atkbd_reset;
 #else
-static int atkbd_reset = 1;
+static bool atkbd_reset = true;
 #endif
 module_param_named(reset, atkbd_reset, bool, 0);
 MODULE_PARM_DESC(reset, "Reset keyboard during initialization");
 
-static int atkbd_softrepeat;
+static bool atkbd_softrepeat;
 module_param_named(softrepeat, atkbd_softrepeat, bool, 0);
 MODULE_PARM_DESC(softrepeat, "Use software keyboard repeat");
 
-static int atkbd_softraw = 1;
+static bool atkbd_softraw = true;
 module_param_named(softraw, atkbd_softraw, bool, 0);
 MODULE_PARM_DESC(softraw, "Use software generated rawmode");
 
-static int atkbd_scroll;
+static bool atkbd_scroll;
 module_param_named(scroll, atkbd_scroll, bool, 0);
 MODULE_PARM_DESC(scroll, "Enable scroll-wheel on MS Office and similar keyboards");
 
-static int atkbd_extra;
+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");
 
@@ -153,16 +153,16 @@ static const unsigned short atkbd_unxlate_table[128] = {
 #define ATKBD_RET_HANGEUL       0xf2
 #define ATKBD_RET_ERR           0xff
 
-#define ATKBD_KEY_UNKNOWN         0
+#define ATKBD_KEY_UNKNOWN       0
 #define ATKBD_KEY_NULL          255
 
-#define ATKBD_SCR_1             254
-#define ATKBD_SCR_2             253
-#define ATKBD_SCR_4             252
-#define ATKBD_SCR_8             251
-#define ATKBD_SCR_CLICK         250
-#define ATKBD_SCR_LEFT          249
-#define ATKBD_SCR_RIGHT         248
+#define ATKBD_SCR_1             0xfffe
+#define ATKBD_SCR_2             0xfffd
+#define ATKBD_SCR_4             0xfffc
+#define ATKBD_SCR_8             0xfffb
+#define ATKBD_SCR_CLICK         0xfffa
+#define ATKBD_SCR_LEFT          0xfff9
+#define ATKBD_SCR_RIGHT         0xfff8
 
 #define ATKBD_SPECIAL           ATKBD_SCR_RIGHT
 
@@ -177,7 +177,7 @@ static const unsigned short atkbd_unxlate_table[128] = {
 #define ATKBD_XL_HANJA          0x20
 
 static const struct {
-        unsigned char keycode;
+        unsigned short keycode;
         unsigned char set2;
 } atkbd_scroll_keys[] = {
         { ATKBD_SCR_1,     0xc5 },
@@ -206,18 +206,18 @@ struct atkbd {
         unsigned short keycode[ATKBD_KEYMAP_SIZE];
         DECLARE_BITMAP(force_release_mask, ATKBD_KEYMAP_SIZE);
         unsigned char set;
-        unsigned char translated;
-        unsigned char extra;
-        unsigned char write;
-        unsigned char softrepeat;
-        unsigned char softraw;
-        unsigned char scroll;
-        unsigned char enabled;
+        bool translated;
+        bool extra;
+        bool write;
+        bool softrepeat;
+        bool softraw;
+        bool scroll;
+        bool enabled;
 
         /* Accessed only from interrupt */
         unsigned char emul;
-        unsigned char resend;
-        unsigned char release;
+        bool resend;
+        bool release;
         unsigned long xl_bit;
         unsigned int last;
         unsigned long time;
@@ -301,18 +301,18 @@ static const unsigned int xl_table[] = {
  * Checks if we should mangle the scancode to extract 'release' bit
  * in translated mode.
  */
-static int atkbd_need_xlate(unsigned long xl_bit, unsigned char code)
+static bool atkbd_need_xlate(unsigned long xl_bit, unsigned char code)
 {
         int i;
 
         if (code == ATKBD_RET_EMUL0 || code == ATKBD_RET_EMUL1)
-                return 0;
+                return false;
 
         for (i = 0; i < ARRAY_SIZE(xl_table); i++)
                 if (code == xl_table[i])
                         return test_bit(i, &xl_bit);
 
-        return 1;
+        return true;
 }
 
 /*
@@ -359,7 +359,7 @@ static unsigned int atkbd_compat_scancode(struct atkbd *atkbd, unsigned int code
  */
 
 static irqreturn_t atkbd_interrupt(struct serio *serio, unsigned char data,
-                        unsigned int flags)
+                                   unsigned int flags)
 {
         struct atkbd *atkbd = serio_get_drvdata(serio);
         struct input_dev *dev = atkbd->dev;
@@ -368,20 +368,18 @@ static irqreturn_t atkbd_interrupt(struct serio *serio, unsigned char data,
         int value;
         unsigned short keycode;
 
-#ifdef ATKBD_DEBUG
-        printk(KERN_DEBUG "atkbd.c: Received %02x flags %02x\n", data, flags);
-#endif
+        dev_dbg(&serio->dev, "Received %02x flags %02x\n", data, flags);
 
 #if !defined(__i386__) && !defined (__x86_64__)
         if ((flags & (SERIO_FRAME | SERIO_PARITY)) && (~flags & SERIO_TIMEOUT) && !atkbd->resend && atkbd->write) {
-                printk(KERN_WARNING "atkbd.c: frame/parity error: %02x\n", flags);
+                dev_warn(&serio->dev, "Frame/parity error: %02x\n", flags);
                 serio_write(serio, ATKBD_CMD_RESEND);
-                atkbd->resend = 1;
+                atkbd->resend = true;
                 goto out;
         }
 
         if (!flags && data == ATKBD_RET_ACK)
-                atkbd->resend = 0;
+                atkbd->resend = false;
 #endif
 
         if (unlikely(atkbd->ps2dev.flags & PS2_FLAG_ACK))
@@ -412,32 +410,32 @@ static irqreturn_t atkbd_interrupt(struct serio *serio, unsigned char data,
         }
 
         switch (code) {
-                case ATKBD_RET_BAT:
-                        atkbd->enabled = 0;
-                        serio_reconnect(atkbd->ps2dev.serio);
-                        goto out;
-                case ATKBD_RET_EMUL0:
-                        atkbd->emul = 1;
-                        goto out;
-                case ATKBD_RET_EMUL1:
-                        atkbd->emul = 2;
-                        goto out;
-                case ATKBD_RET_RELEASE:
-                        atkbd->release = 1;
-                        goto out;
-                case ATKBD_RET_ACK:
-                case ATKBD_RET_NAK:
-                        if (printk_ratelimit())
-                                printk(KERN_WARNING "atkbd.c: Spurious %s on %s. "
-                                       "Some program might be trying access hardware directly.\n",
-                                       data == ATKBD_RET_ACK ? "ACK" : "NAK", serio->phys);
-                        goto out;
-                case ATKBD_RET_ERR:
-                        atkbd->err_count++;
-#ifdef ATKBD_DEBUG
-                        printk(KERN_DEBUG "atkbd.c: Keyboard on %s reports too many keys pressed.\n", serio->phys);
-#endif
-                        goto out;
+        case ATKBD_RET_BAT:
+                atkbd->enabled = false;
+                serio_reconnect(atkbd->ps2dev.serio);
+                goto out;
+        case ATKBD_RET_EMUL0:
+                atkbd->emul = 1;
+                goto out;
+        case ATKBD_RET_EMUL1:
+                atkbd->emul = 2;
+                goto out;
+        case ATKBD_RET_RELEASE:
+                atkbd->release = true;
+                goto out;
+        case ATKBD_RET_ACK:
+        case ATKBD_RET_NAK:
+                if (printk_ratelimit())
+                        dev_warn(&serio->dev,
+                                 "Spurious %s on %s. "
+                                 "Some program might be trying access hardware directly.\n",
+                                 data == ATKBD_RET_ACK ? "ACK" : "NAK", serio->phys);
+                goto out;
+        case ATKBD_RET_ERR:
+                atkbd->err_count++;
+                dev_dbg(&serio->dev, "Keyboard on %s reports too many keys pressed.\n",
+                        serio->phys);
+                goto out;
         }
 
         code = atkbd_compat_scancode(atkbd, code);
@@ -451,71 +449,72 @@ static irqreturn_t atkbd_interrupt(struct serio *serio, unsigned char data,
                 input_event(dev, EV_MSC, MSC_SCAN, code);
 
         switch (keycode) {
-                case ATKBD_KEY_NULL:
-                        break;
-                case ATKBD_KEY_UNKNOWN:
-                        printk(KERN_WARNING
-                               "atkbd.c: Unknown key %s (%s set %d, code %#x on %s).\n",
-                               atkbd->release ? "released" : "pressed",
-                               atkbd->translated ? "translated" : "raw",
-                               atkbd->set, code, serio->phys);
-                        printk(KERN_WARNING
-                               "atkbd.c: Use 'setkeycodes %s%02x <keycode>' to make it known.\n",
-                               code & 0x80 ? "e0" : "", code & 0x7f);
-                        input_sync(dev);
-                        break;
-                case ATKBD_SCR_1:
-                        scroll = 1 - atkbd->release * 2;
-                        break;
-                case ATKBD_SCR_2:
-                        scroll = 2 - atkbd->release * 4;
-                        break;
-                case ATKBD_SCR_4:
-                        scroll = 4 - atkbd->release * 8;
-                        break;
-                case ATKBD_SCR_8:
-                        scroll = 8 - atkbd->release * 16;
-                        break;
-                case ATKBD_SCR_CLICK:
-                        click = !atkbd->release;
-                        break;
-                case ATKBD_SCR_LEFT:
-                        hscroll = -1;
-                        break;
-                case ATKBD_SCR_RIGHT:
-                        hscroll = 1;
-                        break;
-                default:
-                        if (atkbd->release) {
-                                value = 0;
-                                atkbd->last = 0;
-                        } else if (!atkbd->softrepeat && test_bit(keycode, dev->key)) {
-                                /* Workaround Toshiba laptop multiple keypress */
-                                value = time_before(jiffies, atkbd->time) && atkbd->last == code ? 1 : 2;
-                        } else {
-                                value = 1;
-                                atkbd->last = code;
-                                atkbd->time = jiffies + msecs_to_jiffies(dev->rep[REP_DELAY]) / 2;
-                        }
-
-                        input_event(dev, EV_KEY, keycode, value);
-                        input_sync(dev);
+        case ATKBD_KEY_NULL:
+                break;
+        case ATKBD_KEY_UNKNOWN:
+                dev_warn(&serio->dev,
+                         "Unknown key %s (%s set %d, code %#x on %s).\n",
+                         atkbd->release ? "released" : "pressed",
+                         atkbd->translated ? "translated" : "raw",
+                         atkbd->set, code, serio->phys);
+                dev_warn(&serio->dev,
+                         "Use 'setkeycodes %s%02x <keycode>' to make it known.\n",
+                         code & 0x80 ? "e0" : "", code & 0x7f);
+                input_sync(dev);
+                break;
+        case ATKBD_SCR_1:
+                scroll = 1;
+                break;
+        case ATKBD_SCR_2:
+                scroll = 2;
+                break;
+        case ATKBD_SCR_4:
+                scroll = 4;
+                break;
+        case ATKBD_SCR_8:
+                scroll = 8;
+                break;
+        case ATKBD_SCR_CLICK:
+                click = !atkbd->release;
+                break;
+        case ATKBD_SCR_LEFT:
+                hscroll = -1;
+                break;
+        case ATKBD_SCR_RIGHT:
+                hscroll = 1;
+                break;
+        default:
+                if (atkbd->release) {
+                        value = 0;
+                        atkbd->last = 0;
+                } else if (!atkbd->softrepeat && test_bit(keycode, dev->key)) {
+                        /* Workaround Toshiba laptop multiple keypress */
+                        value = time_before(jiffies, atkbd->time) && atkbd->last == code ? 1 : 2;
+                } else {
+                        value = 1;
+                        atkbd->last = code;
+                        atkbd->time = jiffies + msecs_to_jiffies(dev->rep[REP_DELAY]) / 2;
+                }
+
+                input_event(dev, EV_KEY, keycode, value);
+                input_sync(dev);
 
-                        if (value && test_bit(code, atkbd->force_release_mask)) {
-                                input_report_key(dev, keycode, 0);
-                                input_sync(dev);
-                        }
+                if (value && test_bit(code, atkbd->force_release_mask)) {
+                        input_report_key(dev, keycode, 0);
+                        input_sync(dev);
+                }
         }
 
         if (atkbd->scroll) {
                 if (click != -1)
                         input_report_key(dev, BTN_MIDDLE, click);
-                input_report_rel(dev, REL_WHEEL, scroll);
+                input_report_rel(dev, REL_WHEEL,
+                                 atkbd->release ? -scroll : scroll);
                 input_report_rel(dev, REL_HWHEEL, hscroll);
                 input_sync(dev);
         }
 
-        atkbd->release = 0;
+        atkbd->release = false;
 out:
         return IRQ_HANDLED;
 }
@@ -634,17 +633,18 @@ static int atkbd_event(struct input_dev *dev,
 
         switch (type) {
 
-                case EV_LED:
-                        atkbd_schedule_event_work(atkbd, ATKBD_LED_EVENT_BIT);
-                        return 0;
+        case EV_LED:
+                atkbd_schedule_event_work(atkbd, ATKBD_LED_EVENT_BIT);
+                return 0;
 
-                case EV_REP:
-                        if (!atkbd->softrepeat)
-                                atkbd_schedule_event_work(atkbd, ATKBD_REP_EVENT_BIT);
-                        return 0;
-        }
+        case EV_REP:
+                if (!atkbd->softrepeat)
+                        atkbd_schedule_event_work(atkbd, ATKBD_REP_EVENT_BIT);
+                return 0;
 
-        return -1;
+        default:
+                return -1;
+        }
 }
 
 /*
@@ -655,7 +655,7 @@ static int atkbd_event(struct input_dev *dev,
 static inline void atkbd_enable(struct atkbd *atkbd)
 {
         serio_pause_rx(atkbd->ps2dev.serio);
-        atkbd->enabled = 1;
+        atkbd->enabled = true;
         serio_continue_rx(atkbd->ps2dev.serio);
 }
 
@@ -667,7 +667,7 @@ static inline void atkbd_enable(struct atkbd *atkbd)
 static inline void atkbd_disable(struct atkbd *atkbd)
 {
         serio_pause_rx(atkbd->ps2dev.serio);
-        atkbd->enabled = 0;
+        atkbd->enabled = false;
         serio_continue_rx(atkbd->ps2dev.serio);
 }
 
@@ -688,7 +688,9 @@ static int atkbd_probe(struct atkbd *atkbd)
 
         if (atkbd_reset)
                 if (ps2_command(ps2dev, NULL, ATKBD_CMD_RESET_BAT))
-                        printk(KERN_WARNING "atkbd.c: keyboard reset failed on %s\n", ps2dev->serio->phys);
+                        dev_warn(&ps2dev->serio->dev,
+                                 "keyboard reset failed on %s\n",
+                                 ps2dev->serio->phys);
 
 /*
  * Then we check the keyboard ID. We should get 0xab83 under normal conditions.
@@ -718,8 +720,9 @@ static int atkbd_probe(struct atkbd *atkbd)
         atkbd->id = (param[0] << 8) | param[1];
 
         if (atkbd->id == 0xaca1 && atkbd->translated) {
-                printk(KERN_ERR "atkbd.c: NCD terminal keyboards are only supported on non-translating\n");
-                printk(KERN_ERR "atkbd.c: controllers. Use i8042.direct=1 to disable translation.\n");
+                dev_err(&ps2dev->serio->dev,
+                        "NCD terminal keyboards are only supported on non-translating controlelrs. "
+                        "Use i8042.direct=1 to disable translation.\n");
                 return -1;
         }
 
@@ -737,7 +740,7 @@ static int atkbd_select_set(struct atkbd *atkbd, int target_set, int allow_extra
         struct ps2dev *ps2dev = &atkbd->ps2dev;
         unsigned char param[2];
 
-        atkbd->extra = 0;
+        atkbd->extra = false;
 /*
  * For known special keyboards we can go ahead and set the correct set.
  * We check for NCD PS/2 Sun, NorthGate OmniKey 101 and
@@ -756,7 +759,7 @@ static int atkbd_select_set(struct atkbd *atkbd, int target_set, int allow_extra
         if (allow_extra) {
                 param[0] = 0x71;
                 if (!ps2_command(ps2dev, param, ATKBD_CMD_EX_ENABLE)) {
-                        atkbd->extra = 1;
+                        atkbd->extra = true;
                         return 2;
                 }
         }
@@ -821,7 +824,8 @@ static int atkbd_activate(struct atkbd *atkbd)
  */
 
         if (ps2_command(ps2dev, NULL, ATKBD_CMD_ENABLE)) {
-                printk(KERN_ERR "atkbd.c: Failed to enable keyboard on %s\n",
+                dev_err(&ps2dev->serio->dev,
+                        "Failed to enable keyboard on %s\n",
                         ps2dev->serio->phys);
                 return -1;
         }
@@ -1070,9 +1074,13 @@ static void atkbd_set_device_attrs(struct atkbd *atkbd)
         input_dev->keycodesize = sizeof(unsigned short);
         input_dev->keycodemax = ARRAY_SIZE(atkbd_set2_keycode);
 
-        for (i = 0; i < ATKBD_KEYMAP_SIZE; i++)
-                if (atkbd->keycode[i] && atkbd->keycode[i] < ATKBD_SPECIAL)
+        for (i = 0; i < ATKBD_KEYMAP_SIZE; i++) {
+                if (atkbd->keycode[i] != KEY_RESERVED &&
+                    atkbd->keycode[i] != ATKBD_KEY_NULL &&
+                    atkbd->keycode[i] < ATKBD_SPECIAL) {
                         __set_bit(atkbd->keycode[i], input_dev->keybit);
+                }
+        }
 }
 
 /*
@@ -1100,12 +1108,14 @@ static int atkbd_connect(struct serio *serio, struct serio_driver *drv)
 
         switch (serio->id.type) {
 
-                case SERIO_8042_XL:
-                        atkbd->translated = 1;
-                case SERIO_8042:
-                        if (serio->write)
-                                atkbd->write = 1;
-                        break;
+        case SERIO_8042_XL:
+                atkbd->translated = true;
+                /* Fall through */
+
+        case SERIO_8042:
+                if (serio->write)
+                        atkbd->write = true;
+                break;
         }
 
         atkbd->softraw = atkbd_softraw;
@@ -1113,7 +1123,7 @@ static int atkbd_connect(struct serio *serio, struct serio_driver *drv)
         atkbd->scroll = atkbd_scroll;
 
         if (atkbd->softrepeat)
-                atkbd->softraw = 1;
+                atkbd->softraw = true;
 
         serio_set_drvdata(serio, atkbd);
 
@@ -1172,7 +1182,8 @@ static int atkbd_reconnect(struct serio *serio)
         int retval = -1;
 
         if (!atkbd || !drv) {
-                printk(KERN_DEBUG "atkbd: reconnect request, but serio is disconnected, ignoring...\n");
+                dev_dbg(&serio->dev,
+                        "reconnect request, but serio is disconnected, ignoring...\n");
                 return -1;
         }
 
@@ -1286,7 +1297,8 @@ static ssize_t atkbd_set_extra(struct atkbd *atkbd, const char *buf, size_t coun
         struct input_dev *old_dev, *new_dev;
         unsigned long value;
         int err;
-        unsigned char old_extra, old_set;
+        bool old_extra;
+        unsigned char old_set;
 
         if (!atkbd->write)
                 return -EIO;
@@ -1369,7 +1381,7 @@ static ssize_t atkbd_set_scroll(struct atkbd *atkbd, const char *buf, size_t cou
         struct input_dev *old_dev, *new_dev;
         unsigned long value;
         int err;
-        unsigned char old_scroll;
+        bool old_scroll;
 
         if (strict_strtoul(buf, 10, &value) || value > 1)
                 return -EINVAL;
@@ -1413,7 +1425,8 @@ static ssize_t atkbd_set_set(struct atkbd *atkbd, const char *buf, size_t count)
         struct input_dev *old_dev, *new_dev;
         unsigned long value;
         int err;
-        unsigned char old_set, old_extra;
+        unsigned char old_set;
+        bool old_extra;
 
         if (!atkbd->write)
                 return -EIO;
@@ -1463,7 +1476,7 @@ static ssize_t atkbd_set_softrepeat(struct atkbd *atkbd, const char *buf, size_t
         struct input_dev *old_dev, *new_dev;
         unsigned long value;
         int err;
-        unsigned char old_softrepeat, old_softraw;
+        bool old_softrepeat, old_softraw;
 
         if (!atkbd->write)
                 return -EIO;
@@ -1483,7 +1496,7 @@ static ssize_t atkbd_set_softrepeat(struct atkbd *atkbd, const char *buf, size_t
                 atkbd->dev = new_dev;
                 atkbd->softrepeat = value;
                 if (atkbd->softrepeat)
-                        atkbd->softraw = 1;
+                        atkbd->softraw = true;
                 atkbd_set_device_attrs(atkbd);
 
                 err = input_register_device(atkbd->dev);
@@ -1513,7 +1526,7 @@ static ssize_t atkbd_set_softraw(struct atkbd *atkbd, const char *buf, size_t co
         struct input_dev *old_dev, *new_dev;
         unsigned long value;
         int err;
-        unsigned char old_softraw;
+        bool old_softraw;
 
         if (strict_strtoul(buf, 10, &value) || value > 1)
                 return -EINVAL;
diff --git a/drivers/input/keyboard/bf54x-keys.c b/drivers/input/keyboard/bf54x-keys.c
index fe376a27fe57..7d989603f875 100644
--- a/drivers/input/keyboard/bf54x-keys.c
+++ b/drivers/input/keyboard/bf54x-keys.c
@@ -34,6 +34,7 @@
 #include <linux/fs.h>
 #include <linux/interrupt.h>
 #include <linux/irq.h>
+#include <linux/slab.h>
 #include <linux/sched.h>
 #include <linux/pm.h>
 #include <linux/sysctl.h>
@@ -162,7 +163,7 @@ static irqreturn_t bfin_kpad_isr(int irq, void *dev_id)
         input_sync(input);
 
         if (bfin_kpad_get_keypressed(bf54x_kpad)) {
-                disable_irq(bf54x_kpad->irq);
+                disable_irq_nosync(bf54x_kpad->irq);
                 bf54x_kpad->lastkey = key;
                 mod_timer(&bf54x_kpad->timer,
                           jiffies + bf54x_kpad->keyup_test_jiffies);
diff --git a/drivers/input/keyboard/corgikbd.c b/drivers/input/keyboard/corgikbd.c
deleted file mode 100644
index 634af6a8e6b3..000000000000
--- a/drivers/input/keyboard/corgikbd.c
+++ /dev/null
@@ -1,414 +0,0 @@
-/*
- *  Keyboard driver for Sharp Corgi models (SL-C7xx)
- *
- *  Copyright (c) 2004-2005 Richard Purdie
- *
- *  Based on xtkbd.c/locomkbd.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.h>
-#include <linux/interrupt.h>
-#include <linux/jiffies.h>
-#include <linux/module.h>
-#include <linux/slab.h>
-
-#include <mach/corgi.h>
-#include <mach/pxa2xx-gpio.h>
-#include <asm/hardware/scoop.h>
-
-#define KB_ROWS                         8
-#define KB_COLS                         12
-#define KB_ROWMASK(r)           (1 << (r))
-#define SCANCODE(r,c)           ( ((r)<<4) + (c) + 1 )
-/* zero code, 124 scancodes */
-#define NR_SCANCODES            ( SCANCODE(KB_ROWS-1,KB_COLS-1) +1 +1 )
-
-#define SCAN_INTERVAL           (50) /* ms */
-#define HINGE_SCAN_INTERVAL     (250) /* ms */
-
-#define CORGI_KEY_CALENDER      KEY_F1
-#define CORGI_KEY_ADDRESS       KEY_F2
-#define CORGI_KEY_FN            KEY_F3
-#define CORGI_KEY_CANCEL        KEY_F4
-#define CORGI_KEY_OFF           KEY_SUSPEND
-#define CORGI_KEY_EXOK          KEY_F5
-#define CORGI_KEY_EXCANCEL      KEY_F6
-#define CORGI_KEY_EXJOGDOWN     KEY_F7
-#define CORGI_KEY_EXJOGUP       KEY_F8
-#define CORGI_KEY_JAP1          KEY_LEFTCTRL
-#define CORGI_KEY_JAP2          KEY_LEFTALT
-#define CORGI_KEY_MAIL          KEY_F10
-#define CORGI_KEY_OK            KEY_F11
-#define CORGI_KEY_MENU          KEY_F12
-
-static unsigned char corgikbd_keycode[NR_SCANCODES] = {
-        0,                                                                                                                /* 0 */
-        0, KEY_1, KEY_3, KEY_5, KEY_6, KEY_7, KEY_9, KEY_0, KEY_BACKSPACE, 0, 0, 0, 0, 0, 0, 0,                               /* 1-16 */
-        0, KEY_2, KEY_4, KEY_R, KEY_Y, KEY_8, KEY_I, KEY_O, KEY_P, 0, 0, 0, 0, 0, 0, 0,                                   /* 17-32 */
-        KEY_TAB, KEY_Q, KEY_E, KEY_T, KEY_G, KEY_U, KEY_J, KEY_K, 0, 0, 0, 0, 0, 0, 0, 0,                                 /* 33-48 */
-        CORGI_KEY_CALENDER, KEY_W, KEY_S, KEY_F, KEY_V, KEY_H, KEY_M, KEY_L, 0, KEY_RIGHTSHIFT, 0, 0, 0, 0, 0, 0,         /* 49-64 */
-        CORGI_KEY_ADDRESS, KEY_A, KEY_D, KEY_C, KEY_B, KEY_N, KEY_DOT, 0, KEY_ENTER, 0, KEY_LEFTSHIFT, 0, 0, 0, 0, 0,     /* 65-80 */
-        CORGI_KEY_MAIL, KEY_Z, KEY_X, KEY_MINUS, KEY_SPACE, KEY_COMMA, 0, KEY_UP, 0, 0, 0, CORGI_KEY_FN, 0, 0, 0, 0,            /* 81-96 */
-        KEY_SYSRQ, CORGI_KEY_JAP1, CORGI_KEY_JAP2, CORGI_KEY_CANCEL, CORGI_KEY_OK, CORGI_KEY_MENU, KEY_LEFT, KEY_DOWN, KEY_RIGHT, 0, 0, 0, 0, 0, 0, 0,  /* 97-112 */
-        CORGI_KEY_OFF, CORGI_KEY_EXOK, CORGI_KEY_EXCANCEL, CORGI_KEY_EXJOGDOWN, CORGI_KEY_EXJOGUP, 0, 0, 0, 0, 0, 0, 0,   /* 113-124 */
-};
-
-
-struct corgikbd {
-        unsigned char keycode[ARRAY_SIZE(corgikbd_keycode)];
-        struct input_dev *input;
-
-        spinlock_t lock;
-        struct timer_list timer;
-        struct timer_list htimer;
-
-        unsigned int suspended;
-        unsigned long suspend_jiffies;
-};
-
-#define KB_DISCHARGE_DELAY      10
-#define KB_ACTIVATE_DELAY       10
-
-/* Helper functions for reading the keyboard matrix
- * Note: We should really be using the generic gpio functions to alter
- *       GPDR but it requires a function call per GPIO bit which is
- *       excessive when we need to access 12 bits at once, multiple times.
- * These functions must be called within local_irq_save()/local_irq_restore()
- * or similar.
- */
-static inline void corgikbd_discharge_all(void)
-{
-        /* STROBE All HiZ */
-        GPCR2  = CORGI_GPIO_ALL_STROBE_BIT;
-        GPDR2 &= ~CORGI_GPIO_ALL_STROBE_BIT;
-}
-
-static inline void corgikbd_activate_all(void)
-{
-        /* STROBE ALL -> High */
-        GPSR2  = CORGI_GPIO_ALL_STROBE_BIT;
-        GPDR2 |= CORGI_GPIO_ALL_STROBE_BIT;
-
-        udelay(KB_DISCHARGE_DELAY);
-
-        /* Clear any interrupts we may have triggered when altering the GPIO lines */
-        GEDR1 = CORGI_GPIO_HIGH_SENSE_BIT;
-        GEDR2 = CORGI_GPIO_LOW_SENSE_BIT;
-}
-
-static inline void corgikbd_activate_col(int col)
-{
-        /* STROBE col -> High, not col -> HiZ */
-        GPSR2 = CORGI_GPIO_STROBE_BIT(col);
-        GPDR2 = (GPDR2 & ~CORGI_GPIO_ALL_STROBE_BIT) | CORGI_GPIO_STROBE_BIT(col);
-}
-
-static inline void corgikbd_reset_col(int col)
-{
-        /* STROBE col -> Low */
-        GPCR2 = CORGI_GPIO_STROBE_BIT(col);
-        /* STROBE col -> out, not col -> HiZ */
-        GPDR2 = (GPDR2 & ~CORGI_GPIO_ALL_STROBE_BIT) | CORGI_GPIO_STROBE_BIT(col);
-}
-
-#define GET_ROWS_STATUS(c)      (((GPLR1 & CORGI_GPIO_HIGH_SENSE_BIT) >> CORGI_GPIO_HIGH_SENSE_RSHIFT) | ((GPLR2 & CORGI_GPIO_LOW_SENSE_BIT) << CORGI_GPIO_LOW_SENSE_LSHIFT))
-
-/*
- * The corgi keyboard only generates interrupts when a key is pressed.
- * When a key is pressed, we enable a timer which then scans the
- * keyboard to detect when the key is released.
- */
-
-/* Scan the hardware keyboard and push any changes up through the input layer */
-static void corgikbd_scankeyboard(struct corgikbd *corgikbd_data)
-{
-        unsigned int row, col, rowd;
-        unsigned long flags;
-        unsigned int num_pressed;
-
-        if (corgikbd_data->suspended)
-                return;
-
-        spin_lock_irqsave(&corgikbd_data->lock, flags);
-
-        num_pressed = 0;
-        for (col = 0; col < KB_COLS; col++) {
-                /*
-                 * Discharge the output driver capacitatance
-                 * in the keyboard matrix. (Yes it is significant..)
-                 */
-
-                corgikbd_discharge_all();
-                udelay(KB_DISCHARGE_DELAY);
-
-                corgikbd_activate_col(col);
-                udelay(KB_ACTIVATE_DELAY);
-
-                rowd = GET_ROWS_STATUS(col);
-                for (row = 0; row < KB_ROWS; row++) {
-                        unsigned int scancode, pressed;
-
-                        scancode = SCANCODE(row, col);
-                        pressed = rowd & KB_ROWMASK(row);
-
-                        input_report_key(corgikbd_data->input, corgikbd_data->keycode[scancode], pressed);
-
-                        if (pressed)
-                                num_pressed++;
-
-                        if (pressed && (corgikbd_data->keycode[scancode] == CORGI_KEY_OFF)
-                                        && time_after(jiffies, corgikbd_data->suspend_jiffies + HZ)) {
-                                input_event(corgikbd_data->input, EV_PWR, CORGI_KEY_OFF, 1);
-                                corgikbd_data->suspend_jiffies=jiffies;
-                        }
-                }
-                corgikbd_reset_col(col);
-        }
-
-        corgikbd_activate_all();
-
-        input_sync(corgikbd_data->input);
-
-        /* if any keys are pressed, enable the timer */
-        if (num_pressed)
-                mod_timer(&corgikbd_data->timer, jiffies + msecs_to_jiffies(SCAN_INTERVAL));
-
-        spin_unlock_irqrestore(&corgikbd_data->lock, flags);
-}
-
-/*
- * corgi keyboard interrupt handler.
- */
-static irqreturn_t corgikbd_interrupt(int irq, void *dev_id)
-{
-        struct corgikbd *corgikbd_data = dev_id;
-
-        if (!timer_pending(&corgikbd_data->timer)) {
-                /** wait chattering delay **/
-                udelay(20);
-                corgikbd_scankeyboard(corgikbd_data);
-        }
-
-        return IRQ_HANDLED;
-}
-
-/*
- * corgi timer checking for released keys
- */
-static void corgikbd_timer_callback(unsigned long data)
-{
-        struct corgikbd *corgikbd_data = (struct corgikbd *) data;
-        corgikbd_scankeyboard(corgikbd_data);
-}
-
-/*
- * The hinge switches generate no interrupt so they need to be
- * monitored by a timer.
- *
- * We debounce the switches and pass them to the input system.
- *
- *  gprr == 0x00 - Keyboard with Landscape Screen
- *          0x08 - No Keyboard with Portrait Screen
- *          0x0c - Keyboard and Screen Closed
- */
-
-#define READ_GPIO_BIT(x)    (GPLR(x) & GPIO_bit(x))
-#define HINGE_STABLE_COUNT 2
-static int sharpsl_hinge_state;
-static int hinge_count;
-
-static void corgikbd_hinge_timer(unsigned long data)
-{
-        struct corgikbd *corgikbd_data = (struct corgikbd *) data;
-        unsigned long gprr;
-        unsigned long flags;
-
-        gprr = read_scoop_reg(&corgiscoop_device.dev, SCOOP_GPRR) & (CORGI_SCP_SWA | CORGI_SCP_SWB);
-        gprr |= (READ_GPIO_BIT(CORGI_GPIO_AK_INT) != 0);
-        if (gprr != sharpsl_hinge_state) {
-                hinge_count = 0;
-                sharpsl_hinge_state = gprr;
-        } else if (hinge_count < HINGE_STABLE_COUNT) {
-                hinge_count++;
-                if (hinge_count >= HINGE_STABLE_COUNT) {
-                        spin_lock_irqsave(&corgikbd_data->lock, flags);
-
-                        input_report_switch(corgikbd_data->input, SW_LID, ((sharpsl_hinge_state & CORGI_SCP_SWA) != 0));
-                        input_report_switch(corgikbd_data->input, SW_TABLET_MODE, ((sharpsl_hinge_state & CORGI_SCP_SWB) != 0));
-                        input_report_switch(corgikbd_data->input, SW_HEADPHONE_INSERT, (READ_GPIO_BIT(CORGI_GPIO_AK_INT) != 0));
-                        input_sync(corgikbd_data->input);
-
-                        spin_unlock_irqrestore(&corgikbd_data->lock, flags);
-                }
-        }
-        mod_timer(&corgikbd_data->htimer, jiffies + msecs_to_jiffies(HINGE_SCAN_INTERVAL));
-}
-
-#ifdef CONFIG_PM
-static int corgikbd_suspend(struct platform_device *dev, pm_message_t state)
-{
-        int i;
-        struct corgikbd *corgikbd = platform_get_drvdata(dev);
-
-        corgikbd->suspended = 1;
-        /* strobe 0 is the power key so this can't be made an input for
-           powersaving therefore i = 1 */
-        for (i = 1; i < CORGI_KEY_STROBE_NUM; i++)
-                pxa_gpio_mode(CORGI_GPIO_KEY_STROBE(i) | GPIO_IN);
-
-        return 0;
-}
-
-static int corgikbd_resume(struct platform_device *dev)
-{
-        int i;
-        struct corgikbd *corgikbd = platform_get_drvdata(dev);
-
-        for (i = 1; i < CORGI_KEY_STROBE_NUM; i++)
-                pxa_gpio_mode(CORGI_GPIO_KEY_STROBE(i) | GPIO_OUT | GPIO_DFLT_HIGH);
-
-        /* Upon resume, ignore the suspend key for a short while */
-        corgikbd->suspend_jiffies=jiffies;
-        corgikbd->suspended = 0;
-
-        return 0;
-}
-#else
-#define corgikbd_suspend        NULL
-#define corgikbd_resume         NULL
-#endif
-
-static int __devinit corgikbd_probe(struct platform_device *pdev)
-{
-        struct corgikbd *corgikbd;
-        struct input_dev *input_dev;
-        int i, err = -ENOMEM;
-
-        corgikbd = kzalloc(sizeof(struct corgikbd), GFP_KERNEL);
-        input_dev = input_allocate_device();
-        if (!corgikbd || !input_dev)
-                goto fail;
-
-        platform_set_drvdata(pdev, corgikbd);
-
-        corgikbd->input = input_dev;
-        spin_lock_init(&corgikbd->lock);
-
-        /* Init Keyboard rescan timer */
-        init_timer(&corgikbd->timer);
-        corgikbd->timer.function = corgikbd_timer_callback;
-        corgikbd->timer.data = (unsigned long) corgikbd;
-
-        /* Init Hinge Timer */
-        init_timer(&corgikbd->htimer);
-        corgikbd->htimer.function = corgikbd_hinge_timer;
-        corgikbd->htimer.data = (unsigned long) corgikbd;
-
-        corgikbd->suspend_jiffies=jiffies;
-
-        memcpy(corgikbd->keycode, corgikbd_keycode, sizeof(corgikbd->keycode));
-
-        input_dev->name = "Corgi Keyboard";
-        input_dev->phys = "corgikbd/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) |
-                BIT_MASK(EV_PWR) | BIT_MASK(EV_SW);
-        input_dev->keycode = corgikbd->keycode;
-        input_dev->keycodesize = sizeof(unsigned char);
-        input_dev->keycodemax = ARRAY_SIZE(corgikbd_keycode);
-
-        for (i = 0; i < ARRAY_SIZE(corgikbd_keycode); i++)
-                set_bit(corgikbd->keycode[i], input_dev->keybit);
-        clear_bit(0, input_dev->keybit);
-        set_bit(SW_LID, input_dev->swbit);
-        set_bit(SW_TABLET_MODE, input_dev->swbit);
-        set_bit(SW_HEADPHONE_INSERT, input_dev->swbit);
-
-        err = input_register_device(corgikbd->input);
-        if (err)
-                goto fail;
-
-        mod_timer(&corgikbd->htimer, jiffies + msecs_to_jiffies(HINGE_SCAN_INTERVAL));
-
-        /* Setup sense interrupts - RisingEdge Detect, sense lines as inputs */
-        for (i = 0; i < CORGI_KEY_SENSE_NUM; i++) {
-                pxa_gpio_mode(CORGI_GPIO_KEY_SENSE(i) | GPIO_IN);
-                if (request_irq(CORGI_IRQ_GPIO_KEY_SENSE(i), corgikbd_interrupt,
-                                IRQF_DISABLED | IRQF_TRIGGER_RISING,
-                                "corgikbd", corgikbd))
-                        printk(KERN_WARNING "corgikbd: Can't get IRQ: %d!\n", i);
-        }
-
-        /* Set Strobe lines as outputs - set high */
-        for (i = 0; i < CORGI_KEY_STROBE_NUM; i++)
-                pxa_gpio_mode(CORGI_GPIO_KEY_STROBE(i) | GPIO_OUT | GPIO_DFLT_HIGH);
-
-        /* Setup the headphone jack as an input */
-        pxa_gpio_mode(CORGI_GPIO_AK_INT | GPIO_IN);
-
-        return 0;
-
- fail:  input_free_device(input_dev);
-        kfree(corgikbd);
-        return err;
-}
-
-static int __devexit corgikbd_remove(struct platform_device *pdev)
-{
-        int i;
-        struct corgikbd *corgikbd = platform_get_drvdata(pdev);
-
-        for (i = 0; i < CORGI_KEY_SENSE_NUM; i++)
-                free_irq(CORGI_IRQ_GPIO_KEY_SENSE(i), corgikbd);
-
-        del_timer_sync(&corgikbd->htimer);
-        del_timer_sync(&corgikbd->timer);
-
-        input_unregister_device(corgikbd->input);
-
-        kfree(corgikbd);
-
-        return 0;
-}
-
-static struct platform_driver corgikbd_driver = {
-        .probe          = corgikbd_probe,
-        .remove         = __devexit_p(corgikbd_remove),
-        .suspend        = corgikbd_suspend,
-        .resume         = corgikbd_resume,
-        .driver         = {
-                .name   = "corgi-keyboard",
-                .owner  = THIS_MODULE,
-        },
-};
-
-static int __init corgikbd_init(void)
-{
-        return platform_driver_register(&corgikbd_driver);
-}
-
-static void __exit corgikbd_exit(void)
-{
-        platform_driver_unregister(&corgikbd_driver);
-}
-
-module_init(corgikbd_init);
-module_exit(corgikbd_exit);
-
-MODULE_AUTHOR("Richard Purdie <rpurdie@rpsys.net>");
-MODULE_DESCRIPTION("Corgi Keyboard Driver");
-MODULE_LICENSE("GPL v2");
-MODULE_ALIAS("platform:corgi-keyboard");
diff --git a/drivers/input/keyboard/davinci_keyscan.c b/drivers/input/keyboard/davinci_keyscan.c
index d410d7a52f1d..a91ee941b5c1 100644
--- a/drivers/input/keyboard/davinci_keyscan.c
+++ b/drivers/input/keyboard/davinci_keyscan.c
@@ -30,6 +30,7 @@
 #include <linux/delay.h>
 #include <linux/platform_device.h>
 #include <linux/errno.h>
+#include <linux/slab.h>
 
 #include <asm/irq.h>
 
diff --git a/drivers/input/keyboard/ep93xx_keypad.c b/drivers/input/keyboard/ep93xx_keypad.c
index e45740429f7e..c8242dd190d0 100644
--- a/drivers/input/keyboard/ep93xx_keypad.c
+++ b/drivers/input/keyboard/ep93xx_keypad.c
@@ -25,6 +25,7 @@
 #include <linux/clk.h>
 #include <linux/io.h>
 #include <linux/input/matrix_keypad.h>
+#include <linux/slab.h>
 
 #include <mach/hardware.h>
 #include <mach/ep93xx_keypad.h>
@@ -69,7 +70,7 @@ struct ep93xx_keypad {
 
         void __iomem *mmio_base;
 
-        unsigned int matrix_keycodes[EP93XX_MATRIX_SIZE];
+        unsigned short keycodes[EP93XX_MATRIX_SIZE];
 
         int key1;
         int key2;
@@ -79,24 +80,6 @@ struct ep93xx_keypad {
         bool enabled;
 };
 
-static void ep93xx_keypad_build_keycode(struct ep93xx_keypad *keypad)
-{
-        struct ep93xx_keypad_platform_data *pdata = keypad->pdata;
-        struct input_dev *input_dev = keypad->input_dev;
-        unsigned int *key;
-        int i;
-
-        key = &pdata->matrix_key_map[0];
-        for (i = 0; i < pdata->matrix_key_map_size; i++, key++) {
-                int row = KEY_ROW(*key);
-                int col = KEY_COL(*key);
-                int code = KEY_VAL(*key);
-
-                keypad->matrix_keycodes[(row << 3) + col] = code;
-                __set_bit(code, input_dev->keybit);
-        }
-}
-
 static irqreturn_t ep93xx_keypad_irq_handler(int irq, void *dev_id)
 {
         struct ep93xx_keypad *keypad = dev_id;
@@ -107,10 +90,10 @@ static irqreturn_t ep93xx_keypad_irq_handler(int irq, void *dev_id)
         status = __raw_readl(keypad->mmio_base + KEY_REG);
 
         keycode = (status & KEY_REG_KEY1_MASK) >> KEY_REG_KEY1_SHIFT;
-        key1 = keypad->matrix_keycodes[keycode];
+        key1 = keypad->keycodes[keycode];
 
         keycode = (status & KEY_REG_KEY2_MASK) >> KEY_REG_KEY2_SHIFT;
-        key2 = keypad->matrix_keycodes[keycode];
+        key2 = keypad->keycodes[keycode];
 
         if (status & KEY_REG_2KEYS) {
                 if (keypad->key1 && key1 != keypad->key1 && key2 != keypad->key1)
@@ -256,6 +239,7 @@ static int ep93xx_keypad_resume(struct platform_device *pdev)
 static int __devinit ep93xx_keypad_probe(struct platform_device *pdev)
 {
         struct ep93xx_keypad *keypad;
+        const struct matrix_keymap_data *keymap_data;
         struct input_dev *input_dev;
         struct resource *res;
         int err;
@@ -270,6 +254,12 @@ static int __devinit ep93xx_keypad_probe(struct platform_device *pdev)
                 goto failed_free;
         }
 
+        keymap_data = keypad->pdata->keymap_data;
+        if (!keymap_data) {
+                err = -EINVAL;
+                goto failed_free;
+        }
+
         keypad->irq = platform_get_irq(pdev, 0);
         if (!keypad->irq) {
                 err = -ENXIO;
@@ -317,9 +307,9 @@ static int __devinit ep93xx_keypad_probe(struct platform_device *pdev)
         input_dev->open = ep93xx_keypad_open;
         input_dev->close = ep93xx_keypad_close;
         input_dev->dev.parent = &pdev->dev;
-        input_dev->keycode = keypad->matrix_keycodes;
-        input_dev->keycodesize = sizeof(keypad->matrix_keycodes[0]);
-        input_dev->keycodemax = ARRAY_SIZE(keypad->matrix_keycodes);
+        input_dev->keycode = keypad->keycodes;
+        input_dev->keycodesize = sizeof(keypad->keycodes[0]);
+        input_dev->keycodemax = ARRAY_SIZE(keypad->keycodes);
 
         input_set_drvdata(input_dev, keypad);
 
@@ -327,7 +317,8 @@ static int __devinit ep93xx_keypad_probe(struct platform_device *pdev)
         if (keypad->pdata->flags & EP93XX_KEYPAD_AUTOREPEAT)
                 input_dev->evbit[0] |= BIT_MASK(EV_REP);
 
-        ep93xx_keypad_build_keycode(keypad);
+        matrix_keypad_build_keymap(keymap_data, 3,
+                                   input_dev->keycode, input_dev->keybit);
         platform_set_drvdata(pdev, keypad);
 
         err = request_irq(keypad->irq, ep93xx_keypad_irq_handler,
diff --git a/drivers/input/keyboard/gpio_keys.c b/drivers/input/keyboard/gpio_keys.c
index 1aff3b76effd..6069abe31e42 100644
--- a/drivers/input/keyboard/gpio_keys.c
+++ b/drivers/input/keyboard/gpio_keys.c
@@ -16,6 +16,7 @@
 #include <linux/irq.h>
 #include <linux/sched.h>
 #include <linux/pm.h>
+#include <linux/slab.h>
 #include <linux/sysctl.h>
 #include <linux/proc_fs.h>
 #include <linux/delay.h>
@@ -30,13 +31,292 @@ struct gpio_button_data {
         struct input_dev *input;
         struct timer_list timer;
         struct work_struct work;
+        int timer_debounce;     /* in msecs */
+        bool disabled;
 };
 
 struct gpio_keys_drvdata {
         struct input_dev *input;
+        struct mutex disable_lock;
+        unsigned int n_buttons;
+        int (*enable)(struct device *dev);
+        void (*disable)(struct device *dev);
         struct gpio_button_data data[0];
 };
 
+/*
+ * SYSFS interface for enabling/disabling keys and switches:
+ *
+ * There are 4 attributes under /sys/devices/platform/gpio-keys/
+ *      keys [ro]              - bitmap of keys (EV_KEY) which can be
+ *                               disabled
+ *      switches [ro]          - bitmap of switches (EV_SW) which can be
+ *                               disabled
+ *      disabled_keys [rw]     - bitmap of keys currently disabled
+ *      disabled_switches [rw] - bitmap of switches currently disabled
+ *
+ * Userland can change these values and hence disable event generation
+ * for each key (or switch). Disabling a key means its interrupt line
+ * is disabled.
+ *
+ * For example, if we have following switches set up as gpio-keys:
+ *      SW_DOCK = 5
+ *      SW_CAMERA_LENS_COVER = 9
+ *      SW_KEYPAD_SLIDE = 10
+ *      SW_FRONT_PROXIMITY = 11
+ * This is read from switches:
+ *      11-9,5
+ * Next we want to disable proximity (11) and dock (5), we write:
+ *      11,5
+ * to file disabled_switches. Now proximity and dock IRQs are disabled.
+ * This can be verified by reading the file disabled_switches:
+ *      11,5
+ * If we now want to enable proximity (11) switch we write:
+ *      5
+ * to disabled_switches.
+ *
+ * We can disable only those keys which don't allow sharing the irq.
+ */
+
+/**
+ * get_n_events_by_type() - returns maximum number of events per @type
+ * @type: type of button (%EV_KEY, %EV_SW)
+ *
+ * Return value of this function can be used to allocate bitmap
+ * large enough to hold all bits for given type.
+ */
+static inline int get_n_events_by_type(int type)
+{
+        BUG_ON(type != EV_SW && type != EV_KEY);
+
+        return (type == EV_KEY) ? KEY_CNT : SW_CNT;
+}
+
+/**
+ * gpio_keys_disable_button() - disables given GPIO button
+ * @bdata: button data for button to be disabled
+ *
+ * Disables button pointed by @bdata. This is done by masking
+ * IRQ line. After this function is called, button won't generate
+ * input events anymore. Note that one can only disable buttons
+ * that don't share IRQs.
+ *
+ * Make sure that @bdata->disable_lock is locked when entering
+ * this function to avoid races when concurrent threads are
+ * disabling buttons at the same time.
+ */
+static void gpio_keys_disable_button(struct gpio_button_data *bdata)
+{
+        if (!bdata->disabled) {
+                /*
+                 * Disable IRQ and possible debouncing timer.
+                 */
+                disable_irq(gpio_to_irq(bdata->button->gpio));
+                if (bdata->timer_debounce)
+                        del_timer_sync(&bdata->timer);
+
+                bdata->disabled = true;
+        }
+}
+
+/**
+ * gpio_keys_enable_button() - enables given GPIO button
+ * @bdata: button data for button to be disabled
+ *
+ * Enables given button pointed by @bdata.
+ *
+ * Make sure that @bdata->disable_lock is locked when entering
+ * this function to avoid races with concurrent threads trying
+ * to enable the same button at the same time.
+ */
+static void gpio_keys_enable_button(struct gpio_button_data *bdata)
+{
+        if (bdata->disabled) {
+                enable_irq(gpio_to_irq(bdata->button->gpio));
+                bdata->disabled = false;
+        }
+}
+
+/**
+ * gpio_keys_attr_show_helper() - fill in stringified bitmap of buttons
+ * @ddata: pointer to drvdata
+ * @buf: buffer where stringified bitmap is written
+ * @type: button type (%EV_KEY, %EV_SW)
+ * @only_disabled: does caller want only those buttons that are
+ *                 currently disabled or all buttons that can be
+ *                 disabled
+ *
+ * This function writes buttons that can be disabled to @buf. If
+ * @only_disabled is true, then @buf contains only those buttons
+ * that are currently disabled. Returns 0 on success or negative
+ * errno on failure.
+ */
+static ssize_t gpio_keys_attr_show_helper(struct gpio_keys_drvdata *ddata,
+                                          char *buf, unsigned int type,
+                                          bool only_disabled)
+{
+        int n_events = get_n_events_by_type(type);
+        unsigned long *bits;
+        ssize_t ret;
+        int i;
+
+        bits = kcalloc(BITS_TO_LONGS(n_events), sizeof(*bits), GFP_KERNEL);
+        if (!bits)
+                return -ENOMEM;
+
+        for (i = 0; i < ddata->n_buttons; i++) {
+                struct gpio_button_data *bdata = &ddata->data[i];
+
+                if (bdata->button->type != type)
+                        continue;
+
+                if (only_disabled && !bdata->disabled)
+                        continue;
+
+                __set_bit(bdata->button->code, bits);
+        }
+
+        ret = bitmap_scnlistprintf(buf, PAGE_SIZE - 2, bits, n_events);
+        buf[ret++] = '\n';
+        buf[ret] = '\0';
+
+        kfree(bits);
+
+        return ret;
+}
+
+/**
+ * gpio_keys_attr_store_helper() - enable/disable buttons based on given bitmap
+ * @ddata: pointer to drvdata
+ * @buf: buffer from userspace that contains stringified bitmap
+ * @type: button type (%EV_KEY, %EV_SW)
+ *
+ * This function parses stringified bitmap from @buf and disables/enables
+ * GPIO buttons accordinly. Returns 0 on success and negative error
+ * on failure.
+ */
+static ssize_t gpio_keys_attr_store_helper(struct gpio_keys_drvdata *ddata,
+                                           const char *buf, unsigned int type)
+{
+        int n_events = get_n_events_by_type(type);
+        unsigned long *bits;
+        ssize_t error;
+        int i;
+
+        bits = kcalloc(BITS_TO_LONGS(n_events), sizeof(*bits), GFP_KERNEL);
+        if (!bits)
+                return -ENOMEM;
+
+        error = bitmap_parselist(buf, bits, n_events);
+        if (error)
+                goto out;
+
+        /* First validate */
+        for (i = 0; i < ddata->n_buttons; i++) {
+                struct gpio_button_data *bdata = &ddata->data[i];
+
+                if (bdata->button->type != type)
+                        continue;
+
+                if (test_bit(bdata->button->code, bits) &&
+                    !bdata->button->can_disable) {
+                        error = -EINVAL;
+                        goto out;
+                }
+        }
+
+        mutex_lock(&ddata->disable_lock);
+
+        for (i = 0; i < ddata->n_buttons; i++) {
+                struct gpio_button_data *bdata = &ddata->data[i];
+
+                if (bdata->button->type != type)
+                        continue;
+
+                if (test_bit(bdata->button->code, bits))
+                        gpio_keys_disable_button(bdata);
+                else
+                        gpio_keys_enable_button(bdata);
+        }
+
+        mutex_unlock(&ddata->disable_lock);
+
+out:
+        kfree(bits);
+        return error;
+}
+
+#define ATTR_SHOW_FN(name, type, only_disabled)                         \
+static ssize_t gpio_keys_show_##name(struct device *dev,                \
+                                     struct device_attribute *attr,     \
+                                     char *buf)                         \
+{                                                                       \
+        struct platform_device *pdev = to_platform_device(dev);         \
+        struct gpio_keys_drvdata *ddata = platform_get_drvdata(pdev);   \
+                                                                        \
+        return gpio_keys_attr_show_helper(ddata, buf,                   \
+                                          type, only_disabled);         \
+}
+
+ATTR_SHOW_FN(keys, EV_KEY, false);
+ATTR_SHOW_FN(switches, EV_SW, false);
+ATTR_SHOW_FN(disabled_keys, EV_KEY, true);
+ATTR_SHOW_FN(disabled_switches, EV_SW, true);
+
+/*
+ * ATTRIBUTES:
+ *
+ * /sys/devices/platform/gpio-keys/keys [ro]
+ * /sys/devices/platform/gpio-keys/switches [ro]
+ */
+static DEVICE_ATTR(keys, S_IRUGO, gpio_keys_show_keys, NULL);
+static DEVICE_ATTR(switches, S_IRUGO, gpio_keys_show_switches, NULL);
+
+#define ATTR_STORE_FN(name, type)                                       \
+static ssize_t gpio_keys_store_##name(struct device *dev,               \
+                                      struct device_attribute *attr,    \
+                                      const char *buf,                  \
+                                      size_t count)                     \
+{                                                                       \
+        struct platform_device *pdev = to_platform_device(dev);         \
+        struct gpio_keys_drvdata *ddata = platform_get_drvdata(pdev);   \
+        ssize_t error;                                                  \
+                                                                        \
+        error = gpio_keys_attr_store_helper(ddata, buf, type);          \
+        if (error)                                                      \
+                return error;                                           \
+                                                                        \
+        return count;                                                   \
+}
+
+ATTR_STORE_FN(disabled_keys, EV_KEY);
+ATTR_STORE_FN(disabled_switches, EV_SW);
+
+/*
+ * ATTRIBUTES:
+ *
+ * /sys/devices/platform/gpio-keys/disabled_keys [rw]
+ * /sys/devices/platform/gpio-keys/disables_switches [rw]
+ */
+static DEVICE_ATTR(disabled_keys, S_IWUSR | S_IRUGO,
+                   gpio_keys_show_disabled_keys,
+                   gpio_keys_store_disabled_keys);
+static DEVICE_ATTR(disabled_switches, S_IWUSR | S_IRUGO,
+                   gpio_keys_show_disabled_switches,
+                   gpio_keys_store_disabled_switches);
+
+static struct attribute *gpio_keys_attrs[] = {
+        &dev_attr_keys.attr,
+        &dev_attr_switches.attr,
+        &dev_attr_disabled_keys.attr,
+        &dev_attr_disabled_switches.attr,
+        NULL,
+};
+
+static struct attribute_group gpio_keys_attr_group = {
+        .attrs = gpio_keys_attrs,
+};
+
 static void gpio_keys_report_event(struct gpio_button_data *bdata)
 {
         struct gpio_keys_button *button = bdata->button;
@@ -70,20 +350,22 @@ static irqreturn_t gpio_keys_isr(int irq, void *dev_id)
 
         BUG_ON(irq != gpio_to_irq(button->gpio));
 
-        if (button->debounce_interval)
+        if (bdata->timer_debounce)
                 mod_timer(&bdata->timer,
-                        jiffies + msecs_to_jiffies(button->debounce_interval));
+                        jiffies + msecs_to_jiffies(bdata->timer_debounce));
         else
                 schedule_work(&bdata->work);
 
         return IRQ_HANDLED;
 }
 
-static int __devinit gpio_keys_setup_key(struct device *dev,
+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";
+        struct device *dev = &pdev->dev;
+        unsigned long irqflags;
         int irq, error;
 
         setup_timer(&bdata->timer, gpio_keys_timer, (unsigned long)bdata);
@@ -104,6 +386,14 @@ static int __devinit gpio_keys_setup_key(struct device *dev,
                 goto fail3;
         }
 
+        if (button->debounce_interval) {
+                error = gpio_set_debounce(button->gpio,
+                                          button->debounce_interval * 1000);
+                /* use timer if gpiolib doesn't provide debounce */
+                if (error < 0)
+                        bdata->timer_debounce = button->debounce_interval;
+        }
+
         irq = gpio_to_irq(button->gpio);
         if (irq < 0) {
                 error = irq;
@@ -112,10 +402,15 @@ static int __devinit gpio_keys_setup_key(struct device *dev,
                 goto fail3;
         }
 
-        error = request_irq(irq, gpio_keys_isr,
-                            IRQF_SHARED |
-                            IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
-                            desc, bdata);
+        irqflags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING;
+        /*
+         * If platform has specified that the button can be disabled,
+         * we don't want it to share the interrupt line.
+         */
+        if (!button->can_disable)
+                irqflags |= IRQF_SHARED;
+
+        error = request_irq(irq, gpio_keys_isr, irqflags, desc, bdata);
         if (error) {
                 dev_err(dev, "Unable to claim irq %d; error %d\n",
                         irq, error);
@@ -130,6 +425,21 @@ fail2:
         return error;
 }
 
+static int gpio_keys_open(struct input_dev *input)
+{
+        struct gpio_keys_drvdata *ddata = input_get_drvdata(input);
+
+        return ddata->enable ? ddata->enable(input->dev.parent) : 0;
+}
+
+static void gpio_keys_close(struct input_dev *input)
+{
+        struct gpio_keys_drvdata *ddata = input_get_drvdata(input);
+
+        if (ddata->disable)
+                ddata->disable(input->dev.parent);
+}
+
 static int __devinit gpio_keys_probe(struct platform_device *pdev)
 {
         struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
@@ -149,11 +459,20 @@ static int __devinit gpio_keys_probe(struct platform_device *pdev)
                 goto fail1;
         }
 
+        ddata->input = input;
+        ddata->n_buttons = pdata->nbuttons;
+        ddata->enable = pdata->enable;
+        ddata->disable = pdata->disable;
+        mutex_init(&ddata->disable_lock);
+
         platform_set_drvdata(pdev, ddata);
+        input_set_drvdata(input, ddata);
 
         input->name = pdev->name;
         input->phys = "gpio-keys/input0";
         input->dev.parent = &pdev->dev;
+        input->open = gpio_keys_open;
+        input->close = gpio_keys_close;
 
         input->id.bustype = BUS_HOST;
         input->id.vendor = 0x0001;
@@ -164,8 +483,6 @@ static int __devinit gpio_keys_probe(struct platform_device *pdev)
         if (pdata->rep)
                 __set_bit(EV_REP, input->evbit);
 
-        ddata->input = input;
-
         for (i = 0; i < pdata->nbuttons; i++) {
                 struct gpio_keys_button *button = &pdata->buttons[i];
                 struct gpio_button_data *bdata = &ddata->data[i];
@@ -174,7 +491,7 @@ static int __devinit gpio_keys_probe(struct platform_device *pdev)
                 bdata->input = input;
                 bdata->button = button;
 
-                error = gpio_keys_setup_key(dev, bdata, button);
+                error = gpio_keys_setup_key(pdev, bdata, button);
                 if (error)
                         goto fail2;
 
@@ -184,13 +501,20 @@ static int __devinit gpio_keys_probe(struct platform_device *pdev)
                 input_set_capability(input, type, button->code);
         }
 
-        error = input_register_device(input);
+        error = sysfs_create_group(&pdev->dev.kobj, &gpio_keys_attr_group);
         if (error) {
-                dev_err(dev, "Unable to register input device, "
-                        "error: %d\n", error);
+                dev_err(dev, "Unable to export keys/switches, error: %d\n",
+                        error);
                 goto fail2;
         }
 
+        error = input_register_device(input);
+        if (error) {
+                dev_err(dev, "Unable to register input device, error: %d\n",
+                        error);
+                goto fail3;
+        }
+
         /* get current state of buttons */
         for (i = 0; i < pdata->nbuttons; i++)
                 gpio_keys_report_event(&ddata->data[i]);
@@ -200,10 +524,12 @@ static int __devinit gpio_keys_probe(struct platform_device *pdev)
 
         return 0;
 
+ fail3:
+        sysfs_remove_group(&pdev->dev.kobj, &gpio_keys_attr_group);
  fail2:
         while (--i >= 0) {
                 free_irq(gpio_to_irq(pdata->buttons[i].gpio), &ddata->data[i]);
-                if (pdata->buttons[i].debounce_interval)
+                if (ddata->data[i].timer_debounce)
                         del_timer_sync(&ddata->data[i].timer);
                 cancel_work_sync(&ddata->data[i].work);
                 gpio_free(pdata->buttons[i].gpio);
@@ -224,12 +550,14 @@ static int __devexit gpio_keys_remove(struct platform_device *pdev)
         struct input_dev *input = ddata->input;
         int i;
 
+        sysfs_remove_group(&pdev->dev.kobj, &gpio_keys_attr_group);
+
         device_init_wakeup(&pdev->dev, 0);
 
         for (i = 0; i < pdata->nbuttons; i++) {
                 int irq = gpio_to_irq(pdata->buttons[i].gpio);
                 free_irq(irq, &ddata->data[i]);
-                if (pdata->buttons[i].debounce_interval)
+                if (ddata->data[i].timer_debounce)
                         del_timer_sync(&ddata->data[i].timer);
                 cancel_work_sync(&ddata->data[i].work);
                 gpio_free(pdata->buttons[i].gpio);
diff --git a/drivers/input/keyboard/hil_kbd.c b/drivers/input/keyboard/hil_kbd.c
index c83f4b2ec7d3..fed31e0947a1 100644
--- a/drivers/input/keyboard/hil_kbd.c
+++ b/drivers/input/keyboard/hil_kbd.c
@@ -232,15 +232,16 @@ static void hil_dev_handle_ptr_events(struct hil_dev *ptr)
                 if (absdev) {
                         val = lo + (hi << 8);
 #ifdef TABLET_AUTOADJUST
-                        if (val < dev->absmin[ABS_X + i])
-                                dev->absmin[ABS_X + i] = val;
-                        if (val > dev->absmax[ABS_X + i])
-                                dev->absmax[ABS_X + i] = val;
+                        if (val < input_abs_get_min(dev, ABS_X + i))
+                                input_abs_set_min(dev, ABS_X + i, val);
+                        if (val > input_abs_get_max(dev, ABS_X + i))
+                                input_abs_set_max(dev, ABS_X + i, val);
 #endif
-                        if (i%3) val = dev->absmax[ABS_X + i] - val;
+                        if (i % 3)
+                                val = input_abs_get_max(dev, ABS_X + i) - val;
                         input_report_abs(dev, ABS_X + i, val);
                 } else {
-                        val = (int) (((int8_t)lo) | ((int8_t)hi << 8));
+                        val = (int) (((int8_t) lo) | ((int8_t) hi << 8));
                         if (i % 3)
                                 val *= -1;
                         input_report_rel(dev, REL_X + i, val);
@@ -387,9 +388,11 @@ static void hil_dev_pointer_setup(struct hil_dev *ptr)
 
 #ifdef TABLET_AUTOADJUST
                 for (i = 0; i < ABS_MAX; i++) {
-                        int diff = input_dev->absmax[ABS_X + i] / 10;
-                        input_dev->absmin[ABS_X + i] += diff;
-                        input_dev->absmax[ABS_X + i] -= diff;
+                        int diff = input_abs_get_max(input_dev, ABS_X + i) / 10;
+                        input_abs_set_min(input_dev, ABS_X + i,
+                                input_abs_get_min(input_dev, ABS_X + i) + diff);
+                        input_abs_set_max(input_dev, ABS_X + i,
+                                input_abs_get_max(input_dev, ABS_X + i) - diff);
                 }
 #endif
 
@@ -567,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/imx_keypad.c b/drivers/input/keyboard/imx_keypad.c
new file mode 100644
index 000000000000..d92c15c39e68
--- /dev/null
+++ b/drivers/input/keyboard/imx_keypad.c
@@ -0,0 +1,595 @@
+/*
+ * Driver for the IMX keypad port.
+ * Copyright (C) 2009 Alberto Panizzo <maramaopercheseimorto@gmail.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.
+ *
+ * <<Power management needs to be implemented>>.
+ */
+
+#include <linux/clk.h>
+#include <linux/delay.h>
+#include <linux/device.h>
+#include <linux/err.h>
+#include <linux/init.h>
+#include <linux/input/matrix_keypad.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/jiffies.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/timer.h>
+
+/*
+ * Keypad Controller registers (halfword)
+ */
+#define KPCR            0x00 /* Keypad Control Register */
+
+#define KPSR            0x02 /* Keypad Status Register */
+#define KBD_STAT_KPKD   (0x1 << 0) /* Key Press Interrupt Status bit (w1c) */
+#define KBD_STAT_KPKR   (0x1 << 1) /* Key Release Interrupt Status bit (w1c) */
+#define KBD_STAT_KDSC   (0x1 << 2) /* Key Depress Synch Chain Status bit (w1c)*/
+#define KBD_STAT_KRSS   (0x1 << 3) /* Key Release Synch Status bit (w1c)*/
+#define KBD_STAT_KDIE   (0x1 << 8) /* Key Depress Interrupt Enable Status bit */
+#define KBD_STAT_KRIE   (0x1 << 9) /* Key Release Interrupt Enable */
+#define KBD_STAT_KPPEN  (0x1 << 10) /* Keypad Clock Enable */
+
+#define KDDR            0x04 /* Keypad Data Direction Register */
+#define KPDR            0x06 /* Keypad Data Register */
+
+#define MAX_MATRIX_KEY_ROWS     8
+#define MAX_MATRIX_KEY_COLS     8
+#define MATRIX_ROW_SHIFT        3
+
+#define MAX_MATRIX_KEY_NUM      (MAX_MATRIX_KEY_ROWS * MAX_MATRIX_KEY_COLS)
+
+struct imx_keypad {
+
+        struct clk *clk;
+        struct input_dev *input_dev;
+        void __iomem *mmio_base;
+
+        int                     irq;
+        struct timer_list       check_matrix_timer;
+
+        /*
+         * The matrix is stable only if no changes are detected after
+         * IMX_KEYPAD_SCANS_FOR_STABILITY scans
+         */
+#define IMX_KEYPAD_SCANS_FOR_STABILITY 3
+        int                     stable_count;
+
+        bool                    enabled;
+
+        /* Masks for enabled rows/cols */
+        unsigned short          rows_en_mask;
+        unsigned short          cols_en_mask;
+
+        unsigned short          keycodes[MAX_MATRIX_KEY_NUM];
+
+        /*
+         * Matrix states:
+         * -stable: achieved after a complete debounce process.
+         * -unstable: used in the debouncing process.
+         */
+        unsigned short          matrix_stable_state[MAX_MATRIX_KEY_COLS];
+        unsigned short          matrix_unstable_state[MAX_MATRIX_KEY_COLS];
+};
+
+/* Scan the matrix and return the new state in *matrix_volatile_state. */
+static void imx_keypad_scan_matrix(struct imx_keypad *keypad,
+                                  unsigned short *matrix_volatile_state)
+{
+        int col;
+        unsigned short reg_val;
+
+        for (col = 0; col < MAX_MATRIX_KEY_COLS; col++) {
+                if ((keypad->cols_en_mask & (1 << col)) == 0)
+                        continue;
+                /*
+                 * Discharge keypad capacitance:
+                 * 2. write 1s on column data.
+                 * 3. configure columns as totem-pole to discharge capacitance.
+                 * 4. configure columns as open-drain.
+                 */
+                reg_val = readw(keypad->mmio_base + KPDR);
+                reg_val |= 0xff00;
+                writew(reg_val, keypad->mmio_base + KPDR);
+
+                reg_val = readw(keypad->mmio_base + KPCR);
+                reg_val &= ~((keypad->cols_en_mask & 0xff) << 8);
+                writew(reg_val, keypad->mmio_base + KPCR);
+
+                udelay(2);
+
+                reg_val = readw(keypad->mmio_base + KPCR);
+                reg_val |= (keypad->cols_en_mask & 0xff) << 8;
+                writew(reg_val, keypad->mmio_base + KPCR);
+
+                /*
+                 * 5. Write a single column to 0, others to 1.
+                 * 6. Sample row inputs and save data.
+                 * 7. Repeat steps 2 - 6 for remaining columns.
+                 */
+                reg_val = readw(keypad->mmio_base + KPDR);
+                reg_val &= ~(1 << (8 + col));
+                writew(reg_val, keypad->mmio_base + KPDR);
+
+                /*
+                 * Delay added to avoid propagating the 0 from column to row
+                 * when scanning.
+                 */
+                udelay(5);
+
+                /*
+                 * 1s in matrix_volatile_state[col] means key pressures
+                 * throw data from non enabled rows.
+                 */
+                reg_val = readw(keypad->mmio_base + KPDR);
+                matrix_volatile_state[col] = (~reg_val) & keypad->rows_en_mask;
+        }
+
+        /*
+         * Return in standby mode:
+         * 9. write 0s to columns
+         */
+        reg_val = readw(keypad->mmio_base + KPDR);
+        reg_val &= 0x00ff;
+        writew(reg_val, keypad->mmio_base + KPDR);
+}
+
+/*
+ * Compare the new matrix state (volatile) with the stable one stored in
+ * keypad->matrix_stable_state and fire events if changes are detected.
+ */
+static void imx_keypad_fire_events(struct imx_keypad *keypad,
+                                   unsigned short *matrix_volatile_state)
+{
+        struct input_dev *input_dev = keypad->input_dev;
+        int row, col;
+
+        for (col = 0; col < MAX_MATRIX_KEY_COLS; col++) {
+                unsigned short bits_changed;
+                int code;
+
+                if ((keypad->cols_en_mask & (1 << col)) == 0)
+                        continue; /* Column is not enabled */
+
+                bits_changed = keypad->matrix_stable_state[col] ^
+                                                matrix_volatile_state[col];
+
+                if (bits_changed == 0)
+                        continue; /* Column does not contain changes */
+
+                for (row = 0; row < MAX_MATRIX_KEY_ROWS; row++) {
+                        if ((keypad->rows_en_mask & (1 << row)) == 0)
+                                continue; /* Row is not enabled */
+                        if ((bits_changed & (1 << row)) == 0)
+                                continue; /* Row does not contain changes */
+
+                        code = MATRIX_SCAN_CODE(row, col, MATRIX_ROW_SHIFT);
+                        input_event(input_dev, EV_MSC, MSC_SCAN, code);
+                        input_report_key(input_dev, keypad->keycodes[code],
+                                matrix_volatile_state[col] & (1 << row));
+                        dev_dbg(&input_dev->dev, "Event code: %d, val: %d",
+                                keypad->keycodes[code],
+                                matrix_volatile_state[col] & (1 << row));
+                }
+        }
+        input_sync(input_dev);
+}
+
+/*
+ * imx_keypad_check_for_events is the timer handler.
+ */
+static void imx_keypad_check_for_events(unsigned long data)
+{
+        struct imx_keypad *keypad = (struct imx_keypad *) data;
+        unsigned short matrix_volatile_state[MAX_MATRIX_KEY_COLS];
+        unsigned short reg_val;
+        bool state_changed, is_zero_matrix;
+        int i;
+
+        memset(matrix_volatile_state, 0, sizeof(matrix_volatile_state));
+
+        imx_keypad_scan_matrix(keypad, matrix_volatile_state);
+
+        state_changed = false;
+        for (i = 0; i < MAX_MATRIX_KEY_COLS; i++) {
+                if ((keypad->cols_en_mask & (1 << i)) == 0)
+                        continue;
+
+                if (keypad->matrix_unstable_state[i] ^ matrix_volatile_state[i]) {
+                        state_changed = true;
+                        break;
+                }
+        }
+
+        /*
+         * If the matrix state is changed from the previous scan
+         *   (Re)Begin the debouncing process, saving the new state in
+         *    keypad->matrix_unstable_state.
+         * else
+         *   Increase the count of number of scans with a stable state.
+         */
+        if (state_changed) {
+                memcpy(keypad->matrix_unstable_state, matrix_volatile_state,
+                        sizeof(matrix_volatile_state));
+                keypad->stable_count = 0;
+        } else
+                keypad->stable_count++;
+
+        /*
+         * If the matrix is not as stable as we want reschedule scan
+         * in the near future.
+         */
+        if (keypad->stable_count < IMX_KEYPAD_SCANS_FOR_STABILITY) {
+                mod_timer(&keypad->check_matrix_timer,
+                          jiffies + msecs_to_jiffies(10));
+                return;
+        }
+
+        /*
+         * If the matrix state is stable, fire the events and save the new
+         * stable state. Note, if the matrix is kept stable for longer
+         * (keypad->stable_count > IMX_KEYPAD_SCANS_FOR_STABILITY) all
+         * events have already been generated.
+         */
+        if (keypad->stable_count == IMX_KEYPAD_SCANS_FOR_STABILITY) {
+                imx_keypad_fire_events(keypad, matrix_volatile_state);
+
+                memcpy(keypad->matrix_stable_state, matrix_volatile_state,
+                        sizeof(matrix_volatile_state));
+        }
+
+        is_zero_matrix = true;
+        for (i = 0; i < MAX_MATRIX_KEY_COLS; i++) {
+                if (matrix_volatile_state[i] != 0) {
+                        is_zero_matrix = false;
+                        break;
+                }
+        }
+
+
+        if (is_zero_matrix) {
+                /*
+                 * All keys have been released. Enable only the KDI
+                 * interrupt for future key presses (clear the KDI
+                 * status bit and its sync chain before that).
+                 */
+                reg_val = readw(keypad->mmio_base + KPSR);
+                reg_val |= KBD_STAT_KPKD | KBD_STAT_KDSC;
+                writew(reg_val, keypad->mmio_base + KPSR);
+
+                reg_val = readw(keypad->mmio_base + KPSR);
+                reg_val |= KBD_STAT_KDIE;
+                reg_val &= ~KBD_STAT_KRIE;
+                writew(reg_val, keypad->mmio_base + KPSR);
+        } else {
+                /*
+                 * Some keys are still pressed. Schedule a rescan in
+                 * attempt to detect multiple key presses and enable
+                 * the KRI interrupt to react quickly to key release
+                 * event.
+                 */
+                mod_timer(&keypad->check_matrix_timer,
+                          jiffies + msecs_to_jiffies(60));
+
+                reg_val = readw(keypad->mmio_base + KPSR);
+                reg_val |= KBD_STAT_KPKR | KBD_STAT_KRSS;
+                writew(reg_val, keypad->mmio_base + KPSR);
+
+                reg_val = readw(keypad->mmio_base + KPSR);
+                reg_val |= KBD_STAT_KRIE;
+                reg_val &= ~KBD_STAT_KDIE;
+                writew(reg_val, keypad->mmio_base + KPSR);
+        }
+}
+
+static irqreturn_t imx_keypad_irq_handler(int irq, void *dev_id)
+{
+        struct imx_keypad *keypad = dev_id;
+        unsigned short reg_val;
+
+        reg_val = readw(keypad->mmio_base + KPSR);
+
+        /* Disable both interrupt types */
+        reg_val &= ~(KBD_STAT_KRIE | KBD_STAT_KDIE);
+        /* Clear interrupts status bits */
+        reg_val |= KBD_STAT_KPKR | KBD_STAT_KPKD;
+        writew(reg_val, keypad->mmio_base + KPSR);
+
+        if (keypad->enabled) {
+                /* The matrix is supposed to be changed */
+                keypad->stable_count = 0;
+
+                /* Schedule the scanning procedure near in the future */
+                mod_timer(&keypad->check_matrix_timer,
+                          jiffies + msecs_to_jiffies(2));
+        }
+
+        return IRQ_HANDLED;
+}
+
+static void imx_keypad_config(struct imx_keypad *keypad)
+{
+        unsigned short reg_val;
+
+        /*
+         * Include enabled rows in interrupt generation (KPCR[7:0])
+         * Configure keypad columns as open-drain (KPCR[15:8])
+         */
+        reg_val = readw(keypad->mmio_base + KPCR);
+        reg_val |= keypad->rows_en_mask & 0xff;         /* rows */
+        reg_val |= (keypad->cols_en_mask & 0xff) << 8;  /* cols */
+        writew(reg_val, keypad->mmio_base + KPCR);
+
+        /* Write 0's to KPDR[15:8] (Colums) */
+        reg_val = readw(keypad->mmio_base + KPDR);
+        reg_val &= 0x00ff;
+        writew(reg_val, keypad->mmio_base + KPDR);
+
+        /* Configure columns as output, rows as input (KDDR[15:0]) */
+        writew(0xff00, keypad->mmio_base + KDDR);
+
+        /*
+         * Clear Key Depress and Key Release status bit.
+         * Clear both synchronizer chain.
+         */
+        reg_val = readw(keypad->mmio_base + KPSR);
+        reg_val |= KBD_STAT_KPKR | KBD_STAT_KPKD |
+                   KBD_STAT_KDSC | KBD_STAT_KRSS;
+        writew(reg_val, keypad->mmio_base + KPSR);
+
+        /* Enable KDI and disable KRI (avoid false release events). */
+        reg_val |= KBD_STAT_KDIE;
+        reg_val &= ~KBD_STAT_KRIE;
+        writew(reg_val, keypad->mmio_base + KPSR);
+}
+
+static void imx_keypad_inhibit(struct imx_keypad *keypad)
+{
+        unsigned short reg_val;
+
+        /* Inhibit KDI and KRI interrupts. */
+        reg_val = readw(keypad->mmio_base + KPSR);
+        reg_val &= ~(KBD_STAT_KRIE | KBD_STAT_KDIE);
+        writew(reg_val, keypad->mmio_base + KPSR);
+
+        /* Colums as open drain and disable all rows */
+        writew(0xff00, keypad->mmio_base + KPCR);
+}
+
+static void imx_keypad_close(struct input_dev *dev)
+{
+        struct imx_keypad *keypad = input_get_drvdata(dev);
+
+        dev_dbg(&dev->dev, ">%s\n", __func__);
+
+        /* Mark keypad as being inactive */
+        keypad->enabled = false;
+        synchronize_irq(keypad->irq);
+        del_timer_sync(&keypad->check_matrix_timer);
+
+        imx_keypad_inhibit(keypad);
+
+        /* Disable clock unit */
+        clk_disable(keypad->clk);
+}
+
+static int imx_keypad_open(struct input_dev *dev)
+{
+        struct imx_keypad *keypad = input_get_drvdata(dev);
+
+        dev_dbg(&dev->dev, ">%s\n", __func__);
+
+        /* We became active from now */
+        keypad->enabled = true;
+
+        /* Enable the kpp clock */
+        clk_enable(keypad->clk);
+        imx_keypad_config(keypad);
+
+        /* Sanity control, not all the rows must be actived now. */
+        if ((readw(keypad->mmio_base + KPDR) & keypad->rows_en_mask) == 0) {
+                dev_err(&dev->dev,
+                        "too many keys pressed, control pins initialisation\n");
+                goto open_err;
+        }
+
+        return 0;
+
+open_err:
+        imx_keypad_close(dev);
+        return -EIO;
+}
+
+static int __devinit imx_keypad_probe(struct platform_device *pdev)
+{
+        const struct matrix_keymap_data *keymap_data = pdev->dev.platform_data;
+        struct imx_keypad *keypad;
+        struct input_dev *input_dev;
+        struct resource *res;
+        int irq, error, i;
+
+        if (keymap_data == NULL) {
+                dev_err(&pdev->dev, "no keymap defined\n");
+                return -EINVAL;
+        }
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0) {
+                dev_err(&pdev->dev, "no irq defined in platform data\n");
+                return -EINVAL;
+        }
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (res == NULL) {
+                dev_err(&pdev->dev, "no I/O memory defined in platform data\n");
+                return -EINVAL;
+        }
+
+        res = request_mem_region(res->start, resource_size(res), pdev->name);
+        if (res == NULL) {
+                dev_err(&pdev->dev, "failed to request I/O memory\n");
+                return -EBUSY;
+        }
+
+        input_dev = input_allocate_device();
+        if (!input_dev) {
+                dev_err(&pdev->dev, "failed to allocate the input device\n");
+                error = -ENOMEM;
+                goto failed_rel_mem;
+        }
+
+        keypad = kzalloc(sizeof(struct imx_keypad), GFP_KERNEL);
+        if (!keypad) {
+                dev_err(&pdev->dev, "not enough memory for driver data\n");
+                error = -ENOMEM;
+                goto failed_free_input;
+        }
+
+        keypad->input_dev = input_dev;
+        keypad->irq = irq;
+        keypad->stable_count = 0;
+
+        setup_timer(&keypad->check_matrix_timer,
+                    imx_keypad_check_for_events, (unsigned long) keypad);
+
+        keypad->mmio_base = ioremap(res->start, resource_size(res));
+        if (keypad->mmio_base == NULL) {
+                dev_err(&pdev->dev, "failed to remap I/O memory\n");
+                error = -ENOMEM;
+                goto failed_free_priv;
+        }
+
+        keypad->clk = clk_get(&pdev->dev, "kpp");
+        if (IS_ERR(keypad->clk)) {
+                dev_err(&pdev->dev, "failed to get keypad clock\n");
+                error = PTR_ERR(keypad->clk);
+                goto failed_unmap;
+        }
+
+        /* Search for rows and cols enabled */
+        for (i = 0; i < keymap_data->keymap_size; i++) {
+                keypad->rows_en_mask |= 1 << KEY_ROW(keymap_data->keymap[i]);
+                keypad->cols_en_mask |= 1 << KEY_COL(keymap_data->keymap[i]);
+        }
+
+        if (keypad->rows_en_mask > ((1 << MAX_MATRIX_KEY_ROWS) - 1) ||
+           keypad->cols_en_mask > ((1 << MAX_MATRIX_KEY_COLS) - 1)) {
+                dev_err(&pdev->dev,
+                        "invalid key data (too many rows or colums)\n");
+                error = -EINVAL;
+                goto failed_clock_put;
+        }
+        dev_dbg(&pdev->dev, "enabled rows mask: %x\n", keypad->rows_en_mask);
+        dev_dbg(&pdev->dev, "enabled cols mask: %x\n", keypad->cols_en_mask);
+
+        /* Init the Input device */
+        input_dev->name = pdev->name;
+        input_dev->id.bustype = BUS_HOST;
+        input_dev->dev.parent = &pdev->dev;
+        input_dev->open = imx_keypad_open;
+        input_dev->close = imx_keypad_close;
+        input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP);
+        input_dev->keycode = keypad->keycodes;
+        input_dev->keycodesize = sizeof(keypad->keycodes[0]);
+        input_dev->keycodemax = ARRAY_SIZE(keypad->keycodes);
+
+        matrix_keypad_build_keymap(keymap_data, MATRIX_ROW_SHIFT,
+                                keypad->keycodes, input_dev->keybit);
+
+        input_set_capability(input_dev, EV_MSC, MSC_SCAN);
+        input_set_drvdata(input_dev, keypad);
+
+        /* Ensure that the keypad will stay dormant until opened */
+        imx_keypad_inhibit(keypad);
+
+        error = request_irq(irq, imx_keypad_irq_handler, IRQF_DISABLED,
+                            pdev->name, keypad);
+        if (error) {
+                dev_err(&pdev->dev, "failed to request IRQ\n");
+                goto failed_clock_put;
+        }
+
+        /* Register the input device */
+        error = input_register_device(input_dev);
+        if (error) {
+                dev_err(&pdev->dev, "failed to register input device\n");
+                goto failed_free_irq;
+        }
+
+        platform_set_drvdata(pdev, keypad);
+        device_init_wakeup(&pdev->dev, 1);
+
+        return 0;
+
+failed_free_irq:
+        free_irq(irq, pdev);
+failed_clock_put:
+        clk_put(keypad->clk);
+failed_unmap:
+        iounmap(keypad->mmio_base);
+failed_free_priv:
+        kfree(keypad);
+failed_free_input:
+        input_free_device(input_dev);
+failed_rel_mem:
+        release_mem_region(res->start, resource_size(res));
+        return error;
+}
+
+static int __devexit imx_keypad_remove(struct platform_device *pdev)
+{
+        struct imx_keypad *keypad = platform_get_drvdata(pdev);
+        struct resource *res;
+
+        dev_dbg(&pdev->dev, ">%s\n", __func__);
+
+        platform_set_drvdata(pdev, NULL);
+
+        input_unregister_device(keypad->input_dev);
+
+        free_irq(keypad->irq, keypad);
+        clk_put(keypad->clk);
+
+        iounmap(keypad->mmio_base);
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        release_mem_region(res->start, resource_size(res));
+
+        kfree(keypad);
+
+        return 0;
+}
+
+static struct platform_driver imx_keypad_driver = {
+        .driver         = {
+                .name   = "imx-keypad",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = imx_keypad_probe,
+        .remove         = __devexit_p(imx_keypad_remove),
+};
+
+static int __init imx_keypad_init(void)
+{
+        return platform_driver_register(&imx_keypad_driver);
+}
+
+static void __exit imx_keypad_exit(void)
+{
+        platform_driver_unregister(&imx_keypad_driver);
+}
+
+module_init(imx_keypad_init);
+module_exit(imx_keypad_exit);
+
+MODULE_AUTHOR("Alberto Panizzo <maramaopercheseimorto@gmail.com>");
+MODULE_DESCRIPTION("IMX Keypad Port Driver");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:imx-keypad");
diff --git a/drivers/input/keyboard/jornada680_kbd.c b/drivers/input/keyboard/jornada680_kbd.c
index 781fc6102860..7197c5698747 100644
--- a/drivers/input/keyboard/jornada680_kbd.c
+++ b/drivers/input/keyboard/jornada680_kbd.c
@@ -24,6 +24,7 @@
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/platform_device.h>
+#include <linux/slab.h>
 
 #include <asm/delay.h>
 #include <asm/io.h>
@@ -138,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/jornada720_kbd.c b/drivers/input/keyboard/jornada720_kbd.c
index 4e016d823069..2cd3e1d56ea4 100644
--- a/drivers/input/keyboard/jornada720_kbd.c
+++ b/drivers/input/keyboard/jornada720_kbd.c
@@ -23,6 +23,7 @@
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/platform_device.h>
+#include <linux/slab.h>
 
 #include <mach/jornada720.h>
 #include <mach/hardware.h>
diff --git a/drivers/input/keyboard/lm8323.c b/drivers/input/keyboard/lm8323.c
index 574eda2a4957..f7c2a166576b 100644
--- a/drivers/input/keyboard/lm8323.c
+++ b/drivers/input/keyboard/lm8323.c
@@ -31,6 +31,7 @@
 #include <linux/input.h>
 #include <linux/leds.h>
 #include <linux/i2c/lm8323.h>
+#include <linux/slab.h>
 
 /* Commands to send to the chip. */
 #define LM8323_CMD_READ_ID              0x80 /* Read chip ID. */
@@ -641,6 +642,7 @@ static int __devinit lm8323_probe(struct i2c_client *client,
         struct lm8323_platform_data *pdata = client->dev.platform_data;
         struct input_dev *idev;
         struct lm8323_chip *lm;
+        int pwm;
         int i, err;
         unsigned long tmo;
         u8 data[2];
@@ -669,8 +671,6 @@ static int __devinit lm8323_probe(struct i2c_client *client,
                 goto fail1;
         }
 
-        i2c_set_clientdata(client, lm);
-
         lm->client = client;
         lm->idev = idev;
         mutex_init(&lm->lock);
@@ -711,8 +711,9 @@ static int __devinit lm8323_probe(struct i2c_client *client,
                 goto fail1;
         }
 
-        for (i = 0; i < LM8323_NUM_PWMS; i++) {
-                err = init_pwm(lm, i + 1, &client->dev, pdata->pwm_names[i]);
+        for (pwm = 0; pwm < LM8323_NUM_PWMS; pwm++) {
+                err = init_pwm(lm, pwm + 1, &client->dev,
+                               pdata->pwm_names[pwm]);
                 if (err < 0)
                         goto fail2;
         }
@@ -752,6 +753,8 @@ static int __devinit lm8323_probe(struct i2c_client *client,
                 goto fail4;
         }
 
+        i2c_set_clientdata(client, lm);
+
         device_init_wakeup(&client->dev, 1);
         enable_irq_wake(client->irq);
 
@@ -763,9 +766,9 @@ fail4:
 fail3:
         device_remove_file(&client->dev, &dev_attr_disable_kp);
 fail2:
-        while (--i >= 0)
-                if (lm->pwm[i].enabled)
-                        led_classdev_unregister(&lm->pwm[i].cdev);
+        while (--pwm >= 0)
+                if (lm->pwm[pwm].enabled)
+                        led_classdev_unregister(&lm->pwm[pwm].cdev);
 fail1:
         input_free_device(idev);
         kfree(lm);
diff --git a/drivers/input/keyboard/locomokbd.c b/drivers/input/keyboard/locomokbd.c
index 9caed30f3bbb..b1ab29861e1c 100644
--- a/drivers/input/keyboard/locomokbd.c
+++ b/drivers/input/keyboard/locomokbd.c
@@ -192,11 +192,18 @@ static void locomokbd_scankeyboard(struct locomokbd *locomokbd)
 static irqreturn_t locomokbd_interrupt(int irq, void *dev_id)
 {
         struct locomokbd *locomokbd = dev_id;
+        u16 r;
+
+        r = locomo_readl(locomokbd->base + LOCOMO_KIC);
+        if ((r & 0x0001) == 0)
+                return IRQ_HANDLED;
+
+        locomo_writel(r & ~0x0100, locomokbd->base + LOCOMO_KIC); /* Ack */
+
         /** wait chattering delay **/
         udelay(100);
 
         locomokbd_scankeyboard(locomokbd);
-
         return IRQ_HANDLED;
 }
 
@@ -210,6 +217,25 @@ static void locomokbd_timer_callback(unsigned long data)
         locomokbd_scankeyboard(locomokbd);
 }
 
+static int locomokbd_open(struct input_dev *dev)
+{
+        struct locomokbd *locomokbd = input_get_drvdata(dev);
+        u16 r;
+        
+        r = locomo_readl(locomokbd->base + LOCOMO_KIC) | 0x0010;
+        locomo_writel(r, locomokbd->base + LOCOMO_KIC);
+        return 0;
+}
+
+static void locomokbd_close(struct input_dev *dev)
+{
+        struct locomokbd *locomokbd = input_get_drvdata(dev);
+        u16 r;
+        
+        r = locomo_readl(locomokbd->base + LOCOMO_KIC) & ~0x0010;
+        locomo_writel(r, locomokbd->base + LOCOMO_KIC);
+}
+
 static int __devinit locomokbd_probe(struct locomo_dev *dev)
 {
         struct locomokbd *locomokbd;
@@ -253,6 +279,8 @@ static int __devinit locomokbd_probe(struct locomo_dev *dev)
         input_dev->id.vendor = 0x0001;
         input_dev->id.product = 0x0001;
         input_dev->id.version = 0x0100;
+        input_dev->open = locomokbd_open;
+        input_dev->close = locomokbd_close;
         input_dev->dev.parent = &dev->dev;
 
         input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP) |
@@ -261,6 +289,8 @@ static int __devinit locomokbd_probe(struct locomo_dev *dev)
         input_dev->keycodesize = sizeof(locomokbd_keycode[0]);
         input_dev->keycodemax = ARRAY_SIZE(locomokbd_keycode);
 
+        input_set_drvdata(input_dev, locomokbd);
+
         memcpy(locomokbd->keycode, locomokbd_keycode, sizeof(locomokbd->keycode));
         for (i = 0; i < LOCOMOKBD_NUMKEYS; i++)
                 set_bit(locomokbd->keycode[i], input_dev->keybit);
diff --git a/drivers/input/keyboard/matrix_keypad.c b/drivers/input/keyboard/matrix_keypad.c
index d3c8b61a941d..b02e4268e18f 100644
--- a/drivers/input/keyboard/matrix_keypad.c
+++ b/drivers/input/keyboard/matrix_keypad.c
@@ -22,6 +22,7 @@
 #include <linux/module.h>
 #include <linux/gpio.h>
 #include <linux/input/matrix_keypad.h>
+#include <linux/slab.h>
 
 struct matrix_keypad {
         const struct matrix_keypad_platform_data *pdata;
@@ -36,6 +37,7 @@ struct matrix_keypad {
         spinlock_t lock;
         bool scan_pending;
         bool stopped;
+        bool gpio_all_disabled;
 };
 
 /*
@@ -86,8 +88,12 @@ static void enable_row_irqs(struct matrix_keypad *keypad)
         const struct matrix_keypad_platform_data *pdata = keypad->pdata;
         int i;
 
-        for (i = 0; i < pdata->num_row_gpios; i++)
-                enable_irq(gpio_to_irq(pdata->row_gpios[i]));
+        if (pdata->clustered_irq > 0)
+                enable_irq(pdata->clustered_irq);
+        else {
+                for (i = 0; i < pdata->num_row_gpios; i++)
+                        enable_irq(gpio_to_irq(pdata->row_gpios[i]));
+        }
 }
 
 static void disable_row_irqs(struct matrix_keypad *keypad)
@@ -95,8 +101,12 @@ static void disable_row_irqs(struct matrix_keypad *keypad)
         const struct matrix_keypad_platform_data *pdata = keypad->pdata;
         int i;
 
-        for (i = 0; i < pdata->num_row_gpios; i++)
-                disable_irq_nosync(gpio_to_irq(pdata->row_gpios[i]));
+        if (pdata->clustered_irq > 0)
+                disable_irq_nosync(pdata->clustered_irq);
+        else {
+                for (i = 0; i < pdata->num_row_gpios; i++)
+                        disable_irq_nosync(gpio_to_irq(pdata->row_gpios[i]));
+        }
 }
 
 /*
@@ -215,45 +225,69 @@ static void matrix_keypad_stop(struct input_dev *dev)
 }
 
 #ifdef CONFIG_PM
-static int matrix_keypad_suspend(struct device *dev)
+static void matrix_keypad_enable_wakeup(struct matrix_keypad *keypad)
 {
-        struct platform_device *pdev = to_platform_device(dev);
-        struct matrix_keypad *keypad = platform_get_drvdata(pdev);
         const struct matrix_keypad_platform_data *pdata = keypad->pdata;
+        unsigned int gpio;
         int i;
 
-        matrix_keypad_stop(keypad->input_dev);
+        if (pdata->clustered_irq > 0) {
+                if (enable_irq_wake(pdata->clustered_irq) == 0)
+                        keypad->gpio_all_disabled = true;
+        } else {
 
-        if (device_may_wakeup(&pdev->dev)) {
                 for (i = 0; i < pdata->num_row_gpios; i++) {
                         if (!test_bit(i, keypad->disabled_gpios)) {
-                                unsigned int gpio = pdata->row_gpios[i];
+                                gpio = pdata->row_gpios[i];
 
                                 if (enable_irq_wake(gpio_to_irq(gpio)) == 0)
                                         __set_bit(i, keypad->disabled_gpios);
                         }
                 }
         }
-
-        return 0;
 }
 
-static int matrix_keypad_resume(struct device *dev)
+static void matrix_keypad_disable_wakeup(struct matrix_keypad *keypad)
 {
-        struct platform_device *pdev = to_platform_device(dev);
-        struct matrix_keypad *keypad = platform_get_drvdata(pdev);
         const struct matrix_keypad_platform_data *pdata = keypad->pdata;
+        unsigned int gpio;
         int i;
 
-        if (device_may_wakeup(&pdev->dev)) {
+        if (pdata->clustered_irq > 0) {
+                if (keypad->gpio_all_disabled) {
+                        disable_irq_wake(pdata->clustered_irq);
+                        keypad->gpio_all_disabled = false;
+                }
+        } else {
                 for (i = 0; i < pdata->num_row_gpios; i++) {
                         if (test_and_clear_bit(i, keypad->disabled_gpios)) {
-                                unsigned int gpio = pdata->row_gpios[i];
-
+                                gpio = pdata->row_gpios[i];
                                 disable_irq_wake(gpio_to_irq(gpio));
                         }
                 }
         }
+}
+
+static int matrix_keypad_suspend(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct matrix_keypad *keypad = platform_get_drvdata(pdev);
+
+        matrix_keypad_stop(keypad->input_dev);
+
+        if (device_may_wakeup(&pdev->dev))
+                matrix_keypad_enable_wakeup(keypad);
+
+        return 0;
+}
+
+static int matrix_keypad_resume(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct matrix_keypad *keypad = platform_get_drvdata(pdev);
+
+        if (device_may_wakeup(&pdev->dev))
+                matrix_keypad_disable_wakeup(keypad);
 
         matrix_keypad_start(keypad->input_dev);
 
@@ -295,17 +329,31 @@ static int __devinit init_matrix_gpio(struct platform_device *pdev,
                 gpio_direction_input(pdata->row_gpios[i]);
         }
 
-        for (i = 0; i < pdata->num_row_gpios; i++) {
-                err = request_irq(gpio_to_irq(pdata->row_gpios[i]),
+        if (pdata->clustered_irq > 0) {
+                err = request_irq(pdata->clustered_irq,
                                 matrix_keypad_interrupt,
-                                IRQF_DISABLED |
-                                IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
+                                pdata->clustered_irq_flags,
                                 "matrix-keypad", keypad);
                 if (err) {
                         dev_err(&pdev->dev,
-                                "Unable to acquire interrupt for GPIO line %i\n",
-                                pdata->row_gpios[i]);
-                        goto err_free_irqs;
+                                "Unable to acquire clustered interrupt\n");
+                        goto err_free_rows;
+                }
+        } else {
+                for (i = 0; i < pdata->num_row_gpios; i++) {
+                        err = request_irq(gpio_to_irq(pdata->row_gpios[i]),
+                                        matrix_keypad_interrupt,
+                                        IRQF_DISABLED |
+                                        IRQF_TRIGGER_RISING |
+                                        IRQF_TRIGGER_FALLING,
+                                        "matrix-keypad", keypad);
+                        if (err) {
+                                dev_err(&pdev->dev,
+                                        "Unable to acquire interrupt "
+                                        "for GPIO line %i\n",
+                                        pdata->row_gpios[i]);
+                                goto err_free_irqs;
+                        }
                 }
         }
 
@@ -373,7 +421,9 @@ static int __devinit matrix_keypad_probe(struct platform_device *pdev)
         input_dev->name         = pdev->name;
         input_dev->id.bustype   = BUS_HOST;
         input_dev->dev.parent   = &pdev->dev;
-        input_dev->evbit[0]     = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP);
+        input_dev->evbit[0]     = BIT_MASK(EV_KEY);
+        if (!pdata->no_autorepeat)
+                input_dev->evbit[0] |= BIT_MASK(EV_REP);
         input_dev->open         = matrix_keypad_start;
         input_dev->close        = matrix_keypad_stop;
 
@@ -415,11 +465,16 @@ static int __devexit matrix_keypad_remove(struct platform_device *pdev)
 
         device_init_wakeup(&pdev->dev, 0);
 
-        for (i = 0; i < pdata->num_row_gpios; i++) {
-                free_irq(gpio_to_irq(pdata->row_gpios[i]), keypad);
-                gpio_free(pdata->row_gpios[i]);
+        if (pdata->clustered_irq > 0) {
+                free_irq(pdata->clustered_irq, keypad);
+        } else {
+                for (i = 0; i < pdata->num_row_gpios; i++)
+                        free_irq(gpio_to_irq(pdata->row_gpios[i]), keypad);
         }
 
+        for (i = 0; i < pdata->num_row_gpios; i++)
+                gpio_free(pdata->row_gpios[i]);
+
         for (i = 0; i < pdata->num_col_gpios; i++)
                 gpio_free(pdata->col_gpios[i]);
 
diff --git a/drivers/input/keyboard/max7359_keypad.c b/drivers/input/keyboard/max7359_keypad.c
index 3b5b948eba39..9091ff5ea808 100644
--- a/drivers/input/keyboard/max7359_keypad.c
+++ b/drivers/input/keyboard/max7359_keypad.c
@@ -15,6 +15,7 @@
 
 #include <linux/module.h>
 #include <linux/i2c.h>
+#include <linux/slab.h>
 #include <linux/interrupt.h>
 #include <linux/input.h>
 #include <linux/input/matrix_keypad.h>
@@ -264,7 +265,6 @@ static int __devexit max7359_remove(struct i2c_client *client)
 
         free_irq(client->irq, keypad);
         input_unregister_device(keypad->input_dev);
-        i2c_set_clientdata(client, NULL);
         kfree(keypad);
 
         return 0;
diff --git a/drivers/input/keyboard/mcs_touchkey.c b/drivers/input/keyboard/mcs_touchkey.c
new file mode 100644
index 000000000000..63b849d7e90b
--- /dev/null
+++ b/drivers/input/keyboard/mcs_touchkey.c
@@ -0,0 +1,239 @@
+/*
+ * mcs_touchkey.c - Touchkey driver for MELFAS MCS5000/5080 controller
+ *
+ * Copyright (C) 2010 Samsung Electronics Co.Ltd
+ * Author: HeungJun Kim <riverful.kim@samsung.com>
+ * 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/i2c.h>
+#include <linux/i2c/mcs.h>
+#include <linux/interrupt.h>
+#include <linux/input.h>
+#include <linux/irq.h>
+#include <linux/slab.h>
+
+/* MCS5000 Touchkey */
+#define MCS5000_TOUCHKEY_STATUS         0x04
+#define MCS5000_TOUCHKEY_STATUS_PRESS   7
+#define MCS5000_TOUCHKEY_FW             0x0a
+#define MCS5000_TOUCHKEY_BASE_VAL       0x61
+
+/* MCS5080 Touchkey */
+#define MCS5080_TOUCHKEY_STATUS         0x00
+#define MCS5080_TOUCHKEY_STATUS_PRESS   3
+#define MCS5080_TOUCHKEY_FW             0x01
+#define MCS5080_TOUCHKEY_BASE_VAL       0x1
+
+enum mcs_touchkey_type {
+        MCS5000_TOUCHKEY,
+        MCS5080_TOUCHKEY,
+};
+
+struct mcs_touchkey_chip {
+        unsigned int status_reg;
+        unsigned int pressbit;
+        unsigned int press_invert;
+        unsigned int baseval;
+};
+
+struct mcs_touchkey_data {
+        struct i2c_client *client;
+        struct input_dev *input_dev;
+        struct mcs_touchkey_chip chip;
+        unsigned int key_code;
+        unsigned int key_val;
+        unsigned short keycodes[];
+};
+
+static irqreturn_t mcs_touchkey_interrupt(int irq, void *dev_id)
+{
+        struct mcs_touchkey_data *data = dev_id;
+        struct mcs_touchkey_chip *chip = &data->chip;
+        struct i2c_client *client = data->client;
+        struct input_dev *input = data->input_dev;
+        unsigned int key_val;
+        unsigned int pressed;
+        int val;
+
+        val = i2c_smbus_read_byte_data(client, chip->status_reg);
+        if (val < 0) {
+                dev_err(&client->dev, "i2c read error [%d]\n", val);
+                goto out;
+        }
+
+        pressed = (val & (1 << chip->pressbit)) >> chip->pressbit;
+        if (chip->press_invert)
+                pressed ^= chip->press_invert;
+
+        /* key_val is 0 when released, so we should use key_val of press. */
+        if (pressed) {
+                key_val = val & (0xff >> (8 - chip->pressbit));
+                if (!key_val)
+                        goto out;
+                key_val -= chip->baseval;
+                data->key_code = data->keycodes[key_val];
+                data->key_val = key_val;
+        }
+
+        input_event(input, EV_MSC, MSC_SCAN, data->key_val);
+        input_report_key(input, data->key_code, pressed);
+        input_sync(input);
+
+        dev_dbg(&client->dev, "key %d %d %s\n", data->key_val, data->key_code,
+                pressed ? "pressed" : "released");
+
+ out:
+        return IRQ_HANDLED;
+}
+
+static int __devinit mcs_touchkey_probe(struct i2c_client *client,
+                const struct i2c_device_id *id)
+{
+        const struct mcs_platform_data *pdata;
+        struct mcs_touchkey_data *data;
+        struct input_dev *input_dev;
+        unsigned int fw_reg;
+        int fw_ver;
+        int error;
+        int i;
+
+        pdata = client->dev.platform_data;
+        if (!pdata) {
+                dev_err(&client->dev, "no platform data defined\n");
+                return -EINVAL;
+        }
+
+        data = kzalloc(sizeof(struct mcs_touchkey_data) +
+                        sizeof(data->keycodes[0]) * (pdata->key_maxval + 1),
+                        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;
+
+        if (id->driver_data == MCS5000_TOUCHKEY) {
+                data->chip.status_reg = MCS5000_TOUCHKEY_STATUS;
+                data->chip.pressbit = MCS5000_TOUCHKEY_STATUS_PRESS;
+                data->chip.baseval = MCS5000_TOUCHKEY_BASE_VAL;
+                fw_reg = MCS5000_TOUCHKEY_FW;
+        } else {
+                data->chip.status_reg = MCS5080_TOUCHKEY_STATUS;
+                data->chip.pressbit = MCS5080_TOUCHKEY_STATUS_PRESS;
+                data->chip.press_invert = 1;
+                data->chip.baseval = MCS5080_TOUCHKEY_BASE_VAL;
+                fw_reg = MCS5080_TOUCHKEY_FW;
+        }
+
+        fw_ver = i2c_smbus_read_byte_data(client, fw_reg);
+        if (fw_ver < 0) {
+                error = fw_ver;
+                dev_err(&client->dev, "i2c read error[%d]\n", error);
+                goto err_free_mem;
+        }
+        dev_info(&client->dev, "Firmware version: %d\n", fw_ver);
+
+        input_dev->name = "MELPAS MCS Touchkey";
+        input_dev->id.bustype = BUS_I2C;
+        input_dev->dev.parent = &client->dev;
+        input_dev->evbit[0] = BIT_MASK(EV_KEY);
+        if (!pdata->no_autorepeat)
+                input_dev->evbit[0] |= BIT_MASK(EV_REP);
+        input_dev->keycode = data->keycodes;
+        input_dev->keycodesize = sizeof(data->keycodes[0]);
+        input_dev->keycodemax = pdata->key_maxval + 1;
+
+        for (i = 0; i < pdata->keymap_size; i++) {
+                unsigned int val = MCS_KEY_VAL(pdata->keymap[i]);
+                unsigned int code = MCS_KEY_CODE(pdata->keymap[i]);
+
+                data->keycodes[val] = code;
+                __set_bit(code, input_dev->keybit);
+        }
+
+        input_set_capability(input_dev, EV_MSC, MSC_SCAN);
+        input_set_drvdata(input_dev, data);
+
+        if (pdata->cfg_pin)
+                pdata->cfg_pin();
+
+        error = request_threaded_irq(client->irq, NULL, mcs_touchkey_interrupt,
+                        IRQF_TRIGGER_FALLING, client->dev.driver->name, data);
+        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, data);
+        return 0;
+
+err_free_irq:
+        free_irq(client->irq, data);
+err_free_mem:
+        input_free_device(input_dev);
+        kfree(data);
+        return error;
+}
+
+static int __devexit mcs_touchkey_remove(struct i2c_client *client)
+{
+        struct mcs_touchkey_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 mcs_touchkey_id[] = {
+        { "mcs5000_touchkey", MCS5000_TOUCHKEY },
+        { "mcs5080_touchkey", MCS5080_TOUCHKEY },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, mcs_touchkey_id);
+
+static struct i2c_driver mcs_touchkey_driver = {
+        .driver = {
+                .name   = "mcs_touchkey",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = mcs_touchkey_probe,
+        .remove         = __devexit_p(mcs_touchkey_remove),
+        .id_table       = mcs_touchkey_id,
+};
+
+static int __init mcs_touchkey_init(void)
+{
+        return i2c_add_driver(&mcs_touchkey_driver);
+}
+
+static void __exit mcs_touchkey_exit(void)
+{
+        i2c_del_driver(&mcs_touchkey_driver);
+}
+
+module_init(mcs_touchkey_init);
+module_exit(mcs_touchkey_exit);
+
+/* Module information */
+MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
+MODULE_AUTHOR("HeungJun Kim <riverful.kim@samsung.com>");
+MODULE_DESCRIPTION("Touchkey driver for MELFAS MCS5000/5080 controller");
+MODULE_LICENSE("GPL");
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 1a494d505431..a72e61ddca91 100644
--- a/drivers/input/keyboard/omap-keypad.c
+++ b/drivers/input/keyboard/omap-keypad.c
@@ -34,6 +34,7 @@
 #include <linux/platform_device.h>
 #include <linux/mutex.h>
 #include <linux/errno.h>
+#include <linux/slab.h>
 #include <mach/gpio.h>
 #include <plat/keypad.h>
 #include <plat/menelaus.h>
diff --git a/drivers/input/keyboard/omap4-keypad.c b/drivers/input/keyboard/omap4-keypad.c
new file mode 100644
index 000000000000..45bd0977d006
--- /dev/null
+++ b/drivers/input/keyboard/omap4-keypad.c
@@ -0,0 +1,318 @@
+/*
+ * 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 <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[];
+};
+
+static void __devinit omap4_keypad_config(struct omap4_keypad *keypad_data)
+{
+        __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);
+}
+
+/* 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 __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->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);
+
+        omap4_keypad_config(keypad_data);
+
+        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;
+        }
+
+        error = input_register_device(keypad_data->input);
+        if (error < 0) {
+                dev_err(&pdev->dev, "failed to register input device\n");
+                goto err_free_irq;
+        }
+
+
+        platform_set_drvdata(pdev, keypad_data);
+        return 0;
+
+err_free_irq:
+        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);
+        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/opencores-kbd.c b/drivers/input/keyboard/opencores-kbd.c
index 78cccddbf551..1f1a5563f60a 100644
--- a/drivers/input/keyboard/opencores-kbd.c
+++ b/drivers/input/keyboard/opencores-kbd.c
@@ -14,6 +14,7 @@
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/platform_device.h>
+#include <linux/slab.h>
 
 struct opencores_kbd {
         struct input_dev *input;
diff --git a/drivers/input/keyboard/pxa27x_keypad.c b/drivers/input/keyboard/pxa27x_keypad.c
index 79cd3e9fdf2e..4b0ec35259a1 100644
--- a/drivers/input/keyboard/pxa27x_keypad.c
+++ b/drivers/input/keyboard/pxa27x_keypad.c
@@ -26,12 +26,13 @@
 #include <linux/clk.h>
 #include <linux/err.h>
 #include <linux/input/matrix_keypad.h>
+#include <linux/slab.h>
 
 #include <asm/mach/arch.h>
 #include <asm/mach/map.h>
 
 #include <mach/hardware.h>
-#include <mach/pxa27x_keypad.h>
+#include <plat/pxa27x_keypad.h>
 /*
  * Keypad Controller registers
  */
@@ -329,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);
 
@@ -566,8 +577,6 @@ static int __devexit pxa27x_keypad_remove(struct platform_device *pdev)
         clk_put(keypad->clk);
 
         input_unregister_device(keypad->input_dev);
-        input_free_device(keypad->input_dev);
-
         iounmap(keypad->mmio_base);
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
diff --git a/drivers/input/keyboard/pxa930_rotary.c b/drivers/input/keyboard/pxa930_rotary.c
index 95fbba470e65..b7123a44b6ec 100644
--- a/drivers/input/keyboard/pxa930_rotary.c
+++ b/drivers/input/keyboard/pxa930_rotary.c
@@ -13,6 +13,7 @@
 #include <linux/input.h>
 #include <linux/platform_device.h>
 #include <linux/io.h>
+#include <linux/slab.h>
 
 #include <mach/pxa930_rotary.h>
 
diff --git a/drivers/input/keyboard/qt2160.c b/drivers/input/keyboard/qt2160.c
index 191cc51d6cf8..fac695157e8a 100644
--- a/drivers/input/keyboard/qt2160.c
+++ b/drivers/input/keyboard/qt2160.c
@@ -358,11 +358,10 @@ static int __devexit qt2160_remove(struct i2c_client *client)
         input_unregister_device(qt2160->input);
         kfree(qt2160);
 
-        i2c_set_clientdata(client, NULL);
         return 0;
 }
 
-static struct i2c_device_id qt2160_idtable[] = {
+static const struct i2c_device_id qt2160_idtable[] = {
         { "qt2160", 0, },
         { }
 };
diff --git a/drivers/input/keyboard/samsung-keypad.c b/drivers/input/keyboard/samsung-keypad.c
new file mode 100644
index 000000000000..f689f49e3109
--- /dev/null
+++ b/drivers/input/keyboard/samsung-keypad.c
@@ -0,0 +1,491 @@
+/*
+ * Samsung keypad driver
+ *
+ * Copyright (C) 2010 Samsung Electronics Co.Ltd
+ * Author: Joonyoung Shim <jy0922.shim@samsung.com>
+ * Author: Donghwa Lee <dh09.lee@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/clk.h>
+#include <linux/delay.h>
+#include <linux/err.h>
+#include <linux/init.h>
+#include <linux/input.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/sched.h>
+#include <plat/keypad.h>
+
+#define SAMSUNG_KEYIFCON                        0x00
+#define SAMSUNG_KEYIFSTSCLR                     0x04
+#define SAMSUNG_KEYIFCOL                        0x08
+#define SAMSUNG_KEYIFROW                        0x0c
+#define SAMSUNG_KEYIFFC                         0x10
+
+/* SAMSUNG_KEYIFCON */
+#define SAMSUNG_KEYIFCON_INT_F_EN               (1 << 0)
+#define SAMSUNG_KEYIFCON_INT_R_EN               (1 << 1)
+#define SAMSUNG_KEYIFCON_DF_EN                  (1 << 2)
+#define SAMSUNG_KEYIFCON_FC_EN                  (1 << 3)
+#define SAMSUNG_KEYIFCON_WAKEUPEN               (1 << 4)
+
+/* SAMSUNG_KEYIFSTSCLR */
+#define SAMSUNG_KEYIFSTSCLR_P_INT_MASK          (0xff << 0)
+#define SAMSUNG_KEYIFSTSCLR_R_INT_MASK          (0xff << 8)
+#define SAMSUNG_KEYIFSTSCLR_R_INT_OFFSET        8
+#define S5PV210_KEYIFSTSCLR_P_INT_MASK          (0x3fff << 0)
+#define S5PV210_KEYIFSTSCLR_R_INT_MASK          (0x3fff << 16)
+#define S5PV210_KEYIFSTSCLR_R_INT_OFFSET        16
+
+/* SAMSUNG_KEYIFCOL */
+#define SAMSUNG_KEYIFCOL_MASK                   (0xff << 0)
+#define S5PV210_KEYIFCOLEN_MASK                 (0xff << 8)
+
+/* SAMSUNG_KEYIFROW */
+#define SAMSUNG_KEYIFROW_MASK                   (0xff << 0)
+#define S5PV210_KEYIFROW_MASK                   (0x3fff << 0)
+
+/* SAMSUNG_KEYIFFC */
+#define SAMSUNG_KEYIFFC_MASK                    (0x3ff << 0)
+
+enum samsung_keypad_type {
+        KEYPAD_TYPE_SAMSUNG,
+        KEYPAD_TYPE_S5PV210,
+};
+
+struct samsung_keypad {
+        struct input_dev *input_dev;
+        struct clk *clk;
+        void __iomem *base;
+        wait_queue_head_t wait;
+        bool stopped;
+        int irq;
+        unsigned int row_shift;
+        unsigned int rows;
+        unsigned int cols;
+        unsigned int row_state[SAMSUNG_MAX_COLS];
+        unsigned short keycodes[];
+};
+
+static int samsung_keypad_is_s5pv210(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        enum samsung_keypad_type type =
+                platform_get_device_id(pdev)->driver_data;
+
+        return type == KEYPAD_TYPE_S5PV210;
+}
+
+static void samsung_keypad_scan(struct samsung_keypad *keypad,
+                                unsigned int *row_state)
+{
+        struct device *dev = keypad->input_dev->dev.parent;
+        unsigned int col;
+        unsigned int val;
+
+        for (col = 0; col < keypad->cols; col++) {
+                if (samsung_keypad_is_s5pv210(dev)) {
+                        val = S5PV210_KEYIFCOLEN_MASK;
+                        val &= ~(1 << col) << 8;
+                } else {
+                        val = SAMSUNG_KEYIFCOL_MASK;
+                        val &= ~(1 << col);
+                }
+
+                writel(val, keypad->base + SAMSUNG_KEYIFCOL);
+                mdelay(1);
+
+                val = readl(keypad->base + SAMSUNG_KEYIFROW);
+                row_state[col] = ~val & ((1 << keypad->rows) - 1);
+        }
+
+        /* KEYIFCOL reg clear */
+        writel(0, keypad->base + SAMSUNG_KEYIFCOL);
+}
+
+static bool samsung_keypad_report(struct samsung_keypad *keypad,
+                                  unsigned int *row_state)
+{
+        struct input_dev *input_dev = keypad->input_dev;
+        unsigned int changed;
+        unsigned int pressed;
+        unsigned int key_down = 0;
+        unsigned int val;
+        unsigned int col, row;
+
+        for (col = 0; col < keypad->cols; col++) {
+                changed = row_state[col] ^ keypad->row_state[col];
+                key_down |= row_state[col];
+                if (!changed)
+                        continue;
+
+                for (row = 0; row < keypad->rows; row++) {
+                        if (!(changed & (1 << row)))
+                                continue;
+
+                        pressed = row_state[col] & (1 << row);
+
+                        dev_dbg(&keypad->input_dev->dev,
+                                "key %s, row: %d, col: %d\n",
+                                pressed ? "pressed" : "released", row, col);
+
+                        val = MATRIX_SCAN_CODE(row, col, keypad->row_shift);
+
+                        input_event(input_dev, EV_MSC, MSC_SCAN, val);
+                        input_report_key(input_dev,
+                                        keypad->keycodes[val], pressed);
+                }
+                input_sync(keypad->input_dev);
+        }
+
+        memcpy(keypad->row_state, row_state, sizeof(keypad->row_state));
+
+        return key_down;
+}
+
+static irqreturn_t samsung_keypad_irq(int irq, void *dev_id)
+{
+        struct samsung_keypad *keypad = dev_id;
+        unsigned int row_state[SAMSUNG_MAX_COLS];
+        unsigned int val;
+        bool key_down;
+
+        do {
+                val = readl(keypad->base + SAMSUNG_KEYIFSTSCLR);
+                /* Clear interrupt. */
+                writel(~0x0, keypad->base + SAMSUNG_KEYIFSTSCLR);
+
+                samsung_keypad_scan(keypad, row_state);
+
+                key_down = samsung_keypad_report(keypad, row_state);
+                if (key_down)
+                        wait_event_timeout(keypad->wait, keypad->stopped,
+                                           msecs_to_jiffies(50));
+
+        } while (key_down && !keypad->stopped);
+
+        return IRQ_HANDLED;
+}
+
+static void samsung_keypad_start(struct samsung_keypad *keypad)
+{
+        unsigned int val;
+
+        /* Tell IRQ thread that it may poll the device. */
+        keypad->stopped = false;
+
+        clk_enable(keypad->clk);
+
+        /* Enable interrupt bits. */
+        val = readl(keypad->base + SAMSUNG_KEYIFCON);
+        val |= SAMSUNG_KEYIFCON_INT_F_EN | SAMSUNG_KEYIFCON_INT_R_EN;
+        writel(val, keypad->base + SAMSUNG_KEYIFCON);
+
+        /* KEYIFCOL reg clear. */
+        writel(0, keypad->base + SAMSUNG_KEYIFCOL);
+}
+
+static void samsung_keypad_stop(struct samsung_keypad *keypad)
+{
+        unsigned int val;
+
+        /* Signal IRQ thread to stop polling and disable the handler. */
+        keypad->stopped = true;
+        wake_up(&keypad->wait);
+        disable_irq(keypad->irq);
+
+        /* Clear interrupt. */
+        writel(~0x0, keypad->base + SAMSUNG_KEYIFSTSCLR);
+
+        /* Disable interrupt bits. */
+        val = readl(keypad->base + SAMSUNG_KEYIFCON);
+        val &= ~(SAMSUNG_KEYIFCON_INT_F_EN | SAMSUNG_KEYIFCON_INT_R_EN);
+        writel(val, keypad->base + SAMSUNG_KEYIFCON);
+
+        clk_disable(keypad->clk);
+
+        /*
+         * Now that chip should not generate interrupts we can safely
+         * re-enable the handler.
+         */
+        enable_irq(keypad->irq);
+}
+
+static int samsung_keypad_open(struct input_dev *input_dev)
+{
+        struct samsung_keypad *keypad = input_get_drvdata(input_dev);
+
+        samsung_keypad_start(keypad);
+
+        return 0;
+}
+
+static void samsung_keypad_close(struct input_dev *input_dev)
+{
+        struct samsung_keypad *keypad = input_get_drvdata(input_dev);
+
+        samsung_keypad_stop(keypad);
+}
+
+static int __devinit samsung_keypad_probe(struct platform_device *pdev)
+{
+        const struct samsung_keypad_platdata *pdata;
+        const struct matrix_keymap_data *keymap_data;
+        struct samsung_keypad *keypad;
+        struct resource *res;
+        struct input_dev *input_dev;
+        unsigned int row_shift;
+        unsigned int keymap_size;
+        int error;
+
+        pdata = pdev->dev.platform_data;
+        if (!pdata) {
+                dev_err(&pdev->dev, "no platform data defined\n");
+                return -EINVAL;
+        }
+
+        keymap_data = pdata->keymap_data;
+        if (!keymap_data) {
+                dev_err(&pdev->dev, "no keymap data defined\n");
+                return -EINVAL;
+        }
+
+        if (!pdata->rows || pdata->rows > SAMSUNG_MAX_ROWS)
+                return -EINVAL;
+
+        if (!pdata->cols || pdata->cols > SAMSUNG_MAX_COLS)
+                return -EINVAL;
+
+        /* initialize the gpio */
+        if (pdata->cfg_gpio)
+                pdata->cfg_gpio(pdata->rows, pdata->cols);
+
+        row_shift = get_count_order(pdata->cols);
+        keymap_size = (pdata->rows << row_shift) * sizeof(keypad->keycodes[0]);
+
+        keypad = kzalloc(sizeof(*keypad) + keymap_size, GFP_KERNEL);
+        input_dev = input_allocate_device();
+        if (!keypad || !input_dev) {
+                error = -ENOMEM;
+                goto err_free_mem;
+        }
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                error = -ENODEV;
+                goto err_free_mem;
+        }
+
+        keypad->base = ioremap(res->start, resource_size(res));
+        if (!keypad->base) {
+                error = -EBUSY;
+                goto err_free_mem;
+        }
+
+        keypad->clk = clk_get(&pdev->dev, "keypad");
+        if (IS_ERR(keypad->clk)) {
+                dev_err(&pdev->dev, "failed to get keypad clk\n");
+                error = PTR_ERR(keypad->clk);
+                goto err_unmap_base;
+        }
+
+        keypad->input_dev = input_dev;
+        keypad->row_shift = row_shift;
+        keypad->rows = pdata->rows;
+        keypad->cols = pdata->cols;
+        init_waitqueue_head(&keypad->wait);
+
+        input_dev->name = pdev->name;
+        input_dev->id.bustype = BUS_HOST;
+        input_dev->dev.parent = &pdev->dev;
+        input_set_drvdata(input_dev, keypad);
+
+        input_dev->open = samsung_keypad_open;
+        input_dev->close = samsung_keypad_close;
+
+        input_dev->evbit[0] = BIT_MASK(EV_KEY);
+        if (!pdata->no_autorepeat)
+                input_dev->evbit[0] |= BIT_MASK(EV_REP);
+
+        input_set_capability(input_dev, EV_MSC, MSC_SCAN);
+
+        input_dev->keycode = keypad->keycodes;
+        input_dev->keycodesize = sizeof(keypad->keycodes[0]);
+        input_dev->keycodemax = pdata->rows << row_shift;
+
+        matrix_keypad_build_keymap(keymap_data, row_shift,
+                        input_dev->keycode, input_dev->keybit);
+
+        keypad->irq = platform_get_irq(pdev, 0);
+        if (keypad->irq < 0) {
+                error = keypad->irq;
+                goto err_put_clk;
+        }
+
+        error = request_threaded_irq(keypad->irq, NULL, samsung_keypad_irq,
+                        IRQF_ONESHOT, dev_name(&pdev->dev), keypad);
+        if (error) {
+                dev_err(&pdev->dev, "failed to register keypad interrupt\n");
+                goto err_put_clk;
+        }
+
+        error = input_register_device(keypad->input_dev);
+        if (error)
+                goto err_free_irq;
+
+        device_init_wakeup(&pdev->dev, pdata->wakeup);
+        platform_set_drvdata(pdev, keypad);
+        return 0;
+
+err_free_irq:
+        free_irq(keypad->irq, keypad);
+err_put_clk:
+        clk_put(keypad->clk);
+err_unmap_base:
+        iounmap(keypad->base);
+err_free_mem:
+        input_free_device(input_dev);
+        kfree(keypad);
+
+        return error;
+}
+
+static int __devexit samsung_keypad_remove(struct platform_device *pdev)
+{
+        struct samsung_keypad *keypad = platform_get_drvdata(pdev);
+
+        device_init_wakeup(&pdev->dev, 0);
+        platform_set_drvdata(pdev, NULL);
+
+        input_unregister_device(keypad->input_dev);
+
+        /*
+         * It is safe to free IRQ after unregistering device because
+         * samsung_keypad_close will shut off interrupts.
+         */
+        free_irq(keypad->irq, keypad);
+
+        clk_put(keypad->clk);
+
+        iounmap(keypad->base);
+        kfree(keypad);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static void samsung_keypad_toggle_wakeup(struct samsung_keypad *keypad,
+                                         bool enable)
+{
+        struct device *dev = keypad->input_dev->dev.parent;
+        unsigned int val;
+
+        clk_enable(keypad->clk);
+
+        val = readl(keypad->base + SAMSUNG_KEYIFCON);
+        if (enable) {
+                val |= SAMSUNG_KEYIFCON_WAKEUPEN;
+                if (device_may_wakeup(dev))
+                        enable_irq_wake(keypad->irq);
+        } else {
+                val &= ~SAMSUNG_KEYIFCON_WAKEUPEN;
+                if (device_may_wakeup(dev))
+                        disable_irq_wake(keypad->irq);
+        }
+        writel(val, keypad->base + SAMSUNG_KEYIFCON);
+
+        clk_disable(keypad->clk);
+}
+
+static int samsung_keypad_suspend(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct samsung_keypad *keypad = platform_get_drvdata(pdev);
+        struct input_dev *input_dev = keypad->input_dev;
+
+        mutex_lock(&input_dev->mutex);
+
+        if (input_dev->users)
+                samsung_keypad_stop(keypad);
+
+        samsung_keypad_toggle_wakeup(keypad, true);
+
+        mutex_unlock(&input_dev->mutex);
+
+        return 0;
+}
+
+static int samsung_keypad_resume(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct samsung_keypad *keypad = platform_get_drvdata(pdev);
+        struct input_dev *input_dev = keypad->input_dev;
+
+        mutex_lock(&input_dev->mutex);
+
+        samsung_keypad_toggle_wakeup(keypad, false);
+
+        if (input_dev->users)
+                samsung_keypad_start(keypad);
+
+        mutex_unlock(&input_dev->mutex);
+
+        return 0;
+}
+
+static const struct dev_pm_ops samsung_keypad_pm_ops = {
+        .suspend        = samsung_keypad_suspend,
+        .resume         = samsung_keypad_resume,
+};
+#endif
+
+static struct platform_device_id samsung_keypad_driver_ids[] = {
+        {
+                .name           = "samsung-keypad",
+                .driver_data    = KEYPAD_TYPE_SAMSUNG,
+        }, {
+                .name           = "s5pv210-keypad",
+                .driver_data    = KEYPAD_TYPE_S5PV210,
+        },
+        { },
+};
+MODULE_DEVICE_TABLE(platform, samsung_keypad_driver_ids);
+
+static struct platform_driver samsung_keypad_driver = {
+        .probe          = samsung_keypad_probe,
+        .remove         = __devexit_p(samsung_keypad_remove),
+        .driver         = {
+                .name   = "samsung-keypad",
+                .owner  = THIS_MODULE,
+#ifdef CONFIG_PM
+                .pm     = &samsung_keypad_pm_ops,
+#endif
+        },
+        .id_table       = samsung_keypad_driver_ids,
+};
+
+static int __init samsung_keypad_init(void)
+{
+        return platform_driver_register(&samsung_keypad_driver);
+}
+module_init(samsung_keypad_init);
+
+static void __exit samsung_keypad_exit(void)
+{
+        platform_driver_unregister(&samsung_keypad_driver);
+}
+module_exit(samsung_keypad_exit);
+
+MODULE_DESCRIPTION("Samsung keypad driver");
+MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
+MODULE_AUTHOR("Donghwa Lee <dh09.lee@samsung.com>");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:samsung-keypad");
diff --git a/drivers/input/keyboard/sh_keysc.c b/drivers/input/keyboard/sh_keysc.c
index 8e9380bfed40..d7dafd9425b6 100644
--- a/drivers/input/keyboard/sh_keysc.c
+++ b/drivers/input/keyboard/sh_keysc.c
@@ -19,16 +19,10 @@
 #include <linux/platform_device.h>
 #include <linux/input.h>
 #include <linux/input/sh_keysc.h>
+#include <linux/bitmap.h>
 #include <linux/clk.h>
 #include <linux/io.h>
-
-#define KYCR1_OFFS   0x00
-#define KYCR2_OFFS   0x04
-#define KYINDR_OFFS  0x08
-#define KYOUTDR_OFFS 0x0c
-
-#define KYCR2_IRQ_LEVEL    0x10
-#define KYCR2_IRQ_DISABLED 0x00
+#include <linux/slab.h>
 
 static const struct {
         unsigned char kymd, keyout, keyin;
@@ -36,84 +30,131 @@ static const struct {
         [SH_KEYSC_MODE_1] = { 0, 6, 5 },
         [SH_KEYSC_MODE_2] = { 1, 5, 6 },
         [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 },
 };
 
 struct sh_keysc_priv {
         void __iomem *iomem_base;
         struct clk *clk;
-        unsigned long last_keys;
+        DECLARE_BITMAP(last_keys, SH_KEYSC_MAXKEYS);
         struct input_dev *input;
         struct sh_keysc_info pdata;
 };
 
+#define KYCR1 0
+#define KYCR2 1
+#define KYINDR 2
+#define KYOUTDR 3
+
+#define KYCR2_IRQ_LEVEL    0x10
+#define KYCR2_IRQ_DISABLED 0x00
+
+static unsigned long sh_keysc_read(struct sh_keysc_priv *p, int reg_nr)
+{
+        return ioread16(p->iomem_base + (reg_nr << 2));
+}
+
+static void sh_keysc_write(struct sh_keysc_priv *p, int reg_nr,
+                           unsigned long value)
+{
+        iowrite16(value, p->iomem_base + (reg_nr << 2));
+}
+
+static void sh_keysc_level_mode(struct sh_keysc_priv *p,
+                                unsigned long keys_set)
+{
+        struct sh_keysc_info *pdata = &p->pdata;
+
+        sh_keysc_write(p, KYOUTDR, 0);
+        sh_keysc_write(p, KYCR2, KYCR2_IRQ_LEVEL | (keys_set << 8));
+
+        if (pdata->kycr2_delay)
+                udelay(pdata->kycr2_delay);
+}
+
+static void sh_keysc_map_dbg(struct device *dev, unsigned long *map,
+                             const char *str)
+{
+        int k;
+
+        for (k = 0; k < BITS_TO_LONGS(SH_KEYSC_MAXKEYS); k++)
+                dev_dbg(dev, "%s[%d] 0x%lx\n", str, k, map[k]);
+}
+
 static irqreturn_t sh_keysc_isr(int irq, void *dev_id)
 {
         struct platform_device *pdev = dev_id;
         struct sh_keysc_priv *priv = platform_get_drvdata(pdev);
         struct sh_keysc_info *pdata = &priv->pdata;
-        unsigned long keys, keys1, keys0, mask;
+        int keyout_nr = sh_keysc_mode[pdata->mode].keyout;
+        int keyin_nr = sh_keysc_mode[pdata->mode].keyin;
+        DECLARE_BITMAP(keys, SH_KEYSC_MAXKEYS);
+        DECLARE_BITMAP(keys0, SH_KEYSC_MAXKEYS);
+        DECLARE_BITMAP(keys1, SH_KEYSC_MAXKEYS);
         unsigned char keyin_set, tmp;
-        int i, k;
+        int i, k, n;
 
         dev_dbg(&pdev->dev, "isr!\n");
 
-        keys1 = ~0;
-        keys0 = 0;
+        bitmap_fill(keys1, SH_KEYSC_MAXKEYS);
+        bitmap_zero(keys0, SH_KEYSC_MAXKEYS);
 
         do {
-                keys = 0;
+                bitmap_zero(keys, SH_KEYSC_MAXKEYS);
                 keyin_set = 0;
 
-                iowrite16(KYCR2_IRQ_DISABLED, priv->iomem_base + KYCR2_OFFS);
+                sh_keysc_write(priv, KYCR2, KYCR2_IRQ_DISABLED);
+
+                for (i = 0; i < keyout_nr; i++) {
+                        n = keyin_nr * i;
 
-                for (i = 0; i < sh_keysc_mode[pdata->mode].keyout; i++) {
-                        iowrite16(0xfff ^ (3 << (i * 2)),
-                                  priv->iomem_base + KYOUTDR_OFFS);
+                        /* drive one KEYOUT pin low, read KEYIN pins */
+                        sh_keysc_write(priv, KYOUTDR, 0xffff ^ (3 << (i * 2)));
                         udelay(pdata->delay);
-                        tmp = ioread16(priv->iomem_base + KYINDR_OFFS);
-                        keys |= tmp << (sh_keysc_mode[pdata->mode].keyin * i);
-                        tmp ^= (1 << sh_keysc_mode[pdata->mode].keyin) - 1;
-                        keyin_set |= tmp;
-                }
+                        tmp = sh_keysc_read(priv, KYINDR);
 
-                iowrite16(0, priv->iomem_base + KYOUTDR_OFFS);
-                iowrite16(KYCR2_IRQ_LEVEL | (keyin_set << 8),
-                          priv->iomem_base + KYCR2_OFFS);
+                        /* set bit if key press has been detected */
+                        for (k = 0; k < keyin_nr; k++) {
+                                if (tmp & (1 << k))
+                                        __set_bit(n + k, keys);
+                        }
 
-                if (pdata->kycr2_delay)
-                        udelay(pdata->kycr2_delay);
+                        /* keep track of which KEYIN bits that have been set */
+                        keyin_set |= tmp ^ ((1 << keyin_nr) - 1);
+                }
 
-                keys ^= ~0;
-                keys &= (1 << (sh_keysc_mode[pdata->mode].keyin *
-                               sh_keysc_mode[pdata->mode].keyout)) - 1;
-                keys1 &= keys;
-                keys0 |= keys;
+                sh_keysc_level_mode(priv, keyin_set);
 
-                dev_dbg(&pdev->dev, "keys 0x%08lx\n", keys);
+                bitmap_complement(keys, keys, SH_KEYSC_MAXKEYS);
+                bitmap_and(keys1, keys1, keys, SH_KEYSC_MAXKEYS);
+                bitmap_or(keys0, keys0, keys, SH_KEYSC_MAXKEYS);
 
-        } while (ioread16(priv->iomem_base + KYCR2_OFFS) & 0x01);
+                sh_keysc_map_dbg(&pdev->dev, keys, "keys");
 
-        dev_dbg(&pdev->dev, "last_keys 0x%08lx keys0 0x%08lx keys1 0x%08lx\n",
-                priv->last_keys, keys0, keys1);
+        } while (sh_keysc_read(priv, KYCR2) & 0x01);
+
+        sh_keysc_map_dbg(&pdev->dev, priv->last_keys, "last_keys");
+        sh_keysc_map_dbg(&pdev->dev, keys0, "keys0");
+        sh_keysc_map_dbg(&pdev->dev, keys1, "keys1");
 
         for (i = 0; i < SH_KEYSC_MAXKEYS; i++) {
                 k = pdata->keycodes[i];
                 if (!k)
                         continue;
 
-                mask = 1 << i;
-
-                if (!((priv->last_keys ^ keys0) & mask))
+                if (test_bit(i, keys0) == test_bit(i, priv->last_keys))
                         continue;
 
-                if ((keys1 | keys0) & mask) {
+                if (test_bit(i, keys1) || test_bit(i, keys0)) {
                         input_event(priv->input, EV_KEY, k, 1);
-                        priv->last_keys |= mask;
+                        __set_bit(i, priv->last_keys);
                 }
 
-                if (!(keys1 & mask)) {
+                if (!test_bit(i, keys1)) {
                         input_event(priv->input, EV_KEY, k, 0);
-                        priv->last_keys &= ~mask;
+                        __clear_bit(i, priv->last_keys);
                 }
 
         }
@@ -122,8 +163,6 @@ static irqreturn_t sh_keysc_isr(int irq, void *dev_id)
         return IRQ_HANDLED;
 }
 
-#define res_size(res) ((res)->end - (res)->start + 1)
-
 static int __devinit sh_keysc_probe(struct platform_device *pdev)
 {
         struct sh_keysc_priv *priv;
@@ -164,7 +203,7 @@ static int __devinit sh_keysc_probe(struct platform_device *pdev)
         memcpy(&priv->pdata, pdev->dev.platform_data, sizeof(priv->pdata));
         pdata = &priv->pdata;
 
-        priv->iomem_base = ioremap_nocache(res->start, res_size(res));
+        priv->iomem_base = ioremap_nocache(res->start, resource_size(res));
         if (priv->iomem_base == NULL) {
                 dev_err(&pdev->dev, "failed to remap I/O memory\n");
                 error = -ENXIO;
@@ -220,10 +259,9 @@ static int __devinit sh_keysc_probe(struct platform_device *pdev)
 
         clk_enable(priv->clk);
 
-        iowrite16((sh_keysc_mode[pdata->mode].kymd << 8) |
-                  pdata->scan_timing, priv->iomem_base + KYCR1_OFFS);
-        iowrite16(0, priv->iomem_base + KYOUTDR_OFFS);
-        iowrite16(KYCR2_IRQ_LEVEL, priv->iomem_base + KYCR2_OFFS);
+        sh_keysc_write(priv, KYCR1, (sh_keysc_mode[pdata->mode].kymd << 8) |
+                       pdata->scan_timing);
+        sh_keysc_level_mode(priv, 0);
 
         device_init_wakeup(&pdev->dev, 1);
 
@@ -248,7 +286,7 @@ static int __devexit sh_keysc_remove(struct platform_device *pdev)
 {
         struct sh_keysc_priv *priv = platform_get_drvdata(pdev);
 
-        iowrite16(KYCR2_IRQ_DISABLED, priv->iomem_base + KYCR2_OFFS);
+        sh_keysc_write(priv, KYCR2, KYCR2_IRQ_DISABLED);
 
         input_unregister_device(priv->input);
         free_irq(platform_get_irq(pdev, 0), pdev);
@@ -270,7 +308,7 @@ static int sh_keysc_suspend(struct device *dev)
         int irq = platform_get_irq(pdev, 0);
         unsigned short value;
 
-        value = ioread16(priv->iomem_base + KYCR1_OFFS);
+        value = sh_keysc_read(priv, KYCR1);
 
         if (device_may_wakeup(dev)) {
                 value |= 0x80;
@@ -279,7 +317,7 @@ static int sh_keysc_suspend(struct device *dev)
                 value &= ~0x80;
         }
 
-        iowrite16(value, priv->iomem_base + KYCR1_OFFS);
+        sh_keysc_write(priv, KYCR1, value);
 
         return 0;
 }
diff --git a/drivers/input/keyboard/spitzkbd.c b/drivers/input/keyboard/spitzkbd.c
deleted file mode 100644
index 13967422658c..000000000000
--- a/drivers/input/keyboard/spitzkbd.c
+++ /dev/null
@@ -1,496 +0,0 @@
-/*
- *  Keyboard driver for Sharp Spitz, Borzoi and Akita (SL-Cxx00 series)
- *
- *  Copyright (c) 2005 Richard Purdie
- *
- *  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.h>
-#include <linux/interrupt.h>
-#include <linux/jiffies.h>
-#include <linux/module.h>
-#include <linux/slab.h>
-
-#include <mach/spitz.h>
-#include <mach/pxa2xx-gpio.h>
-
-#define KB_ROWS                 7
-#define KB_COLS                 11
-#define KB_ROWMASK(r)           (1 << (r))
-#define SCANCODE(r,c)           (((r)<<4) + (c) + 1)
-#define NR_SCANCODES            ((KB_ROWS<<4) + 1)
-
-#define SCAN_INTERVAL           (50) /* ms */
-#define HINGE_SCAN_INTERVAL     (150) /* ms */
-
-#define SPITZ_KEY_CALENDER      KEY_F1
-#define SPITZ_KEY_ADDRESS       KEY_F2
-#define SPITZ_KEY_FN            KEY_F3
-#define SPITZ_KEY_CANCEL        KEY_F4
-#define SPITZ_KEY_EXOK          KEY_F5
-#define SPITZ_KEY_EXCANCEL      KEY_F6
-#define SPITZ_KEY_EXJOGDOWN     KEY_F7
-#define SPITZ_KEY_EXJOGUP       KEY_F8
-#define SPITZ_KEY_JAP1          KEY_LEFTALT
-#define SPITZ_KEY_JAP2          KEY_RIGHTCTRL
-#define SPITZ_KEY_SYNC          KEY_F9
-#define SPITZ_KEY_MAIL          KEY_F10
-#define SPITZ_KEY_OK            KEY_F11
-#define SPITZ_KEY_MENU          KEY_F12
-
-static unsigned char spitzkbd_keycode[NR_SCANCODES] = {
-        0,                                                                                                                /* 0 */
-        KEY_LEFTCTRL, KEY_1, KEY_3, KEY_5, KEY_6, KEY_7, KEY_9, KEY_0, KEY_BACKSPACE, SPITZ_KEY_EXOK, SPITZ_KEY_EXCANCEL, 0, 0, 0, 0, 0,  /* 1-16 */
-        0, KEY_2, KEY_4, KEY_R, KEY_Y, KEY_8, KEY_I, KEY_O, KEY_P, SPITZ_KEY_EXJOGDOWN, SPITZ_KEY_EXJOGUP, 0, 0, 0, 0, 0, /* 17-32 */
-        KEY_TAB, KEY_Q, KEY_E, KEY_T, KEY_G, KEY_U, KEY_J, KEY_K, 0, 0, 0, 0, 0, 0, 0, 0,                                 /* 33-48 */
-        SPITZ_KEY_ADDRESS, KEY_W, KEY_S, KEY_F, KEY_V, KEY_H, KEY_M, KEY_L, 0, KEY_RIGHTSHIFT, 0, 0, 0, 0, 0, 0,         /* 49-64 */
-        SPITZ_KEY_CALENDER, KEY_A, KEY_D, KEY_C, KEY_B, KEY_N, KEY_DOT, 0, KEY_ENTER, KEY_LEFTSHIFT, 0, 0, 0, 0, 0, 0,    /* 65-80 */
-        SPITZ_KEY_MAIL, KEY_Z, KEY_X, KEY_MINUS, KEY_SPACE, KEY_COMMA, 0, KEY_UP, 0, 0, SPITZ_KEY_FN, 0, 0, 0, 0, 0,      /* 81-96 */
-        KEY_SYSRQ, SPITZ_KEY_JAP1, SPITZ_KEY_JAP2, SPITZ_KEY_CANCEL, SPITZ_KEY_OK, SPITZ_KEY_MENU, KEY_LEFT, KEY_DOWN, KEY_RIGHT, 0, 0, 0, 0, 0, 0, 0  /* 97-112 */
-};
-
-static int spitz_strobes[] = {
-        SPITZ_GPIO_KEY_STROBE0,
-        SPITZ_GPIO_KEY_STROBE1,
-        SPITZ_GPIO_KEY_STROBE2,
-        SPITZ_GPIO_KEY_STROBE3,
-        SPITZ_GPIO_KEY_STROBE4,
-        SPITZ_GPIO_KEY_STROBE5,
-        SPITZ_GPIO_KEY_STROBE6,
-        SPITZ_GPIO_KEY_STROBE7,
-        SPITZ_GPIO_KEY_STROBE8,
-        SPITZ_GPIO_KEY_STROBE9,
-        SPITZ_GPIO_KEY_STROBE10,
-};
-
-static int spitz_senses[] = {
-        SPITZ_GPIO_KEY_SENSE0,
-        SPITZ_GPIO_KEY_SENSE1,
-        SPITZ_GPIO_KEY_SENSE2,
-        SPITZ_GPIO_KEY_SENSE3,
-        SPITZ_GPIO_KEY_SENSE4,
-        SPITZ_GPIO_KEY_SENSE5,
-        SPITZ_GPIO_KEY_SENSE6,
-};
-
-struct spitzkbd {
-        unsigned char keycode[ARRAY_SIZE(spitzkbd_keycode)];
-        struct input_dev *input;
-        char phys[32];
-
-        spinlock_t lock;
-        struct timer_list timer;
-        struct timer_list htimer;
-
-        unsigned int suspended;
-        unsigned long suspend_jiffies;
-};
-
-#define KB_DISCHARGE_DELAY      10
-#define KB_ACTIVATE_DELAY       10
-
-/* Helper functions for reading the keyboard matrix
- * Note: We should really be using the generic gpio functions to alter
- *       GPDR but it requires a function call per GPIO bit which is
- *       excessive when we need to access 11 bits at once, multiple times.
- * These functions must be called within local_irq_save()/local_irq_restore()
- * or similar.
- */
-static inline void spitzkbd_discharge_all(void)
-{
-        /* STROBE All HiZ */
-        GPCR0  =  SPITZ_GPIO_G0_STROBE_BIT;
-        GPDR0 &= ~SPITZ_GPIO_G0_STROBE_BIT;
-        GPCR1  =  SPITZ_GPIO_G1_STROBE_BIT;
-        GPDR1 &= ~SPITZ_GPIO_G1_STROBE_BIT;
-        GPCR2  =  SPITZ_GPIO_G2_STROBE_BIT;
-        GPDR2 &= ~SPITZ_GPIO_G2_STROBE_BIT;
-        GPCR3  =  SPITZ_GPIO_G3_STROBE_BIT;
-        GPDR3 &= ~SPITZ_GPIO_G3_STROBE_BIT;
-}
-
-static inline void spitzkbd_activate_all(void)
-{
-        /* STROBE ALL -> High */
-        GPSR0  =  SPITZ_GPIO_G0_STROBE_BIT;
-        GPDR0 |=  SPITZ_GPIO_G0_STROBE_BIT;
-        GPSR1  =  SPITZ_GPIO_G1_STROBE_BIT;
-        GPDR1 |=  SPITZ_GPIO_G1_STROBE_BIT;
-        GPSR2  =  SPITZ_GPIO_G2_STROBE_BIT;
-        GPDR2 |=  SPITZ_GPIO_G2_STROBE_BIT;
-        GPSR3  =  SPITZ_GPIO_G3_STROBE_BIT;
-        GPDR3 |=  SPITZ_GPIO_G3_STROBE_BIT;
-
-        udelay(KB_DISCHARGE_DELAY);
-
-        /* Clear any interrupts we may have triggered when altering the GPIO lines */
-        GEDR0 = SPITZ_GPIO_G0_SENSE_BIT;
-        GEDR1 = SPITZ_GPIO_G1_SENSE_BIT;
-        GEDR2 = SPITZ_GPIO_G2_SENSE_BIT;
-        GEDR3 = SPITZ_GPIO_G3_SENSE_BIT;
-}
-
-static inline void spitzkbd_activate_col(int col)
-{
-        int gpio = spitz_strobes[col];
-        GPDR0 &= ~SPITZ_GPIO_G0_STROBE_BIT;
-        GPDR1 &= ~SPITZ_GPIO_G1_STROBE_BIT;
-        GPDR2 &= ~SPITZ_GPIO_G2_STROBE_BIT;
-        GPDR3 &= ~SPITZ_GPIO_G3_STROBE_BIT;
-        GPSR(gpio) = GPIO_bit(gpio);
-        GPDR(gpio) |= GPIO_bit(gpio);
-}
-
-static inline void spitzkbd_reset_col(int col)
-{
-        int gpio = spitz_strobes[col];
-        GPDR0 &= ~SPITZ_GPIO_G0_STROBE_BIT;
-        GPDR1 &= ~SPITZ_GPIO_G1_STROBE_BIT;
-        GPDR2 &= ~SPITZ_GPIO_G2_STROBE_BIT;
-        GPDR3 &= ~SPITZ_GPIO_G3_STROBE_BIT;
-        GPCR(gpio) = GPIO_bit(gpio);
-        GPDR(gpio) |= GPIO_bit(gpio);
-}
-
-static inline int spitzkbd_get_row_status(int col)
-{
-        return ((GPLR0 >> 12) & 0x01) | ((GPLR0 >> 16) & 0x02)
-                | ((GPLR2 >> 25) & 0x04) | ((GPLR1 << 1) & 0x08)
-                | ((GPLR1 >> 0) & 0x10) | ((GPLR1 >> 1) & 0x60);
-}
-
-/*
- * The spitz keyboard only generates interrupts when a key is pressed.
- * When a key is pressed, we enable a timer which then scans the
- * keyboard to detect when the key is released.
- */
-
-/* Scan the hardware keyboard and push any changes up through the input layer */
-static void spitzkbd_scankeyboard(struct spitzkbd *spitzkbd_data)
-{
-        unsigned int row, col, rowd;
-        unsigned long flags;
-        unsigned int num_pressed, pwrkey = ((GPLR(SPITZ_GPIO_ON_KEY) & GPIO_bit(SPITZ_GPIO_ON_KEY)) != 0);
-
-        if (spitzkbd_data->suspended)
-                return;
-
-        spin_lock_irqsave(&spitzkbd_data->lock, flags);
-
-        num_pressed = 0;
-        for (col = 0; col < KB_COLS; col++) {
-                /*
-                 * Discharge the output driver capacitatance
-                 * in the keyboard matrix. (Yes it is significant..)
-                 */
-
-                spitzkbd_discharge_all();
-                udelay(KB_DISCHARGE_DELAY);
-
-                spitzkbd_activate_col(col);
-                udelay(KB_ACTIVATE_DELAY);
-
-                rowd = spitzkbd_get_row_status(col);
-                for (row = 0; row < KB_ROWS; row++) {
-                        unsigned int scancode, pressed;
-
-                        scancode = SCANCODE(row, col);
-                        pressed = rowd & KB_ROWMASK(row);
-
-                        input_report_key(spitzkbd_data->input, spitzkbd_data->keycode[scancode], pressed);
-
-                        if (pressed)
-                                num_pressed++;
-                }
-                spitzkbd_reset_col(col);
-        }
-
-        spitzkbd_activate_all();
-
-        input_report_key(spitzkbd_data->input, SPITZ_KEY_SYNC, (GPLR(SPITZ_GPIO_SYNC) & GPIO_bit(SPITZ_GPIO_SYNC)) != 0 );
-        input_report_key(spitzkbd_data->input, KEY_SUSPEND, pwrkey);
-
-        if (pwrkey && time_after(jiffies, spitzkbd_data->suspend_jiffies + msecs_to_jiffies(1000))) {
-                input_event(spitzkbd_data->input, EV_PWR, KEY_SUSPEND, 1);
-                spitzkbd_data->suspend_jiffies = jiffies;
-        }
-
-        input_sync(spitzkbd_data->input);
-
-        /* if any keys are pressed, enable the timer */
-        if (num_pressed)
-                mod_timer(&spitzkbd_data->timer, jiffies + msecs_to_jiffies(SCAN_INTERVAL));
-
-        spin_unlock_irqrestore(&spitzkbd_data->lock, flags);
-}
-
-/*
- * spitz keyboard interrupt handler.
- */
-static irqreturn_t spitzkbd_interrupt(int irq, void *dev_id)
-{
-        struct spitzkbd *spitzkbd_data = dev_id;
-
-        if (!timer_pending(&spitzkbd_data->timer)) {
-                /** wait chattering delay **/
-                udelay(20);
-                spitzkbd_scankeyboard(spitzkbd_data);
-        }
-
-        return IRQ_HANDLED;
-}
-
-/*
- * spitz timer checking for released keys
- */
-static void spitzkbd_timer_callback(unsigned long data)
-{
-        struct spitzkbd *spitzkbd_data = (struct spitzkbd *) data;
-
-        spitzkbd_scankeyboard(spitzkbd_data);
-}
-
-/*
- * The hinge switches generate an interrupt.
- * We debounce the switches and pass them to the input system.
- */
-
-static irqreturn_t spitzkbd_hinge_isr(int irq, void *dev_id)
-{
-        struct spitzkbd *spitzkbd_data = dev_id;
-
-        if (!timer_pending(&spitzkbd_data->htimer))
-                mod_timer(&spitzkbd_data->htimer, jiffies + msecs_to_jiffies(HINGE_SCAN_INTERVAL));
-
-        return IRQ_HANDLED;
-}
-
-#define HINGE_STABLE_COUNT 2
-static int sharpsl_hinge_state;
-static int hinge_count;
-
-static void spitzkbd_hinge_timer(unsigned long data)
-{
-        struct spitzkbd *spitzkbd_data = (struct spitzkbd *) data;
-        unsigned long state;
-        unsigned long flags;
-
-        state = GPLR(SPITZ_GPIO_SWA) & (GPIO_bit(SPITZ_GPIO_SWA)|GPIO_bit(SPITZ_GPIO_SWB));
-        state |= (GPLR(SPITZ_GPIO_AK_INT) & GPIO_bit(SPITZ_GPIO_AK_INT));
-        if (state != sharpsl_hinge_state) {
-                hinge_count = 0;
-                sharpsl_hinge_state = state;
-        } else if (hinge_count < HINGE_STABLE_COUNT) {
-                hinge_count++;
-        }
-
-        if (hinge_count >= HINGE_STABLE_COUNT) {
-                spin_lock_irqsave(&spitzkbd_data->lock, flags);
-
-                input_report_switch(spitzkbd_data->input, SW_LID, ((GPLR(SPITZ_GPIO_SWA) & GPIO_bit(SPITZ_GPIO_SWA)) != 0));
-                input_report_switch(spitzkbd_data->input, SW_TABLET_MODE, ((GPLR(SPITZ_GPIO_SWB) & GPIO_bit(SPITZ_GPIO_SWB)) != 0));
-                input_report_switch(spitzkbd_data->input, SW_HEADPHONE_INSERT, ((GPLR(SPITZ_GPIO_AK_INT) & GPIO_bit(SPITZ_GPIO_AK_INT)) != 0));
-                input_sync(spitzkbd_data->input);
-
-                spin_unlock_irqrestore(&spitzkbd_data->lock, flags);
-        } else {
-                mod_timer(&spitzkbd_data->htimer, jiffies + msecs_to_jiffies(HINGE_SCAN_INTERVAL));
-        }
-}
-
-#ifdef CONFIG_PM
-static int spitzkbd_suspend(struct platform_device *dev, pm_message_t state)
-{
-        int i;
-        struct spitzkbd *spitzkbd = platform_get_drvdata(dev);
-        spitzkbd->suspended = 1;
-
-        /* Set Strobe lines as inputs - *except* strobe line 0 leave this
-           enabled so we can detect a power button press for resume */
-        for (i = 1; i < SPITZ_KEY_STROBE_NUM; i++)
-                pxa_gpio_mode(spitz_strobes[i] | GPIO_IN);
-
-        return 0;
-}
-
-static int spitzkbd_resume(struct platform_device *dev)
-{
-        int i;
-        struct spitzkbd *spitzkbd = platform_get_drvdata(dev);
-
-        for (i = 0; i < SPITZ_KEY_STROBE_NUM; i++)
-                pxa_gpio_mode(spitz_strobes[i] | GPIO_OUT | GPIO_DFLT_HIGH);
-
-        /* Upon resume, ignore the suspend key for a short while */
-        spitzkbd->suspend_jiffies = jiffies;
-        spitzkbd->suspended = 0;
-
-        return 0;
-}
-#else
-#define spitzkbd_suspend        NULL
-#define spitzkbd_resume         NULL
-#endif
-
-static int __devinit spitzkbd_probe(struct platform_device *dev)
-{
-        struct spitzkbd *spitzkbd;
-        struct input_dev *input_dev;
-        int i, err = -ENOMEM;
-
-        spitzkbd = kzalloc(sizeof(struct spitzkbd), GFP_KERNEL);
-        input_dev = input_allocate_device();
-        if (!spitzkbd || !input_dev)
-                goto fail;
-
-        platform_set_drvdata(dev, spitzkbd);
-        strcpy(spitzkbd->phys, "spitzkbd/input0");
-
-        spin_lock_init(&spitzkbd->lock);
-
-        /* Init Keyboard rescan timer */
-        init_timer(&spitzkbd->timer);
-        spitzkbd->timer.function = spitzkbd_timer_callback;
-        spitzkbd->timer.data = (unsigned long) spitzkbd;
-
-        /* Init Hinge Timer */
-        init_timer(&spitzkbd->htimer);
-        spitzkbd->htimer.function = spitzkbd_hinge_timer;
-        spitzkbd->htimer.data = (unsigned long) spitzkbd;
-
-        spitzkbd->suspend_jiffies = jiffies;
-
-        spitzkbd->input = input_dev;
-
-        input_dev->name = "Spitz Keyboard";
-        input_dev->phys = spitzkbd->phys;
-        input_dev->dev.parent = &dev->dev;
-
-        input_dev->id.bustype = BUS_HOST;
-        input_dev->id.vendor = 0x0001;
-        input_dev->id.product = 0x0001;
-        input_dev->id.version = 0x0100;
-
-        input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP) |
-                BIT_MASK(EV_PWR) | BIT_MASK(EV_SW);
-        input_dev->keycode = spitzkbd->keycode;
-        input_dev->keycodesize = sizeof(unsigned char);
-        input_dev->keycodemax = ARRAY_SIZE(spitzkbd_keycode);
-
-        memcpy(spitzkbd->keycode, spitzkbd_keycode, sizeof(spitzkbd->keycode));
-        for (i = 0; i < ARRAY_SIZE(spitzkbd_keycode); i++)
-                set_bit(spitzkbd->keycode[i], input_dev->keybit);
-        clear_bit(0, input_dev->keybit);
-        set_bit(KEY_SUSPEND, input_dev->keybit);
-        set_bit(SW_LID, input_dev->swbit);
-        set_bit(SW_TABLET_MODE, input_dev->swbit);
-        set_bit(SW_HEADPHONE_INSERT, input_dev->swbit);
-
-        err = input_register_device(input_dev);
-        if (err)
-                goto fail;
-
-        mod_timer(&spitzkbd->htimer, jiffies + msecs_to_jiffies(HINGE_SCAN_INTERVAL));
-
-        /* Setup sense interrupts - RisingEdge Detect, sense lines as inputs */
-        for (i = 0; i < SPITZ_KEY_SENSE_NUM; i++) {
-                pxa_gpio_mode(spitz_senses[i] | GPIO_IN);
-                if (request_irq(IRQ_GPIO(spitz_senses[i]), spitzkbd_interrupt,
-                                IRQF_DISABLED|IRQF_TRIGGER_RISING,
-                                "Spitzkbd Sense", spitzkbd))
-                        printk(KERN_WARNING "spitzkbd: Can't get Sense IRQ: %d!\n", i);
-        }
-
-        /* Set Strobe lines as outputs - set high */
-        for (i = 0; i < SPITZ_KEY_STROBE_NUM; i++)
-                pxa_gpio_mode(spitz_strobes[i] | GPIO_OUT | GPIO_DFLT_HIGH);
-
-        pxa_gpio_mode(SPITZ_GPIO_SYNC | GPIO_IN);
-        pxa_gpio_mode(SPITZ_GPIO_ON_KEY | GPIO_IN);
-        pxa_gpio_mode(SPITZ_GPIO_SWA | GPIO_IN);
-        pxa_gpio_mode(SPITZ_GPIO_SWB | GPIO_IN);
-
-        request_irq(SPITZ_IRQ_GPIO_SYNC, spitzkbd_interrupt,
-                    IRQF_DISABLED | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
-                    "Spitzkbd Sync", spitzkbd);
-        request_irq(SPITZ_IRQ_GPIO_ON_KEY, spitzkbd_interrupt,
-                    IRQF_DISABLED | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
-                    "Spitzkbd PwrOn", spitzkbd);
-        request_irq(SPITZ_IRQ_GPIO_SWA, spitzkbd_hinge_isr,
-                    IRQF_DISABLED | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
-                    "Spitzkbd SWA", spitzkbd);
-        request_irq(SPITZ_IRQ_GPIO_SWB, spitzkbd_hinge_isr,
-                    IRQF_DISABLED | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
-                    "Spitzkbd SWB", spitzkbd);
-        request_irq(SPITZ_IRQ_GPIO_AK_INT, spitzkbd_hinge_isr,
-                    IRQF_DISABLED | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
-                    "Spitzkbd HP", spitzkbd);
-
-        return 0;
-
- fail:  input_free_device(input_dev);
-        kfree(spitzkbd);
-        return err;
-}
-
-static int __devexit spitzkbd_remove(struct platform_device *dev)
-{
-        int i;
-        struct spitzkbd *spitzkbd = platform_get_drvdata(dev);
-
-        for (i = 0; i < SPITZ_KEY_SENSE_NUM; i++)
-                free_irq(IRQ_GPIO(spitz_senses[i]), spitzkbd);
-
-        free_irq(SPITZ_IRQ_GPIO_SYNC, spitzkbd);
-        free_irq(SPITZ_IRQ_GPIO_ON_KEY, spitzkbd);
-        free_irq(SPITZ_IRQ_GPIO_SWA, spitzkbd);
-        free_irq(SPITZ_IRQ_GPIO_SWB, spitzkbd);
-        free_irq(SPITZ_IRQ_GPIO_AK_INT, spitzkbd);
-
-        del_timer_sync(&spitzkbd->htimer);
-        del_timer_sync(&spitzkbd->timer);
-
-        input_unregister_device(spitzkbd->input);
-
-        kfree(spitzkbd);
-
-        return 0;
-}
-
-static struct platform_driver spitzkbd_driver = {
-        .probe          = spitzkbd_probe,
-        .remove         = __devexit_p(spitzkbd_remove),
-        .suspend        = spitzkbd_suspend,
-        .resume         = spitzkbd_resume,
-        .driver         = {
-                .name   = "spitz-keyboard",
-                .owner  = THIS_MODULE,
-        },
-};
-
-static int __init spitzkbd_init(void)
-{
-        return platform_driver_register(&spitzkbd_driver);
-}
-
-static void __exit spitzkbd_exit(void)
-{
-        platform_driver_unregister(&spitzkbd_driver);
-}
-
-module_init(spitzkbd_init);
-module_exit(spitzkbd_exit);
-
-MODULE_AUTHOR("Richard Purdie <rpurdie@rpsys.net>");
-MODULE_DESCRIPTION("Spitz Keyboard Driver");
-MODULE_LICENSE("GPL v2");
-MODULE_ALIAS("platform:spitz-keyboard");
diff --git a/drivers/input/keyboard/stmpe-keypad.c b/drivers/input/keyboard/stmpe-keypad.c
new file mode 100644
index 000000000000..ab7610ca10eb
--- /dev/null
+++ b/drivers/input/keyboard/stmpe-keypad.c
@@ -0,0 +1,386 @@
+/*
+ * Copyright (C) ST-Ericsson SA 2010
+ *
+ * License Terms: GNU General Public License, version 2
+ * Author: Rabin Vincent <rabin.vincent@stericsson.com> for ST-Ericsson
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/input.h>
+#include <linux/interrupt.h>
+#include <linux/platform_device.h>
+#include <linux/input/matrix_keypad.h>
+#include <linux/mfd/stmpe.h>
+
+/* These are at the same addresses in all STMPE variants */
+#define STMPE_KPC_COL                   0x60
+#define STMPE_KPC_ROW_MSB               0x61
+#define STMPE_KPC_ROW_LSB               0x62
+#define STMPE_KPC_CTRL_MSB              0x63
+#define STMPE_KPC_CTRL_LSB              0x64
+#define STMPE_KPC_COMBI_KEY_0           0x65
+#define STMPE_KPC_COMBI_KEY_1           0x66
+#define STMPE_KPC_COMBI_KEY_2           0x67
+#define STMPE_KPC_DATA_BYTE0            0x68
+#define STMPE_KPC_DATA_BYTE1            0x69
+#define STMPE_KPC_DATA_BYTE2            0x6a
+#define STMPE_KPC_DATA_BYTE3            0x6b
+#define STMPE_KPC_DATA_BYTE4            0x6c
+
+#define STMPE_KPC_CTRL_LSB_SCAN         (0x1 << 0)
+#define STMPE_KPC_CTRL_LSB_DEBOUNCE     (0x7f << 1)
+#define STMPE_KPC_CTRL_MSB_SCAN_COUNT   (0xf << 4)
+
+#define STMPE_KPC_ROW_MSB_ROWS          0xff
+
+#define STMPE_KPC_DATA_UP               (0x1 << 7)
+#define STMPE_KPC_DATA_ROW              (0xf << 3)
+#define STMPE_KPC_DATA_COL              (0x7 << 0)
+#define STMPE_KPC_DATA_NOKEY_MASK       0x78
+
+#define STMPE_KEYPAD_MAX_DEBOUNCE       127
+#define STMPE_KEYPAD_MAX_SCAN_COUNT     15
+
+#define STMPE_KEYPAD_MAX_ROWS           8
+#define STMPE_KEYPAD_MAX_COLS           8
+#define STMPE_KEYPAD_ROW_SHIFT          3
+#define STMPE_KEYPAD_KEYMAP_SIZE        \
+        (STMPE_KEYPAD_MAX_ROWS * STMPE_KEYPAD_MAX_COLS)
+
+/**
+ * struct stmpe_keypad_variant - model-specific attributes
+ * @auto_increment: whether the KPC_DATA_BYTE register address
+ *                  auto-increments on multiple read
+ * @num_data: number of data bytes
+ * @num_normal_data: number of normal keys' data bytes
+ * @max_cols: maximum number of columns supported
+ * @max_rows: maximum number of rows supported
+ * @col_gpios: bitmask of gpios which can be used for columns
+ * @row_gpios: bitmask of gpios which can be used for rows
+ */
+struct stmpe_keypad_variant {
+        bool            auto_increment;
+        int             num_data;
+        int             num_normal_data;
+        int             max_cols;
+        int             max_rows;
+        unsigned int    col_gpios;
+        unsigned int    row_gpios;
+};
+
+static const struct stmpe_keypad_variant stmpe_keypad_variants[] = {
+        [STMPE1601] = {
+                .auto_increment         = true,
+                .num_data               = 5,
+                .num_normal_data        = 3,
+                .max_cols               = 8,
+                .max_rows               = 8,
+                .col_gpios              = 0x000ff,      /* GPIO 0 - 7 */
+                .row_gpios              = 0x0ff00,      /* GPIO 8 - 15 */
+        },
+        [STMPE2401] = {
+                .auto_increment         = false,
+                .num_data               = 3,
+                .num_normal_data        = 2,
+                .max_cols               = 8,
+                .max_rows               = 12,
+                .col_gpios              = 0x0000ff,     /* GPIO 0 - 7*/
+                .row_gpios              = 0x1fef00,     /* GPIO 8-14, 16-20 */
+        },
+        [STMPE2403] = {
+                .auto_increment         = true,
+                .num_data               = 5,
+                .num_normal_data        = 3,
+                .max_cols               = 8,
+                .max_rows               = 12,
+                .col_gpios              = 0x0000ff,     /* GPIO 0 - 7*/
+                .row_gpios              = 0x1fef00,     /* GPIO 8-14, 16-20 */
+        },
+};
+
+struct stmpe_keypad {
+        struct stmpe *stmpe;
+        struct input_dev *input;
+        const struct stmpe_keypad_variant *variant;
+        const struct stmpe_keypad_platform_data *plat;
+
+        unsigned int rows;
+        unsigned int cols;
+
+        unsigned short keymap[STMPE_KEYPAD_KEYMAP_SIZE];
+};
+
+static int stmpe_keypad_read_data(struct stmpe_keypad *keypad, u8 *data)
+{
+        const struct stmpe_keypad_variant *variant = keypad->variant;
+        struct stmpe *stmpe = keypad->stmpe;
+        int ret;
+        int i;
+
+        if (variant->auto_increment)
+                return stmpe_block_read(stmpe, STMPE_KPC_DATA_BYTE0,
+                                        variant->num_data, data);
+
+        for (i = 0; i < variant->num_data; i++) {
+                ret = stmpe_reg_read(stmpe, STMPE_KPC_DATA_BYTE0 + i);
+                if (ret < 0)
+                        return ret;
+
+                data[i] = ret;
+        }
+
+        return 0;
+}
+
+static irqreturn_t stmpe_keypad_irq(int irq, void *dev)
+{
+        struct stmpe_keypad *keypad = dev;
+        struct input_dev *input = keypad->input;
+        const struct stmpe_keypad_variant *variant = keypad->variant;
+        u8 fifo[variant->num_data];
+        int ret;
+        int i;
+
+        ret = stmpe_keypad_read_data(keypad, fifo);
+        if (ret < 0)
+                return IRQ_NONE;
+
+        for (i = 0; i < variant->num_normal_data; i++) {
+                u8 data = fifo[i];
+                int row = (data & STMPE_KPC_DATA_ROW) >> 3;
+                int col = data & STMPE_KPC_DATA_COL;
+                int code = MATRIX_SCAN_CODE(row, col, STMPE_KEYPAD_ROW_SHIFT);
+                bool up = data & STMPE_KPC_DATA_UP;
+
+                if ((data & STMPE_KPC_DATA_NOKEY_MASK)
+                        == STMPE_KPC_DATA_NOKEY_MASK)
+                        continue;
+
+                input_event(input, EV_MSC, MSC_SCAN, code);
+                input_report_key(input, keypad->keymap[code], !up);
+                input_sync(input);
+        }
+
+        return IRQ_HANDLED;
+}
+
+static int __devinit stmpe_keypad_altfunc_init(struct stmpe_keypad *keypad)
+{
+        const struct stmpe_keypad_variant *variant = keypad->variant;
+        unsigned int col_gpios = variant->col_gpios;
+        unsigned int row_gpios = variant->row_gpios;
+        struct stmpe *stmpe = keypad->stmpe;
+        unsigned int pins = 0;
+        int i;
+
+        /*
+         * Figure out which pins need to be set to the keypad alternate
+         * function.
+         *
+         * {cols,rows}_gpios are bitmasks of which pins on the chip can be used
+         * for the keypad.
+         *
+         * keypad->{cols,rows} are a bitmask of which pins (of the ones useable
+         * for the keypad) are used on the board.
+         */
+
+        for (i = 0; i < variant->max_cols; i++) {
+                int num = __ffs(col_gpios);
+
+                if (keypad->cols & (1 << i))
+                        pins |= 1 << num;
+
+                col_gpios &= ~(1 << num);
+        }
+
+        for (i = 0; i < variant->max_rows; i++) {
+                int num = __ffs(row_gpios);
+
+                if (keypad->rows & (1 << i))
+                        pins |= 1 << num;
+
+                row_gpios &= ~(1 << num);
+        }
+
+        return stmpe_set_altfunc(stmpe, pins, STMPE_BLOCK_KEYPAD);
+}
+
+static int __devinit stmpe_keypad_chip_init(struct stmpe_keypad *keypad)
+{
+        const struct stmpe_keypad_platform_data *plat = keypad->plat;
+        const struct stmpe_keypad_variant *variant = keypad->variant;
+        struct stmpe *stmpe = keypad->stmpe;
+        int ret;
+
+        if (plat->debounce_ms > STMPE_KEYPAD_MAX_DEBOUNCE)
+                return -EINVAL;
+
+        if (plat->scan_count > STMPE_KEYPAD_MAX_SCAN_COUNT)
+                return -EINVAL;
+
+        ret = stmpe_enable(stmpe, STMPE_BLOCK_KEYPAD);
+        if (ret < 0)
+                return ret;
+
+        ret = stmpe_keypad_altfunc_init(keypad);
+        if (ret < 0)
+                return ret;
+
+        ret = stmpe_reg_write(stmpe, STMPE_KPC_COL, keypad->cols);
+        if (ret < 0)
+                return ret;
+
+        ret = stmpe_reg_write(stmpe, STMPE_KPC_ROW_LSB, keypad->rows);
+        if (ret < 0)
+                return ret;
+
+        if (variant->max_rows > 8) {
+                ret = stmpe_set_bits(stmpe, STMPE_KPC_ROW_MSB,
+                                     STMPE_KPC_ROW_MSB_ROWS,
+                                     keypad->rows >> 8);
+                if (ret < 0)
+                        return ret;
+        }
+
+        ret = stmpe_set_bits(stmpe, STMPE_KPC_CTRL_MSB,
+                             STMPE_KPC_CTRL_MSB_SCAN_COUNT,
+                             plat->scan_count << 4);
+        if (ret < 0)
+                return ret;
+
+        return stmpe_set_bits(stmpe, STMPE_KPC_CTRL_LSB,
+                              STMPE_KPC_CTRL_LSB_SCAN |
+                              STMPE_KPC_CTRL_LSB_DEBOUNCE,
+                              STMPE_KPC_CTRL_LSB_SCAN |
+                              (plat->debounce_ms << 1));
+}
+
+static int __devinit stmpe_keypad_probe(struct platform_device *pdev)
+{
+        struct stmpe *stmpe = dev_get_drvdata(pdev->dev.parent);
+        struct stmpe_keypad_platform_data *plat;
+        struct stmpe_keypad *keypad;
+        struct input_dev *input;
+        int ret;
+        int irq;
+        int i;
+
+        plat = stmpe->pdata->keypad;
+        if (!plat)
+                return -ENODEV;
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0)
+                return irq;
+
+        keypad = kzalloc(sizeof(struct stmpe_keypad), GFP_KERNEL);
+        if (!keypad)
+                return -ENOMEM;
+
+        input = input_allocate_device();
+        if (!input) {
+                ret = -ENOMEM;
+                goto out_freekeypad;
+        }
+
+        input->name = "STMPE keypad";
+        input->id.bustype = BUS_I2C;
+        input->dev.parent = &pdev->dev;
+
+        input_set_capability(input, EV_MSC, MSC_SCAN);
+
+        __set_bit(EV_KEY, input->evbit);
+        if (!plat->no_autorepeat)
+                __set_bit(EV_REP, input->evbit);
+
+        input->keycode = keypad->keymap;
+        input->keycodesize = sizeof(keypad->keymap[0]);
+        input->keycodemax = ARRAY_SIZE(keypad->keymap);
+
+        matrix_keypad_build_keymap(plat->keymap_data, STMPE_KEYPAD_ROW_SHIFT,
+                                   input->keycode, input->keybit);
+
+        for (i = 0; i < plat->keymap_data->keymap_size; i++) {
+                unsigned int key = plat->keymap_data->keymap[i];
+
+                keypad->cols |= 1 << KEY_COL(key);
+                keypad->rows |= 1 << KEY_ROW(key);
+        }
+
+        keypad->stmpe = stmpe;
+        keypad->plat = plat;
+        keypad->input = input;
+        keypad->variant = &stmpe_keypad_variants[stmpe->partnum];
+
+        ret = stmpe_keypad_chip_init(keypad);
+        if (ret < 0)
+                goto out_freeinput;
+
+        ret = input_register_device(input);
+        if (ret) {
+                dev_err(&pdev->dev,
+                        "unable to register input device: %d\n", ret);
+                goto out_freeinput;
+        }
+
+        ret = request_threaded_irq(irq, NULL, stmpe_keypad_irq, IRQF_ONESHOT,
+                                   "stmpe-keypad", keypad);
+        if (ret) {
+                dev_err(&pdev->dev, "unable to get irq: %d\n", ret);
+                goto out_unregisterinput;
+        }
+
+        platform_set_drvdata(pdev, keypad);
+
+        return 0;
+
+out_unregisterinput:
+        input_unregister_device(input);
+        input = NULL;
+out_freeinput:
+        input_free_device(input);
+out_freekeypad:
+        kfree(keypad);
+        return ret;
+}
+
+static int __devexit stmpe_keypad_remove(struct platform_device *pdev)
+{
+        struct stmpe_keypad *keypad = platform_get_drvdata(pdev);
+        struct stmpe *stmpe = keypad->stmpe;
+        int irq = platform_get_irq(pdev, 0);
+
+        stmpe_disable(stmpe, STMPE_BLOCK_KEYPAD);
+
+        free_irq(irq, keypad);
+        input_unregister_device(keypad->input);
+        platform_set_drvdata(pdev, NULL);
+        kfree(keypad);
+
+        return 0;
+}
+
+static struct platform_driver stmpe_keypad_driver = {
+        .driver.name    = "stmpe-keypad",
+        .driver.owner   = THIS_MODULE,
+        .probe          = stmpe_keypad_probe,
+        .remove         = __devexit_p(stmpe_keypad_remove),
+};
+
+static int __init stmpe_keypad_init(void)
+{
+        return platform_driver_register(&stmpe_keypad_driver);
+}
+module_init(stmpe_keypad_init);
+
+static void __exit stmpe_keypad_exit(void)
+{
+        platform_driver_unregister(&stmpe_keypad_driver);
+}
+module_exit(stmpe_keypad_exit);
+
+MODULE_LICENSE("GPL v2");
+MODULE_DESCRIPTION("STMPExxxx keypad driver");
+MODULE_AUTHOR("Rabin Vincent <rabin.vincent@stericsson.com>");
diff --git a/drivers/input/keyboard/tca6416-keypad.c b/drivers/input/keyboard/tca6416-keypad.c
new file mode 100644
index 000000000000..00137bebcf97
--- /dev/null
+++ b/drivers/input/keyboard/tca6416-keypad.c
@@ -0,0 +1,347 @@
+/*
+ * Driver for keys on TCA6416 I2C IO expander
+ *
+ * Copyright (C) 2010 Texas Instruments
+ *
+ * Author : Sriramakrishnan.A.G. <srk@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.
+ */
+
+#include <linux/types.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/slab.h>
+#include <linux/interrupt.h>
+#include <linux/workqueue.h>
+#include <linux/gpio.h>
+#include <linux/i2c.h>
+#include <linux/input.h>
+#include <linux/tca6416_keypad.h>
+
+#define TCA6416_INPUT          0
+#define TCA6416_OUTPUT         1
+#define TCA6416_INVERT         2
+#define TCA6416_DIRECTION      3
+
+static const struct i2c_device_id tca6416_id[] = {
+        { "tca6416-keys", 16, },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, tca6416_id);
+
+struct tca6416_drv_data {
+        struct input_dev *input;
+        struct tca6416_button data[0];
+};
+
+struct tca6416_keypad_chip {
+        uint16_t reg_output;
+        uint16_t reg_direction;
+        uint16_t reg_input;
+
+        struct i2c_client *client;
+        struct input_dev *input;
+        struct delayed_work dwork;
+        u16 pinmask;
+        int irqnum;
+        bool use_polling;
+        struct tca6416_button buttons[0];
+};
+
+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);
+        if (error < 0) {
+                dev_err(&chip->client->dev,
+                        "%s failed, reg: %d, val: %d, error: %d\n",
+                        __func__, reg, val, error);
+                return error;
+        }
+
+        return 0;
+}
+
+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);
+        if (retval < 0) {
+                dev_err(&chip->client->dev, "%s failed, reg: %d, error: %d\n",
+                        __func__, reg, retval);
+                return retval;
+        }
+
+        *val = (u16)retval;
+        return 0;
+}
+
+static void tca6416_keys_scan(struct tca6416_keypad_chip *chip)
+{
+        struct input_dev *input = chip->input;
+        u16 reg_val, val;
+        int error, i, pin_index;
+
+        error = tca6416_read_reg(chip, TCA6416_INPUT, &reg_val);
+        if (error)
+                return;
+
+        reg_val &= chip->pinmask;
+
+        /* Figure out which lines have changed */
+        val = reg_val ^ chip->reg_input;
+        chip->reg_input = reg_val;
+
+        for (i = 0, pin_index = 0; i < 16; i++) {
+                if (val & (1 << i)) {
+                        struct tca6416_button *button = &chip->buttons[pin_index];
+                        unsigned int type = button->type ?: EV_KEY;
+                        int state = ((reg_val & (1 << i)) ? 1 : 0)
+                                                ^ button->active_low;
+
+                        input_event(input, type, button->code, !!state);
+                        input_sync(input);
+                }
+
+                if (chip->pinmask & (1 << i))
+                        pin_index++;
+        }
+}
+
+/*
+ * This is threaded IRQ handler and this can (and will) sleep.
+ */
+static irqreturn_t tca6416_keys_isr(int irq, void *dev_id)
+{
+        struct tca6416_keypad_chip *chip = dev_id;
+
+        tca6416_keys_scan(chip);
+
+        return IRQ_HANDLED;
+}
+
+static void tca6416_keys_work_func(struct work_struct *work)
+{
+        struct tca6416_keypad_chip *chip =
+                container_of(work, struct tca6416_keypad_chip, dwork.work);
+
+        tca6416_keys_scan(chip);
+        schedule_delayed_work(&chip->dwork, msecs_to_jiffies(100));
+}
+
+static int tca6416_keys_open(struct input_dev *dev)
+{
+        struct tca6416_keypad_chip *chip = input_get_drvdata(dev);
+
+        /* Get initial device state in case it has switches */
+        tca6416_keys_scan(chip);
+
+        if (chip->use_polling)
+                schedule_delayed_work(&chip->dwork, msecs_to_jiffies(100));
+        else
+                enable_irq(chip->irqnum);
+
+        return 0;
+}
+
+static void tca6416_keys_close(struct input_dev *dev)
+{
+        struct tca6416_keypad_chip *chip = input_get_drvdata(dev);
+
+        if (chip->use_polling)
+                cancel_delayed_work_sync(&chip->dwork);
+        else
+                disable_irq(chip->irqnum);
+}
+
+static int __devinit tca6416_setup_registers(struct tca6416_keypad_chip *chip)
+{
+        int error;
+
+        error = tca6416_read_reg(chip, TCA6416_OUTPUT, &chip->reg_output);
+        if (error)
+                return error;
+
+        error = tca6416_read_reg(chip, TCA6416_DIRECTION, &chip->reg_direction);
+        if (error)
+                return error;
+
+        /* ensure that keypad pins are set to input */
+        error = tca6416_write_reg(chip, TCA6416_DIRECTION,
+                                  chip->reg_direction | chip->pinmask);
+        if (error)
+                return error;
+
+        error = tca6416_read_reg(chip, TCA6416_DIRECTION, &chip->reg_direction);
+        if (error)
+                return error;
+
+        error = tca6416_read_reg(chip, TCA6416_INPUT, &chip->reg_input);
+        if (error)
+                return error;
+
+        chip->reg_input &= chip->pinmask;
+
+        return 0;
+}
+
+static int __devinit tca6416_keypad_probe(struct i2c_client *client,
+                                   const struct i2c_device_id *id)
+{
+        struct tca6416_keys_platform_data *pdata;
+        struct tca6416_keypad_chip *chip;
+        struct input_dev *input;
+        int error;
+        int i;
+
+        /* Check functionality */
+        if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE)) {
+                dev_err(&client->dev, "%s adapter not supported\n",
+                        dev_driver_string(&client->adapter->dev));
+                return -ENODEV;
+        }
+
+        pdata = client->dev.platform_data;
+        if (!pdata) {
+                dev_dbg(&client->dev, "no platform data\n");
+                return -EINVAL;
+        }
+
+        chip = kzalloc(sizeof(struct tca6416_keypad_chip) +
+                       pdata->nbuttons * sizeof(struct tca6416_button),
+                       GFP_KERNEL);
+        input = input_allocate_device();
+        if (!chip || !input) {
+                error = -ENOMEM;
+                goto fail1;
+        }
+
+        chip->client = client;
+        chip->input = input;
+        chip->pinmask = pdata->pinmask;
+        chip->use_polling = pdata->use_polling;
+
+        INIT_DELAYED_WORK(&chip->dwork, tca6416_keys_work_func);
+
+        input->phys = "tca6416-keys/input0";
+        input->name = client->name;
+        input->dev.parent = &client->dev;
+
+        input->open = tca6416_keys_open;
+        input->close = tca6416_keys_close;
+
+        input->id.bustype = BUS_HOST;
+        input->id.vendor = 0x0001;
+        input->id.product = 0x0001;
+        input->id.version = 0x0100;
+
+        /* Enable auto repeat feature of Linux input subsystem */
+        if (pdata->rep)
+                __set_bit(EV_REP, input->evbit);
+
+        for (i = 0; i < pdata->nbuttons; i++) {
+                unsigned int type;
+
+                chip->buttons[i] = pdata->buttons[i];
+                type = (pdata->buttons[i].type) ?: EV_KEY;
+                input_set_capability(input, type, pdata->buttons[i].code);
+        }
+
+        input_set_drvdata(input, chip);
+
+        /*
+         * Initialize cached registers from their original values.
+         * we can't share this chip with another i2c master.
+         */
+        error = tca6416_setup_registers(chip);
+        if (error)
+                goto fail1;
+
+        if (!chip->use_polling) {
+                if (pdata->irq_is_gpio)
+                        chip->irqnum = gpio_to_irq(client->irq);
+                else
+                        chip->irqnum = client->irq;
+
+                error = request_threaded_irq(chip->irqnum, NULL,
+                                             tca6416_keys_isr,
+                                             IRQF_TRIGGER_FALLING,
+                                             "tca6416-keypad", chip);
+                if (error) {
+                        dev_dbg(&client->dev,
+                                "Unable to claim irq %d; error %d\n",
+                                chip->irqnum, error);
+                        goto fail1;
+                }
+                disable_irq(chip->irqnum);
+        }
+
+        error = input_register_device(input);
+        if (error) {
+                dev_dbg(&client->dev,
+                        "Unable to register input device, error: %d\n", error);
+                goto fail2;
+        }
+
+        i2c_set_clientdata(client, chip);
+
+        return 0;
+
+fail2:
+        if (!chip->use_polling) {
+                free_irq(chip->irqnum, chip);
+                enable_irq(chip->irqnum);
+        }
+fail1:
+        input_free_device(input);
+        kfree(chip);
+        return error;
+}
+
+static int __devexit tca6416_keypad_remove(struct i2c_client *client)
+{
+        struct tca6416_keypad_chip *chip = i2c_get_clientdata(client);
+
+        if (!chip->use_polling) {
+                free_irq(chip->irqnum, chip);
+                enable_irq(chip->irqnum);
+        }
+
+        input_unregister_device(chip->input);
+        kfree(chip);
+
+        return 0;
+}
+
+
+static struct i2c_driver tca6416_keypad_driver = {
+        .driver = {
+                .name   = "tca6416-keypad",
+        },
+        .probe          = tca6416_keypad_probe,
+        .remove         = __devexit_p(tca6416_keypad_remove),
+        .id_table       = tca6416_id,
+};
+
+static int __init tca6416_keypad_init(void)
+{
+        return i2c_add_driver(&tca6416_keypad_driver);
+}
+
+subsys_initcall(tca6416_keypad_init);
+
+static void __exit tca6416_keypad_exit(void)
+{
+        i2c_del_driver(&tca6416_keypad_driver);
+}
+module_exit(tca6416_keypad_exit);
+
+MODULE_AUTHOR("Sriramakrishnan <srk@ti.com>");
+MODULE_DESCRIPTION("Keypad driver over tca6146 IO expander");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/keyboard/tnetv107x-keypad.c b/drivers/input/keyboard/tnetv107x-keypad.c
new file mode 100644
index 000000000000..b4a81ebfab92
--- /dev/null
+++ b/drivers/input/keyboard/tnetv107x-keypad.c
@@ -0,0 +1,340 @@
+/*
+ * 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/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 (!kp->clk) {
+                dev_err(dev, "cannot claim device clock\n");
+                error = -EINVAL;
+                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/tosakbd.c b/drivers/input/keyboard/tosakbd.c
deleted file mode 100644
index 42cb3faf7336..000000000000
--- a/drivers/input/keyboard/tosakbd.c
+++ /dev/null
@@ -1,430 +0,0 @@
-/*
- *  Keyboard driver for Sharp Tosa models (SL-6000x)
- *
- *  Copyright (c) 2005 Dirk Opfer
- *  Copyright (c) 2007 Dmitry Baryshkov
- *
- *  Based on xtkbd.c/locomkbd.c/corgikbd.c
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 2 as
- *  published by the Free Software Foundation.
- *
- */
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/platform_device.h>
-#include <linux/input.h>
-#include <linux/delay.h>
-#include <linux/interrupt.h>
-
-#include <mach/gpio.h>
-#include <mach/tosa.h>
-
-#define KB_ROWMASK(r)           (1 << (r))
-#define SCANCODE(r, c)          (((r)<<4) + (c) + 1)
-#define NR_SCANCODES            SCANCODE(TOSA_KEY_SENSE_NUM - 1, TOSA_KEY_STROBE_NUM - 1) + 1
-
-#define SCAN_INTERVAL           (HZ/10)
-
-#define KB_DISCHARGE_DELAY      10
-#define KB_ACTIVATE_DELAY       10
-
-static unsigned short tosakbd_keycode[NR_SCANCODES] = {
-0,
-0, KEY_W, 0, 0, 0, KEY_K, KEY_BACKSPACE, KEY_P,
-0, 0, 0, 0, 0, 0, 0, 0,
-KEY_Q, KEY_E, KEY_T, KEY_Y, 0, KEY_O, KEY_I, KEY_COMMA,
-0, 0, 0, 0, 0, 0, 0, 0,
-KEY_A, KEY_D, KEY_G, KEY_U, 0, KEY_L, KEY_ENTER, KEY_DOT,
-0, 0, 0, 0, 0, 0, 0, 0,
-KEY_Z, KEY_C, KEY_V, KEY_J, TOSA_KEY_ADDRESSBOOK, TOSA_KEY_CANCEL, TOSA_KEY_CENTER, TOSA_KEY_OK,
-KEY_LEFTSHIFT, 0, 0, 0, 0, 0, 0, 0,
-KEY_S, KEY_R, KEY_B, KEY_N, TOSA_KEY_CALENDAR, TOSA_KEY_HOMEPAGE, KEY_LEFTCTRL, TOSA_KEY_LIGHT,
-0, KEY_RIGHTSHIFT, 0, 0, 0, 0, 0, 0,
-KEY_TAB, KEY_SLASH, KEY_H, KEY_M, TOSA_KEY_MENU, 0, KEY_UP, 0,
-0, 0, TOSA_KEY_FN, 0, 0, 0, 0, 0,
-KEY_X, KEY_F, KEY_SPACE, KEY_APOSTROPHE, TOSA_KEY_MAIL, KEY_LEFT, KEY_DOWN, KEY_RIGHT,
-0, 0, 0,
-};
-
-struct tosakbd {
-        unsigned short keycode[ARRAY_SIZE(tosakbd_keycode)];
-        struct input_dev *input;
-        bool suspended;
-        spinlock_t lock; /* protect kbd scanning */
-        struct timer_list timer;
-};
-
-
-/* Helper functions for reading the keyboard matrix
- * Note: We should really be using the generic gpio functions to alter
- *       GPDR but it requires a function call per GPIO bit which is
- *       excessive when we need to access 12 bits at once, multiple times.
- * These functions must be called within local_irq_save()/local_irq_restore()
- * or similar.
- */
-#define GET_ROWS_STATUS(c)      ((GPLR2 & TOSA_GPIO_ALL_SENSE_BIT) >> TOSA_GPIO_ALL_SENSE_RSHIFT)
-
-static inline void tosakbd_discharge_all(void)
-{
-        /* STROBE All HiZ */
-        GPCR1  = TOSA_GPIO_HIGH_STROBE_BIT;
-        GPDR1 &= ~TOSA_GPIO_HIGH_STROBE_BIT;
-        GPCR2  = TOSA_GPIO_LOW_STROBE_BIT;
-        GPDR2 &= ~TOSA_GPIO_LOW_STROBE_BIT;
-}
-
-static inline void tosakbd_activate_all(void)
-{
-        /* STROBE ALL -> High */
-        GPSR1  = TOSA_GPIO_HIGH_STROBE_BIT;
-        GPDR1 |= TOSA_GPIO_HIGH_STROBE_BIT;
-        GPSR2  = TOSA_GPIO_LOW_STROBE_BIT;
-        GPDR2 |= TOSA_GPIO_LOW_STROBE_BIT;
-
-        udelay(KB_DISCHARGE_DELAY);
-
-        /* STATE CLEAR */
-        GEDR2 |= TOSA_GPIO_ALL_SENSE_BIT;
-}
-
-static inline void tosakbd_activate_col(int col)
-{
-        if (col <= 5) {
-                /* STROBE col -> High, not col -> HiZ */
-                GPSR1 = TOSA_GPIO_STROBE_BIT(col);
-                GPDR1 = (GPDR1 & ~TOSA_GPIO_HIGH_STROBE_BIT) | TOSA_GPIO_STROBE_BIT(col);
-        } else {
-                /* STROBE col -> High, not col -> HiZ */
-                GPSR2 = TOSA_GPIO_STROBE_BIT(col);
-                GPDR2 = (GPDR2 & ~TOSA_GPIO_LOW_STROBE_BIT) | TOSA_GPIO_STROBE_BIT(col);
-        }
-}
-
-static inline void tosakbd_reset_col(int col)
-{
-        if (col <= 5) {
-                /* STROBE col -> Low */
-                GPCR1 = TOSA_GPIO_STROBE_BIT(col);
-                /* STROBE col -> out, not col -> HiZ */
-                GPDR1 = (GPDR1 & ~TOSA_GPIO_HIGH_STROBE_BIT) | TOSA_GPIO_STROBE_BIT(col);
-        } else {
-                /* STROBE col -> Low */
-                GPCR2 = TOSA_GPIO_STROBE_BIT(col);
-                /* STROBE col -> out, not col -> HiZ */
-                GPDR2 = (GPDR2 & ~TOSA_GPIO_LOW_STROBE_BIT) | TOSA_GPIO_STROBE_BIT(col);
-        }
-}
-/*
- * The tosa keyboard only generates interrupts when a key is pressed.
- * So when a key is pressed, we enable a timer.  This timer scans the
- * keyboard, and this is how we detect when the key is released.
- */
-
-/* Scan the hardware keyboard and push any changes up through the input layer */
-static void tosakbd_scankeyboard(struct platform_device *dev)
-{
-        struct tosakbd *tosakbd = platform_get_drvdata(dev);
-        unsigned int row, col, rowd;
-        unsigned long flags;
-        unsigned int num_pressed = 0;
-
-        spin_lock_irqsave(&tosakbd->lock, flags);
-
-        if (tosakbd->suspended)
-                goto out;
-
-        for (col = 0; col < TOSA_KEY_STROBE_NUM; col++) {
-                /*
-                 * Discharge the output driver capacitatance
-                 * in the keyboard matrix. (Yes it is significant..)
-                 */
-                tosakbd_discharge_all();
-                udelay(KB_DISCHARGE_DELAY);
-
-                tosakbd_activate_col(col);
-                udelay(KB_ACTIVATE_DELAY);
-
-                rowd = GET_ROWS_STATUS(col);
-
-                for (row = 0; row < TOSA_KEY_SENSE_NUM; row++) {
-                        unsigned int scancode, pressed;
-                        scancode = SCANCODE(row, col);
-                        pressed = rowd & KB_ROWMASK(row);
-
-                        if (pressed && !tosakbd->keycode[scancode])
-                                dev_warn(&dev->dev,
-                                                "unhandled scancode: 0x%02x\n",
-                                                scancode);
-
-                        input_report_key(tosakbd->input,
-                                        tosakbd->keycode[scancode],
-                                        pressed);
-                        if (pressed)
-                                num_pressed++;
-                }
-
-                tosakbd_reset_col(col);
-        }
-
-        tosakbd_activate_all();
-
-        input_sync(tosakbd->input);
-
-        /* if any keys are pressed, enable the timer */
-        if (num_pressed)
-                mod_timer(&tosakbd->timer, jiffies + SCAN_INTERVAL);
-
- out:
-        spin_unlock_irqrestore(&tosakbd->lock, flags);
-}
-
-/*
- * tosa keyboard interrupt handler.
- */
-static irqreturn_t tosakbd_interrupt(int irq, void *__dev)
-{
-        struct platform_device *dev = __dev;
-        struct tosakbd *tosakbd = platform_get_drvdata(dev);
-
-        if (!timer_pending(&tosakbd->timer)) {
-                /** wait chattering delay **/
-                udelay(20);
-                tosakbd_scankeyboard(dev);
-        }
-
-        return IRQ_HANDLED;
-}
-
-/*
- * tosa timer checking for released keys
- */
-static void tosakbd_timer_callback(unsigned long __dev)
-{
-        struct platform_device *dev = (struct platform_device *)__dev;
-
-        tosakbd_scankeyboard(dev);
-}
-
-#ifdef CONFIG_PM
-static int tosakbd_suspend(struct platform_device *dev, pm_message_t state)
-{
-        struct tosakbd *tosakbd = platform_get_drvdata(dev);
-        unsigned long flags;
-
-        spin_lock_irqsave(&tosakbd->lock, flags);
-        tosakbd->suspended = true;
-        spin_unlock_irqrestore(&tosakbd->lock, flags);
-
-        del_timer_sync(&tosakbd->timer);
-
-        return 0;
-}
-
-static int tosakbd_resume(struct platform_device *dev)
-{
-        struct tosakbd *tosakbd = platform_get_drvdata(dev);
-
-        tosakbd->suspended = false;
-        tosakbd_scankeyboard(dev);
-
-        return 0;
-}
-#else
-#define tosakbd_suspend         NULL
-#define tosakbd_resume          NULL
-#endif
-
-static int __devinit tosakbd_probe(struct platform_device *pdev) {
-
-        int i;
-        struct tosakbd *tosakbd;
-        struct input_dev *input_dev;
-        int error;
-
-        tosakbd = kzalloc(sizeof(struct tosakbd), GFP_KERNEL);
-        if (!tosakbd)
-                return -ENOMEM;
-
-        input_dev = input_allocate_device();
-        if (!input_dev) {
-                kfree(tosakbd);
-                return -ENOMEM;
-        }
-
-        platform_set_drvdata(pdev, tosakbd);
-
-        spin_lock_init(&tosakbd->lock);
-
-        /* Init Keyboard rescan timer */
-        init_timer(&tosakbd->timer);
-        tosakbd->timer.function = tosakbd_timer_callback;
-        tosakbd->timer.data = (unsigned long) pdev;
-
-        tosakbd->input = input_dev;
-
-        input_set_drvdata(input_dev, tosakbd);
-        input_dev->name = "Tosa Keyboard";
-        input_dev->phys = "tosakbd/input0";
-        input_dev->dev.parent = &pdev->dev;
-
-        input_dev->id.bustype = BUS_HOST;
-        input_dev->id.vendor = 0x0001;
-        input_dev->id.product = 0x0001;
-        input_dev->id.version = 0x0100;
-
-        input_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_REP);
-        input_dev->keycode = tosakbd->keycode;
-        input_dev->keycodesize = sizeof(tosakbd->keycode[0]);
-        input_dev->keycodemax = ARRAY_SIZE(tosakbd_keycode);
-
-        memcpy(tosakbd->keycode, tosakbd_keycode, sizeof(tosakbd_keycode));
-
-        for (i = 0; i < ARRAY_SIZE(tosakbd_keycode); i++)
-                __set_bit(tosakbd->keycode[i], input_dev->keybit);
-        __clear_bit(KEY_RESERVED, input_dev->keybit);
-
-        /* Setup sense interrupts - RisingEdge Detect, sense lines as inputs */
-        for (i = 0; i < TOSA_KEY_SENSE_NUM; i++) {
-                int gpio = TOSA_GPIO_KEY_SENSE(i);
-                int irq;
-                error = gpio_request(gpio, "tosakbd");
-                if (error < 0) {
-                        printk(KERN_ERR "tosakbd: failed to request GPIO %d, "
-                                " error %d\n", gpio, error);
-                        goto fail;
-                }
-
-                error = gpio_direction_input(TOSA_GPIO_KEY_SENSE(i));
-                if (error < 0) {
-                        printk(KERN_ERR "tosakbd: failed to configure input"
-                                " direction for GPIO %d, error %d\n",
-                                gpio, error);
-                        gpio_free(gpio);
-                        goto fail;
-                }
-
-                irq = gpio_to_irq(gpio);
-                if (irq < 0) {
-                        error = irq;
-                        printk(KERN_ERR "gpio-keys: Unable to get irq number"
-                                " for GPIO %d, error %d\n",
-                                gpio, error);
-                        gpio_free(gpio);
-                        goto fail;
-                }
-
-                error = request_irq(irq, tosakbd_interrupt,
-                                        IRQF_DISABLED | IRQF_TRIGGER_RISING,
-                                        "tosakbd", pdev);
-
-                if (error) {
-                        printk("tosakbd: Can't get IRQ: %d: error %d!\n",
-                                        irq, error);
-                        gpio_free(gpio);
-                        goto fail;
-                }
-        }
-
-        /* Set Strobe lines as outputs - set high */
-        for (i = 0; i < TOSA_KEY_STROBE_NUM; i++) {
-                int gpio = TOSA_GPIO_KEY_STROBE(i);
-                error = gpio_request(gpio, "tosakbd");
-                if (error < 0) {
-                        printk(KERN_ERR "tosakbd: failed to request GPIO %d, "
-                                " error %d\n", gpio, error);
-                        goto fail2;
-                }
-
-                error = gpio_direction_output(gpio, 1);
-                if (error < 0) {
-                        printk(KERN_ERR "tosakbd: failed to configure input"
-                                " direction for GPIO %d, error %d\n",
-                                gpio, error);
-                        gpio_free(gpio);
-                        goto fail2;
-                }
-
-        }
-
-        error = input_register_device(input_dev);
-        if (error) {
-                printk(KERN_ERR "tosakbd: Unable to register input device, "
-                        "error: %d\n", error);
-                goto fail2;
-        }
-
-        printk(KERN_INFO "input: Tosa Keyboard Registered\n");
-
-        return 0;
-
-fail2:
-        while (--i >= 0)
-                gpio_free(TOSA_GPIO_KEY_STROBE(i));
-
-        i = TOSA_KEY_SENSE_NUM;
-fail:
-        while (--i >= 0) {
-                free_irq(gpio_to_irq(TOSA_GPIO_KEY_SENSE(i)), pdev);
-                gpio_free(TOSA_GPIO_KEY_SENSE(i));
-        }
-
-        platform_set_drvdata(pdev, NULL);
-        input_free_device(input_dev);
-        kfree(tosakbd);
-
-        return error;
-}
-
-static int __devexit tosakbd_remove(struct platform_device *dev)
-{
-        int i;
-        struct tosakbd *tosakbd = platform_get_drvdata(dev);
-
-        for (i = 0; i < TOSA_KEY_STROBE_NUM; i++)
-                gpio_free(TOSA_GPIO_KEY_STROBE(i));
-
-        for (i = 0; i < TOSA_KEY_SENSE_NUM; i++) {
-                free_irq(gpio_to_irq(TOSA_GPIO_KEY_SENSE(i)), dev);
-                gpio_free(TOSA_GPIO_KEY_SENSE(i));
-        }
-
-        del_timer_sync(&tosakbd->timer);
-
-        input_unregister_device(tosakbd->input);
-
-        kfree(tosakbd);
-
-        return 0;
-}
-
-static struct platform_driver tosakbd_driver = {
-        .probe          = tosakbd_probe,
-        .remove         = __devexit_p(tosakbd_remove),
-        .suspend        = tosakbd_suspend,
-        .resume         = tosakbd_resume,
-        .driver         = {
-                .name   = "tosa-keyboard",
-                .owner  = THIS_MODULE,
-        },
-};
-
-static int __devinit tosakbd_init(void)
-{
-        return platform_driver_register(&tosakbd_driver);
-}
-
-static void __exit tosakbd_exit(void)
-{
-        platform_driver_unregister(&tosakbd_driver);
-}
-
-module_init(tosakbd_init);
-module_exit(tosakbd_exit);
-
-MODULE_AUTHOR("Dirk Opfer <Dirk@Opfer-Online.de>");
-MODULE_DESCRIPTION("Tosa Keyboard Driver");
-MODULE_LICENSE("GPL v2");
-MODULE_ALIAS("platform:tosa-keyboard");
diff --git a/drivers/input/keyboard/twl4030_keypad.c b/drivers/input/keyboard/twl4030_keypad.c
index 21d6184efa96..09bef79d9da1 100644
--- a/drivers/input/keyboard/twl4030_keypad.c
+++ b/drivers/input/keyboard/twl4030_keypad.c
@@ -32,6 +32,7 @@
 #include <linux/input.h>
 #include <linux/platform_device.h>
 #include <linux/i2c/twl.h>
+#include <linux/slab.h>
 
 
 /*
@@ -50,8 +51,12 @@
  */
 #define TWL4030_MAX_ROWS        8       /* TWL4030 hard limit */
 #define TWL4030_MAX_COLS        8
-#define TWL4030_ROW_SHIFT       3
-#define TWL4030_KEYMAP_SIZE     (TWL4030_MAX_ROWS * TWL4030_MAX_COLS)
+/*
+ * Note that we add space for an extra column so that we can handle
+ * row lines connected to the gnd (see twl4030_col_xlate()).
+ */
+#define TWL4030_ROW_SHIFT       4
+#define TWL4030_KEYMAP_SIZE     (TWL4030_MAX_ROWS << TWL4030_ROW_SHIFT)
 
 struct twl4030_keypad {
         unsigned short  keymap[TWL4030_KEYMAP_SIZE];
@@ -181,7 +186,7 @@ static int twl4030_read_kp_matrix_state(struct twl4030_keypad *kp, u16 *state)
         return ret;
 }
 
-static int twl4030_is_in_ghost_state(struct twl4030_keypad *kp, u16 *key_state)
+static bool twl4030_is_in_ghost_state(struct twl4030_keypad *kp, u16 *key_state)
 {
         int i;
         u16 check = 0;
@@ -190,12 +195,12 @@ static int twl4030_is_in_ghost_state(struct twl4030_keypad *kp, u16 *key_state)
                 u16 col = key_state[i];
 
                 if ((col & check) && hweight16(col) > 1)
-                        return 1;
+                        return true;
 
                 check |= col;
         }
 
-        return 0;
+        return false;
 }
 
 static void twl4030_kp_scan(struct twl4030_keypad *kp, bool release_all)
@@ -224,7 +229,8 @@ static void twl4030_kp_scan(struct twl4030_keypad *kp, bool release_all)
                 if (!changed)
                         continue;
 
-                for (col = 0; col < kp->n_cols; col++) {
+                /* Extra column handles "all gnd" rows */
+                for (col = 0; col < kp->n_cols + 1; col++) {
                         int code;
 
                         if (!(changed & (1 << col)))
@@ -400,23 +406,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/keyboard/w90p910_keypad.c b/drivers/input/keyboard/w90p910_keypad.c
index 6032def03707..ee2bf6bcf291 100644
--- a/drivers/input/keyboard/w90p910_keypad.c
+++ b/drivers/input/keyboard/w90p910_keypad.c
@@ -19,6 +19,7 @@
 #include <linux/clk.h>
 #include <linux/err.h>
 #include <linux/io.h>
+#include <linux/slab.h>
 
 #include <mach/w90p910_keypad.h>
 
@@ -257,7 +258,7 @@ static struct platform_driver w90p910_keypad_driver = {
         .probe          = w90p910_keypad_probe,
         .remove         = __devexit_p(w90p910_keypad_remove),
         .driver         = {
-                .name   = "nuc900-keypad",
+                .name   = "nuc900-kpi",
                 .owner  = THIS_MODULE,
         },
 };
diff --git a/drivers/input/misc/88pm860x_onkey.c b/drivers/input/misc/88pm860x_onkey.c
new file mode 100644
index 000000000000..4cc82826ea6b
--- /dev/null
+++ b/drivers/input/misc/88pm860x_onkey.c
@@ -0,0 +1,155 @@
+/*
+ * 88pm860x_onkey.c - Marvell 88PM860x ONKEY driver
+ *
+ * Copyright (C) 2009-2010 Marvell International Ltd.
+ *      Haojian Zhuang <haojian.zhuang@marvell.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 more details.
+ *
+ * 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/platform_device.h>
+#include <linux/i2c.h>
+#include <linux/input.h>
+#include <linux/interrupt.h>
+#include <linux/mfd/88pm860x.h>
+#include <linux/slab.h>
+
+#define PM8607_WAKEUP           0x0b
+
+#define LONG_ONKEY_EN           (1 << 1)
+#define ONKEY_STATUS            (1 << 0)
+
+struct pm860x_onkey_info {
+        struct input_dev        *idev;
+        struct pm860x_chip      *chip;
+        struct i2c_client       *i2c;
+        struct device           *dev;
+        int                     irq;
+};
+
+/* 88PM860x gives us an interrupt when ONKEY is held */
+static irqreturn_t pm860x_onkey_handler(int irq, void *data)
+{
+        struct pm860x_onkey_info *info = data;
+        int ret;
+
+        ret = pm860x_reg_read(info->i2c, PM8607_STATUS_2);
+        ret &= ONKEY_STATUS;
+        input_report_key(info->idev, KEY_POWER, ret);
+        input_sync(info->idev);
+
+        /* Enable 8-second long onkey detection */
+        pm860x_set_bits(info->i2c, PM8607_WAKEUP, 3, LONG_ONKEY_EN);
+        return IRQ_HANDLED;
+}
+
+static int __devinit pm860x_onkey_probe(struct platform_device *pdev)
+{
+        struct pm860x_chip *chip = dev_get_drvdata(pdev->dev.parent);
+        struct pm860x_onkey_info *info;
+        int irq, ret;
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0) {
+                dev_err(&pdev->dev, "No IRQ resource!\n");
+                return -EINVAL;
+        }
+
+        info = kzalloc(sizeof(struct pm860x_onkey_info), GFP_KERNEL);
+        if (!info)
+                return -ENOMEM;
+        info->chip = chip;
+        info->i2c = (chip->id == CHIP_PM8607) ? chip->client : chip->companion;
+        info->dev = &pdev->dev;
+        info->irq = irq + chip->irq_base;
+
+        info->idev = input_allocate_device();
+        if (!info->idev) {
+                dev_err(chip->dev, "Failed to allocate input dev\n");
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        info->idev->name = "88pm860x_on";
+        info->idev->phys = "88pm860x_on/input0";
+        info->idev->id.bustype = BUS_I2C;
+        info->idev->dev.parent = &pdev->dev;
+        info->idev->evbit[0] = BIT_MASK(EV_KEY);
+        info->idev->keybit[BIT_WORD(KEY_POWER)] = BIT_MASK(KEY_POWER);
+
+        ret = input_register_device(info->idev);
+        if (ret) {
+                dev_err(chip->dev, "Can't register input device: %d\n", ret);
+                goto out_reg;
+        }
+
+        ret = request_threaded_irq(info->irq, NULL, pm860x_onkey_handler,
+                                   IRQF_ONESHOT, "onkey", info);
+        if (ret < 0) {
+                dev_err(chip->dev, "Failed to request IRQ: #%d: %d\n",
+                        info->irq, ret);
+                goto out_irq;
+        }
+
+        platform_set_drvdata(pdev, info);
+        return 0;
+
+out_irq:
+        input_unregister_device(info->idev);
+        kfree(info);
+        return ret;
+
+out_reg:
+        input_free_device(info->idev);
+out:
+        kfree(info);
+        return ret;
+}
+
+static int __devexit pm860x_onkey_remove(struct platform_device *pdev)
+{
+        struct pm860x_onkey_info *info = platform_get_drvdata(pdev);
+
+        free_irq(info->irq, info);
+        input_unregister_device(info->idev);
+        kfree(info);
+        return 0;
+}
+
+static struct platform_driver pm860x_onkey_driver = {
+        .driver         = {
+                .name   = "88pm860x-onkey",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = pm860x_onkey_probe,
+        .remove         = __devexit_p(pm860x_onkey_remove),
+};
+
+static int __init pm860x_onkey_init(void)
+{
+        return platform_driver_register(&pm860x_onkey_driver);
+}
+module_init(pm860x_onkey_init);
+
+static void __exit pm860x_onkey_exit(void)
+{
+        platform_driver_unregister(&pm860x_onkey_driver);
+}
+module_exit(pm860x_onkey_exit);
+
+MODULE_DESCRIPTION("Marvell 88PM860x ONKEY driver");
+MODULE_AUTHOR("Haojian Zhuang <haojian.zhuang@marvell.com>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/misc/Kconfig b/drivers/input/misc/Kconfig
index 16ec5233441c..b99b8cbde02f 100644
--- a/drivers/input/misc/Kconfig
+++ b/drivers/input/misc/Kconfig
@@ -12,6 +12,56 @@ menuconfig INPUT_MISC
 
 if INPUT_MISC
 
+config INPUT_88PM860X_ONKEY
+        tristate "88PM860x ONKEY support"
+        depends on MFD_88PM860X
+        help
+          Support the ONKEY of Marvell 88PM860x PMICs as an input device
+          reporting power button status.
+
+          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
+          Say Y here if you want to support an AD7142/3/7/8/7A touch sensor.
+
+          You should select a bus connection too.
+
+          To compile this driver as a module, choose M here: the
+          module will be called ad714x.
+
+config INPUT_AD714X_I2C
+        tristate "support I2C bus connection"
+        depends on INPUT_AD714X && I2C
+        default y
+        help
+          Say Y here if you have AD7142/AD7147 hooked to an I2C bus.
+
+          To compile this driver as a module, choose M here: the
+          module will be called ad714x-i2c.
+
+config INPUT_AD714X_SPI
+        tristate "support SPI bus connection"
+        depends on INPUT_AD714X && SPI
+        default y
+        help
+          Say Y here if you have AD7142/AD7147 hooked to a SPI bus.
+
+          To compile this driver as a module, choose M here: the
+          module will be called ad714x-spi.
+
 config INPUT_PCSPKR
         tristate "PC Speaker support"
         depends on PCSPKR_PLATFORM
@@ -40,6 +90,16 @@ config INPUT_M68K_BEEP
         tristate "M68k Beeper support"
         depends on M68K
 
+config INPUT_MAX8925_ONKEY
+        tristate "MAX8925 ONKEY support"
+        depends on MFD_MAX8925
+        help
+          Support the ONKEY of MAX8925 PMICs as an input device
+          reporting power button status.
+
+          To compile this driver as a module, choose M here: the module
+          will be called max8925_onkey.
+
 config INPUT_APANEL
         tristate "Fujitsu Lifebook Application Panel buttons"
         depends on X86 && I2C && LEDS_CLASS
@@ -204,6 +264,17 @@ config INPUT_TWL4030_PWRBUTTON
           To compile this driver as a module, choose M here. The module will
           be called twl4030_pwrbutton.
 
+config INPUT_TWL4030_VIBRA
+        tristate "Support for TWL4030 Vibrator"
+        depends on TWL4030_CORE
+        select TWL4030_CODEC
+        select INPUT_FF_MEMLESS
+        help
+          This option enables support for TWL4030 Vibrator Driver.
+
+          To compile this driver as a module, choose M here. The module will
+          be called twl4030_vibra.
+
 config INPUT_UINPUT
         tristate "User level driver support"
         help
@@ -256,6 +327,27 @@ config INPUT_PCF50633_PMU
          Say Y to include support for delivering  PMU events via  input
          layer on NXP PCF50633.
 
+config INPUT_PCF8574
+        tristate "PCF8574 Keypad input device"
+        depends on I2C && EXPERIMENTAL
+        help
+          Say Y here if you want to support a keypad connetced via I2C
+          with a PCF8574.
+
+          To compile this driver as a module, choose M here: the
+          module will be called pcf8574_keypad.
+
+config INPUT_PWM_BEEPER
+        tristate "PWM beeper support"
+        depends on HAVE_PWM
+        help
+          Say Y here to get support for PWM based beeper devices.
+
+          If unsure, say N.
+
+          To compile this driver as a module, choose M here: the module will be
+          called pwm-beeper.
+
 config INPUT_GPIO_ROTARY_ENCODER
         tristate "Rotary encoders connected to GPIO pins"
         depends on GPIOLIB && GENERIC_GPIO
@@ -319,4 +411,41 @@ config INPUT_PCAP
           To compile this driver as a module, choose M here: the
           module will be called pcap_keys.
 
+config INPUT_ADXL34X
+        tristate "Analog Devices ADXL34x Three-Axis Digital Accelerometer"
+        default n
+        help
+          Say Y here if you have a Accelerometer interface using the
+          ADXL345/6 controller, and your board-specific initialization
+          code includes that in its table of devices.
+
+          This driver can use either I2C or SPI communication to the
+          ADXL345/6 controller.  Select the appropriate method for
+          your system.
+
+          If unsure, say N (but it's safe to say "Y").
+
+          To compile this driver as a module, choose M here: the
+          module will be called adxl34x.
+
+config INPUT_ADXL34X_I2C
+        tristate "support I2C bus connection"
+        depends on INPUT_ADXL34X && I2C
+        default y
+        help
+          Say Y here if you have ADXL345/6 hooked to an I2C bus.
+
+          To compile this driver as a module, choose M here: the
+          module will be called adxl34x-i2c.
+
+config INPUT_ADXL34X_SPI
+        tristate "support SPI bus connection"
+        depends on INPUT_ADXL34X && SPI
+        default y
+        help
+          Say Y here if you have ADXL345/6 hooked to a SPI bus.
+
+          To compile this driver as a module, choose M here: the
+          module will be called adxl34x-spi.
+
 endif
diff --git a/drivers/input/misc/Makefile b/drivers/input/misc/Makefile
index a8b84854fb7b..1fe1f6c8b737 100644
--- a/drivers/input/misc/Makefile
+++ b/drivers/input/misc/Makefile
@@ -4,6 +4,14 @@
 
 # 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
+obj-$(CONFIG_INPUT_ADXL34X)             += adxl34x.o
+obj-$(CONFIG_INPUT_ADXL34X_I2C)         += adxl34x-i2c.o
+obj-$(CONFIG_INPUT_ADXL34X_SPI)         += adxl34x-spi.o
 obj-$(CONFIG_INPUT_APANEL)              += apanel.o
 obj-$(CONFIG_INPUT_ATI_REMOTE)          += ati_remote.o
 obj-$(CONFIG_INPUT_ATI_REMOTE2)         += ati_remote2.o
@@ -16,15 +24,19 @@ obj-$(CONFIG_HP_SDC_RTC)		+= hp_sdc_rtc.o
 obj-$(CONFIG_INPUT_IXP4XX_BEEPER)       += ixp4xx-beeper.o
 obj-$(CONFIG_INPUT_KEYSPAN_REMOTE)      += keyspan_remote.o
 obj-$(CONFIG_INPUT_M68K_BEEP)           += m68kspkr.o
+obj-$(CONFIG_INPUT_MAX8925_ONKEY)       += max8925_onkey.o
 obj-$(CONFIG_INPUT_PCAP)                += pcap_keys.o
 obj-$(CONFIG_INPUT_PCF50633_PMU)        += pcf50633-input.o
+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_RB532_BUTTON)        += rb532_button.o
 obj-$(CONFIG_INPUT_GPIO_ROTARY_ENCODER) += rotary_encoder.o
 obj-$(CONFIG_INPUT_SGI_BTNS)            += sgi_btns.o
 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
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
new file mode 100644
index 000000000000..2bef8fa56c94
--- /dev/null
+++ b/drivers/input/misc/ad714x-i2c.c
@@ -0,0 +1,139 @@
+/*
+ * AD714X CapTouch Programmable Controller driver (I2C bus)
+ *
+ * Copyright 2009 Analog Devices Inc.
+ *
+ * Licensed under the GPL-2 or later.
+ */
+
+#include <linux/input.h>        /* BUS_I2C */
+#include <linux/i2c.h>
+#include <linux/module.h>
+#include <linux/types.h>
+#include "ad714x.h"
+
+#ifdef CONFIG_PM
+static int ad714x_i2c_suspend(struct i2c_client *client, pm_message_t message)
+{
+        return ad714x_disable(i2c_get_clientdata(client));
+}
+
+static int ad714x_i2c_resume(struct i2c_client *client)
+{
+        return ad714x_enable(i2c_get_clientdata(client));
+}
+#else
+# define ad714x_i2c_suspend NULL
+# define ad714x_i2c_resume  NULL
+#endif
+
+static int ad714x_i2c_write(struct device *dev, unsigned short reg,
+                                unsigned short data)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        int ret = 0;
+        u8 *_reg = (u8 *)&reg;
+        u8 *_data = (u8 *)&data;
+
+        u8 tx[4] = {
+                _reg[1],
+                _reg[0],
+                _data[1],
+                _data[0]
+        };
+
+        ret = i2c_master_send(client, tx, 4);
+        if (ret < 0)
+                dev_err(&client->dev, "I2C write error\n");
+
+        return ret;
+}
+
+static int ad714x_i2c_read(struct device *dev, unsigned short reg,
+                                unsigned short *data)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        int ret = 0;
+        u8 *_reg = (u8 *)&reg;
+        u8 *_data = (u8 *)data;
+
+        u8 tx[2] = {
+                _reg[1],
+                _reg[0]
+        };
+        u8 rx[2];
+
+        ret = i2c_master_send(client, tx, 2);
+        if (ret >= 0)
+                ret = i2c_master_recv(client, rx, 2);
+
+        if (unlikely(ret < 0)) {
+                dev_err(&client->dev, "I2C read error\n");
+        } else {
+                _data[0] = rx[1];
+                _data[1] = rx[0];
+        }
+
+        return ret;
+}
+
+static int __devinit ad714x_i2c_probe(struct i2c_client *client,
+                                        const struct i2c_device_id *id)
+{
+        struct ad714x_chip *chip;
+
+        chip = ad714x_probe(&client->dev, BUS_I2C, client->irq,
+                            ad714x_i2c_read, ad714x_i2c_write);
+        if (IS_ERR(chip))
+                return PTR_ERR(chip);
+
+        i2c_set_clientdata(client, chip);
+
+        return 0;
+}
+
+static int __devexit ad714x_i2c_remove(struct i2c_client *client)
+{
+        struct ad714x_chip *chip = i2c_get_clientdata(client);
+
+        ad714x_remove(chip);
+
+        return 0;
+}
+
+static const struct i2c_device_id ad714x_id[] = {
+        { "ad7142_captouch", 0 },
+        { "ad7143_captouch", 0 },
+        { "ad7147_captouch", 0 },
+        { "ad7147a_captouch", 0 },
+        { "ad7148_captouch", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, ad714x_id);
+
+static struct i2c_driver ad714x_i2c_driver = {
+        .driver = {
+                .name = "ad714x_captouch",
+        },
+        .probe    = ad714x_i2c_probe,
+        .remove   = __devexit_p(ad714x_i2c_remove),
+        .suspend  = ad714x_i2c_suspend,
+        .resume   = ad714x_i2c_resume,
+        .id_table = ad714x_id,
+};
+
+static __init int ad714x_i2c_init(void)
+{
+        return i2c_add_driver(&ad714x_i2c_driver);
+}
+module_init(ad714x_i2c_init);
+
+static __exit void ad714x_i2c_exit(void)
+{
+        i2c_del_driver(&ad714x_i2c_driver);
+}
+module_exit(ad714x_i2c_exit);
+
+MODULE_DESCRIPTION("Analog Devices AD714X Capacitance Touch Sensor I2C Bus Driver");
+MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/misc/ad714x-spi.c b/drivers/input/misc/ad714x-spi.c
new file mode 100644
index 000000000000..7f8dedfd1bfe
--- /dev/null
+++ b/drivers/input/misc/ad714x-spi.c
@@ -0,0 +1,103 @@
+/*
+ * AD714X CapTouch Programmable Controller driver (SPI bus)
+ *
+ * Copyright 2009 Analog Devices Inc.
+ *
+ * Licensed under the GPL-2 or later.
+ */
+
+#include <linux/input.h>        /* BUS_I2C */
+#include <linux/module.h>
+#include <linux/spi/spi.h>
+#include <linux/types.h>
+#include "ad714x.h"
+
+#define AD714x_SPI_CMD_PREFIX      0xE000   /* bits 15:11 */
+#define AD714x_SPI_READ            BIT(10)
+
+#ifdef CONFIG_PM
+static int ad714x_spi_suspend(struct spi_device *spi, pm_message_t message)
+{
+        return ad714x_disable(spi_get_drvdata(spi));
+}
+
+static int ad714x_spi_resume(struct spi_device *spi)
+{
+        return ad714x_enable(spi_get_drvdata(spi));
+}
+#else
+# define ad714x_spi_suspend NULL
+# define ad714x_spi_resume  NULL
+#endif
+
+static int ad714x_spi_read(struct device *dev, unsigned short reg,
+                unsigned short *data)
+{
+        struct spi_device *spi = to_spi_device(dev);
+        unsigned short tx = AD714x_SPI_CMD_PREFIX | AD714x_SPI_READ | reg;
+
+        return spi_write_then_read(spi, (u8 *)&tx, 2, (u8 *)data, 2);
+}
+
+static int ad714x_spi_write(struct device *dev, unsigned short reg,
+                unsigned short data)
+{
+        struct spi_device *spi = to_spi_device(dev);
+        unsigned short tx[2] = {
+                AD714x_SPI_CMD_PREFIX | reg,
+                data
+        };
+
+        return spi_write(spi, (u8 *)tx, 4);
+}
+
+static int __devinit ad714x_spi_probe(struct spi_device *spi)
+{
+        struct ad714x_chip *chip;
+
+        chip = ad714x_probe(&spi->dev, BUS_SPI, spi->irq,
+                            ad714x_spi_read, ad714x_spi_write);
+        if (IS_ERR(chip))
+                return PTR_ERR(chip);
+
+        spi_set_drvdata(spi, chip);
+
+        return 0;
+}
+
+static int __devexit ad714x_spi_remove(struct spi_device *spi)
+{
+        struct ad714x_chip *chip = spi_get_drvdata(spi);
+
+        ad714x_remove(chip);
+        spi_set_drvdata(spi, NULL);
+
+        return 0;
+}
+
+static struct spi_driver ad714x_spi_driver = {
+        .driver = {
+                .name   = "ad714x_captouch",
+                .owner  = THIS_MODULE,
+        },
+        .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)
+{
+        return spi_register_driver(&ad714x_spi_driver);
+}
+module_init(ad714x_spi_init);
+
+static __exit void ad714x_spi_exit(void)
+{
+        spi_unregister_driver(&ad714x_spi_driver);
+}
+module_exit(ad714x_spi_exit);
+
+MODULE_DESCRIPTION("Analog Devices AD714X Capacitance Touch Sensor SPI Bus Driver");
+MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/misc/ad714x.c b/drivers/input/misc/ad714x.c
new file mode 100644
index 000000000000..c431d09e401a
--- /dev/null
+++ b/drivers/input/misc/ad714x.c
@@ -0,0 +1,1347 @@
+/*
+ * AD714X CapTouch Programmable Controller driver supporting AD7142/3/7/8/7A
+ *
+ * Copyright 2009 Analog Devices Inc.
+ *
+ * Licensed under the GPL-2 or later.
+ */
+
+#include <linux/device.h>
+#include <linux/init.h>
+#include <linux/input.h>
+#include <linux/interrupt.h>
+#include <linux/slab.h>
+#include <linux/input/ad714x.h>
+#include "ad714x.h"
+
+#define AD714X_PWR_CTRL           0x0
+#define AD714X_STG_CAL_EN_REG     0x1
+#define AD714X_AMB_COMP_CTRL0_REG 0x2
+#define AD714X_PARTID_REG         0x17
+#define AD7142_PARTID             0xE620
+#define AD7143_PARTID             0xE630
+#define AD7147_PARTID             0x1470
+#define AD7148_PARTID             0x1480
+#define AD714X_STAGECFG_REG       0x80
+#define AD714X_SYSCFG_REG         0x0
+
+#define STG_LOW_INT_EN_REG     0x5
+#define STG_HIGH_INT_EN_REG    0x6
+#define STG_COM_INT_EN_REG     0x7
+#define STG_LOW_INT_STA_REG    0x8
+#define STG_HIGH_INT_STA_REG   0x9
+#define STG_COM_INT_STA_REG    0xA
+
+#define CDC_RESULT_S0          0xB
+#define CDC_RESULT_S1          0xC
+#define CDC_RESULT_S2          0xD
+#define CDC_RESULT_S3          0xE
+#define CDC_RESULT_S4          0xF
+#define CDC_RESULT_S5          0x10
+#define CDC_RESULT_S6          0x11
+#define CDC_RESULT_S7          0x12
+#define CDC_RESULT_S8          0x13
+#define CDC_RESULT_S9          0x14
+#define CDC_RESULT_S10         0x15
+#define CDC_RESULT_S11         0x16
+
+#define STAGE0_AMBIENT          0xF1
+#define STAGE1_AMBIENT          0x115
+#define STAGE2_AMBIENT          0x139
+#define STAGE3_AMBIENT          0x15D
+#define STAGE4_AMBIENT          0x181
+#define STAGE5_AMBIENT          0x1A5
+#define STAGE6_AMBIENT          0x1C9
+#define STAGE7_AMBIENT          0x1ED
+#define STAGE8_AMBIENT          0x211
+#define STAGE9_AMBIENT          0x234
+#define STAGE10_AMBIENT         0x259
+#define STAGE11_AMBIENT         0x27D
+
+#define PER_STAGE_REG_NUM      36
+#define STAGE_NUM              12
+#define STAGE_CFGREG_NUM       8
+#define SYS_CFGREG_NUM         8
+
+/*
+ * driver information which will be used to maintain the software flow
+ */
+enum ad714x_device_state { IDLE, JITTER, ACTIVE, SPACE };
+
+struct ad714x_slider_drv {
+        int highest_stage;
+        int abs_pos;
+        int flt_pos;
+        enum ad714x_device_state state;
+        struct input_dev *input;
+};
+
+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;
+};
+
+struct ad714x_touchpad_drv {
+        int x_highest_stage;
+        int x_flt_pos;
+        int x_abs_pos;
+        int y_highest_stage;
+        int y_flt_pos;
+        int y_abs_pos;
+        int left_ep;
+        int left_ep_val;
+        int right_ep;
+        int right_ep_val;
+        int top_ep;
+        int top_ep_val;
+        int bottom_ep;
+        int bottom_ep_val;
+        enum ad714x_device_state state;
+        struct input_dev *input;
+};
+
+struct ad714x_button_drv {
+        enum ad714x_device_state state;
+        /*
+         * Unlike slider/wheel/touchpad, all buttons point to
+         * same input_dev instance
+         */
+        struct input_dev *input;
+};
+
+struct ad714x_driver_data {
+        struct ad714x_slider_drv *slider;
+        struct ad714x_wheel_drv *wheel;
+        struct ad714x_touchpad_drv *touchpad;
+        struct ad714x_button_drv *button;
+};
+
+/*
+ * information to integrate all things which will be private data
+ * of spi/i2c device
+ */
+struct ad714x_chip {
+        unsigned short h_state;
+        unsigned short l_state;
+        unsigned short c_state;
+        unsigned short adc_reg[STAGE_NUM];
+        unsigned short amb_reg[STAGE_NUM];
+        unsigned short sensor_val[STAGE_NUM];
+
+        struct ad714x_platform_data *hw;
+        struct ad714x_driver_data *sw;
+
+        int irq;
+        struct device *dev;
+        ad714x_read_t read;
+        ad714x_write_t write;
+
+        struct mutex mutex;
+
+        unsigned product;
+        unsigned version;
+};
+
+static void ad714x_use_com_int(struct ad714x_chip *ad714x,
+                                int start_stage, int end_stage)
+{
+        unsigned short data;
+        unsigned short mask;
+
+        mask = ((1 << (end_stage + 1)) - 1) - (1 << start_stage);
+
+        ad714x->read(ad714x->dev, STG_COM_INT_EN_REG, &data);
+        data |= 1 << start_stage;
+        ad714x->write(ad714x->dev, STG_COM_INT_EN_REG, data);
+
+        ad714x->read(ad714x->dev, STG_HIGH_INT_EN_REG, &data);
+        data &= ~mask;
+        ad714x->write(ad714x->dev, STG_HIGH_INT_EN_REG, data);
+}
+
+static void ad714x_use_thr_int(struct ad714x_chip *ad714x,
+                                int start_stage, int end_stage)
+{
+        unsigned short data;
+        unsigned short mask;
+
+        mask = ((1 << (end_stage + 1)) - 1) - (1 << start_stage);
+
+        ad714x->read(ad714x->dev, STG_COM_INT_EN_REG, &data);
+        data &= ~(1 << start_stage);
+        ad714x->write(ad714x->dev, STG_COM_INT_EN_REG, data);
+
+        ad714x->read(ad714x->dev, STG_HIGH_INT_EN_REG, &data);
+        data |= mask;
+        ad714x->write(ad714x->dev, STG_HIGH_INT_EN_REG, data);
+}
+
+static int ad714x_cal_highest_stage(struct ad714x_chip *ad714x,
+                                        int start_stage, int end_stage)
+{
+        int max_res = 0;
+        int max_idx = 0;
+        int i;
+
+        for (i = start_stage; i <= end_stage; i++) {
+                if (ad714x->sensor_val[i] > max_res) {
+                        max_res = ad714x->sensor_val[i];
+                        max_idx = i;
+                }
+        }
+
+        return max_idx;
+}
+
+static int ad714x_cal_abs_pos(struct ad714x_chip *ad714x,
+                                int start_stage, int end_stage,
+                                int highest_stage, int max_coord)
+{
+        int a_param, b_param;
+
+        if (highest_stage == start_stage) {
+                a_param = ad714x->sensor_val[start_stage + 1];
+                b_param = ad714x->sensor_val[start_stage] +
+                        ad714x->sensor_val[start_stage + 1];
+        } else if (highest_stage == end_stage) {
+                a_param = ad714x->sensor_val[end_stage] *
+                        (end_stage - start_stage) +
+                        ad714x->sensor_val[end_stage - 1] *
+                        (end_stage - start_stage - 1);
+                b_param = ad714x->sensor_val[end_stage] +
+                        ad714x->sensor_val[end_stage - 1];
+        } else {
+                a_param = ad714x->sensor_val[highest_stage] *
+                        (highest_stage - start_stage) +
+                        ad714x->sensor_val[highest_stage - 1] *
+                        (highest_stage - start_stage - 1) +
+                        ad714x->sensor_val[highest_stage + 1] *
+                        (highest_stage - start_stage + 1);
+                b_param = ad714x->sensor_val[highest_stage] +
+                        ad714x->sensor_val[highest_stage - 1] +
+                        ad714x->sensor_val[highest_stage + 1];
+        }
+
+        return (max_coord / (end_stage - start_stage)) * a_param / b_param;
+}
+
+/*
+ * One button can connect to multi positive and negative of CDCs
+ * Multi-buttons can connect to same positive/negative of one CDC
+ */
+static void ad714x_button_state_machine(struct ad714x_chip *ad714x, int idx)
+{
+        struct ad714x_button_plat *hw = &ad714x->hw->button[idx];
+        struct ad714x_button_drv *sw = &ad714x->sw->button[idx];
+
+        switch (sw->state) {
+        case IDLE:
+                if (((ad714x->h_state & hw->h_mask) == hw->h_mask) &&
+                    ((ad714x->l_state & hw->l_mask) == hw->l_mask)) {
+                        dev_dbg(ad714x->dev, "button %d touched\n", idx);
+                        input_report_key(sw->input, hw->keycode, 1);
+                        input_sync(sw->input);
+                        sw->state = ACTIVE;
+                }
+                break;
+
+        case ACTIVE:
+                if (((ad714x->h_state & hw->h_mask) != hw->h_mask) ||
+                    ((ad714x->l_state & hw->l_mask) != hw->l_mask)) {
+                        dev_dbg(ad714x->dev, "button %d released\n", idx);
+                        input_report_key(sw->input, hw->keycode, 0);
+                        input_sync(sw->input);
+                        sw->state = IDLE;
+                }
+                break;
+
+        default:
+                break;
+        }
+}
+
+/*
+ * The response of a sensor is defined by the absolute number of codes
+ * between the current CDC value and the ambient value.
+ */
+static void ad714x_slider_cal_sensor_val(struct ad714x_chip *ad714x, int idx)
+{
+        struct ad714x_slider_plat *hw = &ad714x->hw->slider[idx];
+        int i;
+
+        for (i = hw->start_stage; i <= hw->end_stage; i++) {
+                ad714x->read(ad714x->dev, CDC_RESULT_S0 + i,
+                        &ad714x->adc_reg[i]);
+                ad714x->read(ad714x->dev,
+                                STAGE0_AMBIENT + i * PER_STAGE_REG_NUM,
+                                &ad714x->amb_reg[i]);
+
+                ad714x->sensor_val[i] = abs(ad714x->adc_reg[i] -
+                                ad714x->amb_reg[i]);
+        }
+}
+
+static void ad714x_slider_cal_highest_stage(struct ad714x_chip *ad714x, int idx)
+{
+        struct ad714x_slider_plat *hw = &ad714x->hw->slider[idx];
+        struct ad714x_slider_drv *sw = &ad714x->sw->slider[idx];
+
+        sw->highest_stage = ad714x_cal_highest_stage(ad714x, hw->start_stage,
+                        hw->end_stage);
+
+        dev_dbg(ad714x->dev, "slider %d highest_stage:%d\n", idx,
+                sw->highest_stage);
+}
+
+/*
+ * The formulae are very straight forward. It uses the sensor with the
+ * highest response and the 2 adjacent ones.
+ * When Sensor 0 has the highest response, only sensor 0 and sensor 1
+ * are used in the calculations. Similarly when the last sensor has the
+ * highest response, only the last sensor and the second last sensors
+ * are used in the calculations.
+ *
+ * For i= idx_of_peak_Sensor-1 to i= idx_of_peak_Sensor+1
+ *         v += Sensor response(i)*i
+ *         w += Sensor response(i)
+ * POS=(Number_of_Positions_Wanted/(Number_of_Sensors_Used-1)) *(v/w)
+ */
+static void ad714x_slider_cal_abs_pos(struct ad714x_chip *ad714x, int idx)
+{
+        struct ad714x_slider_plat *hw = &ad714x->hw->slider[idx];
+        struct ad714x_slider_drv *sw = &ad714x->sw->slider[idx];
+
+        sw->abs_pos = ad714x_cal_abs_pos(ad714x, hw->start_stage, hw->end_stage,
+                sw->highest_stage, hw->max_coord);
+
+        dev_dbg(ad714x->dev, "slider %d absolute position:%d\n", idx,
+                sw->abs_pos);
+}
+
+/*
+ * To minimise the Impact of the noise on the algorithm, ADI developed a
+ * routine that filters the CDC results after they have been read by the
+ * host processor.
+ * The filter used is an Infinite Input Response(IIR) filter implemented
+ * in firmware and attenuates the noise on the CDC results after they've
+ * been read by the host processor.
+ * Filtered_CDC_result = (Filtered_CDC_result * (10 - Coefficient) +
+ *                              Latest_CDC_result * Coefficient)/10
+ */
+static void ad714x_slider_cal_flt_pos(struct ad714x_chip *ad714x, int idx)
+{
+        struct ad714x_slider_drv *sw = &ad714x->sw->slider[idx];
+
+        sw->flt_pos = (sw->flt_pos * (10 - 4) +
+                        sw->abs_pos * 4)/10;
+
+        dev_dbg(ad714x->dev, "slider %d filter position:%d\n", idx,
+                sw->flt_pos);
+}
+
+static void ad714x_slider_use_com_int(struct ad714x_chip *ad714x, int idx)
+{
+        struct ad714x_slider_plat *hw = &ad714x->hw->slider[idx];
+
+        ad714x_use_com_int(ad714x, hw->start_stage, hw->end_stage);
+}
+
+static void ad714x_slider_use_thr_int(struct ad714x_chip *ad714x, int idx)
+{
+        struct ad714x_slider_plat *hw = &ad714x->hw->slider[idx];
+
+        ad714x_use_thr_int(ad714x, hw->start_stage, hw->end_stage);
+}
+
+static void ad714x_slider_state_machine(struct ad714x_chip *ad714x, int idx)
+{
+        struct ad714x_slider_plat *hw = &ad714x->hw->slider[idx];
+        struct ad714x_slider_drv *sw = &ad714x->sw->slider[idx];
+        unsigned short h_state, c_state;
+        unsigned short mask;
+
+        mask = ((1 << (hw->end_stage + 1)) - 1) - ((1 << hw->start_stage) - 1);
+
+        h_state = ad714x->h_state & mask;
+        c_state = ad714x->c_state & mask;
+
+        switch (sw->state) {
+        case IDLE:
+                if (h_state) {
+                        sw->state = JITTER;
+                        /* In End of Conversion interrupt mode, the AD714X
+                         * continuously generates hardware interrupts.
+                         */
+                        ad714x_slider_use_com_int(ad714x, idx);
+                        dev_dbg(ad714x->dev, "slider %d touched\n", idx);
+                }
+                break;
+
+        case JITTER:
+                if (c_state == mask) {
+                        ad714x_slider_cal_sensor_val(ad714x, idx);
+                        ad714x_slider_cal_highest_stage(ad714x, idx);
+                        ad714x_slider_cal_abs_pos(ad714x, idx);
+                        sw->flt_pos = sw->abs_pos;
+                        sw->state = ACTIVE;
+                }
+                break;
+
+        case ACTIVE:
+                if (c_state == mask) {
+                        if (h_state) {
+                                ad714x_slider_cal_sensor_val(ad714x, 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 {
+                                /* When the user lifts off the sensor, configure
+                                 * the AD714X back to threshold interrupt mode.
+                                 */
+                                ad714x_slider_use_thr_int(ad714x, idx);
+                                sw->state = IDLE;
+                                input_report_key(sw->input, BTN_TOUCH, 0);
+                                dev_dbg(ad714x->dev, "slider %d released\n",
+                                        idx);
+                        }
+                        input_sync(sw->input);
+                }
+                break;
+
+        default:
+                break;
+        }
+}
+
+/*
+ * 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 with the highest response and we apply weights to these sensors.
+ */
+static void ad714x_wheel_cal_highest_stage(struct ad714x_chip *ad714x, int idx)
+{
+        struct ad714x_wheel_plat *hw = &ad714x->hw->wheel[idx];
+        struct ad714x_wheel_drv *sw = &ad714x->sw->wheel[idx];
+
+        sw->pre_highest_stage = sw->highest_stage;
+        sw->highest_stage = ad714x_cal_highest_stage(ad714x, hw->start_stage,
+                        hw->end_stage);
+
+        dev_dbg(ad714x->dev, "wheel %d highest_stage:%d\n", idx,
+                sw->highest_stage);
+}
+
+static void ad714x_wheel_cal_sensor_val(struct ad714x_chip *ad714x, int idx)
+{
+        struct ad714x_wheel_plat *hw = &ad714x->hw->wheel[idx];
+        int i;
+
+        for (i = hw->start_stage; i <= hw->end_stage; i++) {
+                ad714x->read(ad714x->dev, CDC_RESULT_S0 + i,
+                        &ad714x->adc_reg[i]);
+                ad714x->read(ad714x->dev,
+                                STAGE0_AMBIENT + i * PER_STAGE_REG_NUM,
+                                &ad714x->amb_reg[i]);
+                if (ad714x->adc_reg[i] > ad714x->amb_reg[i])
+                        ad714x->sensor_val[i] = ad714x->adc_reg[i] -
+                                ad714x->amb_reg[i];
+                else
+                        ad714x->sensor_val[i] = 0;
+        }
+}
+
+/*
+ * 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 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
+ */
+
+#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 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] +
+                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;
+        if (sw->abs_pos > hw->max_coord)
+                sw->abs_pos = hw->max_coord;
+}
+
+static void ad714x_wheel_cal_flt_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];
+        if (((sw->pre_highest_stage == hw->end_stage) &&
+                        (sw->highest_stage == hw->start_stage)) ||
+            ((sw->pre_highest_stage == hw->start_stage) &&
+                        (sw->highest_stage == hw->end_stage)))
+                sw->flt_pos = sw->abs_pos;
+        else
+                sw->flt_pos = ((sw->flt_pos * 30) + (sw->abs_pos * 71)) / 100;
+
+        if (sw->flt_pos > hw->max_coord)
+                sw->flt_pos = hw->max_coord;
+}
+
+static void ad714x_wheel_use_com_int(struct ad714x_chip *ad714x, int idx)
+{
+        struct ad714x_wheel_plat *hw = &ad714x->hw->wheel[idx];
+
+        ad714x_use_com_int(ad714x, hw->start_stage, hw->end_stage);
+}
+
+static void ad714x_wheel_use_thr_int(struct ad714x_chip *ad714x, int idx)
+{
+        struct ad714x_wheel_plat *hw = &ad714x->hw->wheel[idx];
+
+        ad714x_use_thr_int(ad714x, hw->start_stage, hw->end_stage);
+}
+
+static void ad714x_wheel_state_machine(struct ad714x_chip *ad714x, int idx)
+{
+        struct ad714x_wheel_plat *hw = &ad714x->hw->wheel[idx];
+        struct ad714x_wheel_drv *sw = &ad714x->sw->wheel[idx];
+        unsigned short h_state, c_state;
+        unsigned short mask;
+
+        mask = ((1 << (hw->end_stage + 1)) - 1) - ((1 << hw->start_stage) - 1);
+
+        h_state = ad714x->h_state & mask;
+        c_state = ad714x->c_state & mask;
+
+        switch (sw->state) {
+        case IDLE:
+                if (h_state) {
+                        sw->state = JITTER;
+                        /* In End of Conversion interrupt mode, the AD714X
+                         * continuously generates hardware interrupts.
+                         */
+                        ad714x_wheel_use_com_int(ad714x, idx);
+                        dev_dbg(ad714x->dev, "wheel %d touched\n", idx);
+                }
+                break;
+
+        case JITTER:
+                if (c_state == mask)    {
+                        ad714x_wheel_cal_sensor_val(ad714x, idx);
+                        ad714x_wheel_cal_highest_stage(ad714x, idx);
+                        ad714x_wheel_cal_abs_pos(ad714x, idx);
+                        sw->flt_pos = sw->abs_pos;
+                        sw->state = ACTIVE;
+                }
+                break;
+
+        case ACTIVE:
+                if (c_state == mask) {
+                        if (h_state) {
+                                ad714x_wheel_cal_sensor_val(ad714x, 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);
+                                input_report_key(sw->input, BTN_TOUCH, 1);
+                        } else {
+                                /* When the user lifts off the sensor, configure
+                                 * the AD714X back to threshold interrupt mode.
+                                 */
+                                ad714x_wheel_use_thr_int(ad714x, idx);
+                                sw->state = IDLE;
+                                input_report_key(sw->input, BTN_TOUCH, 0);
+
+                                dev_dbg(ad714x->dev, "wheel %d released\n",
+                                        idx);
+                        }
+                        input_sync(sw->input);
+                }
+                break;
+
+        default:
+                break;
+        }
+}
+
+static void touchpad_cal_sensor_val(struct ad714x_chip *ad714x, int idx)
+{
+        struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
+        int i;
+
+        for (i = hw->x_start_stage; i <= hw->x_end_stage; i++) {
+                ad714x->read(ad714x->dev, CDC_RESULT_S0 + i,
+                                &ad714x->adc_reg[i]);
+                ad714x->read(ad714x->dev,
+                                STAGE0_AMBIENT + i * PER_STAGE_REG_NUM,
+                                &ad714x->amb_reg[i]);
+                if (ad714x->adc_reg[i] > ad714x->amb_reg[i])
+                        ad714x->sensor_val[i] = ad714x->adc_reg[i] -
+                                ad714x->amb_reg[i];
+                else
+                        ad714x->sensor_val[i] = 0;
+        }
+}
+
+static void touchpad_cal_highest_stage(struct ad714x_chip *ad714x, int idx)
+{
+        struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
+        struct ad714x_touchpad_drv *sw = &ad714x->sw->touchpad[idx];
+
+        sw->x_highest_stage = ad714x_cal_highest_stage(ad714x,
+                hw->x_start_stage, hw->x_end_stage);
+        sw->y_highest_stage = ad714x_cal_highest_stage(ad714x,
+                hw->y_start_stage, hw->y_end_stage);
+
+        dev_dbg(ad714x->dev,
+                "touchpad %d x_highest_stage:%d, y_highest_stage:%d\n",
+                idx, sw->x_highest_stage, sw->y_highest_stage);
+}
+
+/*
+ * If 2 fingers are touching the sensor then 2 peaks can be observed in the
+ * distribution.
+ * The arithmetic doesn't support to get absolute coordinates for multi-touch
+ * yet.
+ */
+static int touchpad_check_second_peak(struct ad714x_chip *ad714x, int idx)
+{
+        struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
+        struct ad714x_touchpad_drv *sw = &ad714x->sw->touchpad[idx];
+        int i;
+
+        for (i = hw->x_start_stage; i < sw->x_highest_stage; i++) {
+                if ((ad714x->sensor_val[i] - ad714x->sensor_val[i + 1])
+                        > (ad714x->sensor_val[i + 1] / 10))
+                        return 1;
+        }
+
+        for (i = sw->x_highest_stage; i < hw->x_end_stage; i++) {
+                if ((ad714x->sensor_val[i + 1] - ad714x->sensor_val[i])
+                        > (ad714x->sensor_val[i] / 10))
+                        return 1;
+        }
+
+        for (i = hw->y_start_stage; i < sw->y_highest_stage; i++) {
+                if ((ad714x->sensor_val[i] - ad714x->sensor_val[i + 1])
+                        > (ad714x->sensor_val[i + 1] / 10))
+                        return 1;
+        }
+
+        for (i = sw->y_highest_stage; i < hw->y_end_stage; i++) {
+                if ((ad714x->sensor_val[i + 1] - ad714x->sensor_val[i])
+                        > (ad714x->sensor_val[i] / 10))
+                        return 1;
+        }
+
+        return 0;
+}
+
+/*
+ * If only one finger is used to activate the touch pad then only 1 peak will be
+ * registered in the distribution. This peak and the 2 adjacent sensors will be
+ * used in the calculation of the absolute position. This will prevent hand
+ * shadows to affect the absolute position calculation.
+ */
+static void touchpad_cal_abs_pos(struct ad714x_chip *ad714x, int idx)
+{
+        struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
+        struct ad714x_touchpad_drv *sw = &ad714x->sw->touchpad[idx];
+
+        sw->x_abs_pos = ad714x_cal_abs_pos(ad714x, hw->x_start_stage,
+                        hw->x_end_stage, sw->x_highest_stage, hw->x_max_coord);
+        sw->y_abs_pos = ad714x_cal_abs_pos(ad714x, hw->y_start_stage,
+                        hw->y_end_stage, sw->y_highest_stage, hw->y_max_coord);
+
+        dev_dbg(ad714x->dev, "touchpad %d absolute position:(%d, %d)\n", idx,
+                        sw->x_abs_pos, sw->y_abs_pos);
+}
+
+static void touchpad_cal_flt_pos(struct ad714x_chip *ad714x, int idx)
+{
+        struct ad714x_touchpad_drv *sw = &ad714x->sw->touchpad[idx];
+
+        sw->x_flt_pos = (sw->x_flt_pos * (10 - 4) +
+                        sw->x_abs_pos * 4)/10;
+        sw->y_flt_pos = (sw->y_flt_pos * (10 - 4) +
+                        sw->y_abs_pos * 4)/10;
+
+        dev_dbg(ad714x->dev, "touchpad %d filter position:(%d, %d)\n",
+                        idx, sw->x_flt_pos, sw->y_flt_pos);
+}
+
+/*
+ * To prevent distortion from showing in the absolute position, it is
+ * necessary to detect the end points. When endpoints are detected, the
+ * driver stops updating the status variables with absolute positions.
+ * End points are detected on the 4 edges of the touchpad sensor. The
+ * method to detect them is the same for all 4.
+ * To detect the end points, the firmware computes the difference in
+ * percent between the sensor on the edge and the adjacent one. The
+ * difference is calculated in percent in order to make the end point
+ * detection independent of the pressure.
+ */
+
+#define LEFT_END_POINT_DETECTION_LEVEL                  550
+#define RIGHT_END_POINT_DETECTION_LEVEL                 750
+#define LEFT_RIGHT_END_POINT_DEAVTIVALION_LEVEL         850
+#define TOP_END_POINT_DETECTION_LEVEL                   550
+#define BOTTOM_END_POINT_DETECTION_LEVEL                950
+#define TOP_BOTTOM_END_POINT_DEAVTIVALION_LEVEL         700
+static int touchpad_check_endpoint(struct ad714x_chip *ad714x, int idx)
+{
+        struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
+        struct ad714x_touchpad_drv *sw  = &ad714x->sw->touchpad[idx];
+        int percent_sensor_diff;
+
+        /* left endpoint detect */
+        percent_sensor_diff = (ad714x->sensor_val[hw->x_start_stage] -
+                        ad714x->sensor_val[hw->x_start_stage + 1]) * 100 /
+                        ad714x->sensor_val[hw->x_start_stage + 1];
+        if (!sw->left_ep) {
+                if (percent_sensor_diff >= LEFT_END_POINT_DETECTION_LEVEL)  {
+                        sw->left_ep = 1;
+                        sw->left_ep_val =
+                                ad714x->sensor_val[hw->x_start_stage + 1];
+                }
+        } else {
+                if ((percent_sensor_diff < LEFT_END_POINT_DETECTION_LEVEL) &&
+                    (ad714x->sensor_val[hw->x_start_stage + 1] >
+                     LEFT_RIGHT_END_POINT_DEAVTIVALION_LEVEL + sw->left_ep_val))
+                        sw->left_ep = 0;
+        }
+
+        /* right endpoint detect */
+        percent_sensor_diff = (ad714x->sensor_val[hw->x_end_stage] -
+                        ad714x->sensor_val[hw->x_end_stage - 1]) * 100 /
+                        ad714x->sensor_val[hw->x_end_stage - 1];
+        if (!sw->right_ep) {
+                if (percent_sensor_diff >= RIGHT_END_POINT_DETECTION_LEVEL)  {
+                        sw->right_ep = 1;
+                        sw->right_ep_val =
+                                ad714x->sensor_val[hw->x_end_stage - 1];
+                }
+        } else {
+                if ((percent_sensor_diff < RIGHT_END_POINT_DETECTION_LEVEL) &&
+                (ad714x->sensor_val[hw->x_end_stage - 1] >
+                LEFT_RIGHT_END_POINT_DEAVTIVALION_LEVEL + sw->right_ep_val))
+                        sw->right_ep = 0;
+        }
+
+        /* top endpoint detect */
+        percent_sensor_diff = (ad714x->sensor_val[hw->y_start_stage] -
+                        ad714x->sensor_val[hw->y_start_stage + 1]) * 100 /
+                        ad714x->sensor_val[hw->y_start_stage + 1];
+        if (!sw->top_ep) {
+                if (percent_sensor_diff >= TOP_END_POINT_DETECTION_LEVEL)  {
+                        sw->top_ep = 1;
+                        sw->top_ep_val =
+                                ad714x->sensor_val[hw->y_start_stage + 1];
+                }
+        } else {
+                if ((percent_sensor_diff < TOP_END_POINT_DETECTION_LEVEL) &&
+                (ad714x->sensor_val[hw->y_start_stage + 1] >
+                TOP_BOTTOM_END_POINT_DEAVTIVALION_LEVEL + sw->top_ep_val))
+                        sw->top_ep = 0;
+        }
+
+        /* bottom endpoint detect */
+        percent_sensor_diff = (ad714x->sensor_val[hw->y_end_stage] -
+                ad714x->sensor_val[hw->y_end_stage - 1]) * 100 /
+                ad714x->sensor_val[hw->y_end_stage - 1];
+        if (!sw->bottom_ep) {
+                if (percent_sensor_diff >= BOTTOM_END_POINT_DETECTION_LEVEL)  {
+                        sw->bottom_ep = 1;
+                        sw->bottom_ep_val =
+                                ad714x->sensor_val[hw->y_end_stage - 1];
+                }
+        } else {
+                if ((percent_sensor_diff < BOTTOM_END_POINT_DETECTION_LEVEL) &&
+                (ad714x->sensor_val[hw->y_end_stage - 1] >
+                 TOP_BOTTOM_END_POINT_DEAVTIVALION_LEVEL + sw->bottom_ep_val))
+                        sw->bottom_ep = 0;
+        }
+
+        return sw->left_ep || sw->right_ep || sw->top_ep || sw->bottom_ep;
+}
+
+static void touchpad_use_com_int(struct ad714x_chip *ad714x, int idx)
+{
+        struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
+
+        ad714x_use_com_int(ad714x, hw->x_start_stage, hw->x_end_stage);
+}
+
+static void touchpad_use_thr_int(struct ad714x_chip *ad714x, int idx)
+{
+        struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
+
+        ad714x_use_thr_int(ad714x, hw->x_start_stage, hw->x_end_stage);
+        ad714x_use_thr_int(ad714x, hw->y_start_stage, hw->y_end_stage);
+}
+
+static void ad714x_touchpad_state_machine(struct ad714x_chip *ad714x, int idx)
+{
+        struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
+        struct ad714x_touchpad_drv *sw = &ad714x->sw->touchpad[idx];
+        unsigned short h_state, c_state;
+        unsigned short mask;
+
+        mask = (((1 << (hw->x_end_stage + 1)) - 1) -
+                ((1 << hw->x_start_stage) - 1)) +
+                (((1 << (hw->y_end_stage + 1)) - 1) -
+                ((1 << hw->y_start_stage) - 1));
+
+        h_state = ad714x->h_state & mask;
+        c_state = ad714x->c_state & mask;
+
+        switch (sw->state) {
+        case IDLE:
+                if (h_state) {
+                        sw->state = JITTER;
+                        /* In End of Conversion interrupt mode, the AD714X
+                         * continuously generates hardware interrupts.
+                         */
+                        touchpad_use_com_int(ad714x, idx);
+                        dev_dbg(ad714x->dev, "touchpad %d touched\n", idx);
+                }
+                break;
+
+        case JITTER:
+                if (c_state == mask) {
+                        touchpad_cal_sensor_val(ad714x, idx);
+                        touchpad_cal_highest_stage(ad714x, idx);
+                        if ((!touchpad_check_second_peak(ad714x, idx)) &&
+                                (!touchpad_check_endpoint(ad714x, idx))) {
+                                dev_dbg(ad714x->dev,
+                                        "touchpad%d, 2 fingers or endpoint\n",
+                                        idx);
+                                touchpad_cal_abs_pos(ad714x, idx);
+                                sw->x_flt_pos = sw->x_abs_pos;
+                                sw->y_flt_pos = sw->y_abs_pos;
+                                sw->state = ACTIVE;
+                        }
+                }
+                break;
+
+        case ACTIVE:
+                if (c_state == mask) {
+                        if (h_state) {
+                                touchpad_cal_sensor_val(ad714x, idx);
+                                touchpad_cal_highest_stage(ad714x, idx);
+                                if ((!touchpad_check_second_peak(ad714x, idx))
+                                  && (!touchpad_check_endpoint(ad714x, idx))) {
+                                        touchpad_cal_abs_pos(ad714x, idx);
+                                        touchpad_cal_flt_pos(ad714x, idx);
+                                        input_report_abs(sw->input, ABS_X,
+                                                sw->x_flt_pos);
+                                        input_report_abs(sw->input, ABS_Y,
+                                                sw->y_flt_pos);
+                                        input_report_key(sw->input, BTN_TOUCH,
+                                                1);
+                                }
+                        } else {
+                                /* When the user lifts off the sensor, configure
+                                 * the AD714X back to threshold interrupt mode.
+                                 */
+                                touchpad_use_thr_int(ad714x, idx);
+                                sw->state = IDLE;
+                                input_report_key(sw->input, BTN_TOUCH, 0);
+                                dev_dbg(ad714x->dev, "touchpad %d released\n",
+                                        idx);
+                        }
+                        input_sync(sw->input);
+                }
+                break;
+
+        default:
+                break;
+        }
+}
+
+static int ad714x_hw_detect(struct ad714x_chip *ad714x)
+{
+        unsigned short data;
+
+        ad714x->read(ad714x->dev, AD714X_PARTID_REG, &data);
+        switch (data & 0xFFF0) {
+        case AD7142_PARTID:
+                ad714x->product = 0x7142;
+                ad714x->version = data & 0xF;
+                dev_info(ad714x->dev, "found AD7142 captouch, rev:%d\n",
+                                ad714x->version);
+                return 0;
+
+        case AD7143_PARTID:
+                ad714x->product = 0x7143;
+                ad714x->version = data & 0xF;
+                dev_info(ad714x->dev, "found AD7143 captouch, rev:%d\n",
+                                ad714x->version);
+                return 0;
+
+        case AD7147_PARTID:
+                ad714x->product = 0x7147;
+                ad714x->version = data & 0xF;
+                dev_info(ad714x->dev, "found AD7147(A) captouch, rev:%d\n",
+                                ad714x->version);
+                return 0;
+
+        case AD7148_PARTID:
+                ad714x->product = 0x7148;
+                ad714x->version = data & 0xF;
+                dev_info(ad714x->dev, "found AD7148 captouch, rev:%d\n",
+                                ad714x->version);
+                return 0;
+
+        default:
+                dev_err(ad714x->dev,
+                        "fail to detect AD714X captouch, read ID is %04x\n",
+                        data);
+                return -ENODEV;
+        }
+}
+
+static void ad714x_hw_init(struct ad714x_chip *ad714x)
+{
+        int i, j;
+        unsigned short reg_base;
+        unsigned short data;
+
+        /* configuration CDC and interrupts */
+
+        for (i = 0; i < STAGE_NUM; i++) {
+                reg_base = AD714X_STAGECFG_REG + i * STAGE_CFGREG_NUM;
+                for (j = 0; j < STAGE_CFGREG_NUM; j++)
+                        ad714x->write(ad714x->dev, reg_base + j,
+                                        ad714x->hw->stage_cfg_reg[i][j]);
+        }
+
+        for (i = 0; i < SYS_CFGREG_NUM; i++)
+                ad714x->write(ad714x->dev, AD714X_SYSCFG_REG + i,
+                        ad714x->hw->sys_cfg_reg[i]);
+        for (i = 0; i < SYS_CFGREG_NUM; i++)
+                ad714x->read(ad714x->dev, AD714X_SYSCFG_REG + i,
+                        &data);
+
+        ad714x->write(ad714x->dev, AD714X_STG_CAL_EN_REG, 0xFFF);
+
+        /* clear all interrupts */
+        ad714x->read(ad714x->dev, STG_LOW_INT_STA_REG, &data);
+        ad714x->read(ad714x->dev, STG_HIGH_INT_STA_REG, &data);
+        ad714x->read(ad714x->dev, STG_COM_INT_STA_REG, &data);
+}
+
+static irqreturn_t ad714x_interrupt_thread(int irq, void *data)
+{
+        struct ad714x_chip *ad714x = data;
+        int i;
+
+        mutex_lock(&ad714x->mutex);
+
+        ad714x->read(ad714x->dev, STG_LOW_INT_STA_REG, &ad714x->l_state);
+        ad714x->read(ad714x->dev, STG_HIGH_INT_STA_REG, &ad714x->h_state);
+        ad714x->read(ad714x->dev, STG_COM_INT_STA_REG, &ad714x->c_state);
+
+        for (i = 0; i < ad714x->hw->button_num; i++)
+                ad714x_button_state_machine(ad714x, i);
+        for (i = 0; i < ad714x->hw->slider_num; i++)
+                ad714x_slider_state_machine(ad714x, i);
+        for (i = 0; i < ad714x->hw->wheel_num; i++)
+                ad714x_wheel_state_machine(ad714x, i);
+        for (i = 0; i < ad714x->hw->touchpad_num; i++)
+                ad714x_touchpad_state_machine(ad714x, i);
+
+        mutex_unlock(&ad714x->mutex);
+
+        return IRQ_HANDLED;
+}
+
+#define MAX_DEVICE_NUM 8
+struct ad714x_chip *ad714x_probe(struct device *dev, u16 bus_type, int irq,
+                                 ad714x_read_t read, ad714x_write_t write)
+{
+        int i, alloc_idx;
+        int error;
+        struct input_dev *input[MAX_DEVICE_NUM];
+
+        struct ad714x_platform_data *plat_data = dev->platform_data;
+        struct ad714x_chip *ad714x;
+        void *drv_mem;
+
+        struct ad714x_button_drv *bt_drv;
+        struct ad714x_slider_drv *sd_drv;
+        struct ad714x_wheel_drv *wl_drv;
+        struct ad714x_touchpad_drv *tp_drv;
+
+
+        if (irq <= 0) {
+                dev_err(dev, "IRQ not configured!\n");
+                error = -EINVAL;
+                goto err_out;
+        }
+
+        if (dev->platform_data == NULL) {
+                dev_err(dev, "platform data for ad714x doesn't exist\n");
+                error = -EINVAL;
+                goto err_out;
+        }
+
+        ad714x = kzalloc(sizeof(*ad714x) + sizeof(*ad714x->sw) +
+                         sizeof(*sd_drv) * plat_data->slider_num +
+                         sizeof(*wl_drv) * plat_data->wheel_num +
+                         sizeof(*tp_drv) * plat_data->touchpad_num +
+                         sizeof(*bt_drv) * plat_data->button_num, GFP_KERNEL);
+        if (!ad714x) {
+                error = -ENOMEM;
+                goto err_out;
+        }
+
+        ad714x->hw = plat_data;
+
+        drv_mem = ad714x + 1;
+        ad714x->sw = drv_mem;
+        drv_mem += sizeof(*ad714x->sw);
+        ad714x->sw->slider = sd_drv = drv_mem;
+        drv_mem += sizeof(*sd_drv) * ad714x->hw->slider_num;
+        ad714x->sw->wheel = wl_drv = drv_mem;
+        drv_mem += sizeof(*wl_drv) * ad714x->hw->wheel_num;
+        ad714x->sw->touchpad = tp_drv = drv_mem;
+        drv_mem += sizeof(*tp_drv) * ad714x->hw->touchpad_num;
+        ad714x->sw->button = bt_drv = drv_mem;
+        drv_mem += sizeof(*bt_drv) * ad714x->hw->button_num;
+
+        ad714x->read = read;
+        ad714x->write = write;
+        ad714x->irq = irq;
+        ad714x->dev = dev;
+
+        error = ad714x_hw_detect(ad714x);
+        if (error)
+                goto err_free_mem;
+
+        /* initialize and request sw/hw resources */
+
+        ad714x_hw_init(ad714x);
+        mutex_init(&ad714x->mutex);
+
+        /*
+         * Allocate and register AD714X input device
+         */
+        alloc_idx = 0;
+
+        /* a slider uses one input_dev instance */
+        if (ad714x->hw->slider_num > 0) {
+                struct ad714x_slider_plat *sd_plat = ad714x->hw->slider;
+
+                for (i = 0; i < ad714x->hw->slider_num; i++) {
+                        sd_drv[i].input = input[alloc_idx] = input_allocate_device();
+                        if (!input[alloc_idx]) {
+                                error = -ENOMEM;
+                                goto err_free_dev;
+                        }
+
+                        __set_bit(EV_ABS, input[alloc_idx]->evbit);
+                        __set_bit(EV_KEY, input[alloc_idx]->evbit);
+                        __set_bit(ABS_X, input[alloc_idx]->absbit);
+                        __set_bit(BTN_TOUCH, input[alloc_idx]->keybit);
+                        input_set_abs_params(input[alloc_idx],
+                                ABS_X, 0, sd_plat->max_coord, 0, 0);
+
+                        input[alloc_idx]->id.bustype = bus_type;
+                        input[alloc_idx]->id.product = ad714x->product;
+                        input[alloc_idx]->id.version = ad714x->version;
+
+                        error = input_register_device(input[alloc_idx]);
+                        if (error)
+                                goto err_free_dev;
+
+                        alloc_idx++;
+                }
+        }
+
+        /* a wheel uses one input_dev instance */
+        if (ad714x->hw->wheel_num > 0) {
+                struct ad714x_wheel_plat *wl_plat = ad714x->hw->wheel;
+
+                for (i = 0; i < ad714x->hw->wheel_num; i++) {
+                        wl_drv[i].input = input[alloc_idx] = input_allocate_device();
+                        if (!input[alloc_idx]) {
+                                error = -ENOMEM;
+                                goto err_free_dev;
+                        }
+
+                        __set_bit(EV_KEY, input[alloc_idx]->evbit);
+                        __set_bit(EV_ABS, input[alloc_idx]->evbit);
+                        __set_bit(ABS_WHEEL, input[alloc_idx]->absbit);
+                        __set_bit(BTN_TOUCH, input[alloc_idx]->keybit);
+                        input_set_abs_params(input[alloc_idx],
+                                ABS_WHEEL, 0, wl_plat->max_coord, 0, 0);
+
+                        input[alloc_idx]->id.bustype = bus_type;
+                        input[alloc_idx]->id.product = ad714x->product;
+                        input[alloc_idx]->id.version = ad714x->version;
+
+                        error = input_register_device(input[alloc_idx]);
+                        if (error)
+                                goto err_free_dev;
+
+                        alloc_idx++;
+                }
+        }
+
+        /* a touchpad uses one input_dev instance */
+        if (ad714x->hw->touchpad_num > 0) {
+                struct ad714x_touchpad_plat *tp_plat = ad714x->hw->touchpad;
+
+                for (i = 0; i < ad714x->hw->touchpad_num; i++) {
+                        tp_drv[i].input = input[alloc_idx] = input_allocate_device();
+                        if (!input[alloc_idx]) {
+                                error = -ENOMEM;
+                                goto err_free_dev;
+                        }
+
+                        __set_bit(EV_ABS, input[alloc_idx]->evbit);
+                        __set_bit(EV_KEY, input[alloc_idx]->evbit);
+                        __set_bit(ABS_X, input[alloc_idx]->absbit);
+                        __set_bit(ABS_Y, input[alloc_idx]->absbit);
+                        __set_bit(BTN_TOUCH, input[alloc_idx]->keybit);
+                        input_set_abs_params(input[alloc_idx],
+                                ABS_X, 0, tp_plat->x_max_coord, 0, 0);
+                        input_set_abs_params(input[alloc_idx],
+                                ABS_Y, 0, tp_plat->y_max_coord, 0, 0);
+
+                        input[alloc_idx]->id.bustype = bus_type;
+                        input[alloc_idx]->id.product = ad714x->product;
+                        input[alloc_idx]->id.version = ad714x->version;
+
+                        error = input_register_device(input[alloc_idx]);
+                        if (error)
+                                goto err_free_dev;
+
+                        alloc_idx++;
+                }
+        }
+
+        /* all buttons use one input node */
+        if (ad714x->hw->button_num > 0) {
+                struct ad714x_button_plat *bt_plat = ad714x->hw->button;
+
+                input[alloc_idx] = input_allocate_device();
+                if (!input[alloc_idx]) {
+                        error = -ENOMEM;
+                        goto err_free_dev;
+                }
+
+                __set_bit(EV_KEY, input[alloc_idx]->evbit);
+                for (i = 0; i < ad714x->hw->button_num; i++) {
+                        bt_drv[i].input = input[alloc_idx];
+                        __set_bit(bt_plat[i].keycode, input[alloc_idx]->keybit);
+                }
+
+                input[alloc_idx]->id.bustype = bus_type;
+                input[alloc_idx]->id.product = ad714x->product;
+                input[alloc_idx]->id.version = ad714x->version;
+
+                error = input_register_device(input[alloc_idx]);
+                if (error)
+                        goto err_free_dev;
+
+                alloc_idx++;
+        }
+
+        error = request_threaded_irq(ad714x->irq, NULL, ad714x_interrupt_thread,
+                        IRQF_TRIGGER_FALLING, "ad714x_captouch", ad714x);
+        if (error) {
+                dev_err(dev, "can't allocate irq %d\n", ad714x->irq);
+                goto err_unreg_dev;
+        }
+
+        return ad714x;
+
+ err_free_dev:
+        dev_err(dev, "failed to setup AD714x input device %i\n", alloc_idx);
+        input_free_device(input[alloc_idx]);
+ err_unreg_dev:
+        while (--alloc_idx >= 0)
+                input_unregister_device(input[alloc_idx]);
+ err_free_mem:
+        kfree(ad714x);
+ err_out:
+        return ERR_PTR(error);
+}
+EXPORT_SYMBOL(ad714x_probe);
+
+void ad714x_remove(struct ad714x_chip *ad714x)
+{
+        struct ad714x_platform_data *hw = ad714x->hw;
+        struct ad714x_driver_data *sw = ad714x->sw;
+        int i;
+
+        free_irq(ad714x->irq, ad714x);
+
+        /* unregister and free all input devices */
+
+        for (i = 0; i < hw->slider_num; i++)
+                input_unregister_device(sw->slider[i].input);
+
+        for (i = 0; i < hw->wheel_num; i++)
+                input_unregister_device(sw->wheel[i].input);
+
+        for (i = 0; i < hw->touchpad_num; i++)
+                input_unregister_device(sw->touchpad[i].input);
+
+        if (hw->button_num)
+                input_unregister_device(sw->button[0].input);
+
+        kfree(ad714x);
+}
+EXPORT_SYMBOL(ad714x_remove);
+
+#ifdef CONFIG_PM
+int ad714x_disable(struct ad714x_chip *ad714x)
+{
+        unsigned short data;
+
+        dev_dbg(ad714x->dev, "%s enter\n", __func__);
+
+        mutex_lock(&ad714x->mutex);
+
+        data = ad714x->hw->sys_cfg_reg[AD714X_PWR_CTRL] | 0x3;
+        ad714x->write(ad714x->dev, AD714X_PWR_CTRL, data);
+
+        mutex_unlock(&ad714x->mutex);
+
+        return 0;
+}
+EXPORT_SYMBOL(ad714x_disable);
+
+int ad714x_enable(struct ad714x_chip *ad714x)
+{
+        unsigned short data;
+
+        dev_dbg(ad714x->dev, "%s enter\n", __func__);
+
+        mutex_lock(&ad714x->mutex);
+
+        /* resume to non-shutdown mode */
+
+        ad714x->write(ad714x->dev, AD714X_PWR_CTRL,
+                        ad714x->hw->sys_cfg_reg[AD714X_PWR_CTRL]);
+
+        /* make sure the interrupt output line is not low level after resume,
+         * otherwise we will get no chance to enter falling-edge irq again
+         */
+
+        ad714x->read(ad714x->dev, STG_LOW_INT_STA_REG, &data);
+        ad714x->read(ad714x->dev, STG_HIGH_INT_STA_REG, &data);
+        ad714x->read(ad714x->dev, STG_COM_INT_STA_REG, &data);
+
+        mutex_unlock(&ad714x->mutex);
+
+        return 0;
+}
+EXPORT_SYMBOL(ad714x_enable);
+#endif
+
+MODULE_DESCRIPTION("Analog Devices AD714X Capacitance Touch Sensor Driver");
+MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/misc/ad714x.h b/drivers/input/misc/ad714x.h
new file mode 100644
index 000000000000..45c54fb13f07
--- /dev/null
+++ b/drivers/input/misc/ad714x.h
@@ -0,0 +1,26 @@
+/*
+ * AD714X CapTouch Programmable Controller driver (bus interfaces)
+ *
+ * Copyright 2009 Analog Devices Inc.
+ *
+ * Licensed under the GPL-2 or later.
+ */
+
+#ifndef _AD714X_H_
+#define _AD714X_H_
+
+#include <linux/types.h>
+
+struct device;
+struct ad714x_chip;
+
+typedef int (*ad714x_read_t)(struct device *, unsigned short, unsigned short *);
+typedef int (*ad714x_write_t)(struct device *, unsigned short, unsigned short);
+
+int ad714x_disable(struct ad714x_chip *ad714x);
+int ad714x_enable(struct ad714x_chip *ad714x);
+struct ad714x_chip *ad714x_probe(struct device *dev, u16 bus_type, int irq,
+                                 ad714x_read_t read, ad714x_write_t write);
+void ad714x_remove(struct ad714x_chip *ad714x);
+
+#endif
diff --git a/drivers/input/misc/adxl34x-i2c.c b/drivers/input/misc/adxl34x-i2c.c
new file mode 100644
index 000000000000..0779724af7e7
--- /dev/null
+++ b/drivers/input/misc/adxl34x-i2c.c
@@ -0,0 +1,163 @@
+/*
+ * ADLX345/346 Three-Axis Digital Accelerometers (I2C Interface)
+ *
+ * Enter bugs at http://blackfin.uclinux.org/
+ *
+ * Copyright (C) 2009 Michael Hennerich, Analog Devices Inc.
+ * Licensed under the GPL-2 or later.
+ */
+
+#include <linux/input.h>        /* BUS_I2C */
+#include <linux/i2c.h>
+#include <linux/module.h>
+#include <linux/types.h>
+#include "adxl34x.h"
+
+static int adxl34x_smbus_read(struct device *dev, unsigned char reg)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+
+        return i2c_smbus_read_byte_data(client, reg);
+}
+
+static int adxl34x_smbus_write(struct device *dev,
+                               unsigned char reg, unsigned char val)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+
+        return i2c_smbus_write_byte_data(client, reg, val);
+}
+
+static int adxl34x_smbus_read_block(struct device *dev,
+                                    unsigned char reg, int count,
+                                    void *buf)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+
+        return i2c_smbus_read_i2c_block_data(client, reg, count, buf);
+}
+
+static int adxl34x_i2c_read_block(struct device *dev,
+                                  unsigned char reg, int count,
+                                  void *buf)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        int ret;
+
+        ret = i2c_master_send(client, &reg, 1);
+        if (ret < 0)
+                return ret;
+
+        ret = i2c_master_recv(client, buf, count);
+        if (ret < 0)
+                return ret;
+
+        if (ret != count)
+                return -EIO;
+
+        return 0;
+}
+
+static const struct adxl34x_bus_ops adxl34x_smbus_bops = {
+        .bustype        = BUS_I2C,
+        .write          = adxl34x_smbus_write,
+        .read           = adxl34x_smbus_read,
+        .read_block     = adxl34x_smbus_read_block,
+};
+
+static const struct adxl34x_bus_ops adxl34x_i2c_bops = {
+        .bustype        = BUS_I2C,
+        .write          = adxl34x_smbus_write,
+        .read           = adxl34x_smbus_read,
+        .read_block     = adxl34x_i2c_read_block,
+};
+
+static int __devinit adxl34x_i2c_probe(struct i2c_client *client,
+                                       const struct i2c_device_id *id)
+{
+        struct adxl34x *ac;
+        int error;
+
+        error = i2c_check_functionality(client->adapter,
+                        I2C_FUNC_SMBUS_BYTE_DATA);
+        if (!error) {
+                dev_err(&client->dev, "SMBUS Byte Data not Supported\n");
+                return -EIO;
+        }
+
+        ac = adxl34x_probe(&client->dev, client->irq, false,
+                           i2c_check_functionality(client->adapter,
+                                                   I2C_FUNC_SMBUS_READ_I2C_BLOCK) ?
+                                &adxl34x_smbus_bops : &adxl34x_i2c_bops);
+        if (IS_ERR(ac))
+                return PTR_ERR(ac);
+
+        i2c_set_clientdata(client, ac);
+
+        return 0;
+}
+
+static int __devexit adxl34x_i2c_remove(struct i2c_client *client)
+{
+        struct adxl34x *ac = i2c_get_clientdata(client);
+
+        return adxl34x_remove(ac);
+}
+
+#ifdef CONFIG_PM
+static int adxl34x_i2c_suspend(struct i2c_client *client, pm_message_t message)
+{
+        struct adxl34x *ac = i2c_get_clientdata(client);
+
+        adxl34x_suspend(ac);
+
+        return 0;
+}
+
+static int adxl34x_i2c_resume(struct i2c_client *client)
+{
+        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 const struct i2c_device_id adxl34x_id[] = {
+        { "adxl34x", 0 },
+        { }
+};
+
+MODULE_DEVICE_TABLE(i2c, adxl34x_id);
+
+static struct i2c_driver adxl34x_driver = {
+        .driver = {
+                .name = "adxl34x",
+                .owner = THIS_MODULE,
+        },
+        .probe    = adxl34x_i2c_probe,
+        .remove   = __devexit_p(adxl34x_i2c_remove),
+        .suspend  = adxl34x_i2c_suspend,
+        .resume   = adxl34x_i2c_resume,
+        .id_table = adxl34x_id,
+};
+
+static int __init adxl34x_i2c_init(void)
+{
+        return i2c_add_driver(&adxl34x_driver);
+}
+module_init(adxl34x_i2c_init);
+
+static void __exit adxl34x_i2c_exit(void)
+{
+        i2c_del_driver(&adxl34x_driver);
+}
+module_exit(adxl34x_i2c_exit);
+
+MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
+MODULE_DESCRIPTION("ADXL345/346 Three-Axis Digital Accelerometer I2C Bus Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/misc/adxl34x-spi.c b/drivers/input/misc/adxl34x-spi.c
new file mode 100644
index 000000000000..782de9e89828
--- /dev/null
+++ b/drivers/input/misc/adxl34x-spi.c
@@ -0,0 +1,145 @@
+/*
+ * ADLX345/346 Three-Axis Digital Accelerometers (SPI Interface)
+ *
+ * Enter bugs at http://blackfin.uclinux.org/
+ *
+ * Copyright (C) 2009 Michael Hennerich, Analog Devices Inc.
+ * Licensed under the GPL-2 or later.
+ */
+
+#include <linux/input.h>        /* BUS_SPI */
+#include <linux/module.h>
+#include <linux/spi/spi.h>
+#include <linux/types.h>
+#include "adxl34x.h"
+
+#define MAX_SPI_FREQ_HZ         5000000
+#define MAX_FREQ_NO_FIFODELAY   1500000
+#define ADXL34X_CMD_MULTB       (1 << 6)
+#define ADXL34X_CMD_READ        (1 << 7)
+#define ADXL34X_WRITECMD(reg)   (reg & 0x3F)
+#define ADXL34X_READCMD(reg)    (ADXL34X_CMD_READ | (reg & 0x3F))
+#define ADXL34X_READMB_CMD(reg) (ADXL34X_CMD_READ | ADXL34X_CMD_MULTB \
+                                        | (reg & 0x3F))
+
+static int adxl34x_spi_read(struct device *dev, unsigned char reg)
+{
+        struct spi_device *spi = to_spi_device(dev);
+        unsigned char cmd;
+
+        cmd = ADXL34X_READCMD(reg);
+
+        return spi_w8r8(spi, cmd);
+}
+
+static int adxl34x_spi_write(struct device *dev,
+                             unsigned char reg, unsigned char val)
+{
+        struct spi_device *spi = to_spi_device(dev);
+        unsigned char buf[2];
+
+        buf[0] = ADXL34X_WRITECMD(reg);
+        buf[1] = val;
+
+        return spi_write(spi, buf, sizeof(buf));
+}
+
+static int adxl34x_spi_read_block(struct device *dev,
+                                  unsigned char reg, int count,
+                                  void *buf)
+{
+        struct spi_device *spi = to_spi_device(dev);
+        ssize_t status;
+
+        reg = ADXL34X_READMB_CMD(reg);
+        status = spi_write_then_read(spi, &reg, 1, buf, count);
+
+        return (status < 0) ? status : 0;
+}
+
+static const struct adxl34x_bus_ops adx134x_spi_bops = {
+        .bustype        = BUS_SPI,
+        .write          = adxl34x_spi_write,
+        .read           = adxl34x_spi_read,
+        .read_block     = adxl34x_spi_read_block,
+};
+
+static int __devinit adxl34x_spi_probe(struct spi_device *spi)
+{
+        struct adxl34x *ac;
+
+        /* don't exceed max specified SPI CLK frequency */
+        if (spi->max_speed_hz > MAX_SPI_FREQ_HZ) {
+                dev_err(&spi->dev, "SPI CLK %d Hz too fast\n", spi->max_speed_hz);
+                return -EINVAL;
+        }
+
+        ac = adxl34x_probe(&spi->dev, spi->irq,
+                           spi->max_speed_hz > MAX_FREQ_NO_FIFODELAY,
+                           &adx134x_spi_bops);
+
+        if (IS_ERR(ac))
+                return PTR_ERR(ac);
+
+        spi_set_drvdata(spi, ac);
+
+        return 0;
+}
+
+static int __devexit adxl34x_spi_remove(struct spi_device *spi)
+{
+        struct adxl34x *ac = dev_get_drvdata(&spi->dev);
+
+        return adxl34x_remove(ac);
+}
+
+#ifdef CONFIG_PM
+static int adxl34x_spi_suspend(struct spi_device *spi, pm_message_t message)
+{
+        struct adxl34x *ac = dev_get_drvdata(&spi->dev);
+
+        adxl34x_suspend(ac);
+
+        return 0;
+}
+
+static int adxl34x_spi_resume(struct spi_device *spi)
+{
+        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 struct spi_driver adxl34x_driver = {
+        .driver = {
+                .name = "adxl34x",
+                .bus = &spi_bus_type,
+                .owner = THIS_MODULE,
+        },
+        .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)
+{
+        return spi_register_driver(&adxl34x_driver);
+}
+module_init(adxl34x_spi_init);
+
+static void __exit adxl34x_spi_exit(void)
+{
+        spi_unregister_driver(&adxl34x_driver);
+}
+module_exit(adxl34x_spi_exit);
+
+MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
+MODULE_DESCRIPTION("ADXL345/346 Three-Axis Digital Accelerometer SPI Bus Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/misc/adxl34x.c b/drivers/input/misc/adxl34x.c
new file mode 100644
index 000000000000..de5900d50788
--- /dev/null
+++ b/drivers/input/misc/adxl34x.c
@@ -0,0 +1,914 @@
+/*
+ * ADXL345/346 Three-Axis Digital Accelerometers
+ *
+ * Enter bugs at http://blackfin.uclinux.org/
+ *
+ * Copyright (C) 2009 Michael Hennerich, Analog Devices Inc.
+ * Licensed under the GPL-2 or later.
+ */
+
+#include <linux/device.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/input.h>
+#include <linux/interrupt.h>
+#include <linux/irq.h>
+#include <linux/slab.h>
+#include <linux/workqueue.h>
+#include <linux/input/adxl34x.h>
+
+#include "adxl34x.h"
+
+/* ADXL345/6 Register Map */
+#define DEVID           0x00    /* R   Device ID */
+#define THRESH_TAP      0x1D    /* R/W Tap threshold */
+#define OFSX            0x1E    /* R/W X-axis offset */
+#define OFSY            0x1F    /* R/W Y-axis offset */
+#define OFSZ            0x20    /* R/W Z-axis offset */
+#define DUR             0x21    /* R/W Tap duration */
+#define LATENT          0x22    /* R/W Tap latency */
+#define WINDOW          0x23    /* R/W Tap window */
+#define THRESH_ACT      0x24    /* R/W Activity threshold */
+#define THRESH_INACT    0x25    /* R/W Inactivity threshold */
+#define TIME_INACT      0x26    /* R/W Inactivity time */
+#define ACT_INACT_CTL   0x27    /* R/W Axis enable control for activity and */
+                                /* inactivity detection */
+#define THRESH_FF       0x28    /* R/W Free-fall threshold */
+#define TIME_FF         0x29    /* R/W Free-fall time */
+#define TAP_AXES        0x2A    /* R/W Axis control for tap/double tap */
+#define ACT_TAP_STATUS  0x2B    /* R   Source of tap/double tap */
+#define BW_RATE         0x2C    /* R/W Data rate and power mode control */
+#define POWER_CTL       0x2D    /* R/W Power saving features control */
+#define INT_ENABLE      0x2E    /* R/W Interrupt enable control */
+#define INT_MAP         0x2F    /* R/W Interrupt mapping control */
+#define INT_SOURCE      0x30    /* R   Source of interrupts */
+#define DATA_FORMAT     0x31    /* R/W Data format control */
+#define DATAX0          0x32    /* R   X-Axis Data 0 */
+#define DATAX1          0x33    /* R   X-Axis Data 1 */
+#define DATAY0          0x34    /* R   Y-Axis Data 0 */
+#define DATAY1          0x35    /* R   Y-Axis Data 1 */
+#define DATAZ0          0x36    /* R   Z-Axis Data 0 */
+#define DATAZ1          0x37    /* R   Z-Axis Data 1 */
+#define FIFO_CTL        0x38    /* R/W FIFO control */
+#define FIFO_STATUS     0x39    /* R   FIFO status */
+#define TAP_SIGN        0x3A    /* R   Sign and source for tap/double tap */
+/* Orientation ADXL346 only */
+#define ORIENT_CONF     0x3B    /* R/W Orientation configuration */
+#define ORIENT          0x3C    /* R   Orientation status */
+
+/* DEVIDs */
+#define ID_ADXL345      0xE5
+#define ID_ADXL346      0xE6
+
+/* INT_ENABLE/INT_MAP/INT_SOURCE Bits */
+#define DATA_READY      (1 << 7)
+#define SINGLE_TAP      (1 << 6)
+#define DOUBLE_TAP      (1 << 5)
+#define ACTIVITY        (1 << 4)
+#define INACTIVITY      (1 << 3)
+#define FREE_FALL       (1 << 2)
+#define WATERMARK       (1 << 1)
+#define OVERRUN         (1 << 0)
+
+/* ACT_INACT_CONTROL Bits */
+#define ACT_ACDC        (1 << 7)
+#define ACT_X_EN        (1 << 6)
+#define ACT_Y_EN        (1 << 5)
+#define ACT_Z_EN        (1 << 4)
+#define INACT_ACDC      (1 << 3)
+#define INACT_X_EN      (1 << 2)
+#define INACT_Y_EN      (1 << 1)
+#define INACT_Z_EN      (1 << 0)
+
+/* TAP_AXES Bits */
+#define SUPPRESS        (1 << 3)
+#define TAP_X_EN        (1 << 2)
+#define TAP_Y_EN        (1 << 1)
+#define TAP_Z_EN        (1 << 0)
+
+/* ACT_TAP_STATUS Bits */
+#define ACT_X_SRC       (1 << 6)
+#define ACT_Y_SRC       (1 << 5)
+#define ACT_Z_SRC       (1 << 4)
+#define ASLEEP          (1 << 3)
+#define TAP_X_SRC       (1 << 2)
+#define TAP_Y_SRC       (1 << 1)
+#define TAP_Z_SRC       (1 << 0)
+
+/* BW_RATE Bits */
+#define LOW_POWER       (1 << 4)
+#define RATE(x)         ((x) & 0xF)
+
+/* POWER_CTL Bits */
+#define PCTL_LINK       (1 << 5)
+#define PCTL_AUTO_SLEEP (1 << 4)
+#define PCTL_MEASURE    (1 << 3)
+#define PCTL_SLEEP      (1 << 2)
+#define PCTL_WAKEUP(x)  ((x) & 0x3)
+
+/* DATA_FORMAT Bits */
+#define SELF_TEST       (1 << 7)
+#define SPI             (1 << 6)
+#define INT_INVERT      (1 << 5)
+#define FULL_RES        (1 << 3)
+#define JUSTIFY         (1 << 2)
+#define RANGE(x)        ((x) & 0x3)
+#define RANGE_PM_2g     0
+#define RANGE_PM_4g     1
+#define RANGE_PM_8g     2
+#define RANGE_PM_16g    3
+
+/*
+ * Maximum value our axis may get in full res mode for the input device
+ * (signed 13 bits)
+ */
+#define ADXL_FULLRES_MAX_VAL 4096
+
+/*
+ * Maximum value our axis may get in fixed res mode for the input device
+ * (signed 10 bits)
+ */
+#define ADXL_FIXEDRES_MAX_VAL 512
+
+/* FIFO_CTL Bits */
+#define FIFO_MODE(x)    (((x) & 0x3) << 6)
+#define FIFO_BYPASS     0
+#define FIFO_FIFO       1
+#define FIFO_STREAM     2
+#define FIFO_TRIGGER    3
+#define TRIGGER         (1 << 5)
+#define SAMPLES(x)      ((x) & 0x1F)
+
+/* FIFO_STATUS Bits */
+#define FIFO_TRIG       (1 << 7)
+#define ENTRIES(x)      ((x) & 0x3F)
+
+/* TAP_SIGN Bits ADXL346 only */
+#define XSIGN           (1 << 6)
+#define YSIGN           (1 << 5)
+#define ZSIGN           (1 << 4)
+#define XTAP            (1 << 3)
+#define YTAP            (1 << 2)
+#define ZTAP            (1 << 1)
+
+/* ORIENT_CONF ADXL346 only */
+#define ORIENT_DEADZONE(x)      (((x) & 0x7) << 4)
+#define ORIENT_DIVISOR(x)       ((x) & 0x7)
+
+/* ORIENT ADXL346 only */
+#define ADXL346_2D_VALID                (1 << 6)
+#define ADXL346_2D_ORIENT(x)            (((x) & 0x3) >> 4)
+#define ADXL346_3D_VALID                (1 << 3)
+#define ADXL346_3D_ORIENT(x)            ((x) & 0x7)
+#define ADXL346_2D_PORTRAIT_POS         0       /* +X */
+#define ADXL346_2D_PORTRAIT_NEG         1       /* -X */
+#define ADXL346_2D_LANDSCAPE_POS        2       /* +Y */
+#define ADXL346_2D_LANDSCAPE_NEG        3       /* -Y */
+
+#define ADXL346_3D_FRONT                3       /* +X */
+#define ADXL346_3D_BACK                 4       /* -X */
+#define ADXL346_3D_RIGHT                2       /* +Y */
+#define ADXL346_3D_LEFT                 5       /* -Y */
+#define ADXL346_3D_TOP                  1       /* +Z */
+#define ADXL346_3D_BOTTOM               6       /* -Z */
+
+#undef ADXL_DEBUG
+
+#define ADXL_X_AXIS                     0
+#define ADXL_Y_AXIS                     1
+#define ADXL_Z_AXIS                     2
+
+#define AC_READ(ac, reg)        ((ac)->bops->read((ac)->dev, reg))
+#define AC_WRITE(ac, reg, val)  ((ac)->bops->write((ac)->dev, reg, val))
+
+struct axis_triple {
+        int x;
+        int y;
+        int z;
+};
+
+struct adxl34x {
+        struct device *dev;
+        struct input_dev *input;
+        struct mutex mutex;     /* reentrant protection for struct */
+        struct adxl34x_platform_data pdata;
+        struct axis_triple swcal;
+        struct axis_triple hwcal;
+        struct axis_triple saved;
+        char phys[32];
+        unsigned orient2d_saved;
+        unsigned orient3d_saved;
+        bool disabled;  /* P: mutex */
+        bool opened;    /* P: mutex */
+        bool suspended; /* P: mutex */
+        bool fifo_delay;
+        int irq;
+        unsigned model;
+        unsigned int_mask;
+
+        const struct adxl34x_bus_ops *bops;
+};
+
+static const struct adxl34x_platform_data adxl34x_default_init = {
+        .tap_threshold = 35,
+        .tap_duration = 3,
+        .tap_latency = 20,
+        .tap_window = 20,
+        .tap_axis_control = ADXL_TAP_X_EN | ADXL_TAP_Y_EN | ADXL_TAP_Z_EN,
+        .act_axis_control = 0xFF,
+        .activity_threshold = 6,
+        .inactivity_threshold = 4,
+        .inactivity_time = 3,
+        .free_fall_threshold = 8,
+        .free_fall_time = 0x20,
+        .data_rate = 8,
+        .data_range = ADXL_FULL_RES,
+
+        .ev_type = EV_ABS,
+        .ev_code_x = ABS_X,     /* EV_REL */
+        .ev_code_y = ABS_Y,     /* EV_REL */
+        .ev_code_z = ABS_Z,     /* EV_REL */
+
+        .ev_code_tap = {BTN_TOUCH, BTN_TOUCH, BTN_TOUCH}, /* EV_KEY {x,y,z} */
+        .power_mode = ADXL_AUTO_SLEEP | ADXL_LINK,
+        .fifo_mode = FIFO_STREAM,
+        .watermark = 0,
+};
+
+static void adxl34x_get_triple(struct adxl34x *ac, struct axis_triple *axis)
+{
+        short buf[3];
+
+        ac->bops->read_block(ac->dev, DATAX0, DATAZ1 - DATAX0 + 1, buf);
+
+        mutex_lock(&ac->mutex);
+        ac->saved.x = (s16) le16_to_cpu(buf[0]);
+        axis->x = ac->saved.x;
+
+        ac->saved.y = (s16) le16_to_cpu(buf[1]);
+        axis->y = ac->saved.y;
+
+        ac->saved.z = (s16) le16_to_cpu(buf[2]);
+        axis->z = ac->saved.z;
+        mutex_unlock(&ac->mutex);
+}
+
+static void adxl34x_service_ev_fifo(struct adxl34x *ac)
+{
+        struct adxl34x_platform_data *pdata = &ac->pdata;
+        struct axis_triple axis;
+
+        adxl34x_get_triple(ac, &axis);
+
+        input_event(ac->input, pdata->ev_type, pdata->ev_code_x,
+                    axis.x - ac->swcal.x);
+        input_event(ac->input, pdata->ev_type, pdata->ev_code_y,
+                    axis.y - ac->swcal.y);
+        input_event(ac->input, pdata->ev_type, pdata->ev_code_z,
+                    axis.z - ac->swcal.z);
+}
+
+static void adxl34x_report_key_single(struct input_dev *input, int key)
+{
+        input_report_key(input, key, true);
+        input_sync(input);
+        input_report_key(input, key, false);
+}
+
+static void adxl34x_send_key_events(struct adxl34x *ac,
+                struct adxl34x_platform_data *pdata, int status, int press)
+{
+        int i;
+
+        for (i = ADXL_X_AXIS; i <= ADXL_Z_AXIS; i++) {
+                if (status & (1 << (ADXL_Z_AXIS - i)))
+                        input_report_key(ac->input,
+                                         pdata->ev_code_tap[i], press);
+        }
+}
+
+static void adxl34x_do_tap(struct adxl34x *ac,
+                struct adxl34x_platform_data *pdata, int status)
+{
+        adxl34x_send_key_events(ac, pdata, status, true);
+        input_sync(ac->input);
+        adxl34x_send_key_events(ac, pdata, status, false);
+}
+
+static irqreturn_t adxl34x_irq(int irq, void *handle)
+{
+        struct adxl34x *ac = handle;
+        struct adxl34x_platform_data *pdata = &ac->pdata;
+        int int_stat, tap_stat, samples, orient, orient_code;
+
+        /*
+         * ACT_TAP_STATUS should be read before clearing the interrupt
+         * Avoid reading ACT_TAP_STATUS in case TAP detection is disabled
+         */
+
+        if (pdata->tap_axis_control & (TAP_X_EN | TAP_Y_EN | TAP_Z_EN))
+                tap_stat = AC_READ(ac, ACT_TAP_STATUS);
+        else
+                tap_stat = 0;
+
+        int_stat = AC_READ(ac, INT_SOURCE);
+
+        if (int_stat & FREE_FALL)
+                adxl34x_report_key_single(ac->input, pdata->ev_code_ff);
+
+        if (int_stat & OVERRUN)
+                dev_dbg(ac->dev, "OVERRUN\n");
+
+        if (int_stat & (SINGLE_TAP | DOUBLE_TAP)) {
+                adxl34x_do_tap(ac, pdata, tap_stat);
+
+                if (int_stat & DOUBLE_TAP)
+                        adxl34x_do_tap(ac, pdata, tap_stat);
+        }
+
+        if (pdata->ev_code_act_inactivity) {
+                if (int_stat & ACTIVITY)
+                        input_report_key(ac->input,
+                                         pdata->ev_code_act_inactivity, 1);
+                if (int_stat & INACTIVITY)
+                        input_report_key(ac->input,
+                                         pdata->ev_code_act_inactivity, 0);
+        }
+
+        /*
+         * ORIENTATION SENSING ADXL346 only
+         */
+        if (pdata->orientation_enable) {
+                orient = AC_READ(ac, ORIENT);
+                if ((pdata->orientation_enable & ADXL_EN_ORIENTATION_2D) &&
+                    (orient & ADXL346_2D_VALID)) {
+
+                        orient_code = ADXL346_2D_ORIENT(orient);
+                        /* Report orientation only when it changes */
+                        if (ac->orient2d_saved != orient_code) {
+                                ac->orient2d_saved = orient_code;
+                                adxl34x_report_key_single(ac->input,
+                                        pdata->ev_codes_orient_2d[orient_code]);
+                        }
+                }
+
+                if ((pdata->orientation_enable & ADXL_EN_ORIENTATION_3D) &&
+                    (orient & ADXL346_3D_VALID)) {
+
+                        orient_code = ADXL346_3D_ORIENT(orient) - 1;
+                        /* Report orientation only when it changes */
+                        if (ac->orient3d_saved != orient_code) {
+                                ac->orient3d_saved = orient_code;
+                                adxl34x_report_key_single(ac->input,
+                                        pdata->ev_codes_orient_3d[orient_code]);
+                        }
+                }
+        }
+
+        if (int_stat & (DATA_READY | WATERMARK)) {
+
+                if (pdata->fifo_mode)
+                        samples = ENTRIES(AC_READ(ac, FIFO_STATUS)) + 1;
+                else
+                        samples = 1;
+
+                for (; samples > 0; samples--) {
+                        adxl34x_service_ev_fifo(ac);
+                        /*
+                         * To ensure that the FIFO has
+                         * completely popped, there must be at least 5 us between
+                         * the end of reading the data registers, signified by the
+                         * transition to register 0x38 from 0x37 or the CS pin
+                         * going high, and the start of new reads of the FIFO or
+                         * reading the FIFO_STATUS register. For SPI operation at
+                         * 1.5 MHz or lower, the register addressing portion of the
+                         * transmission is sufficient delay to ensure the FIFO has
+                         * completely popped. It is necessary for SPI operation
+                         * greater than 1.5 MHz to de-assert the CS pin to ensure a
+                         * total of 5 us, which is at most 3.4 us at 5 MHz
+                         * operation.
+                         */
+                        if (ac->fifo_delay && (samples > 1))
+                                udelay(3);
+                }
+        }
+
+        input_sync(ac->input);
+
+        return IRQ_HANDLED;
+}
+
+static void __adxl34x_disable(struct adxl34x *ac)
+{
+        /*
+         * A '0' places the ADXL34x into standby mode
+         * with minimum power consumption.
+         */
+        AC_WRITE(ac, POWER_CTL, 0);
+}
+
+static void __adxl34x_enable(struct adxl34x *ac)
+{
+        AC_WRITE(ac, POWER_CTL, ac->pdata.power_mode | PCTL_MEASURE);
+}
+
+void adxl34x_suspend(struct adxl34x *ac)
+{
+        mutex_lock(&ac->mutex);
+
+        if (!ac->suspended && !ac->disabled && ac->opened)
+                __adxl34x_disable(ac);
+
+        ac->suspended = true;
+
+        mutex_unlock(&ac->mutex);
+}
+EXPORT_SYMBOL_GPL(adxl34x_suspend);
+
+void adxl34x_resume(struct adxl34x *ac)
+{
+        mutex_lock(&ac->mutex);
+
+        if (ac->suspended && !ac->disabled && ac->opened)
+                __adxl34x_enable(ac);
+
+        ac->suspended = false;
+
+        mutex_unlock(&ac->mutex);
+}
+EXPORT_SYMBOL_GPL(adxl34x_resume);
+
+static ssize_t adxl34x_disable_show(struct device *dev,
+                                    struct device_attribute *attr, char *buf)
+{
+        struct adxl34x *ac = dev_get_drvdata(dev);
+
+        return sprintf(buf, "%u\n", ac->disabled);
+}
+
+static ssize_t adxl34x_disable_store(struct device *dev,
+                                     struct device_attribute *attr,
+                                     const char *buf, size_t count)
+{
+        struct adxl34x *ac = dev_get_drvdata(dev);
+        unsigned long val;
+        int error;
+
+        error = strict_strtoul(buf, 10, &val);
+        if (error)
+                return error;
+
+        mutex_lock(&ac->mutex);
+
+        if (!ac->suspended && ac->opened) {
+                if (val) {
+                        if (!ac->disabled)
+                                __adxl34x_disable(ac);
+                } else {
+                        if (ac->disabled)
+                                __adxl34x_enable(ac);
+                }
+        }
+
+        ac->disabled = !!val;
+
+        mutex_unlock(&ac->mutex);
+
+        return count;
+}
+
+static DEVICE_ATTR(disable, 0664, adxl34x_disable_show, adxl34x_disable_store);
+
+static ssize_t adxl34x_calibrate_show(struct device *dev,
+                                      struct device_attribute *attr, char *buf)
+{
+        struct adxl34x *ac = dev_get_drvdata(dev);
+        ssize_t count;
+
+        mutex_lock(&ac->mutex);
+        count = sprintf(buf, "%d,%d,%d\n",
+                        ac->hwcal.x * 4 + ac->swcal.x,
+                        ac->hwcal.y * 4 + ac->swcal.y,
+                        ac->hwcal.z * 4 + ac->swcal.z);
+        mutex_unlock(&ac->mutex);
+
+        return count;
+}
+
+static ssize_t adxl34x_calibrate_store(struct device *dev,
+                                       struct device_attribute *attr,
+                                       const char *buf, size_t count)
+{
+        struct adxl34x *ac = dev_get_drvdata(dev);
+
+        /*
+         * Hardware offset calibration has a resolution of 15.6 mg/LSB.
+         * We use HW calibration and handle the remaining bits in SW. (4mg/LSB)
+         */
+
+        mutex_lock(&ac->mutex);
+        ac->hwcal.x -= (ac->saved.x / 4);
+        ac->swcal.x = ac->saved.x % 4;
+
+        ac->hwcal.y -= (ac->saved.y / 4);
+        ac->swcal.y = ac->saved.y % 4;
+
+        ac->hwcal.z -= (ac->saved.z / 4);
+        ac->swcal.z = ac->saved.z % 4;
+
+        AC_WRITE(ac, OFSX, (s8) ac->hwcal.x);
+        AC_WRITE(ac, OFSY, (s8) ac->hwcal.y);
+        AC_WRITE(ac, OFSZ, (s8) ac->hwcal.z);
+        mutex_unlock(&ac->mutex);
+
+        return count;
+}
+
+static DEVICE_ATTR(calibrate, 0664,
+                   adxl34x_calibrate_show, adxl34x_calibrate_store);
+
+static ssize_t adxl34x_rate_show(struct device *dev,
+                                 struct device_attribute *attr, char *buf)
+{
+        struct adxl34x *ac = dev_get_drvdata(dev);
+
+        return sprintf(buf, "%u\n", RATE(ac->pdata.data_rate));
+}
+
+static ssize_t adxl34x_rate_store(struct device *dev,
+                                  struct device_attribute *attr,
+                                  const char *buf, size_t count)
+{
+        struct adxl34x *ac = dev_get_drvdata(dev);
+        unsigned long val;
+        int error;
+
+        error = strict_strtoul(buf, 10, &val);
+        if (error)
+                return error;
+
+        mutex_lock(&ac->mutex);
+
+        ac->pdata.data_rate = RATE(val);
+        AC_WRITE(ac, BW_RATE,
+                 ac->pdata.data_rate |
+                        (ac->pdata.low_power_mode ? LOW_POWER : 0));
+
+        mutex_unlock(&ac->mutex);
+
+        return count;
+}
+
+static DEVICE_ATTR(rate, 0664, adxl34x_rate_show, adxl34x_rate_store);
+
+static ssize_t adxl34x_autosleep_show(struct device *dev,
+                                 struct device_attribute *attr, char *buf)
+{
+        struct adxl34x *ac = dev_get_drvdata(dev);
+
+        return sprintf(buf, "%u\n",
+                ac->pdata.power_mode & (PCTL_AUTO_SLEEP | PCTL_LINK) ? 1 : 0);
+}
+
+static ssize_t adxl34x_autosleep_store(struct device *dev,
+                                  struct device_attribute *attr,
+                                  const char *buf, size_t count)
+{
+        struct adxl34x *ac = dev_get_drvdata(dev);
+        unsigned long val;
+        int error;
+
+        error = strict_strtoul(buf, 10, &val);
+        if (error)
+                return error;
+
+        mutex_lock(&ac->mutex);
+
+        if (val)
+                ac->pdata.power_mode |= (PCTL_AUTO_SLEEP | PCTL_LINK);
+        else
+                ac->pdata.power_mode &= ~(PCTL_AUTO_SLEEP | PCTL_LINK);
+
+        if (!ac->disabled && !ac->suspended && ac->opened)
+                AC_WRITE(ac, POWER_CTL, ac->pdata.power_mode | PCTL_MEASURE);
+
+        mutex_unlock(&ac->mutex);
+
+        return count;
+}
+
+static DEVICE_ATTR(autosleep, 0664,
+                   adxl34x_autosleep_show, adxl34x_autosleep_store);
+
+static ssize_t adxl34x_position_show(struct device *dev,
+                                 struct device_attribute *attr, char *buf)
+{
+        struct adxl34x *ac = dev_get_drvdata(dev);
+        ssize_t count;
+
+        mutex_lock(&ac->mutex);
+        count = sprintf(buf, "(%d, %d, %d)\n",
+                        ac->saved.x, ac->saved.y, ac->saved.z);
+        mutex_unlock(&ac->mutex);
+
+        return count;
+}
+
+static DEVICE_ATTR(position, S_IRUGO, adxl34x_position_show, NULL);
+
+#ifdef ADXL_DEBUG
+static ssize_t adxl34x_write_store(struct device *dev,
+                                   struct device_attribute *attr,
+                                   const char *buf, size_t count)
+{
+        struct adxl34x *ac = dev_get_drvdata(dev);
+        unsigned long val;
+        int error;
+
+        /*
+         * This allows basic ADXL register write access for debug purposes.
+         */
+        error = strict_strtoul(buf, 16, &val);
+        if (error)
+                return error;
+
+        mutex_lock(&ac->mutex);
+        AC_WRITE(ac, val >> 8, val & 0xFF);
+        mutex_unlock(&ac->mutex);
+
+        return count;
+}
+
+static DEVICE_ATTR(write, 0664, NULL, adxl34x_write_store);
+#endif
+
+static struct attribute *adxl34x_attributes[] = {
+        &dev_attr_disable.attr,
+        &dev_attr_calibrate.attr,
+        &dev_attr_rate.attr,
+        &dev_attr_autosleep.attr,
+        &dev_attr_position.attr,
+#ifdef ADXL_DEBUG
+        &dev_attr_write.attr,
+#endif
+        NULL
+};
+
+static const struct attribute_group adxl34x_attr_group = {
+        .attrs = adxl34x_attributes,
+};
+
+static int adxl34x_input_open(struct input_dev *input)
+{
+        struct adxl34x *ac = input_get_drvdata(input);
+
+        mutex_lock(&ac->mutex);
+
+        if (!ac->suspended && !ac->disabled)
+                __adxl34x_enable(ac);
+
+        ac->opened = true;
+
+        mutex_unlock(&ac->mutex);
+
+        return 0;
+}
+
+static void adxl34x_input_close(struct input_dev *input)
+{
+        struct adxl34x *ac = input_get_drvdata(input);
+
+        mutex_lock(&ac->mutex);
+
+        if (!ac->suspended && !ac->disabled)
+                __adxl34x_disable(ac);
+
+        ac->opened = false;
+
+        mutex_unlock(&ac->mutex);
+}
+
+struct adxl34x *adxl34x_probe(struct device *dev, int irq,
+                              bool fifo_delay_default,
+                              const struct adxl34x_bus_ops *bops)
+{
+        struct adxl34x *ac;
+        struct input_dev *input_dev;
+        const struct adxl34x_platform_data *pdata;
+        int err, range, i;
+        unsigned char revid;
+
+        if (!irq) {
+                dev_err(dev, "no IRQ?\n");
+                err = -ENODEV;
+                goto err_out;
+        }
+
+        ac = kzalloc(sizeof(*ac), GFP_KERNEL);
+        input_dev = input_allocate_device();
+        if (!ac || !input_dev) {
+                err = -ENOMEM;
+                goto err_free_mem;
+        }
+
+        ac->fifo_delay = fifo_delay_default;
+
+        pdata = dev->platform_data;
+        if (!pdata) {
+                dev_dbg(dev,
+                        "No platfrom data: Using default initialization\n");
+                pdata = &adxl34x_default_init;
+        }
+
+        ac->pdata = *pdata;
+        pdata = &ac->pdata;
+
+        ac->input = input_dev;
+        ac->dev = dev;
+        ac->irq = irq;
+        ac->bops = bops;
+
+        mutex_init(&ac->mutex);
+
+        input_dev->name = "ADXL34x accelerometer";
+        revid = ac->bops->read(dev, DEVID);
+
+        switch (revid) {
+        case ID_ADXL345:
+                ac->model = 345;
+                break;
+        case ID_ADXL346:
+                ac->model = 346;
+                break;
+        default:
+                dev_err(dev, "Failed to probe %s\n", input_dev->name);
+                err = -ENODEV;
+                goto err_free_mem;
+        }
+
+        snprintf(ac->phys, sizeof(ac->phys), "%s/input0", dev_name(dev));
+
+        input_dev->phys = ac->phys;
+        input_dev->dev.parent = dev;
+        input_dev->id.product = ac->model;
+        input_dev->id.bustype = bops->bustype;
+        input_dev->open = adxl34x_input_open;
+        input_dev->close = adxl34x_input_close;
+
+        input_set_drvdata(input_dev, ac);
+
+        __set_bit(ac->pdata.ev_type, input_dev->evbit);
+
+        if (ac->pdata.ev_type == EV_REL) {
+                __set_bit(REL_X, input_dev->relbit);
+                __set_bit(REL_Y, input_dev->relbit);
+                __set_bit(REL_Z, input_dev->relbit);
+        } else {
+                /* EV_ABS */
+                __set_bit(ABS_X, input_dev->absbit);
+                __set_bit(ABS_Y, input_dev->absbit);
+                __set_bit(ABS_Z, input_dev->absbit);
+
+                if (pdata->data_range & FULL_RES)
+                        range = ADXL_FULLRES_MAX_VAL;   /* Signed 13-bit */
+                else
+                        range = ADXL_FIXEDRES_MAX_VAL;  /* Signed 10-bit */
+
+                input_set_abs_params(input_dev, ABS_X, -range, range, 3, 3);
+                input_set_abs_params(input_dev, ABS_Y, -range, range, 3, 3);
+                input_set_abs_params(input_dev, ABS_Z, -range, range, 3, 3);
+        }
+
+        __set_bit(EV_KEY, input_dev->evbit);
+        __set_bit(pdata->ev_code_tap[ADXL_X_AXIS], input_dev->keybit);
+        __set_bit(pdata->ev_code_tap[ADXL_Y_AXIS], input_dev->keybit);
+        __set_bit(pdata->ev_code_tap[ADXL_Z_AXIS], input_dev->keybit);
+
+        if (pdata->ev_code_ff) {
+                ac->int_mask = FREE_FALL;
+                __set_bit(pdata->ev_code_ff, input_dev->keybit);
+        }
+
+        if (pdata->ev_code_act_inactivity)
+                __set_bit(pdata->ev_code_act_inactivity, input_dev->keybit);
+
+        ac->int_mask |= ACTIVITY | INACTIVITY;
+
+        if (pdata->watermark) {
+                ac->int_mask |= WATERMARK;
+                if (!FIFO_MODE(pdata->fifo_mode))
+                        ac->pdata.fifo_mode |= FIFO_STREAM;
+        } else {
+                ac->int_mask |= DATA_READY;
+        }
+
+        if (pdata->tap_axis_control & (TAP_X_EN | TAP_Y_EN | TAP_Z_EN))
+                ac->int_mask |= SINGLE_TAP | DOUBLE_TAP;
+
+        if (FIFO_MODE(pdata->fifo_mode) == FIFO_BYPASS)
+                ac->fifo_delay = false;
+
+        ac->bops->write(dev, POWER_CTL, 0);
+
+        err = request_threaded_irq(ac->irq, NULL, adxl34x_irq,
+                                   IRQF_TRIGGER_HIGH | IRQF_ONESHOT,
+                                   dev_name(dev), ac);
+        if (err) {
+                dev_err(dev, "irq %d busy?\n", ac->irq);
+                goto err_free_mem;
+        }
+
+        err = sysfs_create_group(&dev->kobj, &adxl34x_attr_group);
+        if (err)
+                goto err_free_irq;
+
+        err = input_register_device(input_dev);
+        if (err)
+                goto err_remove_attr;
+
+        AC_WRITE(ac, THRESH_TAP, pdata->tap_threshold);
+        AC_WRITE(ac, OFSX, pdata->x_axis_offset);
+        ac->hwcal.x = pdata->x_axis_offset;
+        AC_WRITE(ac, OFSY, pdata->y_axis_offset);
+        ac->hwcal.y = pdata->y_axis_offset;
+        AC_WRITE(ac, OFSZ, pdata->z_axis_offset);
+        ac->hwcal.z = pdata->z_axis_offset;
+        AC_WRITE(ac, THRESH_TAP, pdata->tap_threshold);
+        AC_WRITE(ac, DUR, pdata->tap_duration);
+        AC_WRITE(ac, LATENT, pdata->tap_latency);
+        AC_WRITE(ac, WINDOW, pdata->tap_window);
+        AC_WRITE(ac, THRESH_ACT, pdata->activity_threshold);
+        AC_WRITE(ac, THRESH_INACT, pdata->inactivity_threshold);
+        AC_WRITE(ac, TIME_INACT, pdata->inactivity_time);
+        AC_WRITE(ac, THRESH_FF, pdata->free_fall_threshold);
+        AC_WRITE(ac, TIME_FF, pdata->free_fall_time);
+        AC_WRITE(ac, TAP_AXES, pdata->tap_axis_control);
+        AC_WRITE(ac, ACT_INACT_CTL, pdata->act_axis_control);
+        AC_WRITE(ac, BW_RATE, RATE(ac->pdata.data_rate) |
+                 (pdata->low_power_mode ? LOW_POWER : 0));
+        AC_WRITE(ac, DATA_FORMAT, pdata->data_range);
+        AC_WRITE(ac, FIFO_CTL, FIFO_MODE(pdata->fifo_mode) |
+                        SAMPLES(pdata->watermark));
+
+        if (pdata->use_int2) {
+                /* Map all INTs to INT2 */
+                AC_WRITE(ac, INT_MAP, ac->int_mask | OVERRUN);
+        } else {
+                /* Map all INTs to INT1 */
+                AC_WRITE(ac, INT_MAP, 0);
+        }
+
+        if (ac->model == 346 && ac->pdata.orientation_enable) {
+                AC_WRITE(ac, ORIENT_CONF,
+                        ORIENT_DEADZONE(ac->pdata.deadzone_angle) |
+                        ORIENT_DIVISOR(ac->pdata.divisor_length));
+
+                ac->orient2d_saved = 1234;
+                ac->orient3d_saved = 1234;
+
+                if (pdata->orientation_enable & ADXL_EN_ORIENTATION_3D)
+                        for (i = 0; i < ARRAY_SIZE(pdata->ev_codes_orient_3d); i++)
+                                __set_bit(pdata->ev_codes_orient_3d[i],
+                                          input_dev->keybit);
+
+                if (pdata->orientation_enable & ADXL_EN_ORIENTATION_2D)
+                        for (i = 0; i < ARRAY_SIZE(pdata->ev_codes_orient_2d); i++)
+                                __set_bit(pdata->ev_codes_orient_2d[i],
+                                          input_dev->keybit);
+        } else {
+                ac->pdata.orientation_enable = 0;
+        }
+
+        AC_WRITE(ac, INT_ENABLE, ac->int_mask | OVERRUN);
+
+        ac->pdata.power_mode &= (PCTL_AUTO_SLEEP | PCTL_LINK);
+
+        return ac;
+
+ err_remove_attr:
+        sysfs_remove_group(&dev->kobj, &adxl34x_attr_group);
+ err_free_irq:
+        free_irq(ac->irq, ac);
+ err_free_mem:
+        input_free_device(input_dev);
+        kfree(ac);
+ err_out:
+        return ERR_PTR(err);
+}
+EXPORT_SYMBOL_GPL(adxl34x_probe);
+
+int adxl34x_remove(struct adxl34x *ac)
+{
+        sysfs_remove_group(&ac->dev->kobj, &adxl34x_attr_group);
+        free_irq(ac->irq, ac);
+        input_unregister_device(ac->input);
+        dev_dbg(ac->dev, "unregistered accelerometer\n");
+        kfree(ac);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(adxl34x_remove);
+
+MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
+MODULE_DESCRIPTION("ADXL345/346 Three-Axis Digital Accelerometer Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/misc/adxl34x.h b/drivers/input/misc/adxl34x.h
new file mode 100644
index 000000000000..bbbc80fda164
--- /dev/null
+++ b/drivers/input/misc/adxl34x.h
@@ -0,0 +1,30 @@
+/*
+ * ADXL345/346 Three-Axis Digital Accelerometers (I2C/SPI Interface)
+ *
+ * Enter bugs at http://blackfin.uclinux.org/
+ *
+ * Copyright (C) 2009 Michael Hennerich, Analog Devices Inc.
+ * Licensed under the GPL-2 or later.
+ */
+
+#ifndef _ADXL34X_H_
+#define _ADXL34X_H_
+
+struct device;
+struct adxl34x;
+
+struct adxl34x_bus_ops {
+        u16 bustype;
+        int (*read)(struct device *, unsigned char);
+        int (*read_block)(struct device *, unsigned char, int, void *);
+        int (*write)(struct device *, unsigned char, unsigned char);
+};
+
+void adxl34x_suspend(struct adxl34x *ac);
+void adxl34x_resume(struct adxl34x *ac);
+struct adxl34x *adxl34x_probe(struct device *dev, int irq,
+                              bool fifo_delay_default,
+                              const struct adxl34x_bus_ops *bops);
+int adxl34x_remove(struct adxl34x *ac);
+
+#endif
diff --git a/drivers/input/misc/apanel.c b/drivers/input/misc/apanel.c
index 71b82434264d..a8d2b8db4e35 100644
--- a/drivers/input/misc/apanel.c
+++ b/drivers/input/misc/apanel.c
@@ -149,7 +149,7 @@ static void apanel_shutdown(struct i2c_client *client)
         apanel_remove(client);
 }
 
-static struct i2c_device_id apanel_id[] = {
+static const struct i2c_device_id apanel_id[] = {
         { "fujitsu_apanel", 0 },
         { }
 };
diff --git a/drivers/input/misc/ati_remote.c b/drivers/input/misc/ati_remote.c
index 614b65d78fe9..bce57129afba 100644
--- a/drivers/input/misc/ati_remote.c
+++ b/drivers/input/misc/ati_remote.c
@@ -98,10 +98,12 @@
  * Module and Version Information, Module Parameters
  */
 
-#define ATI_REMOTE_VENDOR_ID    0x0bc7
-#define ATI_REMOTE_PRODUCT_ID   0x004
-#define LOLA_REMOTE_PRODUCT_ID  0x002
-#define MEDION_REMOTE_PRODUCT_ID 0x006
+#define ATI_REMOTE_VENDOR_ID            0x0bc7
+#define LOLA_REMOTE_PRODUCT_ID          0x0002
+#define LOLA2_REMOTE_PRODUCT_ID         0x0003
+#define ATI_REMOTE_PRODUCT_ID           0x0004
+#define NVIDIA_REMOTE_PRODUCT_ID        0x0005
+#define MEDION_REMOTE_PRODUCT_ID        0x0006
 
 #define DRIVER_VERSION          "2.2.1"
 #define DRIVER_AUTHOR           "Torrey Hoffman <thoffman@arnor.net>"
@@ -142,8 +144,10 @@ MODULE_PARM_DESC(repeat_delay, "Delay before sending repeats, default = 500 msec
 #define err(format, arg...) printk(KERN_ERR format , ## arg)
 
 static struct usb_device_id ati_remote_table[] = {
-        { USB_DEVICE(ATI_REMOTE_VENDOR_ID, ATI_REMOTE_PRODUCT_ID) },
         { USB_DEVICE(ATI_REMOTE_VENDOR_ID, LOLA_REMOTE_PRODUCT_ID) },
+        { USB_DEVICE(ATI_REMOTE_VENDOR_ID, LOLA2_REMOTE_PRODUCT_ID) },
+        { USB_DEVICE(ATI_REMOTE_VENDOR_ID, ATI_REMOTE_PRODUCT_ID) },
+        { USB_DEVICE(ATI_REMOTE_VENDOR_ID, NVIDIA_REMOTE_PRODUCT_ID) },
         { USB_DEVICE(ATI_REMOTE_VENDOR_ID, MEDION_REMOTE_PRODUCT_ID) },
         {}      /* Terminating entry */
 };
@@ -620,13 +624,13 @@ static void ati_remote_irq_in(struct urb *urb)
 static int ati_remote_alloc_buffers(struct usb_device *udev,
                                     struct ati_remote *ati_remote)
 {
-        ati_remote->inbuf = usb_buffer_alloc(udev, DATA_BUFSIZE, GFP_ATOMIC,
-                                             &ati_remote->inbuf_dma);
+        ati_remote->inbuf = usb_alloc_coherent(udev, DATA_BUFSIZE, GFP_ATOMIC,
+                                               &ati_remote->inbuf_dma);
         if (!ati_remote->inbuf)
                 return -1;
 
-        ati_remote->outbuf = usb_buffer_alloc(udev, DATA_BUFSIZE, GFP_ATOMIC,
-                                              &ati_remote->outbuf_dma);
+        ati_remote->outbuf = usb_alloc_coherent(udev, DATA_BUFSIZE, GFP_ATOMIC,
+                                                &ati_remote->outbuf_dma);
         if (!ati_remote->outbuf)
                 return -1;
 
@@ -649,10 +653,10 @@ static void ati_remote_free_buffers(struct ati_remote *ati_remote)
         usb_free_urb(ati_remote->irq_urb);
         usb_free_urb(ati_remote->out_urb);
 
-        usb_buffer_free(ati_remote->udev, DATA_BUFSIZE,
+        usb_free_coherent(ati_remote->udev, DATA_BUFSIZE,
                 ati_remote->inbuf, ati_remote->inbuf_dma);
 
-        usb_buffer_free(ati_remote->udev, DATA_BUFSIZE,
+        usb_free_coherent(ati_remote->udev, DATA_BUFSIZE,
                 ati_remote->outbuf, ati_remote->outbuf_dma);
 }
 
diff --git a/drivers/input/misc/ati_remote2.c b/drivers/input/misc/ati_remote2.c
index 0501f0e65157..0b0e9be63542 100644
--- a/drivers/input/misc/ati_remote2.c
+++ b/drivers/input/misc/ati_remote2.c
@@ -10,6 +10,7 @@
  */
 
 #include <linux/usb/input.h>
+#include <linux/slab.h>
 
 #define DRIVER_DESC    "ATI/Philips USB RF remote driver"
 #define DRIVER_VERSION "0.3"
@@ -37,7 +38,8 @@ enum {
 };
 
 static int ati_remote2_set_mask(const char *val,
-                                struct kernel_param *kp, unsigned int max)
+                                const struct kernel_param *kp,
+                                unsigned int max)
 {
         unsigned long mask;
         int ret;
@@ -58,28 +60,31 @@ static int ati_remote2_set_mask(const char *val,
 }
 
 static int ati_remote2_set_channel_mask(const char *val,
-                                        struct kernel_param *kp)
+                                        const struct kernel_param *kp)
 {
         pr_debug("%s()\n", __func__);
 
         return ati_remote2_set_mask(val, kp, ATI_REMOTE2_MAX_CHANNEL_MASK);
 }
 
-static int ati_remote2_get_channel_mask(char *buffer, struct kernel_param *kp)
+static int ati_remote2_get_channel_mask(char *buffer,
+                                        const struct kernel_param *kp)
 {
         pr_debug("%s()\n", __func__);
 
         return sprintf(buffer, "0x%04x", *(unsigned int *)kp->arg);
 }
 
-static int ati_remote2_set_mode_mask(const char *val, struct kernel_param *kp)
+static int ati_remote2_set_mode_mask(const char *val,
+                                     const struct kernel_param *kp)
 {
         pr_debug("%s()\n", __func__);
 
         return ati_remote2_set_mask(val, kp, ATI_REMOTE2_MAX_MODE_MASK);
 }
 
-static int ati_remote2_get_mode_mask(char *buffer, struct kernel_param *kp)
+static int ati_remote2_get_mode_mask(char *buffer,
+                                     const struct kernel_param *kp)
 {
         pr_debug("%s()\n", __func__);
 
@@ -88,15 +93,19 @@ static int ati_remote2_get_mode_mask(char *buffer, struct kernel_param *kp)
 
 static unsigned int channel_mask = ATI_REMOTE2_MAX_CHANNEL_MASK;
 #define param_check_channel_mask(name, p) __param_check(name, p, unsigned int)
-#define param_set_channel_mask ati_remote2_set_channel_mask
-#define param_get_channel_mask ati_remote2_get_channel_mask
+static struct kernel_param_ops param_ops_channel_mask = {
+        .set = ati_remote2_set_channel_mask,
+        .get = ati_remote2_get_channel_mask,
+};
 module_param(channel_mask, channel_mask, 0644);
 MODULE_PARM_DESC(channel_mask, "Bitmask of channels to accept <15:Channel16>...<1:Channel2><0:Channel1>");
 
 static unsigned int mode_mask = ATI_REMOTE2_MAX_MODE_MASK;
 #define param_check_mode_mask(name, p) __param_check(name, p, unsigned int)
-#define param_set_mode_mask ati_remote2_set_mode_mask
-#define param_get_mode_mask ati_remote2_get_mode_mask
+static struct kernel_param_ops param_ops_mode_mask = {
+        .set = ati_remote2_set_mode_mask,
+        .get = ati_remote2_get_mode_mask,
+};
 module_param(mode_mask, mode_mask, 0644);
 MODULE_PARM_DESC(mode_mask, "Bitmask of modes to accept <4:PC><3:AUX4><2:AUX3><1:AUX2><0:AUX1>");
 
@@ -474,51 +483,88 @@ static void ati_remote2_complete_key(struct urb *urb)
 }
 
 static int ati_remote2_getkeycode(struct input_dev *idev,
-                                  int scancode, int *keycode)
+                                  struct input_keymap_entry *ke)
 {
         struct ati_remote2 *ar2 = input_get_drvdata(idev);
-        int index, mode;
-
-        mode = scancode >> 8;
-        if (mode > ATI_REMOTE2_PC || !((1 << mode) & ar2->mode_mask))
-                return -EINVAL;
+        unsigned int mode;
+        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, int scancode, int keycode)
+static int ati_remote2_setkeycode(struct input_dev *idev,
+                                  const struct input_keymap_entry *ke,
+                                  unsigned int *old_keycode)
 {
         struct ati_remote2 *ar2 = input_get_drvdata(idev);
-        int index, mode, old_keycode;
-
-        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;
-
-        if (keycode < KEY_RESERVED || keycode > KEY_MAX)
-                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;
 }
@@ -566,8 +612,8 @@ static int ati_remote2_input_init(struct ati_remote2 *ar2)
         idev->open = ati_remote2_open;
         idev->close = ati_remote2_close;
 
-        idev->getkeycode = ati_remote2_getkeycode;
-        idev->setkeycode = ati_remote2_setkeycode;
+        idev->getkeycode_new = ati_remote2_getkeycode;
+        idev->setkeycode_new = ati_remote2_setkeycode;
 
         idev->name = ar2->name;
         idev->phys = ar2->phys;
@@ -588,7 +634,7 @@ static int ati_remote2_urb_init(struct ati_remote2 *ar2)
         int i, pipe, maxp;
 
         for (i = 0; i < 2; i++) {
-                ar2->buf[i] = usb_buffer_alloc(udev, 4, GFP_KERNEL, &ar2->buf_dma[i]);
+                ar2->buf[i] = usb_alloc_coherent(udev, 4, GFP_KERNEL, &ar2->buf_dma[i]);
                 if (!ar2->buf[i])
                         return -ENOMEM;
 
@@ -616,7 +662,7 @@ static void ati_remote2_urb_cleanup(struct ati_remote2 *ar2)
 
         for (i = 0; i < 2; i++) {
                 usb_free_urb(ar2->urb[i]);
-                usb_buffer_free(ar2->udev, 4, ar2->buf[i], ar2->buf_dma[i]);
+                usb_free_coherent(ar2->udev, 4, ar2->buf[i], ar2->buf_dma[i]);
         }
 }
 
diff --git a/drivers/input/misc/atlas_btns.c b/drivers/input/misc/atlas_btns.c
index 1b871917340a..601f7372f9c4 100644
--- a/drivers/input/misc/atlas_btns.c
+++ b/drivers/input/misc/atlas_btns.c
@@ -21,6 +21,8 @@
  *
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/init.h>
@@ -47,7 +49,7 @@ static acpi_status acpi_atlas_button_setup(acpi_handle region_handle,
 
 static acpi_status acpi_atlas_button_handler(u32 function,
                       acpi_physical_address address,
-                      u32 bit_width, acpi_integer *value,
+                      u32 bit_width, u64 *value,
                       void *handler_context, void *region_context)
 {
         acpi_status status;
@@ -60,12 +62,11 @@ static acpi_status acpi_atlas_button_handler(u32 function,
                 input_report_key(input_dev, atlas_keymap[code], key_down);
                 input_sync(input_dev);
 
-                status = 0;
+                status = AE_OK;
         } else {
-                printk(KERN_WARNING "atlas: shrugged on unexpected function"
-                        ":function=%x,address=%lx,value=%x\n",
+                pr_warn("shrugged on unexpected function: function=%x,address=%lx,value=%x\n",
                         function, (unsigned long)address, (u32)*value);
-                status = -EINVAL;
+                status = AE_BAD_PARAMETER;
         }
 
         return status;
@@ -79,7 +80,7 @@ static int atlas_acpi_button_add(struct acpi_device *device)
 
         input_dev = input_allocate_device();
         if (!input_dev) {
-                printk(KERN_ERR "atlas: unable to allocate input device\n");
+                pr_err("unable to allocate input device\n");
                 return -ENOMEM;
         }
 
@@ -102,7 +103,7 @@ static int atlas_acpi_button_add(struct acpi_device *device)
 
         err = input_register_device(input_dev);
         if (err) {
-                printk(KERN_ERR "atlas: couldn't register input device\n");
+                pr_err("couldn't register input device\n");
                 input_free_device(input_dev);
                 return err;
         }
@@ -112,12 +113,12 @@ static int atlas_acpi_button_add(struct acpi_device *device)
                                 0x81, &acpi_atlas_button_handler,
                                 &acpi_atlas_button_setup, device);
         if (ACPI_FAILURE(status)) {
-                printk(KERN_ERR "Atlas: Error installing addr spc handler\n");
+                pr_err("error installing addr spc handler\n");
                 input_unregister_device(input_dev);
-                status = -EINVAL;
+                err = -EINVAL;
         }
 
-        return status;
+        return err;
 }
 
 static int atlas_acpi_button_remove(struct acpi_device *device, int type)
@@ -126,14 +127,12 @@ static int atlas_acpi_button_remove(struct acpi_device *device, int type)
 
         status = acpi_remove_address_space_handler(device->handle,
                                 0x81, &acpi_atlas_button_handler);
-        if (ACPI_FAILURE(status)) {
-                printk(KERN_ERR "Atlas: Error removing addr spc handler\n");
-                status = -EINVAL;
-        }
+        if (ACPI_FAILURE(status))
+                pr_err("error removing addr spc handler\n");
 
         input_unregister_device(input_dev);
 
-        return status;
+        return 0;
 }
 
 static const struct acpi_device_id atlas_device_ids[] = {
@@ -145,6 +144,7 @@ MODULE_DEVICE_TABLE(acpi, atlas_device_ids);
 static struct acpi_driver atlas_acpi_driver = {
         .name   = ACPI_ATLAS_NAME,
         .class  = ACPI_ATLAS_CLASS,
+        .owner  = THIS_MODULE,
         .ids    = atlas_device_ids,
         .ops    = {
                 .add    = atlas_acpi_button_add,
@@ -154,18 +154,10 @@ static struct acpi_driver atlas_acpi_driver = {
 
 static int __init atlas_acpi_init(void)
 {
-        int result;
-
         if (acpi_disabled)
                 return -ENODEV;
 
-        result = acpi_bus_register_driver(&atlas_acpi_driver);
-        if (result < 0) {
-                printk(KERN_ERR "Atlas ACPI: Unable to register driver\n");
-                return -ENODEV;
-        }
-
-        return 0;
+        return acpi_bus_register_driver(&atlas_acpi_driver);
 }
 
 static void __exit atlas_acpi_exit(void)
diff --git a/drivers/input/misc/bfin_rotary.c b/drivers/input/misc/bfin_rotary.c
index 61d10177fa83..4f72bdd69410 100644
--- a/drivers/input/misc/bfin_rotary.c
+++ b/drivers/input/misc/bfin_rotary.c
@@ -13,6 +13,7 @@
 #include <linux/pm.h>
 #include <linux/platform_device.h>
 #include <linux/input.h>
+#include <linux/slab.h>
 
 #include <asm/portmux.h>
 #include <asm/bfin_rotary.h>
diff --git a/drivers/input/misc/cm109.c b/drivers/input/misc/cm109.c
index 86457feccfc4..b09c7d127219 100644
--- a/drivers/input/misc/cm109.c
+++ b/drivers/input/misc/cm109.c
@@ -102,7 +102,6 @@ struct cm109_dev {
         struct cm109_ctl_packet *ctl_data;
         dma_addr_t ctl_dma;
         struct usb_ctrlrequest *ctl_req;
-        dma_addr_t ctl_req_dma;
         struct urb *urb_ctl;
         /*
          * The 3 bitfields below are protected by ctl_submit_lock.
@@ -260,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
  *
@@ -629,15 +628,13 @@ static const struct usb_device_id cm109_usb_table[] = {
 
 static void cm109_usb_cleanup(struct cm109_dev *dev)
 {
-        if (dev->ctl_req)
-                usb_buffer_free(dev->udev, sizeof(*(dev->ctl_req)),
-                                dev->ctl_req, dev->ctl_req_dma);
+        kfree(dev->ctl_req);
         if (dev->ctl_data)
-                usb_buffer_free(dev->udev, USB_PKT_LEN,
-                                dev->ctl_data, dev->ctl_dma);
+                usb_free_coherent(dev->udev, USB_PKT_LEN,
+                                  dev->ctl_data, dev->ctl_dma);
         if (dev->irq_data)
-                usb_buffer_free(dev->udev, USB_PKT_LEN,
-                                dev->irq_data, dev->irq_dma);
+                usb_free_coherent(dev->udev, USB_PKT_LEN,
+                                  dev->irq_data, dev->irq_dma);
 
         usb_free_urb(dev->urb_irq);     /* parameter validation in core/urb */
         usb_free_urb(dev->urb_ctl);     /* parameter validation in core/urb */
@@ -686,18 +683,17 @@ static int cm109_usb_probe(struct usb_interface *intf,
                 goto err_out;
 
         /* allocate usb buffers */
-        dev->irq_data = usb_buffer_alloc(udev, USB_PKT_LEN,
-                                         GFP_KERNEL, &dev->irq_dma);
+        dev->irq_data = usb_alloc_coherent(udev, USB_PKT_LEN,
+                                           GFP_KERNEL, &dev->irq_dma);
         if (!dev->irq_data)
                 goto err_out;
 
-        dev->ctl_data = usb_buffer_alloc(udev, USB_PKT_LEN,
-                                         GFP_KERNEL, &dev->ctl_dma);
+        dev->ctl_data = usb_alloc_coherent(udev, USB_PKT_LEN,
+                                           GFP_KERNEL, &dev->ctl_dma);
         if (!dev->ctl_data)
                 goto err_out;
 
-        dev->ctl_req = usb_buffer_alloc(udev, sizeof(*(dev->ctl_req)),
-                                        GFP_KERNEL, &dev->ctl_req_dma);
+        dev->ctl_req = kmalloc(sizeof(*(dev->ctl_req)), GFP_KERNEL);
         if (!dev->ctl_req)
                 goto err_out;
 
@@ -735,10 +731,8 @@ static int cm109_usb_probe(struct usb_interface *intf,
         usb_fill_control_urb(dev->urb_ctl, udev, usb_sndctrlpipe(udev, 0),
                              (void *)dev->ctl_req, dev->ctl_data, USB_PKT_LEN,
                              cm109_urb_ctl_callback, dev);
-        dev->urb_ctl->setup_dma = dev->ctl_req_dma;
         dev->urb_ctl->transfer_dma = dev->ctl_dma;
-        dev->urb_ctl->transfer_flags |= URB_NO_SETUP_DMA_MAP |
-                                        URB_NO_TRANSFER_DMA_MAP;
+        dev->urb_ctl->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
         dev->urb_ctl->dev = udev;
 
         /* find out the physical bus location */
diff --git a/drivers/input/misc/cobalt_btns.c b/drivers/input/misc/cobalt_btns.c
index ee73d7219c92..fd8407a29631 100644
--- a/drivers/input/misc/cobalt_btns.c
+++ b/drivers/input/misc/cobalt_btns.c
@@ -22,6 +22,7 @@
 #include <linux/ioport.h>
 #include <linux/module.h>
 #include <linux/platform_device.h>
+#include <linux/slab.h>
 
 #define BUTTONS_POLL_INTERVAL   30      /* msec */
 #define BUTTONS_COUNT_THRESHOLD 3
diff --git a/drivers/input/misc/dm355evm_keys.c b/drivers/input/misc/dm355evm_keys.c
index 766c06911f41..19af682c24fb 100644
--- a/drivers/input/misc/dm355evm_keys.c
+++ b/drivers/input/misc/dm355evm_keys.c
@@ -10,6 +10,7 @@
  */
 #include <linux/kernel.h>
 #include <linux/init.h>
+#include <linux/slab.h>
 #include <linux/input.h>
 #include <linux/input/sparse-keymap.h>
 #include <linux/platform_device.h>
diff --git a/drivers/input/misc/hp_sdc_rtc.c b/drivers/input/misc/hp_sdc_rtc.c
index ad730e15afc0..0b4f54265f62 100644
--- a/drivers/input/misc/hp_sdc_rtc.c
+++ b/drivers/input/misc/hp_sdc_rtc.c
@@ -43,6 +43,7 @@
 #include <linux/proc_fs.h>
 #include <linux/poll.h>
 #include <linux/rtc.h>
+#include <linux/mutex.h>
 #include <linux/semaphore.h>
 
 MODULE_AUTHOR("Brian S. Julin <bri@calyx.com>");
@@ -51,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;
@@ -64,8 +66,8 @@ static DECLARE_WAIT_QUEUE_HEAD(hp_sdc_rtc_wait);
 static ssize_t hp_sdc_rtc_read(struct file *file, char __user *buf,
                                size_t count, loff_t *ppos);
 
-static int hp_sdc_rtc_ioctl(struct inode *inode, struct file *file,
-                            unsigned int cmd, unsigned long arg);
+static long hp_sdc_rtc_unlocked_ioctl(struct file *file,
+                                      unsigned int cmd, unsigned long arg);
 
 static unsigned int hp_sdc_rtc_poll(struct file *file, poll_table *wait);
 
@@ -103,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;
         
@@ -512,7 +514,7 @@ static int hp_sdc_rtc_read_proc(char *page, char **start, off_t off,
         return len;
 }
 
-static int hp_sdc_rtc_ioctl(struct inode *inode, struct file *file, 
+static int hp_sdc_rtc_ioctl(struct file *file, 
                             unsigned int cmd, unsigned long arg)
 {
 #if 1
@@ -659,14 +661,27 @@ static int hp_sdc_rtc_ioctl(struct inode *inode, struct file *file,
 #endif
 }
 
+static long hp_sdc_rtc_unlocked_ioctl(struct file *file,
+                                      unsigned int cmd, unsigned long arg)
+{
+        int ret;
+
+        mutex_lock(&hp_sdc_rtc_mutex);
+        ret = hp_sdc_rtc_ioctl(file, cmd, arg);
+        mutex_unlock(&hp_sdc_rtc_mutex);
+
+        return ret;
+}
+
+
 static const struct file_operations hp_sdc_rtc_fops = {
-        .owner =        THIS_MODULE,
-        .llseek =       no_llseek,
-        .read =         hp_sdc_rtc_read,
-        .poll =         hp_sdc_rtc_poll,
-        .ioctl =        hp_sdc_rtc_ioctl,
-        .open =         hp_sdc_rtc_open,
-        .fasync =       hp_sdc_rtc_fasync,
+        .owner =                THIS_MODULE,
+        .llseek =               no_llseek,
+        .read =                 hp_sdc_rtc_read,
+        .poll =                 hp_sdc_rtc_poll,
+        .unlocked_ioctl =       hp_sdc_rtc_unlocked_ioctl,
+        .open =                 hp_sdc_rtc_open,
+        .fasync =               hp_sdc_rtc_fasync,
 };
 
 static struct miscdevice hp_sdc_rtc_dev = {
@@ -684,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 9946d73624b9..9dfd6e5f786f 100644
--- a/drivers/input/misc/ixp4xx-beeper.c
+++ b/drivers/input/misc/ixp4xx-beeper.c
@@ -115,7 +115,8 @@ static int __devinit ixp4xx_spkr_probe(struct platform_device *dev)
         input_dev->event = ixp4xx_spkr_event;
 
         err = request_irq(IRQ_IXP4XX_TIMER2, &ixp4xx_spkr_interrupt,
-                          IRQF_DISABLED | IRQF_TIMER, "ixp4xx-beeper", (void *) dev->id);
+                          IRQF_DISABLED | IRQF_NO_SUSPEND, "ixp4xx-beeper",
+                          (void *) dev->id);
         if (err)
                 goto err_free_device;
 
diff --git a/drivers/input/misc/keyspan_remote.c b/drivers/input/misc/keyspan_remote.c
index 86afdd1fdf9d..a93c525475c6 100644
--- a/drivers/input/misc/keyspan_remote.c
+++ b/drivers/input/misc/keyspan_remote.c
@@ -464,7 +464,7 @@ static int keyspan_probe(struct usb_interface *interface, const struct usb_devic
         remote->in_endpoint = endpoint;
         remote->toggle = -1;    /* Set to -1 so we will always not match the toggle from the first remote message. */
 
-        remote->in_buffer = usb_buffer_alloc(udev, RECV_SIZE, GFP_ATOMIC, &remote->in_dma);
+        remote->in_buffer = usb_alloc_coherent(udev, RECV_SIZE, GFP_ATOMIC, &remote->in_dma);
         if (!remote->in_buffer) {
                 error = -ENOMEM;
                 goto fail1;
@@ -543,7 +543,7 @@ static int keyspan_probe(struct usb_interface *interface, const struct usb_devic
         return 0;
 
  fail3: usb_free_urb(remote->irq_urb);
- fail2: usb_buffer_free(udev, RECV_SIZE, remote->in_buffer, remote->in_dma);
+ fail2: usb_free_coherent(udev, RECV_SIZE, remote->in_buffer, remote->in_dma);
  fail1: kfree(remote);
         input_free_device(input_dev);
 
@@ -564,7 +564,7 @@ static void keyspan_disconnect(struct usb_interface *interface)
                 input_unregister_device(remote->input);
                 usb_kill_urb(remote->irq_urb);
                 usb_free_urb(remote->irq_urb);
-                usb_buffer_free(remote->udev, RECV_SIZE, remote->in_buffer, remote->in_dma);
+                usb_free_coherent(remote->udev, RECV_SIZE, remote->in_buffer, remote->in_dma);
                 kfree(remote);
         }
 }
diff --git a/drivers/input/misc/max8925_onkey.c b/drivers/input/misc/max8925_onkey.c
new file mode 100644
index 000000000000..7de0ded4ccc3
--- /dev/null
+++ b/drivers/input/misc/max8925_onkey.c
@@ -0,0 +1,184 @@
+/**
+ * max8925_onkey.c - MAX8925 ONKEY driver
+ *
+ * Copyright (C) 2009 Marvell International Ltd.
+ *      Haojian Zhuang <haojian.zhuang@marvell.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 more details.
+ *
+ * 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/platform_device.h>
+#include <linux/i2c.h>
+#include <linux/input.h>
+#include <linux/interrupt.h>
+#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;
+        struct device           *dev;
+        int                     irq[2];
+};
+
+/*
+ * 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;
+        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);
+
+        return IRQ_HANDLED;
+}
+
+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 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->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) {
+                dev_err(chip->dev, "Failed to allocate input dev\n");
+                error = -ENOMEM;
+                goto out_input;
+        }
+
+        info->idev->name = "max8925_on";
+        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 = input_register_device(info->idev);
+        if (error) {
+                dev_err(chip->dev, "Can't register input device: %d\n", error);
+                goto out_reg;
+        }
+
+        platform_set_drvdata(pdev, info);
+
+        return 0;
+
+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;
+}
+
+static int __devexit max8925_onkey_remove(struct platform_device *pdev)
+{
+        struct max8925_onkey_info *info = platform_get_drvdata(pdev);
+
+        free_irq(info->irq[0], info);
+        free_irq(info->irq[1], info);
+        input_unregister_device(info->idev);
+        kfree(info);
+
+        platform_set_drvdata(pdev, NULL);
+
+        return 0;
+}
+
+static struct platform_driver max8925_onkey_driver = {
+        .driver         = {
+                .name   = "max8925-onkey",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = max8925_onkey_probe,
+        .remove         = __devexit_p(max8925_onkey_remove),
+};
+
+static int __init max8925_onkey_init(void)
+{
+        return platform_driver_register(&max8925_onkey_driver);
+}
+module_init(max8925_onkey_init);
+
+static void __exit max8925_onkey_exit(void)
+{
+        platform_driver_unregister(&max8925_onkey_driver);
+}
+module_exit(max8925_onkey_exit);
+
+MODULE_DESCRIPTION("Maxim MAX8925 ONKEY driver");
+MODULE_AUTHOR("Haojian Zhuang <haojian.zhuang@marvell.com>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/misc/pcap_keys.c b/drivers/input/misc/pcap_keys.c
index 7ea969347ca9..99335c286250 100644
--- a/drivers/input/misc/pcap_keys.c
+++ b/drivers/input/misc/pcap_keys.c
@@ -17,6 +17,7 @@
 #include <linux/platform_device.h>
 #include <linux/input.h>
 #include <linux/mfd/ezx-pcap.h>
+#include <linux/slab.h>
 
 struct pcap_keys {
         struct pcap_chip *pcap;
diff --git a/drivers/input/misc/pcf50633-input.c b/drivers/input/misc/pcf50633-input.c
index 008de0c5834b..95562735728d 100644
--- a/drivers/input/misc/pcf50633-input.c
+++ b/drivers/input/misc/pcf50633-input.c
@@ -20,6 +20,7 @@
 #include <linux/device.h>
 #include <linux/platform_device.h>
 #include <linux/input.h>
+#include <linux/slab.h>
 
 #include <linux/mfd/pcf50633/core.h>
 
diff --git a/drivers/input/misc/pcf8574_keypad.c b/drivers/input/misc/pcf8574_keypad.c
new file mode 100644
index 000000000000..4b42ffc0532a
--- /dev/null
+++ b/drivers/input/misc/pcf8574_keypad.c
@@ -0,0 +1,225 @@
+/*
+ * Driver for a keypad w/16 buttons connected to a PCF8574 I2C I/O expander
+ *
+ * Copyright 2005-2008 Analog Devices Inc.
+ *
+ * Licensed under the GPL-2 or later.
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/input.h>
+#include <linux/interrupt.h>
+#include <linux/i2c.h>
+#include <linux/slab.h>
+#include <linux/workqueue.h>
+
+#define DRV_NAME "pcf8574_keypad"
+
+static const unsigned char pcf8574_kp_btncode[] = {
+        [0] = KEY_RESERVED,
+        [1] = KEY_ENTER,
+        [2] = KEY_BACKSLASH,
+        [3] = KEY_0,
+        [4] = KEY_RIGHTBRACE,
+        [5] = KEY_C,
+        [6] = KEY_9,
+        [7] = KEY_8,
+        [8] = KEY_7,
+        [9] = KEY_B,
+        [10] = KEY_6,
+        [11] = KEY_5,
+        [12] = KEY_4,
+        [13] = KEY_A,
+        [14] = KEY_3,
+        [15] = KEY_2,
+        [16] = KEY_1
+};
+
+struct kp_data {
+        unsigned short btncode[ARRAY_SIZE(pcf8574_kp_btncode)];
+        struct input_dev *idev;
+        struct i2c_client *client;
+        char name[64];
+        char phys[32];
+        unsigned char laststate;
+};
+
+static short read_state(struct kp_data *lp)
+{
+        unsigned char x, y, a, b;
+
+        i2c_smbus_write_byte(lp->client, 240);
+        x = 0xF & (~(i2c_smbus_read_byte(lp->client) >> 4));
+
+        i2c_smbus_write_byte(lp->client, 15);
+        y = 0xF & (~i2c_smbus_read_byte(lp->client));
+
+        for (a = 0; x > 0; a++)
+                x = x >> 1;
+        for (b = 0; y > 0; b++)
+                y = y >> 1;
+
+        return ((a - 1) * 4) + b;
+}
+
+static irqreturn_t pcf8574_kp_irq_handler(int irq, void *dev_id)
+{
+        struct kp_data *lp = dev_id;
+        unsigned char nextstate = read_state(lp);
+
+        if (lp->laststate != nextstate) {
+                int key_down = nextstate < ARRAY_SIZE(lp->btncode);
+                unsigned short keycode = key_down ?
+                        lp->btncode[nextstate] : lp->btncode[lp->laststate];
+
+                input_report_key(lp->idev, keycode, key_down);
+                input_sync(lp->idev);
+
+                lp->laststate = nextstate;
+        }
+
+        return IRQ_HANDLED;
+}
+
+static int __devinit pcf8574_kp_probe(struct i2c_client *client, const struct i2c_device_id *id)
+{
+        int i, ret;
+        struct input_dev *idev;
+        struct kp_data *lp;
+
+        if (i2c_smbus_write_byte(client, 240) < 0) {
+                dev_err(&client->dev, "probe: write fail\n");
+                return -ENODEV;
+        }
+
+        lp = kzalloc(sizeof(*lp), GFP_KERNEL);
+        if (!lp)
+                return -ENOMEM;
+
+        idev = input_allocate_device();
+        if (!idev) {
+                dev_err(&client->dev, "Can't allocate input device\n");
+                ret = -ENOMEM;
+                goto fail_allocate;
+        }
+
+        lp->idev = idev;
+        lp->client = client;
+
+        idev->evbit[0] = BIT_MASK(EV_KEY);
+        idev->keycode = lp->btncode;
+        idev->keycodesize = sizeof(lp->btncode[0]);
+        idev->keycodemax = ARRAY_SIZE(lp->btncode);
+
+        for (i = 0; i < ARRAY_SIZE(pcf8574_kp_btncode); i++) {
+                lp->btncode[i] = pcf8574_kp_btncode[i];
+                __set_bit(lp->btncode[i] & KEY_MAX, idev->keybit);
+        }
+
+        sprintf(lp->name, DRV_NAME);
+        sprintf(lp->phys, "kp_data/input0");
+
+        idev->name = lp->name;
+        idev->phys = lp->phys;
+        idev->id.bustype = BUS_I2C;
+        idev->id.vendor = 0x0001;
+        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,
+                                   IRQF_TRIGGER_LOW | IRQF_ONESHOT,
+                                   DRV_NAME, lp);
+        if (ret) {
+                dev_err(&client->dev, "IRQ %d is not free\n", client->irq);
+                goto fail_irq;
+        }
+
+        i2c_set_clientdata(client, lp);
+        return 0;
+
+ fail_irq:
+        input_unregister_device(idev);
+ fail_register:
+        input_set_drvdata(idev, NULL);
+        input_free_device(idev);
+ fail_allocate:
+        kfree(lp);
+
+        return ret;
+}
+
+static int __devexit pcf8574_kp_remove(struct i2c_client *client)
+{
+        struct kp_data *lp = i2c_get_clientdata(client);
+
+        free_irq(client->irq, lp);
+
+        input_unregister_device(lp->idev);
+        kfree(lp);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int pcf8574_kp_resume(struct i2c_client *client)
+{
+        enable_irq(client->irq);
+
+        return 0;
+}
+
+static int pcf8574_kp_suspend(struct i2c_client *client, pm_message_t mesg)
+{
+        disable_irq(client->irq);
+
+        return 0;
+}
+#else
+# define pcf8574_kp_resume  NULL
+# define pcf8574_kp_suspend NULL
+#endif
+
+static const struct i2c_device_id pcf8574_kp_id[] = {
+        { DRV_NAME, 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, pcf8574_kp_id);
+
+static struct i2c_driver pcf8574_kp_driver = {
+        .driver = {
+                .name  = DRV_NAME,
+                .owner = THIS_MODULE,
+        },
+        .probe    = pcf8574_kp_probe,
+        .remove   = __devexit_p(pcf8574_kp_remove),
+        .suspend  = pcf8574_kp_suspend,
+        .resume   = pcf8574_kp_resume,
+        .id_table = pcf8574_kp_id,
+};
+
+static int __init pcf8574_kp_init(void)
+{
+        return i2c_add_driver(&pcf8574_kp_driver);
+}
+module_init(pcf8574_kp_init);
+
+static void __exit pcf8574_kp_exit(void)
+{
+        i2c_del_driver(&pcf8574_kp_driver);
+}
+module_exit(pcf8574_kp_exit);
+
+MODULE_AUTHOR("Michael Hennerich");
+MODULE_DESCRIPTION("Keypad input driver for 16 keys connected to PCF8574");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/misc/pcspkr.c b/drivers/input/misc/pcspkr.c
index ea4e1fd12651..f080dd31499b 100644
--- a/drivers/input/misc/pcspkr.c
+++ b/drivers/input/misc/pcspkr.c
@@ -30,7 +30,7 @@ MODULE_ALIAS("platform:pcspkr");
 #include <asm/i8253.h>
 #else
 #include <asm/8253pit.h>
-static DEFINE_SPINLOCK(i8253_lock);
+static DEFINE_RAW_SPINLOCK(i8253_lock);
 #endif
 
 static int pcspkr_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
@@ -50,7 +50,7 @@ static int pcspkr_event(struct input_dev *dev, unsigned int type, unsigned int c
         if (value > 20 && value < 32767)
                 count = PIT_TICK_RATE / value;
 
-        spin_lock_irqsave(&i8253_lock, flags);
+        raw_spin_lock_irqsave(&i8253_lock, flags);
 
         if (count) {
                 /* set command for counter 2, 2 byte write */
@@ -65,7 +65,7 @@ static int pcspkr_event(struct input_dev *dev, unsigned int type, unsigned int c
                 outb(inb_p(0x61) & 0xFC, 0x61);
         }
 
-        spin_unlock_irqrestore(&i8253_lock, flags);
+        raw_spin_unlock_irqrestore(&i8253_lock, flags);
 
         return 0;
 }
diff --git a/drivers/input/misc/powermate.c b/drivers/input/misc/powermate.c
index 668913d12044..f45947190e4f 100644
--- a/drivers/input/misc/powermate.c
+++ b/drivers/input/misc/powermate.c
@@ -64,7 +64,6 @@ struct powermate_device {
         dma_addr_t data_dma;
         struct urb *irq, *config;
         struct usb_ctrlrequest *configcr;
-        dma_addr_t configcr_dma;
         struct usb_device *udev;
         struct input_dev *input;
         spinlock_t lock;
@@ -182,8 +181,6 @@ static void powermate_sync_state(struct powermate_device *pm)
         usb_fill_control_urb(pm->config, pm->udev, usb_sndctrlpipe(pm->udev, 0),
                              (void *) pm->configcr, NULL, 0,
                              powermate_config_complete, pm);
-        pm->config->setup_dma = pm->configcr_dma;
-        pm->config->transfer_flags |= URB_NO_SETUP_DMA_MAP;
 
         if (usb_submit_urb(pm->config, GFP_ATOMIC))
                 printk(KERN_ERR "powermate: usb_submit_urb(config) failed");
@@ -276,25 +273,23 @@ static int powermate_input_event(struct input_dev *dev, unsigned int type, unsig
 
 static int powermate_alloc_buffers(struct usb_device *udev, struct powermate_device *pm)
 {
-        pm->data = usb_buffer_alloc(udev, POWERMATE_PAYLOAD_SIZE_MAX,
-                                    GFP_ATOMIC, &pm->data_dma);
+        pm->data = usb_alloc_coherent(udev, POWERMATE_PAYLOAD_SIZE_MAX,
+                                      GFP_ATOMIC, &pm->data_dma);
         if (!pm->data)
                 return -1;
 
-        pm->configcr = usb_buffer_alloc(udev, sizeof(*(pm->configcr)),
-                                        GFP_ATOMIC, &pm->configcr_dma);
+        pm->configcr = kmalloc(sizeof(*(pm->configcr)), GFP_KERNEL);
         if (!pm->configcr)
-                return -1;
+                return -ENOMEM;
 
         return 0;
 }
 
 static void powermate_free_buffers(struct usb_device *udev, struct powermate_device *pm)
 {
-        usb_buffer_free(udev, POWERMATE_PAYLOAD_SIZE_MAX,
-                        pm->data, pm->data_dma);
-        usb_buffer_free(udev, sizeof(*(pm->configcr)),
-                        pm->configcr, pm->configcr_dma);
+        usb_free_coherent(udev, POWERMATE_PAYLOAD_SIZE_MAX,
+                          pm->data, pm->data_dma);
+        kfree(pm->configcr);
 }
 
 /* Called whenever a USB device matching one in our supported devices table is connected */
diff --git a/drivers/input/misc/pwm-beeper.c b/drivers/input/misc/pwm-beeper.c
new file mode 100644
index 000000000000..57c294f07198
--- /dev/null
+++ b/drivers/input/misc/pwm-beeper.c
@@ -0,0 +1,199 @@
+/*
+ *  Copyright (C) 2010, Lars-Peter Clausen <lars@metafoo.de>
+ *  PWM beeper driver
+ *
+ *  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.
+ *
+ *  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/input.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/platform_device.h>
+#include <linux/pwm.h>
+#include <linux/slab.h>
+
+struct pwm_beeper {
+        struct input_dev *input;
+        struct pwm_device *pwm;
+        unsigned long period;
+};
+
+#define HZ_TO_NANOSECONDS(x) (1000000000UL/(x))
+
+static int pwm_beeper_event(struct input_dev *input,
+                            unsigned int type, unsigned int code, int value)
+{
+        int ret = 0;
+        struct pwm_beeper *beeper = input_get_drvdata(input);
+        unsigned long period;
+
+        if (type != EV_SND || value < 0)
+                return -EINVAL;
+
+        switch (code) {
+        case SND_BELL:
+                value = value ? 1000 : 0;
+                break;
+        case SND_TONE:
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        if (value == 0) {
+                pwm_config(beeper->pwm, 0, 0);
+                pwm_disable(beeper->pwm);
+        } else {
+                period = HZ_TO_NANOSECONDS(value);
+                ret = pwm_config(beeper->pwm, period / 2, period);
+                if (ret)
+                        return ret;
+                ret = pwm_enable(beeper->pwm);
+                if (ret)
+                        return ret;
+                beeper->period = period;
+        }
+
+        return 0;
+}
+
+static int __devinit pwm_beeper_probe(struct platform_device *pdev)
+{
+        unsigned long pwm_id = (unsigned long)pdev->dev.platform_data;
+        struct pwm_beeper *beeper;
+        int error;
+
+        beeper = kzalloc(sizeof(*beeper), GFP_KERNEL);
+        if (!beeper)
+                return -ENOMEM;
+
+        beeper->pwm = pwm_request(pwm_id, "pwm beeper");
+
+        if (IS_ERR(beeper->pwm)) {
+                error = PTR_ERR(beeper->pwm);
+                dev_err(&pdev->dev, "Failed to request pwm device: %d\n", error);
+                goto err_free;
+        }
+
+        beeper->input = input_allocate_device();
+        if (!beeper->input) {
+                dev_err(&pdev->dev, "Failed to allocate input device\n");
+                error = -ENOMEM;
+                goto err_pwm_free;
+        }
+        beeper->input->dev.parent = &pdev->dev;
+
+        beeper->input->name = "pwm-beeper";
+        beeper->input->phys = "pwm/input0";
+        beeper->input->id.bustype = BUS_HOST;
+        beeper->input->id.vendor = 0x001f;
+        beeper->input->id.product = 0x0001;
+        beeper->input->id.version = 0x0100;
+
+        beeper->input->evbit[0] = BIT(EV_SND);
+        beeper->input->sndbit[0] = BIT(SND_TONE) | BIT(SND_BELL);
+
+        beeper->input->event = pwm_beeper_event;
+
+        input_set_drvdata(beeper->input, beeper);
+
+        error = input_register_device(beeper->input);
+        if (error) {
+                dev_err(&pdev->dev, "Failed to register input device: %d\n", error);
+                goto err_input_free;
+        }
+
+        platform_set_drvdata(pdev, beeper);
+
+        return 0;
+
+err_input_free:
+        input_free_device(beeper->input);
+err_pwm_free:
+        pwm_free(beeper->pwm);
+err_free:
+        kfree(beeper);
+
+        return error;
+}
+
+static int __devexit pwm_beeper_remove(struct platform_device *pdev)
+{
+        struct pwm_beeper *beeper = platform_get_drvdata(pdev);
+
+        platform_set_drvdata(pdev, NULL);
+        input_unregister_device(beeper->input);
+
+        pwm_disable(beeper->pwm);
+        pwm_free(beeper->pwm);
+
+        kfree(beeper);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int pwm_beeper_suspend(struct device *dev)
+{
+        struct pwm_beeper *beeper = dev_get_drvdata(dev);
+
+        if (beeper->period)
+                pwm_disable(beeper->pwm);
+
+        return 0;
+}
+
+static int pwm_beeper_resume(struct device *dev)
+{
+        struct pwm_beeper *beeper = dev_get_drvdata(dev);
+
+        if (beeper->period) {
+                pwm_config(beeper->pwm, beeper->period / 2, beeper->period);
+                pwm_enable(beeper->pwm);
+        }
+
+        return 0;
+}
+
+static SIMPLE_DEV_PM_OPS(pwm_beeper_pm_ops,
+                         pwm_beeper_suspend, pwm_beeper_resume);
+
+#define PWM_BEEPER_PM_OPS (&pwm_beeper_pm_ops)
+#else
+#define PWM_BEEPER_PM_OPS NULL
+#endif
+
+static struct platform_driver pwm_beeper_driver = {
+        .probe  = pwm_beeper_probe,
+        .remove = __devexit_p(pwm_beeper_remove),
+        .driver = {
+                .name   = "pwm-beeper",
+                .owner  = THIS_MODULE,
+                .pm     = PWM_BEEPER_PM_OPS,
+        },
+};
+
+static int __init pwm_beeper_init(void)
+{
+        return platform_driver_register(&pwm_beeper_driver);
+}
+module_init(pwm_beeper_init);
+
+static void __exit pwm_beeper_exit(void)
+{
+        platform_driver_unregister(&pwm_beeper_driver);
+}
+module_exit(pwm_beeper_exit);
+
+MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
+MODULE_DESCRIPTION("PWM beeper driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:pwm-beeper");
diff --git a/drivers/input/misc/rotary_encoder.c b/drivers/input/misc/rotary_encoder.c
index 3b9f588fc747..1f8e0108962e 100644
--- a/drivers/input/misc/rotary_encoder.c
+++ b/drivers/input/misc/rotary_encoder.c
@@ -22,6 +22,7 @@
 #include <linux/platform_device.h>
 #include <linux/gpio.h>
 #include <linux/rotary_encoder.h>
+#include <linux/slab.h>
 
 #define DRV_NAME "rotary-encoder"
 
@@ -152,6 +153,13 @@ static int __devinit rotary_encoder_probe(struct platform_device *pdev)
                 goto exit_unregister_input;
         }
 
+        err = gpio_direction_input(pdata->gpio_a);
+        if (err) {
+                dev_err(&pdev->dev, "unable to set GPIO %d for input\n",
+                        pdata->gpio_a);
+                goto exit_unregister_input;
+        }
+
         err = gpio_request(pdata->gpio_b, DRV_NAME);
         if (err) {
                 dev_err(&pdev->dev, "unable to request GPIO %d\n",
@@ -159,6 +167,13 @@ static int __devinit rotary_encoder_probe(struct platform_device *pdev)
                 goto exit_free_gpio_a;
         }
 
+        err = gpio_direction_input(pdata->gpio_b);
+        if (err) {
+                dev_err(&pdev->dev, "unable to set GPIO %d for input\n",
+                        pdata->gpio_b);
+                goto exit_free_gpio_a;
+        }
+
         /* request the IRQs */
         err = request_irq(encoder->irq_a, &rotary_encoder_irq,
                           IORESOURCE_IRQ_HIGHEDGE | IORESOURCE_IRQ_LOWEDGE,
diff --git a/drivers/input/misc/sgi_btns.c b/drivers/input/misc/sgi_btns.c
index be3a15f5b25d..1a80c0dab83b 100644
--- a/drivers/input/misc/sgi_btns.c
+++ b/drivers/input/misc/sgi_btns.c
@@ -22,6 +22,7 @@
 #include <linux/ioport.h>
 #include <linux/module.h>
 #include <linux/platform_device.h>
+#include <linux/slab.h>
 
 #ifdef CONFIG_SGI_IP22
 #include <asm/sgi/ioc.h>
diff --git a/drivers/input/misc/sparcspkr.c b/drivers/input/misc/sparcspkr.c
index b064419b90a2..8e130bf7d32b 100644
--- a/drivers/input/misc/sparcspkr.c
+++ b/drivers/input/misc/sparcspkr.c
@@ -9,6 +9,7 @@
 #include <linux/init.h>
 #include <linux/input.h>
 #include <linux/of_device.h>
+#include <linux/slab.h>
 
 #include <asm/io.h>
 
@@ -172,7 +173,7 @@ static int __devinit sparcspkr_probe(struct device *dev)
         return 0;
 }
 
-static int sparcspkr_shutdown(struct of_device *dev)
+static int sparcspkr_shutdown(struct platform_device *dev)
 {
         struct sparcspkr_state *state = dev_get_drvdata(&dev->dev);
         struct input_dev *input_dev = state->input_dev;
@@ -183,7 +184,7 @@ static int sparcspkr_shutdown(struct of_device *dev)
         return 0;
 }
 
-static int __devinit bbc_beep_probe(struct of_device *op, const struct of_device_id *match)
+static int __devinit bbc_beep_probe(struct platform_device *op, const struct of_device_id *match)
 {
         struct sparcspkr_state *state;
         struct bbc_beep_info *info;
@@ -230,7 +231,7 @@ out_err:
         return err;
 }
 
-static int __devexit bbc_remove(struct of_device *op)
+static int __devexit bbc_remove(struct platform_device *op)
 {
         struct sparcspkr_state *state = dev_get_drvdata(&op->dev);
         struct input_dev *input_dev = state->input_dev;
@@ -258,14 +259,17 @@ static const struct of_device_id bbc_beep_match[] = {
 };
 
 static struct of_platform_driver bbc_beep_driver = {
-        .name           = "bbcbeep",
-        .match_table    = bbc_beep_match,
+        .driver = {
+                .name = "bbcbeep",
+                .owner = THIS_MODULE,
+                .of_match_table = bbc_beep_match,
+        },
         .probe          = bbc_beep_probe,
         .remove         = __devexit_p(bbc_remove),
         .shutdown       = sparcspkr_shutdown,
 };
 
-static int __devinit grover_beep_probe(struct of_device *op, const struct of_device_id *match)
+static int __devinit grover_beep_probe(struct platform_device *op, const struct of_device_id *match)
 {
         struct sparcspkr_state *state;
         struct grover_beep_info *info;
@@ -308,7 +312,7 @@ out_err:
         return err;
 }
 
-static int __devexit grover_remove(struct of_device *op)
+static int __devexit grover_remove(struct platform_device *op)
 {
         struct sparcspkr_state *state = dev_get_drvdata(&op->dev);
         struct grover_beep_info *info = &state->u.grover;
@@ -337,8 +341,11 @@ static const struct of_device_id grover_beep_match[] = {
 };
 
 static struct of_platform_driver grover_beep_driver = {
-        .name           = "groverbeep",
-        .match_table    = grover_beep_match,
+        .driver = {
+                .name = "groverbeep",
+                .owner = THIS_MODULE,
+                .of_match_table = grover_beep_match,
+        },
         .probe          = grover_beep_probe,
         .remove         = __devexit_p(grover_remove),
         .shutdown       = sparcspkr_shutdown,
@@ -346,14 +353,12 @@ static struct of_platform_driver grover_beep_driver = {
 
 static int __init sparcspkr_init(void)
 {
-        int err = of_register_driver(&bbc_beep_driver,
-                                     &of_platform_bus_type);
+        int err = of_register_platform_driver(&bbc_beep_driver);
 
         if (!err) {
-                err = of_register_driver(&grover_beep_driver,
-                                         &of_platform_bus_type);
+                err = of_register_platform_driver(&grover_beep_driver);
                 if (err)
-                        of_unregister_driver(&bbc_beep_driver);
+                        of_unregister_platform_driver(&bbc_beep_driver);
         }
 
         return err;
@@ -361,8 +366,8 @@ static int __init sparcspkr_init(void)
 
 static void __exit sparcspkr_exit(void)
 {
-        of_unregister_driver(&bbc_beep_driver);
-        of_unregister_driver(&grover_beep_driver);
+        of_unregister_platform_driver(&bbc_beep_driver);
+        of_unregister_platform_driver(&grover_beep_driver);
 }
 
 module_init(sparcspkr_init);
diff --git a/drivers/input/misc/twl4030-pwrbutton.c b/drivers/input/misc/twl4030-pwrbutton.c
index e9069b87fde2..f16972bddca4 100644
--- a/drivers/input/misc/twl4030-pwrbutton.c
+++ b/drivers/input/misc/twl4030-pwrbutton.c
@@ -52,7 +52,7 @@ static irqreturn_t powerbutton_irq(int irq, void *_pwr)
         return IRQ_HANDLED;
 }
 
-static int __devinit twl4030_pwrbutton_probe(struct platform_device *pdev)
+static int __init twl4030_pwrbutton_probe(struct platform_device *pdev)
 {
         struct input_dev *pwr;
         int irq = platform_get_irq(pdev, 0);
@@ -95,7 +95,7 @@ free_input_dev:
         return err;
 }
 
-static int __devexit twl4030_pwrbutton_remove(struct platform_device *pdev)
+static int __exit twl4030_pwrbutton_remove(struct platform_device *pdev)
 {
         struct input_dev *pwr = platform_get_drvdata(pdev);
         int irq = platform_get_irq(pdev, 0);
@@ -106,9 +106,8 @@ static int __devexit twl4030_pwrbutton_remove(struct platform_device *pdev)
         return 0;
 }
 
-struct platform_driver twl4030_pwrbutton_driver = {
-        .probe          = twl4030_pwrbutton_probe,
-        .remove         = __devexit_p(twl4030_pwrbutton_remove),
+static struct platform_driver twl4030_pwrbutton_driver = {
+        .remove         = __exit_p(twl4030_pwrbutton_remove),
         .driver         = {
                 .name   = "twl4030_pwrbutton",
                 .owner  = THIS_MODULE,
@@ -117,7 +116,8 @@ struct platform_driver twl4030_pwrbutton_driver = {
 
 static int __init twl4030_pwrbutton_init(void)
 {
-        return platform_driver_register(&twl4030_pwrbutton_driver);
+        return platform_driver_probe(&twl4030_pwrbutton_driver,
+                        twl4030_pwrbutton_probe);
 }
 module_init(twl4030_pwrbutton_init);
 
diff --git a/drivers/input/misc/twl4030-vibra.c b/drivers/input/misc/twl4030-vibra.c
new file mode 100644
index 000000000000..014dd4ad0d4f
--- /dev/null
+++ b/drivers/input/misc/twl4030-vibra.c
@@ -0,0 +1,298 @@
+/*
+ * twl4030-vibra.c - TWL4030 Vibrator driver
+ *
+ * Copyright (C) 2008-2010 Nokia Corporation
+ *
+ * Written by Henrik Saari <henrik.saari@nokia.com>
+ * Updates by Felipe Balbi <felipe.balbi@nokia.com>
+ * Input by Jari Vanhala <ext-jari.vanhala@nokia.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, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/jiffies.h>
+#include <linux/platform_device.h>
+#include <linux/workqueue.h>
+#include <linux/i2c/twl.h>
+#include <linux/mfd/twl4030-codec.h>
+#include <linux/input.h>
+#include <linux/slab.h>
+
+/* MODULE ID2 */
+#define LEDEN           0x00
+
+/* ForceFeedback */
+#define EFFECT_DIR_180_DEG      0x8000 /* range is 0 - 0xFFFF */
+
+struct vibra_info {
+        struct device           *dev;
+        struct input_dev        *input_dev;
+
+        struct workqueue_struct *workqueue;
+        struct work_struct      play_work;
+
+        bool                    enabled;
+        int                     speed;
+        int                     direction;
+
+        bool                    coexist;
+};
+
+static void vibra_disable_leds(void)
+{
+        u8 reg;
+
+        /* Disable LEDA & LEDB, cannot be used with vibra (PWM) */
+        twl_i2c_read_u8(TWL4030_MODULE_LED, &reg, LEDEN);
+        reg &= ~0x03;
+        twl_i2c_write_u8(TWL4030_MODULE_LED, LEDEN, reg);
+}
+
+/* Powers H-Bridge and enables audio clk */
+static void vibra_enable(struct vibra_info *info)
+{
+        u8 reg;
+
+        twl4030_codec_enable_resource(TWL4030_CODEC_RES_POWER);
+
+        /* turn H-Bridge on */
+        twl_i2c_read_u8(TWL4030_MODULE_AUDIO_VOICE,
+                        &reg, TWL4030_REG_VIBRA_CTL);
+        twl_i2c_write_u8(TWL4030_MODULE_AUDIO_VOICE,
+                         (reg | TWL4030_VIBRA_EN), TWL4030_REG_VIBRA_CTL);
+
+        twl4030_codec_enable_resource(TWL4030_CODEC_RES_APLL);
+
+        info->enabled = true;
+}
+
+static void vibra_disable(struct vibra_info *info)
+{
+        u8 reg;
+
+        /* Power down H-Bridge */
+        twl_i2c_read_u8(TWL4030_MODULE_AUDIO_VOICE,
+                        &reg, TWL4030_REG_VIBRA_CTL);
+        twl_i2c_write_u8(TWL4030_MODULE_AUDIO_VOICE,
+                         (reg & ~TWL4030_VIBRA_EN), TWL4030_REG_VIBRA_CTL);
+
+        twl4030_codec_disable_resource(TWL4030_CODEC_RES_APLL);
+        twl4030_codec_disable_resource(TWL4030_CODEC_RES_POWER);
+
+        info->enabled = false;
+}
+
+static void vibra_play_work(struct work_struct *work)
+{
+        struct vibra_info *info = container_of(work,
+                        struct vibra_info, play_work);
+        int dir;
+        int pwm;
+        u8 reg;
+
+        dir = info->direction;
+        pwm = info->speed;
+
+        twl_i2c_read_u8(TWL4030_MODULE_AUDIO_VOICE,
+                        &reg, TWL4030_REG_VIBRA_CTL);
+        if (pwm && (!info->coexist || !(reg & TWL4030_VIBRA_SEL))) {
+
+                if (!info->enabled)
+                        vibra_enable(info);
+
+                /* set vibra rotation direction */
+                twl_i2c_read_u8(TWL4030_MODULE_AUDIO_VOICE,
+                                &reg, TWL4030_REG_VIBRA_CTL);
+                reg = (dir) ? (reg | TWL4030_VIBRA_DIR) :
+                        (reg & ~TWL4030_VIBRA_DIR);
+                twl_i2c_write_u8(TWL4030_MODULE_AUDIO_VOICE,
+                                 reg, TWL4030_REG_VIBRA_CTL);
+
+                /* set PWM, 1 = max, 255 = min */
+                twl_i2c_write_u8(TWL4030_MODULE_AUDIO_VOICE,
+                                 256 - pwm, TWL4030_REG_VIBRA_SET);
+        } else {
+                if (info->enabled)
+                        vibra_disable(info);
+        }
+}
+
+/*** Input/ForceFeedback ***/
+
+static int vibra_play(struct input_dev *input, void *data,
+                      struct ff_effect *effect)
+{
+        struct vibra_info *info = input_get_drvdata(input);
+
+        info->speed = effect->u.rumble.strong_magnitude >> 8;
+        if (!info->speed)
+                info->speed = effect->u.rumble.weak_magnitude >> 9;
+        info->direction = effect->direction < EFFECT_DIR_180_DEG ? 0 : 1;
+        queue_work(info->workqueue, &info->play_work);
+        return 0;
+}
+
+static int twl4030_vibra_open(struct input_dev *input)
+{
+        struct vibra_info *info = input_get_drvdata(input);
+
+        info->workqueue = create_singlethread_workqueue("vibra");
+        if (info->workqueue == NULL) {
+                dev_err(&input->dev, "couldn't create workqueue\n");
+                return -ENOMEM;
+        }
+        return 0;
+}
+
+static void twl4030_vibra_close(struct input_dev *input)
+{
+        struct vibra_info *info = input_get_drvdata(input);
+
+        cancel_work_sync(&info->play_work);
+        INIT_WORK(&info->play_work, vibra_play_work); /* cleanup */
+        destroy_workqueue(info->workqueue);
+        info->workqueue = NULL;
+
+        if (info->enabled)
+                vibra_disable(info);
+}
+
+/*** Module ***/
+#if CONFIG_PM
+static int twl4030_vibra_suspend(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct vibra_info *info = platform_get_drvdata(pdev);
+
+        if (info->enabled)
+                vibra_disable(info);
+
+        return 0;
+}
+
+static int twl4030_vibra_resume(struct device *dev)
+{
+        vibra_disable_leds();
+        return 0;
+}
+
+static SIMPLE_DEV_PM_OPS(twl4030_vibra_pm_ops,
+                         twl4030_vibra_suspend, twl4030_vibra_resume);
+#endif
+
+static int __devinit twl4030_vibra_probe(struct platform_device *pdev)
+{
+        struct twl4030_codec_vibra_data *pdata = pdev->dev.platform_data;
+        struct vibra_info *info;
+        int ret;
+
+        if (!pdata) {
+                dev_dbg(&pdev->dev, "platform_data not available\n");
+                return -EINVAL;
+        }
+
+        info = kzalloc(sizeof(*info), GFP_KERNEL);
+        if (!info)
+                return -ENOMEM;
+
+        info->dev = &pdev->dev;
+        info->coexist = pdata->coexist;
+        INIT_WORK(&info->play_work, vibra_play_work);
+
+        info->input_dev = input_allocate_device();
+        if (info->input_dev == NULL) {
+                dev_err(&pdev->dev, "couldn't allocate input device\n");
+                ret = -ENOMEM;
+                goto err_kzalloc;
+        }
+
+        input_set_drvdata(info->input_dev, info);
+
+        info->input_dev->name = "twl4030:vibrator";
+        info->input_dev->id.version = 1;
+        info->input_dev->dev.parent = pdev->dev.parent;
+        info->input_dev->open = twl4030_vibra_open;
+        info->input_dev->close = twl4030_vibra_close;
+        __set_bit(FF_RUMBLE, info->input_dev->ffbit);
+
+        ret = input_ff_create_memless(info->input_dev, NULL, vibra_play);
+        if (ret < 0) {
+                dev_dbg(&pdev->dev, "couldn't register vibrator to FF\n");
+                goto err_ialloc;
+        }
+
+        ret = input_register_device(info->input_dev);
+        if (ret < 0) {
+                dev_dbg(&pdev->dev, "couldn't register input device\n");
+                goto err_iff;
+        }
+
+        vibra_disable_leds();
+
+        platform_set_drvdata(pdev, info);
+        return 0;
+
+err_iff:
+        input_ff_destroy(info->input_dev);
+err_ialloc:
+        input_free_device(info->input_dev);
+err_kzalloc:
+        kfree(info);
+        return ret;
+}
+
+static int __devexit twl4030_vibra_remove(struct platform_device *pdev)
+{
+        struct vibra_info *info = platform_get_drvdata(pdev);
+
+        /* this also free ff-memless and calls close if needed */
+        input_unregister_device(info->input_dev);
+        kfree(info);
+        platform_set_drvdata(pdev, NULL);
+
+        return 0;
+}
+
+static struct platform_driver twl4030_vibra_driver = {
+        .probe          = twl4030_vibra_probe,
+        .remove         = __devexit_p(twl4030_vibra_remove),
+        .driver         = {
+                .name   = "twl4030-vibra",
+                .owner  = THIS_MODULE,
+#ifdef CONFIG_PM
+                .pm     = &twl4030_vibra_pm_ops,
+#endif
+        },
+};
+
+static int __init twl4030_vibra_init(void)
+{
+        return platform_driver_register(&twl4030_vibra_driver);
+}
+module_init(twl4030_vibra_init);
+
+static void __exit twl4030_vibra_exit(void)
+{
+        platform_driver_unregister(&twl4030_vibra_driver);
+}
+module_exit(twl4030_vibra_exit);
+
+MODULE_ALIAS("platform:twl4030-vibra");
+
+MODULE_DESCRIPTION("TWL4030 Vibra driver");
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Nokia Corporation");
diff --git a/drivers/input/misc/uinput.c b/drivers/input/misc/uinput.c
index d3f57245420a..b9410784e6a1 100644
--- a/drivers/input/misc/uinput.c
+++ b/drivers/input/misc/uinput.c
@@ -34,7 +34,6 @@
 #include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/init.h>
-#include <linux/smp_lock.h>
 #include <linux/fs.h>
 #include <linux/miscdevice.h>
 #include <linux/uinput.h>
@@ -284,7 +283,6 @@ static int uinput_open(struct inode *inode, struct file *file)
         if (!newdev)
                 return -ENOMEM;
 
-        lock_kernel();
         mutex_init(&newdev->mutex);
         spin_lock_init(&newdev->requests_lock);
         init_waitqueue_head(&newdev->requests_waitq);
@@ -292,7 +290,7 @@ static int uinput_open(struct inode *inode, struct file *file)
         newdev->state = UIST_NEW_DEVICE;
 
         file->private_data = newdev;
-        unlock_kernel();
+        nonseekable_open(inode, file);
 
         return 0;
 }
@@ -302,25 +300,29 @@ static int uinput_validate_absbits(struct input_dev *dev)
         unsigned int cnt;
         int retval = 0;
 
-        for (cnt = 0; cnt < ABS_MAX + 1; cnt++) {
+        for (cnt = 0; cnt < ABS_CNT; cnt++) {
                 if (!test_bit(cnt, dev->absbit))
                         continue;
 
-                if ((dev->absmax[cnt] <= dev->absmin[cnt])) {
+                if (input_abs_get_max(dev, cnt) <= input_abs_get_min(dev, cnt)) {
                         printk(KERN_DEBUG
                                 "%s: invalid abs[%02x] min:%d max:%d\n",
                                 UINPUT_NAME, cnt,
-                                dev->absmin[cnt], dev->absmax[cnt]);
+                                input_abs_get_min(dev, cnt),
+                                input_abs_get_max(dev, cnt));
                         retval = -EINVAL;
                         break;
                 }
 
-                if (dev->absflat[cnt] > (dev->absmax[cnt] - dev->absmin[cnt])) {
+                if (input_abs_get_flat(dev, cnt) >
+                    input_abs_get_max(dev, cnt) - input_abs_get_min(dev, cnt)) {
                         printk(KERN_DEBUG
-                                "%s: absflat[%02x] out of range: %d "
+                                "%s: abs_flat #%02x out of range: %d "
                                 "(min:%d/max:%d)\n",
-                                UINPUT_NAME, cnt, dev->absflat[cnt],
-                                dev->absmin[cnt], dev->absmax[cnt]);
+                                UINPUT_NAME, cnt,
+                                input_abs_get_flat(dev, cnt),
+                                input_abs_get_min(dev, cnt),
+                                input_abs_get_max(dev, cnt));
                         retval = -EINVAL;
                         break;
                 }
@@ -345,7 +347,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                     size;
+        int                     i, size;
         int                     retval;
 
         if (count != sizeof(struct uinput_user_dev))
@@ -389,11 +391,12 @@ static int uinput_setup_device(struct uinput_device *udev, const char __user *bu
         dev->id.product = user_dev->id.product;
         dev->id.version = user_dev->id.version;
 
-        size = sizeof(int) * (ABS_MAX + 1);
-        memcpy(dev->absmax, user_dev->absmax, size);
-        memcpy(dev->absmin, user_dev->absmin, size);
-        memcpy(dev->absfuzz, user_dev->absfuzz, size);
-        memcpy(dev->absflat, user_dev->absflat, size);
+        for (i = 0; i < ABS_CNT; i++) {
+                input_abs_set_max(dev, i, user_dev->absmax[i]);
+                input_abs_set_min(dev, i, user_dev->absmin[i]);
+                input_abs_set_fuzz(dev, i, user_dev->absfuzz[i]);
+                input_abs_set_flat(dev, i, user_dev->absflat[i]);
+        }
 
         /* check if absmin/absmax/absfuzz/absflat are filled as
          * told in Documentation/input/input-programming.txt */
@@ -401,6 +404,13 @@ static int uinput_setup_device(struct uinput_device *udev, const char __user *bu
                 retval = uinput_validate_absbits(dev);
                 if (retval < 0)
                         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);
+                } else if (test_bit(ABS_MT_POSITION_X, dev->absbit)) {
+                        input_set_events_per_packet(dev, 60);
+                }
         }
 
         udev->state = UIST_SETUP_COMPLETE;
@@ -801,6 +811,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 = {
@@ -808,6 +819,8 @@ static struct miscdevice uinput_misc = {
         .minor          = UINPUT_MINOR,
         .name           = UINPUT_NAME,
 };
+MODULE_ALIAS_MISCDEV(UINPUT_MINOR);
+MODULE_ALIAS("devname:" UINPUT_NAME);
 
 static int __init uinput_init(void)
 {
diff --git a/drivers/input/misc/winbond-cir.c b/drivers/input/misc/winbond-cir.c
index c8f5a9a3fa14..64f1de7960c6 100644
--- a/drivers/input/misc/winbond-cir.c
+++ b/drivers/input/misc/winbond-cir.c
@@ -56,6 +56,7 @@
 #include <linux/io.h>
 #include <linux/bitrev.h>
 #include <linux/bitops.h>
+#include <linux/slab.h>
 
 #define DRVNAME "winbond-cir"
 
@@ -385,26 +386,24 @@ wbcir_do_getkeycode(struct wbcir_data *data, u32 scancode)
 }
 
 static int
-wbcir_getkeycode(struct input_dev *dev, int scancode, int *keycode)
+wbcir_getkeycode(struct input_dev *dev,
+                 unsigned int scancode, unsigned int *keycode)
 {
         struct wbcir_data *data = input_get_drvdata(dev);
 
-        *keycode = (int)wbcir_do_getkeycode(data, (u32)scancode);
+        *keycode = wbcir_do_getkeycode(data, scancode);
         return 0;
 }
 
 static int
-wbcir_setkeycode(struct input_dev *dev, int sscancode, int keycode)
+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;
-        u32 scancode = (u32)sscancode;
-
-        if (keycode < 0 || keycode > KEY_MAX)
-                return -EINVAL;
 
         new_keyentry = kmalloc(sizeof(*new_keyentry), GFP_KERNEL);
         if (!new_keyentry)
@@ -538,6 +537,7 @@ wbcir_reset_irdata(struct wbcir_data *data)
         data->irdata_count = 0;
         data->irdata_off = 0;
         data->irdata_error = 0;
+        data->idle_count = 0;
 }
 
 /* Adds one bit of irdata */
@@ -1006,7 +1006,6 @@ wbcir_irq_handler(int irqno, void *cookie)
                 }
 
                 wbcir_reset_irdata(data);
-                data->idle_count = 0;
         }
 
 out:
@@ -1018,7 +1017,7 @@ out:
 
 /*****************************************************************************
  *
- * SUSPEND/RESUME FUNCTIONS
+ * SETUP/INIT/SUSPEND/RESUME FUNCTIONS
  *
  *****************************************************************************/
 
@@ -1197,7 +1196,16 @@ finish:
         }
 
         /* 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
@@ -1207,37 +1215,15 @@ wbcir_suspend(struct pnp_dev *device, pm_message_t state)
         return 0;
 }
 
-static int
-wbcir_resume(struct pnp_dev *device)
-{
-        struct wbcir_data *data = pnp_get_drvdata(device);
-
-        /* 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);
-
-        /* Enable interrupts */
-        wbcir_reset_irdata(data);
-        outb(WBCIR_IRQ_RX | WBCIR_IRQ_ERR, data->sbase + WBCIR_REG_SP3_IER);
-
-        return 0;
-}
-
-
-
-/*****************************************************************************
- *
- * SETUP/INIT FUNCTIONS
- *
- *****************************************************************************/
-
 static void
-wbcir_cfg_ceir(struct wbcir_data *data)
+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)
@@ -1264,6 +1250,93 @@ wbcir_cfg_ceir(struct wbcir_data *data)
          * 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
@@ -1393,86 +1466,7 @@ wbcir_probe(struct pnp_dev *device, const struct pnp_device_id *dev_id)
 
         device_init_wakeup(&device->dev, 1);
 
-        wbcir_cfg_ceir(data);
-
-        /* Disable interrupts */
-        wbcir_select_bank(data, WBCIR_BANK_0);
-        outb(WBCIR_IRQ_NONE, data->sbase + WBCIR_REG_SP3_IER);
-
-        /* 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 */
-        outb(WBCIR_IRQ_RX | WBCIR_IRQ_ERR, data->sbase + WBCIR_REG_SP3_IER);
+        wbcir_init_hw(data);
 
         return 0;
 
diff --git a/drivers/input/misc/wistron_btns.c b/drivers/input/misc/wistron_btns.c
index c0afb71a3a6d..12501de0c5cd 100644
--- a/drivers/input/misc/wistron_btns.c
+++ b/drivers/input/misc/wistron_btns.c
@@ -29,6 +29,7 @@
 #include <linux/module.h>
 #include <linux/preempt.h>
 #include <linux/string.h>
+#include <linux/slab.h>
 #include <linux/types.h>
 #include <linux/platform_device.h>
 #include <linux/leds.h>
@@ -982,11 +983,11 @@ static int __init copy_keymap(void)
         for (key = keymap; key->type != KE_END; key++)
                 length++;
 
-        new_keymap = kmalloc(length * sizeof(struct key_entry), GFP_KERNEL);
+        new_keymap = kmemdup(keymap, length * sizeof(struct key_entry),
+                             GFP_KERNEL);
         if (!new_keymap)
                 return -ENOMEM;
 
-        memcpy(new_keymap, keymap, length * sizeof(struct key_entry));
         keymap = new_keymap;
 
         return 0;
@@ -1346,7 +1347,7 @@ static int __init wb_module_init(void)
 
         err = map_bios();
         if (err)
-                return err;
+                goto err_free_keymap;
 
         err = platform_driver_register(&wistron_driver);
         if (err)
@@ -1370,6 +1371,8 @@ static int __init wb_module_init(void)
         platform_driver_unregister(&wistron_driver);
  err_unmap_bios:
         unmap_bios();
+ err_free_keymap:
+        kfree(keymap);
 
         return err;
 }
diff --git a/drivers/input/misc/wm831x-on.c b/drivers/input/misc/wm831x-on.c
index ba4f5dd7c60e..c3d7ba5f5b47 100644
--- a/drivers/input/misc/wm831x-on.c
+++ b/drivers/input/misc/wm831x-on.c
@@ -19,6 +19,7 @@
 
 #include <linux/module.h>
 #include <linux/init.h>
+#include <linux/slab.h>
 #include <linux/kernel.h>
 #include <linux/errno.h>
 #include <linux/input.h>
@@ -97,8 +98,9 @@ static int __devinit wm831x_on_probe(struct platform_device *pdev)
         wm831x_on->dev->phys = "wm831x_on/input0";
         wm831x_on->dev->dev.parent = &pdev->dev;
 
-        ret = wm831x_request_irq(wm831x, irq, wm831x_on_irq,
-                                 IRQF_TRIGGER_RISING, "wm831x_on", wm831x_on);
+        ret = request_threaded_irq(irq, NULL, wm831x_on_irq,
+                                   IRQF_TRIGGER_RISING, "wm831x_on",
+                                   wm831x_on);
         if (ret < 0) {
                 dev_err(&pdev->dev, "Unable to request IRQ: %d\n", ret);
                 goto err_input_dev;
@@ -114,7 +116,7 @@ static int __devinit wm831x_on_probe(struct platform_device *pdev)
         return 0;
 
 err_irq:
-        wm831x_free_irq(wm831x, irq, NULL);
+        free_irq(irq, wm831x_on);
 err_input_dev:
         input_free_device(wm831x_on->dev);
 err:
@@ -127,7 +129,7 @@ static int __devexit wm831x_on_remove(struct platform_device *pdev)
         struct wm831x_on *wm831x_on = platform_get_drvdata(pdev);
         int irq = platform_get_irq(pdev, 0);
 
-        wm831x_free_irq(wm831x_on->wm831x, irq, wm831x_on);
+        free_irq(irq, wm831x_on);
         cancel_delayed_work_sync(&wm831x_on->work);
         input_unregister_device(wm831x_on->dev);
         kfree(wm831x_on);
diff --git a/drivers/input/misc/yealink.c b/drivers/input/misc/yealink.c
index 93a22ac0f88c..41201c6b5e68 100644
--- a/drivers/input/misc/yealink.c
+++ b/drivers/input/misc/yealink.c
@@ -111,7 +111,6 @@ struct yealink_dev {
         struct yld_ctl_packet   *ctl_data;
         dma_addr_t              ctl_dma;
         struct usb_ctrlrequest  *ctl_req;
-        dma_addr_t              ctl_req_dma;
         struct urb              *urb_ctl;
 
         char phys[64];                  /* physical device path */
@@ -836,12 +835,9 @@ static int usb_cleanup(struct yealink_dev *yld, int err)
         usb_free_urb(yld->urb_irq);
         usb_free_urb(yld->urb_ctl);
 
-        usb_buffer_free(yld->udev, sizeof(*(yld->ctl_req)),
-                        yld->ctl_req, yld->ctl_req_dma);
-        usb_buffer_free(yld->udev, USB_PKT_LEN,
-                        yld->ctl_data, yld->ctl_dma);
-        usb_buffer_free(yld->udev, USB_PKT_LEN,
-                        yld->irq_data, yld->irq_dma);
+        kfree(yld->ctl_req);
+        usb_free_coherent(yld->udev, USB_PKT_LEN, yld->ctl_data, yld->ctl_dma);
+        usb_free_coherent(yld->udev, USB_PKT_LEN, yld->irq_data, yld->irq_dma);
 
         kfree(yld);
         return err;
@@ -886,18 +882,17 @@ static int usb_probe(struct usb_interface *intf, const struct usb_device_id *id)
                 return usb_cleanup(yld, -ENOMEM);
 
         /* allocate usb buffers */
-        yld->irq_data = usb_buffer_alloc(udev, USB_PKT_LEN,
-                                        GFP_ATOMIC, &yld->irq_dma);
+        yld->irq_data = usb_alloc_coherent(udev, USB_PKT_LEN,
+                                           GFP_ATOMIC, &yld->irq_dma);
         if (yld->irq_data == NULL)
                 return usb_cleanup(yld, -ENOMEM);
 
-        yld->ctl_data = usb_buffer_alloc(udev, USB_PKT_LEN,
-                                        GFP_ATOMIC, &yld->ctl_dma);
+        yld->ctl_data = usb_alloc_coherent(udev, USB_PKT_LEN,
+                                           GFP_ATOMIC, &yld->ctl_dma);
         if (!yld->ctl_data)
                 return usb_cleanup(yld, -ENOMEM);
 
-        yld->ctl_req = usb_buffer_alloc(udev, sizeof(*(yld->ctl_req)),
-                                        GFP_ATOMIC, &yld->ctl_req_dma);
+        yld->ctl_req = kmalloc(sizeof(*(yld->ctl_req)), GFP_KERNEL);
         if (yld->ctl_req == NULL)
                 return usb_cleanup(yld, -ENOMEM);
 
@@ -936,10 +931,8 @@ static int usb_probe(struct usb_interface *intf, const struct usb_device_id *id)
         usb_fill_control_urb(yld->urb_ctl, udev, usb_sndctrlpipe(udev, 0),
                         (void *)yld->ctl_req, yld->ctl_data, USB_PKT_LEN,
                         urb_ctl_callback, yld);
-        yld->urb_ctl->setup_dma = yld->ctl_req_dma;
         yld->urb_ctl->transfer_dma      = yld->ctl_dma;
-        yld->urb_ctl->transfer_flags    |= URB_NO_SETUP_DMA_MAP |
-                                        URB_NO_TRANSFER_DMA_MAP;
+        yld->urb_ctl->transfer_flags    |= URB_NO_TRANSFER_DMA_MAP;
         yld->urb_ctl->dev = udev;
 
         /* find out the physical bus location */
diff --git a/drivers/input/misc/yealink.h b/drivers/input/misc/yealink.h
index 48af0be9cbdf..1e0f52397010 100644
--- a/drivers/input/misc/yealink.h
+++ b/drivers/input/misc/yealink.h
@@ -127,7 +127,7 @@ struct yld_ctl_packet {
  * yld_status struct.
  */
 
-/* LCD, each segment must be driven seperately.
+/* LCD, each segment must be driven separately.
  *
  * Layout:
  *
diff --git a/drivers/input/mouse/Kconfig b/drivers/input/mouse/Kconfig
index c714ca2407f8..bf5fd7f6a313 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.
diff --git a/drivers/input/mouse/alps.c b/drivers/input/mouse/alps.c
index f93c2c0daf1f..99d58764ef03 100644
--- a/drivers/input/mouse/alps.c
+++ b/drivers/input/mouse/alps.c
@@ -15,6 +15,7 @@
  * the Free Software Foundation.
  */
 
+#include <linux/slab.h>
 #include <linux/input.h>
 #include <linux/serio.h>
 #include <linux/libps2.h>
@@ -63,6 +64,8 @@ static const struct alps_model_info alps_model_data[] = {
         { { 0x62, 0x02, 0x14 }, 0xcf, 0xcf,
                 ALPS_PASS | ALPS_DUALPOINT | ALPS_PS2_INTERLEAVED },
         { { 0x73, 0x02, 0x50 }, 0xcf, 0xcf, ALPS_FOUR_BUTTONS },          /* Dell Vostro 1400 */
+        { { 0x52, 0x01, 0x14 }, 0xff, 0xff,
+                ALPS_PASS | ALPS_DUALPOINT | ALPS_PS2_INTERLEAVED },      /* Toshiba Tecra A11-11L */
 };
 
 /*
@@ -118,40 +121,27 @@ static void alps_report_buttons(struct psmouse *psmouse,
                                 struct input_dev *dev1, struct input_dev *dev2,
                                 int left, int right, int middle)
 {
-        struct alps_data *priv = psmouse->private;
-        const struct alps_model_info *model = priv->i;
-
-        if (model->flags & ALPS_PS2_INTERLEAVED) {
-                struct input_dev *dev;
+        struct input_dev *dev;
 
-                /*
-                 * If shared button has already been reported on the
-                 * other device (dev2) then this event should be also
-                 * sent through that device.
-                 */
-                dev = test_bit(BTN_LEFT, dev2->key) ? dev2 : dev1;
-                input_report_key(dev, BTN_LEFT, left);
+        /*
+         * If shared button has already been reported on the
+         * other device (dev2) then this event should be also
+         * sent through that device.
+         */
+        dev = test_bit(BTN_LEFT, dev2->key) ? dev2 : dev1;
+        input_report_key(dev, BTN_LEFT, left);
 
-                dev = test_bit(BTN_RIGHT, dev2->key) ? dev2 : dev1;
-                input_report_key(dev, BTN_RIGHT, right);
+        dev = test_bit(BTN_RIGHT, dev2->key) ? dev2 : dev1;
+        input_report_key(dev, BTN_RIGHT, right);
 
-                dev = test_bit(BTN_MIDDLE, dev2->key) ? dev2 : dev1;
-                input_report_key(dev, BTN_MIDDLE, middle);
+        dev = test_bit(BTN_MIDDLE, dev2->key) ? dev2 : dev1;
+        input_report_key(dev, BTN_MIDDLE, middle);
 
-                /*
-                 * Sync the _other_ device now, we'll do the first
-                 * device later once we report the rest of the events.
-                 */
-                input_sync(dev2);
-        } else {
-                /*
-                 * For devices with non-interleaved packets we know what
-                 * device buttons belong to so we can simply report them.
-                 */
-                input_report_key(dev1, BTN_LEFT, left);
-                input_report_key(dev1, BTN_RIGHT, right);
-                input_report_key(dev1, BTN_MIDDLE, middle);
-        }
+        /*
+         * Sync the _other_ device now, we'll do the first
+         * device later once we report the rest of the events.
+         */
+        input_sync(dev2);
 }
 
 static void alps_process_packet(struct psmouse *psmouse)
diff --git a/drivers/input/mouse/amimouse.c b/drivers/input/mouse/amimouse.c
index a185ac78a42c..ff5f61a0fd3a 100644
--- a/drivers/input/mouse/amimouse.c
+++ b/drivers/input/mouse/amimouse.c
@@ -21,6 +21,7 @@
 #include <linux/init.h>
 #include <linux/input.h>
 #include <linux/interrupt.h>
+#include <linux/platform_device.h>
 
 #include <asm/irq.h>
 #include <asm/setup.h>
@@ -34,10 +35,10 @@ MODULE_DESCRIPTION("Amiga mouse driver");
 MODULE_LICENSE("GPL");
 
 static int amimouse_lastx, amimouse_lasty;
-static struct input_dev *amimouse_dev;
 
-static irqreturn_t amimouse_interrupt(int irq, void *dummy)
+static irqreturn_t amimouse_interrupt(int irq, void *data)
 {
+        struct input_dev *dev = data;
         unsigned short joy0dat, potgor;
         int nx, ny, dx, dy;
 
@@ -59,14 +60,14 @@ static irqreturn_t amimouse_interrupt(int irq, void *dummy)
 
         potgor = amiga_custom.potgor;
 
-        input_report_rel(amimouse_dev, REL_X, dx);
-        input_report_rel(amimouse_dev, REL_Y, dy);
+        input_report_rel(dev, REL_X, dx);
+        input_report_rel(dev, REL_Y, dy);
 
-        input_report_key(amimouse_dev, BTN_LEFT,   ciaa.pra & 0x40);
-        input_report_key(amimouse_dev, BTN_MIDDLE, potgor & 0x0100);
-        input_report_key(amimouse_dev, BTN_RIGHT,  potgor & 0x0400);
+        input_report_key(dev, BTN_LEFT,   ciaa.pra & 0x40);
+        input_report_key(dev, BTN_MIDDLE, potgor & 0x0100);
+        input_report_key(dev, BTN_RIGHT,  potgor & 0x0400);
 
-        input_sync(amimouse_dev);
+        input_sync(dev);
 
         return IRQ_HANDLED;
 }
@@ -74,63 +75,90 @@ static irqreturn_t amimouse_interrupt(int irq, void *dummy)
 static int amimouse_open(struct input_dev *dev)
 {
         unsigned short joy0dat;
+        int error;
 
         joy0dat = amiga_custom.joy0dat;
 
         amimouse_lastx = joy0dat & 0xff;
         amimouse_lasty = joy0dat >> 8;
 
-        if (request_irq(IRQ_AMIGA_VERTB, amimouse_interrupt, 0, "amimouse", amimouse_interrupt)) {
-                printk(KERN_ERR "amimouse.c: Can't allocate irq %d\n", IRQ_AMIGA_VERTB);
-                return -EBUSY;
-        }
+        error = request_irq(IRQ_AMIGA_VERTB, amimouse_interrupt, 0, "amimouse",
+                            dev);
+        if (error)
+                dev_err(&dev->dev, "Can't allocate irq %d\n", IRQ_AMIGA_VERTB);
 
-        return 0;
+        return error;
 }
 
 static void amimouse_close(struct input_dev *dev)
 {
-        free_irq(IRQ_AMIGA_VERTB, amimouse_interrupt);
+        free_irq(IRQ_AMIGA_VERTB, dev);
 }
 
-static int __init amimouse_init(void)
+static int __init amimouse_probe(struct platform_device *pdev)
 {
         int err;
+        struct input_dev *dev;
 
-        if (!MACH_IS_AMIGA || !AMIGAHW_PRESENT(AMI_MOUSE))
-                return -ENODEV;
-
-        amimouse_dev = input_allocate_device();
-        if (!amimouse_dev)
+        dev = input_allocate_device();
+        if (!dev)
                 return -ENOMEM;
 
-        amimouse_dev->name = "Amiga mouse";
-        amimouse_dev->phys = "amimouse/input0";
-        amimouse_dev->id.bustype = BUS_AMIGA;
-        amimouse_dev->id.vendor = 0x0001;
-        amimouse_dev->id.product = 0x0002;
-        amimouse_dev->id.version = 0x0100;
+        dev->name = pdev->name;
+        dev->phys = "amimouse/input0";
+        dev->id.bustype = BUS_AMIGA;
+        dev->id.vendor = 0x0001;
+        dev->id.product = 0x0002;
+        dev->id.version = 0x0100;
 
-        amimouse_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL);
-        amimouse_dev->relbit[0] = BIT_MASK(REL_X) | BIT_MASK(REL_Y);
-        amimouse_dev->keybit[BIT_WORD(BTN_LEFT)] = BIT_MASK(BTN_LEFT) |
+        dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL);
+        dev->relbit[0] = BIT_MASK(REL_X) | BIT_MASK(REL_Y);
+        dev->keybit[BIT_WORD(BTN_LEFT)] = BIT_MASK(BTN_LEFT) |
                 BIT_MASK(BTN_MIDDLE) | BIT_MASK(BTN_RIGHT);
-        amimouse_dev->open = amimouse_open;
-        amimouse_dev->close = amimouse_close;
+        dev->open = amimouse_open;
+        dev->close = amimouse_close;
+        dev->dev.parent = &pdev->dev;
 
-        err = input_register_device(amimouse_dev);
+        err = input_register_device(dev);
         if (err) {
-                input_free_device(amimouse_dev);
+                input_free_device(dev);
                 return err;
         }
 
+        platform_set_drvdata(pdev, dev);
+
         return 0;
 }
 
-static void __exit amimouse_exit(void)
+static int __exit amimouse_remove(struct platform_device *pdev)
 {
-        input_unregister_device(amimouse_dev);
+        struct input_dev *dev = platform_get_drvdata(pdev);
+
+        platform_set_drvdata(pdev, NULL);
+        input_unregister_device(dev);
+        return 0;
+}
+
+static struct platform_driver amimouse_driver = {
+        .remove = __exit_p(amimouse_remove),
+        .driver   = {
+                .name   = "amiga-mouse",
+                .owner  = THIS_MODULE,
+        },
+};
+
+static int __init amimouse_init(void)
+{
+        return platform_driver_probe(&amimouse_driver, amimouse_probe);
 }
 
 module_init(amimouse_init);
+
+static void __exit amimouse_exit(void)
+{
+        platform_driver_unregister(&amimouse_driver);
+}
+
 module_exit(amimouse_exit);
+
+MODULE_ALIAS("platform:amiga-mouse");
diff --git a/drivers/input/mouse/appletouch.c b/drivers/input/mouse/appletouch.c
index 908b5b44052f..a9cf76831634 100644
--- a/drivers/input/mouse/appletouch.c
+++ b/drivers/input/mouse/appletouch.c
@@ -806,8 +806,8 @@ static int atp_probe(struct usb_interface *iface,
         if (!dev->urb)
                 goto err_free_devs;
 
-        dev->data = usb_buffer_alloc(dev->udev, dev->info->datalen, GFP_KERNEL,
-                                     &dev->urb->transfer_dma);
+        dev->data = usb_alloc_coherent(dev->udev, dev->info->datalen, GFP_KERNEL,
+                                       &dev->urb->transfer_dma);
         if (!dev->data)
                 goto err_free_urb;
 
@@ -862,8 +862,8 @@ static int atp_probe(struct usb_interface *iface,
         return 0;
 
  err_free_buffer:
-        usb_buffer_free(dev->udev, dev->info->datalen,
-                        dev->data, dev->urb->transfer_dma);
+        usb_free_coherent(dev->udev, dev->info->datalen,
+                          dev->data, dev->urb->transfer_dma);
  err_free_urb:
         usb_free_urb(dev->urb);
  err_free_devs:
@@ -881,8 +881,8 @@ static void atp_disconnect(struct usb_interface *iface)
         if (dev) {
                 usb_kill_urb(dev->urb);
                 input_unregister_device(dev->input);
-                usb_buffer_free(dev->udev, dev->info->datalen,
-                                dev->data, dev->urb->transfer_dma);
+                usb_free_coherent(dev->udev, dev->info->datalen,
+                                  dev->data, dev->urb->transfer_dma);
                 usb_free_urb(dev->urb);
                 kfree(dev);
         }
diff --git a/drivers/input/mouse/bcm5974.c b/drivers/input/mouse/bcm5974.c
index 4f8fe0886b2a..b95231763911 100644
--- a/drivers/input/mouse/bcm5974.c
+++ b/drivers/input/mouse/bcm5974.c
@@ -312,6 +312,8 @@ static void setup_events_to_report(struct input_dev *input_dev,
         __set_bit(BTN_TOOL_TRIPLETAP, input_dev->keybit);
         __set_bit(BTN_TOOL_QUADTAP, input_dev->keybit);
         __set_bit(BTN_LEFT, input_dev->keybit);
+
+        input_set_events_per_packet(input_dev, 60);
 }
 
 /* report button data as logical button state */
@@ -335,10 +337,14 @@ static void report_finger_data(struct input_dev *input,
                                const struct bcm5974_config *cfg,
                                const struct tp_finger *f)
 {
-        input_report_abs(input, ABS_MT_TOUCH_MAJOR, raw2int(f->force_major));
-        input_report_abs(input, ABS_MT_TOUCH_MINOR, raw2int(f->force_minor));
-        input_report_abs(input, ABS_MT_WIDTH_MAJOR, raw2int(f->size_major));
-        input_report_abs(input, ABS_MT_WIDTH_MINOR, raw2int(f->size_minor));
+        input_report_abs(input, ABS_MT_TOUCH_MAJOR,
+                         raw2int(f->force_major) << 1);
+        input_report_abs(input, ABS_MT_TOUCH_MINOR,
+                         raw2int(f->force_minor) << 1);
+        input_report_abs(input, ABS_MT_WIDTH_MAJOR,
+                         raw2int(f->size_major) << 1);
+        input_report_abs(input, ABS_MT_WIDTH_MINOR,
+                         raw2int(f->size_minor) << 1);
         input_report_abs(input, ABS_MT_ORIENTATION,
                          MAX_FINGER_ORIENTATION - raw2int(f->orientation));
         input_report_abs(input, ABS_MT_POSITION_X, raw2int(f->abs_x));
@@ -580,23 +586,30 @@ exit:
  */
 static int bcm5974_start_traffic(struct bcm5974 *dev)
 {
-        if (bcm5974_wellspring_mode(dev, true)) {
+        int error;
+
+        error = bcm5974_wellspring_mode(dev, true);
+        if (error) {
                 dprintk(1, "bcm5974: mode switch failed\n");
-                goto error;
+                goto err_out;
         }
 
-        if (usb_submit_urb(dev->bt_urb, GFP_KERNEL))
-                goto error;
+        error = usb_submit_urb(dev->bt_urb, GFP_KERNEL);
+        if (error)
+                goto err_reset_mode;
 
-        if (usb_submit_urb(dev->tp_urb, GFP_KERNEL))
+        error = usb_submit_urb(dev->tp_urb, GFP_KERNEL);
+        if (error)
                 goto err_kill_bt;
 
         return 0;
 
 err_kill_bt:
         usb_kill_urb(dev->bt_urb);
-error:
-        return -EIO;
+err_reset_mode:
+        bcm5974_wellspring_mode(dev, false);
+err_out:
+        return error;
 }
 
 static void bcm5974_pause_traffic(struct bcm5974 *dev)
@@ -715,15 +728,15 @@ static int bcm5974_probe(struct usb_interface *iface,
         if (!dev->tp_urb)
                 goto err_free_bt_urb;
 
-        dev->bt_data = usb_buffer_alloc(dev->udev,
-                                        dev->cfg.bt_datalen, GFP_KERNEL,
-                                        &dev->bt_urb->transfer_dma);
+        dev->bt_data = usb_alloc_coherent(dev->udev,
+                                          dev->cfg.bt_datalen, GFP_KERNEL,
+                                          &dev->bt_urb->transfer_dma);
         if (!dev->bt_data)
                 goto err_free_urb;
 
-        dev->tp_data = usb_buffer_alloc(dev->udev,
-                                        dev->cfg.tp_datalen, GFP_KERNEL,
-                                        &dev->tp_urb->transfer_dma);
+        dev->tp_data = usb_alloc_coherent(dev->udev,
+                                          dev->cfg.tp_datalen, GFP_KERNEL,
+                                          &dev->tp_urb->transfer_dma);
         if (!dev->tp_data)
                 goto err_free_bt_buffer;
 
@@ -765,10 +778,10 @@ static int bcm5974_probe(struct usb_interface *iface,
         return 0;
 
 err_free_buffer:
-        usb_buffer_free(dev->udev, dev->cfg.tp_datalen,
+        usb_free_coherent(dev->udev, dev->cfg.tp_datalen,
                 dev->tp_data, dev->tp_urb->transfer_dma);
 err_free_bt_buffer:
-        usb_buffer_free(dev->udev, dev->cfg.bt_datalen,
+        usb_free_coherent(dev->udev, dev->cfg.bt_datalen,
                 dev->bt_data, dev->bt_urb->transfer_dma);
 err_free_urb:
         usb_free_urb(dev->tp_urb);
@@ -788,10 +801,10 @@ static void bcm5974_disconnect(struct usb_interface *iface)
         usb_set_intfdata(iface, NULL);
 
         input_unregister_device(dev->input);
-        usb_buffer_free(dev->udev, dev->cfg.tp_datalen,
-                        dev->tp_data, dev->tp_urb->transfer_dma);
-        usb_buffer_free(dev->udev, dev->cfg.bt_datalen,
-                        dev->bt_data, dev->bt_urb->transfer_dma);
+        usb_free_coherent(dev->udev, dev->cfg.tp_datalen,
+                          dev->tp_data, dev->tp_urb->transfer_dma);
+        usb_free_coherent(dev->udev, dev->cfg.bt_datalen,
+                          dev->bt_data, dev->bt_urb->transfer_dma);
         usb_free_urb(dev->tp_urb);
         usb_free_urb(dev->bt_urb);
         kfree(dev);
@@ -803,7 +816,6 @@ static struct usb_driver bcm5974_driver = {
         .disconnect             = bcm5974_disconnect,
         .suspend                = bcm5974_suspend,
         .resume                 = bcm5974_resume,
-        .reset_resume           = bcm5974_resume,
         .id_table               = bcm5974_table,
         .supports_autosuspend   = 1,
 };
diff --git a/drivers/input/mouse/elantech.c b/drivers/input/mouse/elantech.c
index b27684f267bf..04d9bf320a4f 100644
--- a/drivers/input/mouse/elantech.c
+++ b/drivers/input/mouse/elantech.c
@@ -10,7 +10,10 @@
  * Trademarks are the property of their respective owners.
  */
 
+#define pr_fmt(fmt) KBUILD_BASENAME ": " fmt
+
 #include <linux/delay.h>
+#include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/input.h>
 #include <linux/serio.h>
@@ -18,12 +21,16 @@
 #include "psmouse.h"
 #include "elantech.h"
 
-#define elantech_debug(format, arg...)                          \
-        do {                                                    \
-                if (etd->debug)                                 \
-                        printk(KERN_DEBUG format, ##arg);       \
+#define elantech_debug(fmt, ...)                                        \
+        do {                                                            \
+                if (etd->debug)                                         \
+                        printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__);  \
         } while (0)
 
+static bool force_elantech;
+module_param_named(force_elantech, force_elantech, bool, 0644);
+MODULE_PARM_DESC(force_elantech, "Force the Elantech PS/2 protocol extension to be used, 1 = enabled, 0 = disabled (default).");
+
 /*
  * Send a Synaptics style sliced query command
  */
@@ -32,7 +39,7 @@ static int synaptics_send_cmd(struct psmouse *psmouse, unsigned char c,
 {
         if (psmouse_sliced_command(psmouse, c) ||
             ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_GETINFO)) {
-                pr_err("elantech.c: synaptics_send_cmd query 0x%02x failed.\n", c);
+                pr_err("synaptics_send_cmd query 0x%02x failed.\n", c);
                 return -1;
         }
 
@@ -55,13 +62,13 @@ static int elantech_ps2_command(struct psmouse *psmouse,
                 if (rc == 0)
                         break;
                 tries--;
-                elantech_debug("elantech.c: retrying ps2 command 0x%02x (%d).\n",
-                        command, tries);
+                elantech_debug("retrying ps2 command 0x%02x (%d).\n",
+                                command, tries);
                 msleep(ETP_PS2_COMMAND_DELAY);
         } while (tries > 0);
 
         if (rc)
-                pr_err("elantech.c: ps2 command 0x%02x failed.\n", command);
+                pr_err("ps2 command 0x%02x failed.\n", command);
 
         return rc;
 }
@@ -103,7 +110,7 @@ static int elantech_read_reg(struct psmouse *psmouse, unsigned char reg,
         }
 
         if (rc)
-                pr_err("elantech.c: failed to read register 0x%02x.\n", reg);
+                pr_err("failed to read register 0x%02x.\n", reg);
         else
                 *val = param[0];
 
@@ -149,7 +156,7 @@ static int elantech_write_reg(struct psmouse *psmouse, unsigned char reg,
         }
 
         if (rc)
-                pr_err("elantech.c: failed to write register 0x%02x with value 0x%02x.\n",
+                pr_err("failed to write register 0x%02x with value 0x%02x.\n",
                         reg, val);
 
         return rc;
@@ -162,7 +169,7 @@ static void elantech_packet_dump(unsigned char *packet, int size)
 {
         int     i;
 
-        printk(KERN_DEBUG "elantech.c: PS/2 packet [");
+        printk(KERN_DEBUG pr_fmt("PS/2 packet ["));
         for (i = 0; i < size; i++)
                 printk("%s0x%02x ", (i) ? ", " : " ", packet[i]);
         printk("]\n");
@@ -178,36 +185,44 @@ static void elantech_report_absolute_v1(struct psmouse *psmouse)
         struct elantech_data *etd = psmouse->private;
         unsigned char *packet = psmouse->packet;
         int fingers;
-        static int old_fingers;
 
-        if (etd->fw_version_maj == 0x01) {
-                /* byte 0:  D   U  p1  p2   1  p3   R   L
-                   byte 1:  f   0  th  tw  x9  x8  y9  y8 */
+        if (etd->fw_version < 0x020000) {
+                /*
+                 * byte 0:  D   U  p1  p2   1  p3   R   L
+                 * byte 1:  f   0  th  tw  x9  x8  y9  y8
+                 */
                 fingers = ((packet[1] & 0x80) >> 7) +
                                 ((packet[1] & 0x30) >> 4);
         } else {
-                /* byte 0: n1  n0  p2  p1   1  p3   R   L
-                   byte 1:  0   0   0   0  x9  x8  y9  y8 */
+                /*
+                 * byte 0: n1  n0  p2  p1   1  p3   R   L
+                 * byte 1:  0   0   0   0  x9  x8  y9  y8
+                 */
                 fingers = (packet[0] & 0xc0) >> 6;
         }
 
         if (etd->jumpy_cursor) {
-                /* Discard packets that are likely to have bogus coordinates */
-                if (fingers > old_fingers) {
-                        elantech_debug("elantech.c: discarding packet\n");
-                        goto discard_packet_v1;
+                if (fingers != 1) {
+                        etd->single_finger_reports = 0;
+                } else if (etd->single_finger_reports < 2) {
+                        /* Discard first 2 reports of one finger, bogus */
+                        etd->single_finger_reports++;
+                        elantech_debug("discarding packet\n");
+                        return;
                 }
         }
 
         input_report_key(dev, BTN_TOUCH, fingers != 0);
 
-        /* byte 2: x7  x6  x5  x4  x3  x2  x1  x0
-           byte 3: y7  y6  y5  y4  y3  y2  y1  y0 */
+        /*
+         * byte 2: x7  x6  x5  x4  x3  x2  x1  x0
+         * byte 3: y7  y6  y5  y4  y3  y2  y1  y0
+         */
         if (fingers) {
                 input_report_abs(dev, ABS_X,
                         ((packet[1] & 0x0c) << 6) | packet[2]);
-                input_report_abs(dev, ABS_Y, ETP_YMAX_V1 -
-                        (((packet[1] & 0x03) << 8) | packet[3]));
+                input_report_abs(dev, ABS_Y,
+                        ETP_YMAX_V1 - (((packet[1] & 0x03) << 8) | packet[3]));
         }
 
         input_report_key(dev, BTN_TOOL_FINGER, fingers == 1);
@@ -216,7 +231,7 @@ static void elantech_report_absolute_v1(struct psmouse *psmouse)
         input_report_key(dev, BTN_LEFT, packet[0] & 0x01);
         input_report_key(dev, BTN_RIGHT, packet[0] & 0x02);
 
-        if ((etd->fw_version_maj == 0x01) &&
+        if (etd->fw_version < 0x020000 &&
             (etd->capabilities & ETP_CAP_HAS_ROCKER)) {
                 /* rocker up */
                 input_report_key(dev, BTN_FORWARD, packet[0] & 0x40);
@@ -225,9 +240,6 @@ static void elantech_report_absolute_v1(struct psmouse *psmouse)
         }
 
         input_sync(dev);
-
- discard_packet_v1:
-        old_fingers = fingers;
 }
 
 /*
@@ -245,35 +257,56 @@ static void elantech_report_absolute_v2(struct psmouse *psmouse)
         input_report_key(dev, BTN_TOUCH, fingers != 0);
 
         switch (fingers) {
+        case 3:
+                /*
+                 * Same as one finger, except report of more than 3 fingers:
+                 * byte 3:  n4  .   w1  w0   .   .   .   .
+                 */
+                if (packet[3] & 0x80)
+                        fingers = 4;
+                /* pass through... */
         case 1:
-                /* byte 1: x15 x14 x13 x12 x11 x10 x9  x8
-                   byte 2: x7  x6  x5  x4  x4  x2  x1  x0 */
-                input_report_abs(dev, ABS_X, (packet[1] << 8) | packet[2]);
-                /* byte 4: y15 y14 y13 y12 y11 y10 y8  y8
-                   byte 5: y7  y6  y5  y4  y3  y2  y1  y0 */
-                input_report_abs(dev, ABS_Y, ETP_YMAX_V2 -
-                        ((packet[4] << 8) | packet[5]));
+                /*
+                 * 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]);
+                /*
+                 * 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]));
                 break;
 
         case 2:
-                /* The coordinate of each finger is reported separately with
-                   a lower resolution for two finger touches */
-                /* byte 0:  .   .  ay8 ax8  .   .   .   .
-                   byte 1: ax7 ax6 ax5 ax4 ax3 ax2 ax1 ax0 */
+                /*
+                 * The coordinate of each finger is reported separately
+                 * with a lower resolution for two finger touches:
+                 * byte 0:  .   .  ay8 ax8  .   .   .   .
+                 * byte 1: ax7 ax6 ax5 ax4 ax3 ax2 ax1 ax0
+                 */
                 x1 = ((packet[0] & 0x10) << 4) | packet[1];
                 /* byte 2: ay7 ay6 ay5 ay4 ay3 ay2 ay1 ay0 */
                 y1 = ETP_2FT_YMAX - (((packet[0] & 0x20) << 3) | packet[2]);
-                /* byte 3:  .   .  by8 bx8  .   .   .   .
-                   byte 4: bx7 bx6 bx5 bx4 bx3 bx2 bx1 bx0 */
+                /*
+                 * byte 3:  .   .  by8 bx8  .   .   .   .
+                 * byte 4: bx7 bx6 bx5 bx4 bx3 bx2 bx1 bx0
+                 */
                 x2 = ((packet[3] & 0x10) << 4) | packet[4];
                 /* byte 5: by7 by8 by5 by4 by3 by2 by1 by0 */
                 y2 = ETP_2FT_YMAX - (((packet[3] & 0x20) << 3) | packet[5]);
-                /* For compatibility with the X Synaptics driver scale up one
-                   coordinate and report as ordinary mouse movent */
+                /*
+                 * For compatibility with the X Synaptics driver scale up
+                 * one coordinate and report as ordinary mouse movent
+                 */
                 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 */
+                /*
+                 * 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);
@@ -284,6 +317,7 @@ static void elantech_report_absolute_v2(struct psmouse *psmouse)
         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);
 
@@ -297,7 +331,7 @@ static int elantech_check_parity_v1(struct psmouse *psmouse)
         unsigned char p1, p2, p3;
 
         /* Parity bits are placed differently */
-        if (etd->fw_version_maj == 0x01) {
+        if (etd->fw_version < 0x020000) {
                 /* byte 0:  D   U  p1  p2   1  p3   R   L */
                 p1 = (packet[0] & 0x20) >> 5;
                 p2 = (packet[0] & 0x10) >> 4;
@@ -389,23 +423,21 @@ static int elantech_set_absolute_mode(struct psmouse *psmouse)
                         if (rc == 0)
                                 break;
                         tries--;
-                        elantech_debug("elantech.c: retrying read (%d).\n",
-                                        tries);
+                        elantech_debug("retrying read (%d).\n", tries);
                         msleep(ETP_READ_BACK_DELAY);
                 } while (tries > 0);
 
                 if (rc) {
-                        pr_err("elantech.c: failed to read back register 0x10.\n");
+                        pr_err("failed to read back register 0x10.\n");
                 } else if (etd->hw_version == 1 &&
                            !(val & ETP_R10_ABSOLUTE_MODE)) {
-                        pr_err("elantech.c: touchpad refuses "
-                                "to switch to absolute mode.\n");
+                        pr_err("touchpad refuses to switch to absolute mode.\n");
                         rc = -1;
                 }
         }
 
         if (rc)
-                pr_err("elantech.c: failed to initialise registers.\n");
+                pr_err("failed to initialise registers.\n");
 
         return rc;
 }
@@ -433,7 +465,7 @@ static void elantech_set_input_params(struct psmouse *psmouse)
         switch (etd->hw_version) {
         case 1:
                 /* Rocker button */
-                if ((etd->fw_version_maj == 0x01) &&
+                if (etd->fw_version < 0x020000 &&
                     (etd->capabilities & ETP_CAP_HAS_ROCKER)) {
                         __set_bit(BTN_FORWARD, dev->keybit);
                         __set_bit(BTN_BACK, dev->keybit);
@@ -443,6 +475,7 @@ static void elantech_set_input_params(struct psmouse *psmouse)
                 break;
 
         case 2:
+                __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);
@@ -551,6 +584,24 @@ static struct attribute_group elantech_attr_group = {
         .attrs = elantech_attrs,
 };
 
+static bool elantech_is_signature_valid(const unsigned char *param)
+{
+        static const unsigned char rates[] = { 200, 100, 80, 60, 40, 20, 10 };
+        int i;
+
+        if (param[0] == 0)
+                return false;
+
+        if (param[1] == 0)
+                return true;
+
+        for (i = 0; i < ARRAY_SIZE(rates); i++)
+                if (param[2] == rates[i])
+                        return false;
+
+        return true;
+}
+
 /*
  * Use magic knock to detect Elantech touchpad
  */
@@ -566,7 +617,7 @@ int elantech_detect(struct psmouse *psmouse, bool set_properties)
             ps2_command(ps2dev,  NULL, PSMOUSE_CMD_SETSCALE11) ||
             ps2_command(ps2dev,  NULL, PSMOUSE_CMD_SETSCALE11) ||
             ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO)) {
-                pr_debug("elantech.c: sending Elantech magic knock failed.\n");
+                pr_debug("sending Elantech magic knock failed.\n");
                 return -1;
         }
 
@@ -575,8 +626,7 @@ int elantech_detect(struct psmouse *psmouse, bool set_properties)
          * set of magic numbers
          */
         if (param[0] != 0x3c || param[1] != 0x03 || param[2] != 0xc8) {
-                pr_debug("elantech.c: "
-                         "unexpected magic knock result 0x%02x, 0x%02x, 0x%02x.\n",
+                pr_debug("unexpected magic knock result 0x%02x, 0x%02x, 0x%02x.\n",
                          param[0], param[1], param[2]);
                 return -1;
         }
@@ -587,16 +637,20 @@ int elantech_detect(struct psmouse *psmouse, bool set_properties)
          * to Elantech magic knock and there might be more.
          */
         if (synaptics_send_cmd(psmouse, ETP_FW_VERSION_QUERY, param)) {
-                pr_debug("elantech.c: failed to query firmware version.\n");
+                pr_debug("failed to query firmware version.\n");
                 return -1;
         }
 
-        pr_debug("elantech.c: Elantech version query result 0x%02x, 0x%02x, 0x%02x.\n",
+        pr_debug("Elantech version query result 0x%02x, 0x%02x, 0x%02x.\n",
                  param[0], param[1], param[2]);
 
-        if (param[0] == 0 || param[1] != 0) {
-                pr_debug("elantech.c: Probably not a real Elantech touchpad. Aborting.\n");
-                return -1;
+        if (!elantech_is_signature_valid(param)) {
+                if (!force_elantech) {
+                        pr_debug("Probably not a real Elantech touchpad. Aborting.\n");
+                        return -1;
+                }
+
+                pr_debug("Probably not a real Elantech touchpad. Enabling anyway due to force_elantech.\n");
         }
 
         if (set_properties) {
@@ -627,7 +681,7 @@ static int elantech_reconnect(struct psmouse *psmouse)
                 return -1;
 
         if (elantech_set_absolute_mode(psmouse)) {
-                pr_err("elantech.c: failed to put touchpad back into absolute mode.\n");
+                pr_err("failed to put touchpad back into absolute mode.\n");
                 return -1;
         }
 
@@ -645,7 +699,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++)
@@ -655,17 +709,17 @@ int elantech_init(struct psmouse *psmouse)
          * Do the version query again so we can store the result
          */
         if (synaptics_send_cmd(psmouse, ETP_FW_VERSION_QUERY, param)) {
-                pr_err("elantech.c: failed to query firmware version.\n");
+                pr_err("failed to query firmware version.\n");
                 goto init_fail;
         }
-        etd->fw_version_maj = param[0];
-        etd->fw_version_min = param[2];
+
+        etd->fw_version = (param[0] << 16) | (param[1] << 8) | param[2];
 
         /*
          * Assume every version greater than this is new EeePC style
          * hardware with 6 byte packets
          */
-        if (etd->fw_version_maj >= 0x02 && etd->fw_version_min >= 0x30) {
+        if (etd->fw_version >= 0x020030) {
                 etd->hw_version = 2;
                 /* For now show extra debug information */
                 etd->debug = 1;
@@ -675,30 +729,30 @@ int elantech_init(struct psmouse *psmouse)
                 etd->hw_version = 1;
                 etd->paritycheck = 1;
         }
-        pr_info("elantech.c: assuming hardware version %d, firmware version %d.%d\n",
-                etd->hw_version, etd->fw_version_maj, etd->fw_version_min);
+
+        pr_info("assuming hardware version %d, firmware version %d.%d.%d\n",
+                etd->hw_version, param[0], param[1], param[2]);
 
         if (synaptics_send_cmd(psmouse, ETP_CAPABILITIES_QUERY, param)) {
-                pr_err("elantech.c: failed to query capabilities.\n");
+                pr_err("failed to query capabilities.\n");
                 goto init_fail;
         }
-        pr_info("elantech.c: Synaptics capabilities query result 0x%02x, 0x%02x, 0x%02x.\n",
+        pr_info("Synaptics capabilities query result 0x%02x, 0x%02x, 0x%02x.\n",
                 param[0], param[1], param[2]);
         etd->capabilities = param[0];
 
         /*
-         * This firmware seems to suffer from misreporting coordinates when
+         * This firmware suffers from misreporting coordinates when
          * a touch action starts causing the mouse cursor or scrolled page
          * to jump. Enable a workaround.
          */
-        if (etd->fw_version_maj == 0x02 && etd->fw_version_min == 0x22) {
-                pr_info("elantech.c: firmware version 2.34 detected, "
-                        "enabling jumpy cursor workaround\n");
-                etd->jumpy_cursor = 1;
+        if (etd->fw_version == 0x020022 || etd->fw_version == 0x020600) {
+                pr_info("firmware version 2.0.34/2.6.0 detected, enabling jumpy cursor workaround\n");
+                etd->jumpy_cursor = true;
         }
 
         if (elantech_set_absolute_mode(psmouse)) {
-                pr_err("elantech.c: failed to put touchpad into absolute mode.\n");
+                pr_err("failed to put touchpad into absolute mode.\n");
                 goto init_fail;
         }
 
@@ -707,8 +761,7 @@ int elantech_init(struct psmouse *psmouse)
         error = sysfs_create_group(&psmouse->ps2dev.serio->dev.kobj,
                                    &elantech_attr_group);
         if (error) {
-                pr_err("elantech.c: failed to create sysfs attributes, error: %d.\n",
-                        error);
+                pr_err("failed to create sysfs attributes, error: %d.\n", error);
                 goto init_fail;
         }
 
diff --git a/drivers/input/mouse/elantech.h b/drivers/input/mouse/elantech.h
index feac5f7af966..aa4aac5d2198 100644
--- a/drivers/input/mouse/elantech.h
+++ b/drivers/input/mouse/elantech.h
@@ -100,11 +100,11 @@ struct elantech_data {
         unsigned char reg_26;
         unsigned char debug;
         unsigned char capabilities;
-        unsigned char fw_version_maj;
-        unsigned char fw_version_min;
+        bool paritycheck;
+        bool jumpy_cursor;
         unsigned char hw_version;
-        unsigned char paritycheck;
-        unsigned char jumpy_cursor;
+        unsigned int fw_version;
+        unsigned int single_finger_reports;
         unsigned char parity[256];
 };
 
diff --git a/drivers/input/mouse/hgpk.c b/drivers/input/mouse/hgpk.c
index 90be30e93556..1d2205b24800 100644
--- a/drivers/input/mouse/hgpk.c
+++ b/drivers/input/mouse/hgpk.c
@@ -30,6 +30,7 @@
  */
 
 #define DEBUG
+#include <linux/slab.h>
 #include <linux/input.h>
 #include <linux/serio.h>
 #include <linux/libps2.h>
@@ -39,8 +40,8 @@
 #include "psmouse.h"
 #include "hgpk.h"
 
-static int tpdebug;
-module_param(tpdebug, int, 0644);
+static bool tpdebug;
+module_param(tpdebug, bool, 0644);
 MODULE_PARM_DESC(tpdebug, "enable debugging, dumping packets to KERN_DEBUG.");
 
 static int recalib_delta = 100;
@@ -68,10 +69,6 @@ module_param(post_interrupt_delay, int, 0644);
 MODULE_PARM_DESC(post_interrupt_delay,
         "delay (ms) before recal after recal interrupt detected");
 
-static int autorecal = 1;
-module_param(autorecal, int, 0644);
-MODULE_PARM_DESC(autorecal, "enable recalibration in the driver");
-
 /*
  * 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
diff --git a/drivers/input/mouse/lifebook.c b/drivers/input/mouse/lifebook.c
index 7c1d7d420ae3..c31ad11df6bb 100644
--- a/drivers/input/mouse/lifebook.c
+++ b/drivers/input/mouse/lifebook.c
@@ -16,6 +16,7 @@
 #include <linux/serio.h>
 #include <linux/libps2.h>
 #include <linux/dmi.h>
+#include <linux/slab.h>
 
 #include "psmouse.h"
 #include "lifebook.h"
diff --git a/drivers/input/mouse/logips2pp.c b/drivers/input/mouse/logips2pp.c
index 543c240a85f2..c9983aee9082 100644
--- a/drivers/input/mouse/logips2pp.c
+++ b/drivers/input/mouse/logips2pp.c
@@ -56,36 +56,36 @@ static psmouse_ret_t ps2pp_process_byte(struct psmouse *psmouse)
                 /* Logitech extended packet */
                 switch ((packet[1] >> 4) | (packet[0] & 0x30)) {
 
-                        case 0x0d: /* Mouse extra info */
+                case 0x0d: /* Mouse extra info */
 
-                                input_report_rel(dev, packet[2] & 0x80 ? REL_HWHEEL : REL_WHEEL,
-                                        (int) (packet[2] & 8) - (int) (packet[2] & 7));
-                                input_report_key(dev, BTN_SIDE, (packet[2] >> 4) & 1);
-                                input_report_key(dev, BTN_EXTRA, (packet[2] >> 5) & 1);
+                        input_report_rel(dev, packet[2] & 0x80 ? REL_HWHEEL : REL_WHEEL,
+                                (int) (packet[2] & 8) - (int) (packet[2] & 7));
+                        input_report_key(dev, BTN_SIDE, (packet[2] >> 4) & 1);
+                        input_report_key(dev, BTN_EXTRA, (packet[2] >> 5) & 1);
 
-                                break;
+                        break;
 
-                        case 0x0e: /* buttons 4, 5, 6, 7, 8, 9, 10 info */
+                case 0x0e: /* buttons 4, 5, 6, 7, 8, 9, 10 info */
 
-                                input_report_key(dev, BTN_SIDE, (packet[2]) & 1);
-                                input_report_key(dev, BTN_EXTRA, (packet[2] >> 1) & 1);
-                                input_report_key(dev, BTN_BACK, (packet[2] >> 3) & 1);
-                                input_report_key(dev, BTN_FORWARD, (packet[2] >> 4) & 1);
-                                input_report_key(dev, BTN_TASK, (packet[2] >> 2) & 1);
+                        input_report_key(dev, BTN_SIDE, (packet[2]) & 1);
+                        input_report_key(dev, BTN_EXTRA, (packet[2] >> 1) & 1);
+                        input_report_key(dev, BTN_BACK, (packet[2] >> 3) & 1);
+                        input_report_key(dev, BTN_FORWARD, (packet[2] >> 4) & 1);
+                        input_report_key(dev, BTN_TASK, (packet[2] >> 2) & 1);
 
-                                break;
+                        break;
 
-                        case 0x0f: /* TouchPad extra info */
+                case 0x0f: /* TouchPad extra info */
 
-                                input_report_rel(dev, packet[2] & 0x08 ? REL_HWHEEL : REL_WHEEL,
-                                        (int) ((packet[2] >> 4) & 8) - (int) ((packet[2] >> 4) & 7));
-                                packet[0] = packet[2] | 0x08;
-                                break;
+                        input_report_rel(dev, packet[2] & 0x08 ? REL_HWHEEL : REL_WHEEL,
+                                (int) ((packet[2] >> 4) & 8) - (int) ((packet[2] >> 4) & 7));
+                        packet[0] = packet[2] | 0x08;
+                        break;
 
 #ifdef DEBUG
-                        default:
-                                printk(KERN_WARNING "psmouse.c: Received PS2++ packet #%x, but don't know how to handle.\n",
-                                        (packet[1] >> 4) | (packet[0] & 0x30));
+                default:
+                        printk(KERN_WARNING "psmouse.c: Received PS2++ packet #%x, but don't know how to handle.\n",
+                                (packet[1] >> 4) | (packet[0] & 0x30));
 #endif
                 }
         } else {
@@ -250,7 +250,6 @@ static const struct ps2pp_info *get_model_info(unsigned char model)
                 if (model == ps2pp_list[i].model)
                         return &ps2pp_list[i];
 
-        printk(KERN_WARNING "logips2pp: Detected unknown logitech mouse model %d\n", model);
         return NULL;
 }
 
@@ -285,31 +284,32 @@ static void ps2pp_set_model_properties(struct psmouse *psmouse,
                 __set_bit(REL_HWHEEL, input_dev->relbit);
 
         switch (model_info->kind) {
-                case PS2PP_KIND_WHEEL:
-                        psmouse->name = "Wheel Mouse";
-                        break;
-
-                case PS2PP_KIND_MX:
-                        psmouse->name = "MX Mouse";
-                        break;
 
-                case PS2PP_KIND_TP3:
-                        psmouse->name = "TouchPad 3";
-                        break;
-
-                case PS2PP_KIND_TRACKMAN:
-                        psmouse->name = "TrackMan";
-                        break;
-
-                default:
-                        /*
-                         * Set name to "Mouse" only when using PS2++,
-                         * otherwise let other protocols define suitable
-                         * name
-                         */
-                        if (using_ps2pp)
-                                psmouse->name = "Mouse";
-                        break;
+        case PS2PP_KIND_WHEEL:
+                psmouse->name = "Wheel Mouse";
+                break;
+
+        case PS2PP_KIND_MX:
+                psmouse->name = "MX Mouse";
+                break;
+
+        case PS2PP_KIND_TP3:
+                psmouse->name = "TouchPad 3";
+                break;
+
+        case PS2PP_KIND_TRACKMAN:
+                psmouse->name = "TrackMan";
+                break;
+
+        default:
+                /*
+                 * Set name to "Mouse" only when using PS2++,
+                 * otherwise let other protocols define suitable
+                 * name
+                 */
+                if (using_ps2pp)
+                        psmouse->name = "Mouse";
+                break;
         }
 }
 
@@ -343,7 +343,8 @@ int ps2pp_init(struct psmouse *psmouse, bool set_properties)
         if (!model || !buttons)
                 return -1;
 
-        if ((model_info = get_model_info(model)) != NULL) {
+        model_info = get_model_info(model);
+        if (model_info) {
 
 /*
  * Do Logitech PS2++ / PS2T++ magic init.
@@ -379,6 +380,9 @@ int ps2pp_init(struct psmouse *psmouse, bool set_properties)
                                 use_ps2pp = true;
                         }
                 }
+
+        } else {
+                printk(KERN_WARNING "logips2pp: Detected unknown logitech mouse model %d\n", model);
         }
 
         if (set_properties) {
diff --git a/drivers/input/mouse/pc110pad.c b/drivers/input/mouse/pc110pad.c
index 3941f97cfa60..7b02b652e267 100644
--- a/drivers/input/mouse/pc110pad.c
+++ b/drivers/input/mouse/pc110pad.c
@@ -145,8 +145,8 @@ static int __init pc110pad_init(void)
         pc110pad_dev->absbit[0] = BIT_MASK(ABS_X) | BIT_MASK(ABS_Y);
         pc110pad_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
 
-        pc110pad_dev->absmax[ABS_X] = 0x1ff;
-        pc110pad_dev->absmax[ABS_Y] = 0x0ff;
+        input_abs_set_max(pc110pad_dev, ABS_X, 0x1ff);
+        input_abs_set_max(pc110pad_dev, ABS_Y, 0x0ff);
 
         pc110pad_dev->open = pc110pad_open;
         pc110pad_dev->close = pc110pad_close;
diff --git a/drivers/input/mouse/psmouse-base.c b/drivers/input/mouse/psmouse-base.c
index 9774bdfaa482..cd9d0c97e429 100644
--- a/drivers/input/mouse/psmouse-base.c
+++ b/drivers/input/mouse/psmouse-base.c
@@ -39,11 +39,13 @@ MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE("GPL");
 
 static unsigned int psmouse_max_proto = PSMOUSE_AUTO;
-static int psmouse_set_maxproto(const char *val, struct kernel_param *kp);
-static int psmouse_get_maxproto(char *buffer, struct kernel_param *kp);
+static int psmouse_set_maxproto(const char *val, const struct kernel_param *);
+static int psmouse_get_maxproto(char *buffer, const struct kernel_param *kp);
+static struct kernel_param_ops param_ops_proto_abbrev = {
+        .set = psmouse_set_maxproto,
+        .get = psmouse_get_maxproto,
+};
 #define param_check_proto_abbrev(name, p)       __param_check(name, p, unsigned int)
-#define param_set_proto_abbrev                  psmouse_set_maxproto
-#define param_get_proto_abbrev                  psmouse_get_maxproto
 module_param_named(proto, psmouse_max_proto, proto_abbrev, 0644);
 MODULE_PARM_DESC(proto, "Highest protocol extension to probe (bare, imps, exps, any). Useful for KVM switches.");
 
@@ -110,6 +112,7 @@ static struct workqueue_struct *kpsmoused_wq;
 struct psmouse_protocol {
         enum psmouse_type type;
         bool maxproto;
+        bool ignore_parity; /* Protocol should ignore parity errors from KBC */
         const char *name;
         const char *alias;
         int (*detect)(struct psmouse *, bool);
@@ -146,18 +149,18 @@ static psmouse_ret_t psmouse_process_byte(struct psmouse *psmouse)
 
         if (psmouse->type == PSMOUSE_IMEX) {
                 switch (packet[3] & 0xC0) {
-                        case 0x80: /* vertical scroll on IntelliMouse Explorer 4.0 */
-                                input_report_rel(dev, REL_WHEEL, (int) (packet[3] & 32) - (int) (packet[3] & 31));
-                                break;
-                        case 0x40: /* horizontal scroll on IntelliMouse Explorer 4.0 */
-                                input_report_rel(dev, REL_HWHEEL, (int) (packet[3] & 32) - (int) (packet[3] & 31));
-                                break;
-                        case 0x00:
-                        case 0xC0:
-                                input_report_rel(dev, REL_WHEEL, (int) (packet[3] & 8) - (int) (packet[3] & 7));
-                                input_report_key(dev, BTN_SIDE, (packet[3] >> 4) & 1);
-                                input_report_key(dev, BTN_EXTRA, (packet[3] >> 5) & 1);
-                                break;
+                case 0x80: /* vertical scroll on IntelliMouse Explorer 4.0 */
+                        input_report_rel(dev, REL_WHEEL, (int) (packet[3] & 32) - (int) (packet[3] & 31));
+                        break;
+                case 0x40: /* horizontal scroll on IntelliMouse Explorer 4.0 */
+                        input_report_rel(dev, REL_HWHEEL, (int) (packet[3] & 32) - (int) (packet[3] & 31));
+                        break;
+                case 0x00:
+                case 0xC0:
+                        input_report_rel(dev, REL_WHEEL, (int) (packet[3] & 8) - (int) (packet[3] & 7));
+                        input_report_key(dev, BTN_SIDE, (packet[3] >> 4) & 1);
+                        input_report_key(dev, BTN_EXTRA, (packet[3] >> 5) & 1);
+                        break;
                 }
         }
 
@@ -246,31 +249,31 @@ static int psmouse_handle_byte(struct psmouse *psmouse)
         psmouse_ret_t rc = psmouse->protocol_handler(psmouse);
 
         switch (rc) {
-                case PSMOUSE_BAD_DATA:
-                        if (psmouse->state == PSMOUSE_ACTIVATED) {
-                                printk(KERN_WARNING "psmouse.c: %s at %s lost sync at byte %d\n",
-                                        psmouse->name, psmouse->phys, psmouse->pktcnt);
-                                if (++psmouse->out_of_sync_cnt == psmouse->resetafter) {
-                                        __psmouse_set_state(psmouse, PSMOUSE_IGNORE);
-                                        printk(KERN_NOTICE "psmouse.c: issuing reconnect request\n");
-                                        serio_reconnect(psmouse->ps2dev.serio);
-                                        return -1;
-                                }
-                        }
-                        psmouse->pktcnt = 0;
-                        break;
-
-                case PSMOUSE_FULL_PACKET:
-                        psmouse->pktcnt = 0;
-                        if (psmouse->out_of_sync_cnt) {
-                                psmouse->out_of_sync_cnt = 0;
-                                printk(KERN_NOTICE "psmouse.c: %s at %s - driver resynched.\n",
-                                        psmouse->name, psmouse->phys);
+        case PSMOUSE_BAD_DATA:
+                if (psmouse->state == PSMOUSE_ACTIVATED) {
+                        printk(KERN_WARNING "psmouse.c: %s at %s lost sync at byte %d\n",
+                                psmouse->name, psmouse->phys, psmouse->pktcnt);
+                        if (++psmouse->out_of_sync_cnt == psmouse->resetafter) {
+                                __psmouse_set_state(psmouse, PSMOUSE_IGNORE);
+                                printk(KERN_NOTICE "psmouse.c: issuing reconnect request\n");
+                                serio_reconnect(psmouse->ps2dev.serio);
+                                return -1;
                         }
-                        break;
+                }
+                psmouse->pktcnt = 0;
+                break;
+
+        case PSMOUSE_FULL_PACKET:
+                psmouse->pktcnt = 0;
+                if (psmouse->out_of_sync_cnt) {
+                        psmouse->out_of_sync_cnt = 0;
+                        printk(KERN_NOTICE "psmouse.c: %s at %s - driver resynched.\n",
+                                psmouse->name, psmouse->phys);
+                }
+                break;
 
-                case PSMOUSE_GOOD_DATA:
-                        break;
+        case PSMOUSE_GOOD_DATA:
+                break;
         }
         return 0;
 }
@@ -288,7 +291,9 @@ static irqreturn_t psmouse_interrupt(struct serio *serio,
         if (psmouse->state == PSMOUSE_IGNORE)
                 goto out;
 
-        if (flags & (SERIO_PARITY|SERIO_TIMEOUT)) {
+        if (unlikely((flags & SERIO_TIMEOUT) ||
+                     ((flags & SERIO_PARITY) && !psmouse->ignore_parity))) {
+
                 if (psmouse->state == PSMOUSE_ACTIVATED)
                         printk(KERN_WARNING "psmouse.c: bad data from KBC -%s%s\n",
                                 flags & SERIO_TIMEOUT ? " timeout" : "",
@@ -759,6 +764,7 @@ static const struct psmouse_protocol psmouse_protocols[] = {
                 .name           = "PS/2",
                 .alias          = "bare",
                 .maxproto       = true,
+                .ignore_parity  = true,
                 .detect         = ps2bare_detect,
         },
 #ifdef CONFIG_MOUSE_PS2_LOGIPS2PP
@@ -786,6 +792,7 @@ static const struct psmouse_protocol psmouse_protocols[] = {
                 .name           = "ImPS/2",
                 .alias          = "imps",
                 .maxproto       = true,
+                .ignore_parity  = true,
                 .detect         = intellimouse_detect,
         },
         {
@@ -793,6 +800,7 @@ static const struct psmouse_protocol psmouse_protocols[] = {
                 .name           = "ImExPS/2",
                 .alias          = "exps",
                 .maxproto       = true,
+                .ignore_parity  = true,
                 .detect         = im_explorer_detect,
         },
 #ifdef CONFIG_MOUSE_PS2_SYNAPTICS
@@ -1141,7 +1149,14 @@ static void psmouse_cleanup(struct serio *serio)
                 psmouse_deactivate(parent);
         }
 
-        psmouse_deactivate(psmouse);
+        psmouse_set_state(psmouse, PSMOUSE_INITIALIZING);
+
+        /*
+         * Disable stream mode so cleanup routine can proceed undisturbed.
+         */
+        if (ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_DISABLE))
+                printk(KERN_WARNING "psmouse.c: Failed to disable mouse on %s\n",
+                        psmouse->ps2dev.serio->phys);
 
         if (psmouse->cleanup)
                 psmouse->cleanup(psmouse);
@@ -1215,6 +1230,7 @@ static void psmouse_disconnect(struct serio *serio)
 static int psmouse_switch_protocol(struct psmouse *psmouse,
                                    const struct psmouse_protocol *proto)
 {
+        const struct psmouse_protocol *selected_proto;
         struct input_dev *input_dev = psmouse->dev;
 
         input_dev->dev.parent = &psmouse->ps2dev.serio->dev;
@@ -1231,16 +1247,21 @@ static int psmouse_switch_protocol(struct psmouse *psmouse,
         psmouse->pktsize = 3;
 
         if (proto && (proto->detect || proto->init)) {
-                if (proto->detect && proto->detect(psmouse, 1) < 0)
+                if (proto->detect && proto->detect(psmouse, true) < 0)
                         return -1;
 
                 if (proto->init && proto->init(psmouse) < 0)
                         return -1;
 
                 psmouse->type = proto->type;
-        } else
+                selected_proto = proto;
+        } else {
                 psmouse->type = psmouse_extensions(psmouse,
                                                    psmouse_max_proto, true);
+                selected_proto = psmouse_protocol_by_type(psmouse->type);
+        }
+
+        psmouse->ignore_parity = selected_proto->ignore_parity;
 
         /*
          * If mouse's packet size is 3 there is no point in polling the
@@ -1260,7 +1281,7 @@ static int psmouse_switch_protocol(struct psmouse *psmouse,
                 psmouse->resync_time = 0;
 
         snprintf(psmouse->devname, sizeof(psmouse->devname), "%s %s %s",
-                 psmouse_protocol_by_type(psmouse->type)->name, psmouse->vendor, psmouse->name);
+                 selected_proto->name, psmouse->vendor, psmouse->name);
 
         input_dev->name = psmouse->devname;
         input_dev->phys = psmouse->phys;
@@ -1375,6 +1396,7 @@ static int psmouse_reconnect(struct serio *serio)
         struct psmouse *psmouse = serio_get_drvdata(serio);
         struct psmouse *parent = NULL;
         struct serio_driver *drv = serio->drv;
+        unsigned char type;
         int rc = -1;
 
         if (!drv || !psmouse) {
@@ -1394,10 +1416,15 @@ static int psmouse_reconnect(struct serio *serio)
         if (psmouse->reconnect) {
                 if (psmouse->reconnect(psmouse))
                         goto out;
-        } else if (psmouse_probe(psmouse) < 0 ||
-                   psmouse->type != psmouse_extensions(psmouse,
-                                                psmouse_max_proto, false)) {
-                goto out;
+        } else {
+                psmouse_reset(psmouse);
+
+                if (psmouse_probe(psmouse) < 0)
+                        goto out;
+
+                type = psmouse_extensions(psmouse, psmouse_max_proto, false);
+                if (psmouse->type != type)
+                        goto out;
         }
 
         /* ok, the device type (and capabilities) match the old one,
@@ -1557,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;
@@ -1654,7 +1681,7 @@ static ssize_t psmouse_attr_set_resolution(struct psmouse *psmouse, void *data,
 }
 
 
-static int psmouse_set_maxproto(const char *val, struct kernel_param *kp)
+static int psmouse_set_maxproto(const char *val, const struct kernel_param *kp)
 {
         const struct psmouse_protocol *proto;
 
@@ -1671,7 +1698,7 @@ static int psmouse_set_maxproto(const char *val, struct kernel_param *kp)
         return 0;
 }
 
-static int psmouse_get_maxproto(char *buffer, struct kernel_param *kp)
+static int psmouse_get_maxproto(char *buffer, const struct kernel_param *kp)
 {
         int type = *((unsigned int *)kp->arg);
 
diff --git a/drivers/input/mouse/psmouse.h b/drivers/input/mouse/psmouse.h
index e053bdd137ff..593e910bfc7a 100644
--- a/drivers/input/mouse/psmouse.h
+++ b/drivers/input/mouse/psmouse.h
@@ -47,6 +47,7 @@ struct psmouse {
         unsigned char pktcnt;
         unsigned char pktsize;
         unsigned char type;
+        bool ignore_parity;
         bool acks_disable_command;
         unsigned int model;
         unsigned long last;
diff --git a/drivers/input/mouse/pxa930_trkball.c b/drivers/input/mouse/pxa930_trkball.c
index 1e827ad0afbe..943cfec15665 100644
--- a/drivers/input/mouse/pxa930_trkball.c
+++ b/drivers/input/mouse/pxa930_trkball.c
@@ -18,6 +18,7 @@
 #include <linux/platform_device.h>
 #include <linux/delay.h>
 #include <linux/io.h>
+#include <linux/slab.h>
 
 #include <mach/hardware.h>
 #include <mach/pxa930_trkball.h>
diff --git a/drivers/input/mouse/sentelic.c b/drivers/input/mouse/sentelic.c
index 81a6b81cb2fe..1242775fee19 100644
--- a/drivers/input/mouse/sentelic.c
+++ b/drivers/input/mouse/sentelic.c
@@ -26,6 +26,7 @@
 #include <linux/libps2.h>
 #include <linux/serio.h>
 #include <linux/jiffies.h>
+#include <linux/slab.h>
 
 #include "psmouse.h"
 #include "sentelic.h"
diff --git a/drivers/input/mouse/synaptics.c b/drivers/input/mouse/synaptics.c
index d3f5243fa093..2e300a460556 100644
--- a/drivers/input/mouse/synaptics.c
+++ b/drivers/input/mouse/synaptics.c
@@ -28,6 +28,7 @@
 #include <linux/input.h>
 #include <linux/serio.h>
 #include <linux/libps2.h>
+#include <linux/slab.h>
 #include "psmouse.h"
 #include "synaptics.h"
 
@@ -35,6 +36,8 @@
  * The x/y limits are taken from the Synaptics TouchPad interfacing Guide,
  * section 2.3.2, which says that they should be valid regardless of the
  * actual size of the sensor.
+ * Note that newer firmware allows querying device for maximum useable
+ * coordinates.
  */
 #define XMIN_NOMINAL 1472
 #define XMAX_NOMINAL 5472
@@ -136,9 +139,15 @@ static int synaptics_capability(struct psmouse *psmouse)
         if (synaptics_send_cmd(psmouse, SYN_QUE_CAPABILITIES, cap))
                 return -1;
         priv->capabilities = (cap[0] << 16) | (cap[1] << 8) | cap[2];
-        priv->ext_cap = 0;
-        if (!SYN_CAP_VALID(priv->capabilities))
+        priv->ext_cap = priv->ext_cap_0c = 0;
+
+        /*
+         * Older firmwares had submodel ID fixed to 0x47
+         */
+        if (SYN_ID_FULL(priv->identity) < 0x705 &&
+            SYN_CAP_SUBMODEL_ID(priv->capabilities) != 0x47) {
                 return -1;
+        }
 
         /*
          * Unless capExtended is set the rest of the flags should be ignored
@@ -149,7 +158,7 @@ static int synaptics_capability(struct psmouse *psmouse)
         if (SYN_EXT_CAP_REQUESTS(priv->capabilities) >= 1) {
                 if (synaptics_send_cmd(psmouse, SYN_QUE_EXT_CAPAB, cap)) {
                         printk(KERN_ERR "Synaptics claims to have extended capabilities,"
-                               " but I'm not able to read them.");
+                               " but I'm not able to read them.\n");
                 } else {
                         priv->ext_cap = (cap[0] << 16) | (cap[1] << 8) | cap[2];
 
@@ -161,6 +170,16 @@ static int synaptics_capability(struct psmouse *psmouse)
                                 priv->ext_cap &= 0xff0fff;
                 }
         }
+
+        if (SYN_EXT_CAP_REQUESTS(priv->capabilities) >= 4) {
+                if (synaptics_send_cmd(psmouse, SYN_QUE_EXT_CAPAB_0C, cap)) {
+                        printk(KERN_ERR "Synaptics claims to have extended capability 0x0c,"
+                               " but I'm not able to read it.\n");
+                } else {
+                        priv->ext_cap_0c = (cap[0] << 16) | (cap[1] << 8) | cap[2];
+                }
+        }
+
         return 0;
 }
 
@@ -182,23 +201,34 @@ static int synaptics_identify(struct psmouse *psmouse)
 }
 
 /*
- * Read touchpad resolution
+ * Read touchpad resolution and maximum reported coordinates
  * Resolution is left zero if touchpad does not support the query
  */
 static int synaptics_resolution(struct psmouse *psmouse)
 {
         struct synaptics_data *priv = psmouse->private;
         unsigned char res[3];
+        unsigned char max[3];
 
         if (SYN_ID_MAJOR(priv->identity) < 4)
                 return 0;
 
-        if (synaptics_send_cmd(psmouse, SYN_QUE_RESOLUTION, res))
-                return 0;
+        if (synaptics_send_cmd(psmouse, SYN_QUE_RESOLUTION, res) == 0) {
+                if (res[0] != 0 && (res[1] & 0x80) && res[2] != 0) {
+                        priv->x_res = res[0]; /* x resolution in units/mm */
+                        priv->y_res = res[2]; /* y resolution in units/mm */
+                }
+        }
 
-        if ((res[0] != 0) && (res[1] & 0x80) && (res[2] != 0)) {
-                priv->x_res = res[0]; /* x resolution in units/mm */
-                priv->y_res = res[2]; /* y resolution in units/mm */
+        if (SYN_EXT_CAP_REQUESTS(priv->capabilities) >= 5 &&
+            SYN_CAP_MAX_DIMENSIONS(priv->ext_cap_0c)) {
+                if (synaptics_send_cmd(psmouse, SYN_QUE_EXT_DIMENSIONS, max)) {
+                        printk(KERN_ERR "Synaptics claims to have dimensions query,"
+                               " but I'm not able to read it.\n");
+                } else {
+                        priv->x_max = (max[0] << 5) | ((max[1] & 0x0f) << 1);
+                        priv->y_max = (max[2] << 5) | ((max[1] & 0xf0) >> 3);
+                }
         }
 
         return 0;
@@ -264,7 +294,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;
 }
@@ -285,9 +337,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) {
@@ -315,6 +366,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;
@@ -347,7 +400,15 @@ 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;
 
-                if (SYN_CAP_MIDDLE_BUTTON(priv->capabilities)) {
+                if (SYN_CAP_CLICKPAD(priv->ext_cap_0c)) {
+                        /*
+                         * Clickpad's button is transmitted as middle button,
+                         * however, since it is primary button, we will report
+                         * it as BTN_LEFT.
+                         */
+                        hw->left = ((buf[0] ^ buf[3]) & 0x01) ? 1 : 0;
+
+                } else if (SYN_CAP_MIDDLE_BUTTON(priv->capabilities)) {
                         hw->middle = ((buf[0] ^ buf[3]) & 0x01) ? 1 : 0;
                         if (hw->w == 2)
                                 hw->scroll = (signed char)(buf[1]);
@@ -464,7 +525,9 @@ static void synaptics_process_packet(struct psmouse *psmouse)
         }
         input_report_abs(dev, ABS_PRESSURE, hw.z);
 
-        input_report_abs(dev, ABS_TOOL_WIDTH, finger_width);
+        if (SYN_CAP_PALMDETECT(priv->capabilities))
+                input_report_abs(dev, ABS_TOOL_WIDTH, finger_width);
+
         input_report_key(dev, BTN_TOOL_FINGER, num_fingers == 1);
         input_report_key(dev, BTN_LEFT, hw.left);
         input_report_key(dev, BTN_RIGHT, hw.right);
@@ -500,19 +563,20 @@ static int synaptics_validate_byte(unsigned char packet[], int idx, unsigned cha
                 return 0;
 
         switch (pkt_type) {
-                case SYN_NEWABS:
-                case SYN_NEWABS_RELAXED:
-                        return (packet[idx] & newabs_rel_mask[idx]) == newabs_rslt[idx];
 
-                case SYN_NEWABS_STRICT:
-                        return (packet[idx] & newabs_mask[idx]) == newabs_rslt[idx];
+        case SYN_NEWABS:
+        case SYN_NEWABS_RELAXED:
+                return (packet[idx] & newabs_rel_mask[idx]) == newabs_rslt[idx];
 
-                case SYN_OLDABS:
-                        return (packet[idx] & oldabs_mask[idx]) == oldabs_rslt[idx];
+        case SYN_NEWABS_STRICT:
+                return (packet[idx] & newabs_mask[idx]) == newabs_rslt[idx];
 
-                default:
-                        printk(KERN_ERR "synaptics: unknown packet type %d\n", pkt_type);
-                        return 0;
+        case SYN_OLDABS:
+                return (packet[idx] & oldabs_mask[idx]) == oldabs_rslt[idx];
+
+        default:
+                printk(KERN_ERR "synaptics: unknown packet type %d\n", pkt_type);
+                return 0;
         }
 }
 
@@ -537,9 +601,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);
 
@@ -558,10 +623,14 @@ static void set_input_params(struct input_dev *dev, struct synaptics_data *priv)
         int i;
 
         __set_bit(EV_ABS, dev->evbit);
-        input_set_abs_params(dev, ABS_X, XMIN_NOMINAL, XMAX_NOMINAL, 0, 0);
-        input_set_abs_params(dev, ABS_Y, YMIN_NOMINAL, YMAX_NOMINAL, 0, 0);
+        input_set_abs_params(dev, ABS_X,
+                             XMIN_NOMINAL, priv->x_max ?: XMAX_NOMINAL, 0, 0);
+        input_set_abs_params(dev, ABS_Y,
+                             YMIN_NOMINAL, priv->y_max ?: YMAX_NOMINAL, 0, 0);
         input_set_abs_params(dev, ABS_PRESSURE, 0, 255, 0, 0);
-        __set_bit(ABS_TOOL_WIDTH, dev->absbit);
+
+        if (SYN_CAP_PALMDETECT(priv->capabilities))
+                input_set_abs_params(dev, ABS_TOOL_WIDTH, 0, 15, 0, 0);
 
         __set_bit(EV_KEY, dev->evbit);
         __set_bit(BTN_TOUCH, dev->keybit);
@@ -590,8 +659,14 @@ static void set_input_params(struct input_dev *dev, struct synaptics_data *priv)
         __clear_bit(REL_X, dev->relbit);
         __clear_bit(REL_Y, dev->relbit);
 
-        dev->absres[ABS_X] = priv->x_res;
-        dev->absres[ABS_Y] = priv->y_res;
+        input_abs_set_res(dev, ABS_X, priv->x_res);
+        input_abs_set_res(dev, ABS_Y, priv->y_res);
+
+        if (SYN_CAP_CLICKPAD(priv->ext_cap_0c)) {
+                /* Clickpads report only left button */
+                __clear_bit(BTN_RIGHT, dev->keybit);
+                __clear_bit(BTN_MIDDLE, dev->keybit);
+        }
 }
 
 static void synaptics_disconnect(struct psmouse *psmouse)
@@ -680,7 +755,7 @@ int synaptics_init(struct psmouse *psmouse)
 
         psmouse->private = priv = kzalloc(sizeof(struct synaptics_data), GFP_KERNEL);
         if (!priv)
-                return -1;
+                return -ENOMEM;
 
         psmouse_reset(psmouse);
 
@@ -696,10 +771,10 @@ int synaptics_init(struct psmouse *psmouse)
 
         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\n",
+        printk(KERN_INFO "Synaptics Touchpad, model: %ld, fw: %ld.%ld, id: %#lx, caps: %#lx/%#lx/%#lx\n",
                 SYN_ID_MODEL(priv->identity),
                 SYN_ID_MAJOR(priv->identity), SYN_ID_MINOR(priv->identity),
-                priv->model_id, priv->capabilities, priv->ext_cap);
+                priv->model_id, priv->capabilities, priv->ext_cap, priv->ext_cap_0c);
 
         set_input_params(psmouse->dev, priv);
 
diff --git a/drivers/input/mouse/synaptics.h b/drivers/input/mouse/synaptics.h
index f0f40a331dc8..613a3652f98f 100644
--- a/drivers/input/mouse/synaptics.h
+++ b/drivers/input/mouse/synaptics.h
@@ -18,6 +18,8 @@
 #define SYN_QUE_SERIAL_NUMBER_SUFFIX    0x07
 #define SYN_QUE_RESOLUTION              0x08
 #define SYN_QUE_EXT_CAPAB               0x09
+#define SYN_QUE_EXT_CAPAB_0C            0x0c
+#define SYN_QUE_EXT_DIMENSIONS          0x0d
 
 /* synatics modes */
 #define SYN_BIT_ABSOLUTE_MODE           (1 << 7)
@@ -45,9 +47,12 @@
 #define SYN_CAP_FOUR_BUTTON(c)          ((c) & (1 << 3))
 #define SYN_CAP_MULTIFINGER(c)          ((c) & (1 << 1))
 #define SYN_CAP_PALMDETECT(c)           ((c) & (1 << 0))
-#define SYN_CAP_VALID(c)                ((((c) & 0x00ff00) >> 8) == 0x47)
+#define SYN_CAP_SUBMODEL_ID(c)          (((c) & 0x00ff00) >> 8)
 #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)
+#define SYN_CAP_MAX_DIMENSIONS(ex0c)    ((ex0c) & 0x020000)
 
 /* synaptics modes query bits */
 #define SYN_MODE_ABSOLUTE(m)            ((m) & (1 << 7))
@@ -61,6 +66,7 @@
 #define SYN_ID_MODEL(i)                 (((i) >> 4) & 0x0f)
 #define SYN_ID_MAJOR(i)                 ((i) & 0x0f)
 #define SYN_ID_MINOR(i)                 (((i) >> 16) & 0xff)
+#define SYN_ID_FULL(i)                  ((SYN_ID_MAJOR(i) << 8) | SYN_ID_MINOR(i))
 #define SYN_ID_IS_SYNAPTICS(i)          ((((i) >> 8) & 0xff) == 0x47)
 
 /* synaptics special commands */
@@ -96,13 +102,16 @@ struct synaptics_data {
         unsigned long int model_id;             /* Model-ID */
         unsigned long int capabilities;         /* Capabilities */
         unsigned long int ext_cap;              /* Extended Capabilities */
+        unsigned long int ext_cap_0c;           /* Ext Caps from 0x0c query */
         unsigned long int identity;             /* Identification */
-        int x_res;                              /* X resolution in units/mm */
-        int y_res;                              /* Y resolution in units/mm */
+        unsigned int x_res, y_res;              /* X/Y resolution in units/mm */
+        unsigned int x_max, y_max;              /* Max dimensions (from FW) */
 
         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 */
 };
 
 void synaptics_module_init(void);
diff --git a/drivers/input/mouse/synaptics_i2c.c b/drivers/input/mouse/synaptics_i2c.c
index 9867dfe2a638..0ae62f0bcb32 100644
--- a/drivers/input/mouse/synaptics_i2c.c
+++ b/drivers/input/mouse/synaptics_i2c.c
@@ -17,6 +17,7 @@
 #include <linux/input.h>
 #include <linux/delay.h>
 #include <linux/workqueue.h>
+#include <linux/slab.h>
 
 #define DRIVER_NAME             "synaptics_i2c"
 /* maximum product id is 15 characters */
@@ -612,7 +613,6 @@ static int __devexit synaptics_i2c_remove(struct i2c_client *client)
                 free_irq(client->irq, touch);
 
         input_unregister_device(touch->input);
-        i2c_set_clientdata(client, NULL);
         kfree(touch);
 
         return 0;
diff --git a/drivers/input/mouse/touchkit_ps2.c b/drivers/input/mouse/touchkit_ps2.c
index 909431c31ab4..1fd8f5e192f9 100644
--- a/drivers/input/mouse/touchkit_ps2.c
+++ b/drivers/input/mouse/touchkit_ps2.c
@@ -21,12 +21,11 @@
  *
  * 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>
-#include <linux/slab.h>
 
 #include <linux/input.h>
 #include <linux/serio.h>
diff --git a/drivers/input/mouse/trackpoint.c b/drivers/input/mouse/trackpoint.c
index 63d4a67830f2..54b2fa892e19 100644
--- a/drivers/input/mouse/trackpoint.c
+++ b/drivers/input/mouse/trackpoint.c
@@ -8,6 +8,7 @@
  * Trademarks are the property of their respective owners.
  */
 
+#include <linux/slab.h>
 #include <linux/delay.h>
 #include <linux/serio.h>
 #include <linux/module.h>
@@ -302,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/mousedev.c b/drivers/input/mousedev.c
index a13d80f7da17..2a00ddf4f23a 100644
--- a/drivers/input/mousedev.c
+++ b/drivers/input/mousedev.c
@@ -15,7 +15,6 @@
 
 #include <linux/sched.h>
 #include <linux/slab.h>
-#include <linux/smp_lock.h>
 #include <linux/poll.h>
 #include <linux/module.h>
 #include <linux/init.h>
@@ -23,6 +22,7 @@
 #include <linux/random.h>
 #include <linux/major.h>
 #include <linux/device.h>
+#include <linux/kernel.h>
 #ifdef CONFIG_INPUT_MOUSEDEV_PSAUX
 #include <linux/miscdevice.h>
 #endif
@@ -58,7 +58,6 @@ struct mousedev_hw_data {
 };
 
 struct mousedev {
-        int exist;
         int open;
         int minor;
         struct input_handle handle;
@@ -67,6 +66,7 @@ struct mousedev {
         spinlock_t client_lock; /* protects client_list */
         struct mutex mutex;
         struct device dev;
+        bool exist;
 
         struct list_head mixdev_node;
         int mixdev_open;
@@ -135,11 +135,14 @@ static void mousedev_touchpad_event(struct input_dev *dev,
         switch (code) {
 
         case ABS_X:
+
                 fx(0) = value;
                 if (mousedev->touch && mousedev->pkt_count >= 2) {
-                        size = dev->absmax[ABS_X] - dev->absmin[ABS_X];
+                        size = input_abs_get_max(dev, ABS_X) -
+                                        input_abs_get_min(dev, ABS_X);
                         if (size == 0)
                                 size = 256 * 2;
+
                         tmp = ((value - fx(2)) * 256 * FRACTION_DENOM) / size;
                         tmp += mousedev->frac_dx;
                         mousedev->packet.dx = tmp / FRACTION_DENOM;
@@ -151,10 +154,12 @@ static void mousedev_touchpad_event(struct input_dev *dev,
         case ABS_Y:
                 fy(0) = value;
                 if (mousedev->touch && mousedev->pkt_count >= 2) {
-                        /* use X size to keep the same scale */
-                        size = dev->absmax[ABS_X] - dev->absmin[ABS_X];
+                        /* use X size for ABS_Y to keep the same scale */
+                        size = input_abs_get_max(dev, ABS_X) -
+                                        input_abs_get_min(dev, ABS_X);
                         if (size == 0)
                                 size = 256 * 2;
+
                         tmp = -((value - fy(2)) * 256 * FRACTION_DENOM) / size;
                         tmp += mousedev->frac_dy;
                         mousedev->packet.dy = tmp / FRACTION_DENOM;
@@ -168,33 +173,35 @@ static void mousedev_touchpad_event(struct input_dev *dev,
 static void mousedev_abs_event(struct input_dev *dev, struct mousedev *mousedev,
                                 unsigned int code, int value)
 {
-        int size;
+        int min, max, size;
 
         switch (code) {
 
         case ABS_X:
-                size = dev->absmax[ABS_X] - dev->absmin[ABS_X];
+                min = input_abs_get_min(dev, ABS_X);
+                max = input_abs_get_max(dev, ABS_X);
+
+                size = max - min;
                 if (size == 0)
                         size = xres ? : 1;
-                if (value > dev->absmax[ABS_X])
-                        value = dev->absmax[ABS_X];
-                if (value < dev->absmin[ABS_X])
-                        value = dev->absmin[ABS_X];
-                mousedev->packet.x =
-                        ((value - dev->absmin[ABS_X]) * xres) / size;
+
+                clamp(value, min, max);
+
+                mousedev->packet.x = ((value - min) * xres) / size;
                 mousedev->packet.abs_event = 1;
                 break;
 
         case ABS_Y:
-                size = dev->absmax[ABS_Y] - dev->absmin[ABS_Y];
+                min = input_abs_get_min(dev, ABS_Y);
+                max = input_abs_get_max(dev, ABS_Y);
+
+                size = max - min;
                 if (size == 0)
                         size = yres ? : 1;
-                if (value > dev->absmax[ABS_Y])
-                        value = dev->absmax[ABS_Y];
-                if (value < dev->absmin[ABS_Y])
-                        value = dev->absmin[ABS_Y];
-                mousedev->packet.y = yres -
-                        ((value - dev->absmin[ABS_Y]) * yres) / size;
+
+                clamp(value, min, max);
+
+                mousedev->packet.y = yres - ((value - min) * yres) / size;
                 mousedev->packet.abs_event = 1;
                 break;
         }
@@ -542,10 +549,8 @@ static int mousedev_open(struct inode *inode, struct file *file)
         if (i >= MOUSEDEV_MINORS)
                 return -ENODEV;
 
-        lock_kernel();
         error = mutex_lock_interruptible(&mousedev_table_mutex);
         if (error) {
-                unlock_kernel();
                 return error;
         }
         mousedev = mousedev_table[i];
@@ -554,7 +559,6 @@ static int mousedev_open(struct inode *inode, struct file *file)
         mutex_unlock(&mousedev_table_mutex);
 
         if (!mousedev) {
-                unlock_kernel();
                 return -ENODEV;
         }
 
@@ -575,7 +579,6 @@ static int mousedev_open(struct inode *inode, struct file *file)
                 goto err_free_client;
 
         file->private_data = client;
-        unlock_kernel();
         return 0;
 
  err_free_client:
@@ -583,7 +586,6 @@ static int mousedev_open(struct inode *inode, struct file *file)
         kfree(client);
  err_put_mousedev:
         put_device(&mousedev->dev);
-        unlock_kernel();
         return error;
 }
 
@@ -771,10 +773,15 @@ static unsigned int mousedev_poll(struct file *file, poll_table *wait)
 {
         struct mousedev_client *client = file->private_data;
         struct mousedev *mousedev = client->mousedev;
+        unsigned int mask;
 
         poll_wait(file, &mousedev->wait, wait);
-        return ((client->ready || client->buffer) ? (POLLIN | POLLRDNORM) : 0) |
-                (mousedev->exist ? 0 : (POLLHUP | POLLERR));
+
+        mask = mousedev->exist ? POLLOUT | POLLWRNORM : POLLHUP | POLLERR;
+        if (client->ready || client->buffer)
+                mask |= POLLIN | POLLRDNORM;
+
+        return mask;
 }
 
 static const struct file_operations mousedev_fops = {
@@ -785,6 +792,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)
@@ -808,7 +816,7 @@ static void mousedev_remove_chrdev(struct mousedev *mousedev)
 static void mousedev_mark_dead(struct mousedev *mousedev)
 {
         mutex_lock(&mousedev->mutex);
-        mousedev->exist = 0;
+        mousedev->exist = false;
         mutex_unlock(&mousedev->mutex);
 }
 
@@ -859,7 +867,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)
@@ -868,7 +876,7 @@ static struct mousedev *mousedev_create(struct input_dev *dev,
                 dev_set_name(&mousedev->dev, "mouse%d", minor);
 
         mousedev->minor = minor;
-        mousedev->exist = 1;
+        mousedev->exist = true;
         mousedev->handle.dev = input_get_device(dev);
         mousedev->handle.name = dev_name(&mousedev->dev);
         mousedev->handle.handler = handler;
diff --git a/drivers/input/serio/Kconfig b/drivers/input/serio/Kconfig
index 7e319d65ec57..6256233d2bfb 100644
--- a/drivers/input/serio/Kconfig
+++ b/drivers/input/serio/Kconfig
@@ -21,7 +21,8 @@ if SERIO
 config SERIO_I8042
         tristate "i8042 PC Keyboard controller" if EMBEDDED || !X86
         default y
-        depends on !PARISC && (!ARM || ARCH_SHARK || FOOTBRIDGE_HOST) && !M68K && !BLACKFIN
+        depends on !PARISC && (!ARM || ARCH_SHARK || FOOTBRIDGE_HOST) && \
+                   (!SUPERH || SH_CAYMAN) && !M68K && !BLACKFIN
         help
           i8042 is the chip over which the standard AT keyboard and PS/2
           mouse are connected to the computer. If you use these devices,
@@ -209,4 +210,29 @@ config SERIO_ALTERA_PS2
           To compile this driver as a module, choose M here: the
           module will be called altera_ps2.
 
+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.
+
+          When used for the E3 mailboard, a non-standard key table
+          must be loaded from userspace, possibly using udev extras
+          provided keymap helper utility.
+
+          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 boads.
+
+          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 bf945f789d05..dbbe37616c92 100644
--- a/drivers/input/serio/Makefile
+++ b/drivers/input/serio/Makefile
@@ -18,8 +18,10 @@ 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
+obj-$(CONFIG_SERIO_AMS_DELTA)   += ams_delta_serio.o
 obj-$(CONFIG_SERIO_XILINX_XPS_PS2)      += xilinx_ps2.o
 obj-$(CONFIG_SERIO_ALTERA_PS2)  += altera_ps2.o
diff --git a/drivers/input/serio/altera_ps2.c b/drivers/input/serio/altera_ps2.c
index 320b7ca48bf8..7998560a1904 100644
--- a/drivers/input/serio/altera_ps2.c
+++ b/drivers/input/serio/altera_ps2.c
@@ -18,6 +18,7 @@
 #include <linux/interrupt.h>
 #include <linux/platform_device.h>
 #include <linux/io.h>
+#include <linux/slab.h>
 
 #define DRV_NAME "altera_ps2"
 
diff --git a/drivers/input/serio/ams_delta_serio.c b/drivers/input/serio/ams_delta_serio.c
new file mode 100644
index 000000000000..8f1770e1e08b
--- /dev/null
+++ b/drivers/input/serio/ams_delta_serio.c
@@ -0,0 +1,177 @@
+/*
+ *  Amstrad E3 (Delta) keyboard port driver
+ *
+ *  Copyright (c) 2006 Matt Callow
+ *  Copyright (c) 2010 Janusz Krzysztofik
+ *
+ * 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.
+ *
+ * Thanks to Cliff Lawson for his help
+ *
+ * The Amstrad Delta keyboard (aka mailboard) uses normal PC-AT style serial
+ * transmission.  The keyboard port is formed of two GPIO lines, for clock
+ * and data.  Due to strict timing requirements of the interface,
+ * the serial data stream is read and processed by a FIQ handler.
+ * The resulting words are fetched by this driver from a circular buffer.
+ *
+ * Standard AT keyboard driver (atkbd) is used for handling the keyboard data.
+ * However, when used with the E3 mailboard that producecs non-standard
+ * scancodes, a custom key table must be prepared and loaded from userspace.
+ */
+#include <linux/gpio.h>
+#include <linux/irq.h>
+#include <linux/serio.h>
+#include <linux/slab.h>
+
+#include <asm/mach-types.h>
+#include <plat/board-ams-delta.h>
+
+#include <mach/ams-delta-fiq.h>
+
+MODULE_AUTHOR("Matt Callow");
+MODULE_DESCRIPTION("AMS Delta (E3) keyboard port driver");
+MODULE_LICENSE("GPL");
+
+static struct serio *ams_delta_serio;
+
+static int check_data(int data)
+{
+        int i, parity = 0;
+
+        /* check valid stop bit */
+        if (!(data & 0x400)) {
+                dev_warn(&ams_delta_serio->dev,
+                                "invalid stop bit, data=0x%X\n",
+                                data);
+                return SERIO_FRAME;
+        }
+        /* calculate the parity */
+        for (i = 1; i < 10; i++) {
+                if (data & (1 << i))
+                        parity++;
+        }
+        /* it should be odd */
+        if (!(parity & 0x01)) {
+                dev_warn(&ams_delta_serio->dev,
+                                "paritiy check failed, data=0x%X parity=0x%X\n",
+                                data, parity);
+                return SERIO_PARITY;
+        }
+        return 0;
+}
+
+static irqreturn_t ams_delta_serio_interrupt(int irq, void *dev_id)
+{
+        int *circ_buff = &fiq_buffer[FIQ_CIRC_BUFF];
+        int data, dfl;
+        u8 scancode;
+
+        fiq_buffer[FIQ_IRQ_PEND] = 0;
+
+        /*
+         * Read data from the circular buffer, check it
+         * and then pass it on the serio
+         */
+        while (fiq_buffer[FIQ_KEYS_CNT] > 0) {
+
+                data = circ_buff[fiq_buffer[FIQ_HEAD_OFFSET]++];
+                fiq_buffer[FIQ_KEYS_CNT]--;
+                if (fiq_buffer[FIQ_HEAD_OFFSET] == fiq_buffer[FIQ_BUF_LEN])
+                        fiq_buffer[FIQ_HEAD_OFFSET] = 0;
+
+                dfl = check_data(data);
+                scancode = (u8) (data >> 1) & 0xFF;
+                serio_interrupt(ams_delta_serio, scancode, dfl);
+        }
+        return IRQ_HANDLED;
+}
+
+static int ams_delta_serio_open(struct serio *serio)
+{
+        /* enable keyboard */
+        ams_delta_latch2_write(AMD_DELTA_LATCH2_KEYBRD_PWR,
+                        AMD_DELTA_LATCH2_KEYBRD_PWR);
+
+        return 0;
+}
+
+static void ams_delta_serio_close(struct serio *serio)
+{
+        /* disable keyboard */
+        ams_delta_latch2_write(AMD_DELTA_LATCH2_KEYBRD_PWR, 0);
+}
+
+static int __init ams_delta_serio_init(void)
+{
+        int err;
+
+        if (!machine_is_ams_delta())
+                return -ENODEV;
+
+        ams_delta_serio = kzalloc(sizeof(struct serio), GFP_KERNEL);
+        if (!ams_delta_serio)
+                return -ENOMEM;
+
+        ams_delta_serio->id.type = SERIO_8042;
+        ams_delta_serio->open = ams_delta_serio_open;
+        ams_delta_serio->close = ams_delta_serio_close;
+        strlcpy(ams_delta_serio->name, "AMS DELTA keyboard adapter",
+                        sizeof(ams_delta_serio->name));
+        strlcpy(ams_delta_serio->phys, "GPIO/serio0",
+                        sizeof(ams_delta_serio->phys));
+
+        err = gpio_request(AMS_DELTA_GPIO_PIN_KEYBRD_DATA, "serio-data");
+        if (err) {
+                pr_err("ams_delta_serio: Couldn't request gpio pin for data\n");
+                goto serio;
+        }
+        gpio_direction_input(AMS_DELTA_GPIO_PIN_KEYBRD_DATA);
+
+        err = gpio_request(AMS_DELTA_GPIO_PIN_KEYBRD_CLK, "serio-clock");
+        if (err) {
+                pr_err("ams_delta_serio: couldn't request gpio pin for clock\n");
+                goto gpio_data;
+        }
+        gpio_direction_input(AMS_DELTA_GPIO_PIN_KEYBRD_CLK);
+
+        err = request_irq(gpio_to_irq(AMS_DELTA_GPIO_PIN_KEYBRD_CLK),
+                        ams_delta_serio_interrupt, IRQ_TYPE_EDGE_RISING,
+                        "ams-delta-serio", 0);
+        if (err < 0) {
+                pr_err("ams_delta_serio: couldn't request gpio interrupt %d\n",
+                                gpio_to_irq(AMS_DELTA_GPIO_PIN_KEYBRD_CLK));
+                goto gpio_clk;
+        }
+        /*
+         * Since GPIO register handling for keyboard clock pin is performed
+         * 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),
+                        handle_simple_irq);
+
+        serio_register_port(ams_delta_serio);
+        dev_info(&ams_delta_serio->dev, "%s\n", ams_delta_serio->name);
+
+        return 0;
+gpio_clk:
+        gpio_free(AMS_DELTA_GPIO_PIN_KEYBRD_CLK);
+gpio_data:
+        gpio_free(AMS_DELTA_GPIO_PIN_KEYBRD_DATA);
+serio:
+        kfree(ams_delta_serio);
+        return err;
+}
+module_init(ams_delta_serio_init);
+
+static void __exit ams_delta_serio_exit(void)
+{
+        serio_unregister_port(ams_delta_serio);
+        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/at32psif.c b/drivers/input/serio/at32psif.c
index b54452a8c771..6ee8f0ddad51 100644
--- a/drivers/input/serio/at32psif.c
+++ b/drivers/input/serio/at32psif.c
@@ -18,6 +18,7 @@
 #include <linux/io.h>
 #include <linux/clk.h>
 #include <linux/platform_device.h>
+#include <linux/slab.h>
 
 /* PSIF register offsets */
 #define PSIF_CR                         0x00
diff --git a/drivers/input/serio/ct82c710.c b/drivers/input/serio/ct82c710.c
index d1380fc72cc6..4a3084695c00 100644
--- a/drivers/input/serio/ct82c710.c
+++ b/drivers/input/serio/ct82c710.c
@@ -35,6 +35,7 @@
 #include <linux/errno.h>
 #include <linux/err.h>
 #include <linux/platform_device.h>
+#include <linux/slab.h>
 
 #include <asm/io.h>
 
diff --git a/drivers/input/serio/gscps2.c b/drivers/input/serio/gscps2.c
index 06addfa7cc47..3c287dd879d3 100644
--- a/drivers/input/serio/gscps2.c
+++ b/drivers/input/serio/gscps2.c
@@ -24,6 +24,7 @@
 
 #include <linux/init.h>
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/serio.h>
 #include <linux/input.h>
 #include <linux/interrupt.h>
diff --git a/drivers/input/serio/hil_mlc.c b/drivers/input/serio/hil_mlc.c
index 6cd03ebaf5fb..e5624d8f1709 100644
--- a/drivers/input/serio/hil_mlc.c
+++ b/drivers/input/serio/hil_mlc.c
@@ -58,6 +58,7 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
+#include <linux/slab.h>
 #include <linux/timer.h>
 #include <linux/list.h>
 
@@ -914,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);
diff --git a/drivers/input/serio/hp_sdc.c b/drivers/input/serio/hp_sdc.c
index bcc2d30ec245..8c0b51c31424 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 */
 
@@ -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/i8042-io.h b/drivers/input/serio/i8042-io.h
index 847f4aad7ed5..5d48bb66aa73 100644
--- a/drivers/input/serio/i8042-io.h
+++ b/drivers/input/serio/i8042-io.h
@@ -27,6 +27,11 @@
 #include <asm/irq.h>
 #elif defined(CONFIG_SH_CAYMAN)
 #include <asm/irq.h>
+#elif defined(CONFIG_PPC)
+extern int of_i8042_kbd_irq;
+extern int of_i8042_aux_irq;
+# define I8042_KBD_IRQ  of_i8042_kbd_irq
+# define I8042_AUX_IRQ  of_i8042_aux_irq
 #else
 # define I8042_KBD_IRQ  1
 # define I8042_AUX_IRQ  12
diff --git a/drivers/input/serio/i8042-ppcio.h b/drivers/input/serio/i8042-ppcio.h
index 2906e1b60c04..f708c75d16f1 100644
--- a/drivers/input/serio/i8042-ppcio.h
+++ b/drivers/input/serio/i8042-ppcio.h
@@ -52,81 +52,6 @@ static inline void i8042_platform_exit(void)
 {
 }
 
-#elif defined(CONFIG_SPRUCE)
-
-#define I8042_KBD_IRQ 22
-#define I8042_AUX_IRQ 21
-
-#define I8042_KBD_PHYS_DESC "spruceps2/serio0"
-#define I8042_AUX_PHYS_DESC "spruceps2/serio1"
-#define I8042_MUX_PHYS_DESC "spruceps2/serio%d"
-
-#define I8042_COMMAND_REG 0xff810000
-#define I8042_DATA_REG 0xff810001
-
-static inline int i8042_read_data(void)
-{
-        unsigned long kbd_data;
-
-        __raw_writel(0x00000088, 0xff500008);
-        eieio();
-
-        __raw_writel(0x03000000, 0xff50000c);
-        eieio();
-
-        asm volatile("lis     7,0xff88        \n\
-                      lswi    6,7,0x8         \n\
-                      mr      %0,6"
-                      : "=r" (kbd_data) :: "6", "7");
-
-        __raw_writel(0x00000000, 0xff50000c);
-        eieio();
-
-        return (unsigned char)(kbd_data >> 24);
-}
-
-static inline int i8042_read_status(void)
-{
-        unsigned long kbd_status;
-
-        __raw_writel(0x00000088, 0xff500008);
-        eieio();
-
-        __raw_writel(0x03000000, 0xff50000c);
-        eieio();
-
-        asm volatile("lis     7,0xff88        \n\
-                      ori     7,7,0x8         \n\
-                      lswi    6,7,0x8         \n\
-                      mr      %0,6"
-                      : "=r" (kbd_status) :: "6", "7");
-
-        __raw_writel(0x00000000, 0xff50000c);
-        eieio();
-
-        return (unsigned char)(kbd_status >> 24);
-}
-
-static inline void i8042_write_data(int val)
-{
-        *((unsigned char *)0xff810000) = (char)val;
-}
-
-static inline void i8042_write_command(int val)
-{
-        *((unsigned char *)0xff810001) = (char)val;
-}
-
-static inline int i8042_platform_init(void)
-{
-        i8042_reset = 1;
-        return 0;
-}
-
-static inline void i8042_platform_exit(void)
-{
-}
-
 #else
 
 #include "i8042-io.h"
diff --git a/drivers/input/serio/i8042-sparcio.h b/drivers/input/serio/i8042-sparcio.h
index 5071af2c0604..c5cc4508d6df 100644
--- a/drivers/input/serio/i8042-sparcio.h
+++ b/drivers/input/serio/i8042-sparcio.h
@@ -49,28 +49,28 @@ 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 of_device *op, const struct of_device_id *match)
+static int __devinit sparc_i8042_probe(struct platform_device *op, const struct of_device_id *match)
 {
-        struct device_node *dp = op->node;
+        struct device_node *dp = op->dev.of_node;
 
         dp = dp->child;
         while (dp) {
                 if (!strcmp(dp->name, OBP_PS2KBD_NAME1) ||
                     !strcmp(dp->name, OBP_PS2KBD_NAME2)) {
-                        struct of_device *kbd = of_find_device_by_node(dp);
-                        unsigned int irq = kbd->irqs[0];
+                        struct platform_device *kbd = of_find_device_by_node(dp);
+                        unsigned int irq = kbd->archdata.irqs[0];
                         if (irq == 0xffffffff)
-                                irq = op->irqs[0];
+                                irq = op->archdata.irqs[0];
                         i8042_kbd_irq = irq;
                         kbd_iobase = of_ioremap(&kbd->resource[0],
                                                 0, 8, "kbd");
                         kbd_res = &kbd->resource[0];
                 } else if (!strcmp(dp->name, OBP_PS2MS_NAME1) ||
                            !strcmp(dp->name, OBP_PS2MS_NAME2)) {
-                        struct of_device *ms = of_find_device_by_node(dp);
-                        unsigned int irq = ms->irqs[0];
+                        struct platform_device *ms = of_find_device_by_node(dp);
+                        unsigned int irq = ms->archdata.irqs[0];
                         if (irq == 0xffffffff)
-                                irq = op->irqs[0];
+                                irq = op->archdata.irqs[0];
                         i8042_aux_irq = irq;
                 }
 
@@ -80,7 +80,7 @@ static int __devinit sparc_i8042_probe(struct of_device *op, const struct of_dev
         return 0;
 }
 
-static int __devexit sparc_i8042_remove(struct of_device *op)
+static int __devexit sparc_i8042_remove(struct platform_device *op)
 {
         of_iounmap(kbd_res, kbd_iobase, 8);
 
@@ -96,8 +96,11 @@ static const struct of_device_id sparc_i8042_match[] = {
 MODULE_DEVICE_TABLE(of, sparc_i8042_match);
 
 static struct of_platform_driver sparc_i8042_driver = {
-        .name           = "i8042",
-        .match_table    = sparc_i8042_match,
+        .driver = {
+                .name = "i8042",
+                .owner = THIS_MODULE,
+                .of_match_table = sparc_i8042_match,
+        },
         .probe          = sparc_i8042_probe,
         .remove         = __devexit_p(sparc_i8042_remove),
 };
@@ -113,8 +116,7 @@ static int __init i8042_platform_init(void)
                 if (!kbd_iobase)
                         return -ENODEV;
         } else {
-                int err = of_register_driver(&sparc_i8042_driver,
-                                             &of_bus_type);
+                int err = of_register_platform_driver(&sparc_i8042_driver);
                 if (err)
                         return err;
 
@@ -138,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_driver(&sparc_i8042_driver);
+                of_unregister_platform_driver(&sparc_i8042_driver);
 }
 
 #else /* !CONFIG_PCI */
diff --git a/drivers/input/serio/i8042-x86ia64io.h b/drivers/input/serio/i8042-x86ia64io.h
index 2a5982e532f8..ed7ad7416b24 100644
--- a/drivers/input/serio/i8042-x86ia64io.h
+++ b/drivers/input/serio/i8042-x86ia64io.h
@@ -7,6 +7,10 @@
  * the Free Software Foundation.
  */
 
+#ifdef CONFIG_X86
+#include <asm/x86_init.h>
+#endif
+
 /*
  * Names.
  */
@@ -166,6 +170,13 @@ static const struct dmi_system_id __initconst i8042_dmi_noloop_table[] = {
                 },
         },
         {
+                /* Gigabyte Spring Peak - defines wrong chassis type */
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "GIGABYTE"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "Spring Peak"),
+                },
+        },
+        {
                 .matches = {
                         DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
                         DMI_MATCH(DMI_PRODUCT_NAME, "HP Pavilion dv9700"),
@@ -442,6 +453,13 @@ static const struct dmi_system_id __initconst i8042_dmi_reset_table[] = {
                 },
         },
         {
+                /* Medion Akoya E1222 */
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "MEDION"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "E122X"),
+                },
+        },
+        {
                 /* Mivvy M310 */
                 .matches = {
                         DMI_MATCH(DMI_SYS_VENDOR, "VIOOO"),
@@ -624,6 +642,9 @@ static int i8042_pnp_kbd_probe(struct pnp_dev *dev, const struct pnp_device_id *
                 strlcat(i8042_pnp_kbd_name, pnp_dev_name(dev), sizeof(i8042_pnp_kbd_name));
         }
 
+        /* Keyboard ports are always supposed to be wakeup-enabled */
+        device_set_wakeup_enable(&dev->dev, true);
+
         i8042_pnp_kbd_devices++;
         return 0;
 }
@@ -650,8 +671,21 @@ static int i8042_pnp_aux_probe(struct pnp_dev *dev, const struct pnp_device_id *
 }
 
 static struct pnp_device_id pnp_kbd_devids[] = {
+        { .id = "PNP0300", .driver_data = 0 },
+        { .id = "PNP0301", .driver_data = 0 },
+        { .id = "PNP0302", .driver_data = 0 },
         { .id = "PNP0303", .driver_data = 0 },
+        { .id = "PNP0304", .driver_data = 0 },
+        { .id = "PNP0305", .driver_data = 0 },
+        { .id = "PNP0306", .driver_data = 0 },
+        { .id = "PNP0309", .driver_data = 0 },
+        { .id = "PNP030a", .driver_data = 0 },
         { .id = "PNP030b", .driver_data = 0 },
+        { .id = "PNP0320", .driver_data = 0 },
+        { .id = "PNP0343", .driver_data = 0 },
+        { .id = "PNP0344", .driver_data = 0 },
+        { .id = "PNP0345", .driver_data = 0 },
+        { .id = "CPQA0D7", .driver_data = 0 },
         { .id = "", },
 };
 
@@ -662,6 +696,7 @@ static struct pnp_driver i8042_pnp_kbd_driver = {
 };
 
 static struct pnp_device_id pnp_aux_devids[] = {
+        { .id = "AUI0200", .driver_data = 0 },
         { .id = "FJC6000", .driver_data = 0 },
         { .id = "FJC6001", .driver_data = 0 },
         { .id = "PNP0f03", .driver_data = 0 },
@@ -816,6 +851,12 @@ static int __init i8042_platform_init(void)
 {
         int retval;
 
+#ifdef CONFIG_X86
+        /* Just return if pre-detection shows no i8042 controller exist */
+        if (!x86_platform.i8042_detect())
+                return -ENODEV;
+#endif
+
 /*
  * On ix86 platforms touching the i8042 data register region can do really
  * bad things. Because of this the region is always reserved on ix86 boxes.
diff --git a/drivers/input/serio/i8042.c b/drivers/input/serio/i8042.c
index d84a36e545f6..18db5a8c7478 100644
--- a/drivers/input/serio/i8042.c
+++ b/drivers/input/serio/i8042.c
@@ -21,6 +21,7 @@
 #include <linux/rcupdate.h>
 #include <linux/platform_device.h>
 #include <linux/i8042.h>
+#include <linux/slab.h>
 
 #include <asm/io.h>
 
@@ -38,7 +39,7 @@ MODULE_PARM_DESC(noaux, "Do not probe or use AUX (mouse) port.");
 
 static bool i8042_nomux;
 module_param_named(nomux, i8042_nomux, bool, 0);
-MODULE_PARM_DESC(nomux, "Do not check whether an active multiplexing conrtoller is present.");
+MODULE_PARM_DESC(nomux, "Do not check whether an active multiplexing controller is present.");
 
 static bool i8042_unlock;
 module_param_named(unlock, i8042_unlock, bool, 0);
@@ -60,10 +61,6 @@ 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 unsigned int i8042_blink_frequency = 500;
-module_param_named(panicblink, i8042_blink_frequency, uint, 0600);
-MODULE_PARM_DESC(panicblink, "Frequency with which keyboard LEDs should blink when kernel panics");
-
 #ifdef CONFIG_X86
 static bool i8042_dritek;
 module_param_named(dritek, i8042_dritek, bool, 0);
@@ -430,7 +427,7 @@ static bool i8042_filter(unsigned char data, unsigned char str,
         }
 
         if (i8042_platform_filter && i8042_platform_filter(data, str, serio)) {
-                dbg("Filtered out by platfrom filter\n");
+                dbg("Filtered out by platform filter\n");
                 return true;
         }
 
@@ -860,9 +857,6 @@ static int i8042_controller_selftest(void)
         unsigned char param;
         int i = 0;
 
-        if (!i8042_reset)
-                return 0;
-
         /*
          * We try this 5 times; on some really fragile systems this does not
          * take the first time...
@@ -1019,7 +1013,8 @@ static void i8042_controller_reset(void)
  * Reset the controller if requested.
  */
 
-        i8042_controller_selftest();
+        if (i8042_reset)
+                i8042_controller_selftest();
 
 /*
  * Restore the original control register setting.
@@ -1031,8 +1026,8 @@ static void i8042_controller_reset(void)
 
 
 /*
- * i8042_panic_blink() will flash the keyboard LEDs and is called when
- * kernel panics. Flashing LEDs is useful for users running X who may
+ * i8042_panic_blink() will turn the keyboard LEDs on or off and is called
+ * when kernel panics. Flashing LEDs is useful for users running X who may
  * not see the console and will help distingushing panics from "real"
  * lockups.
  *
@@ -1042,22 +1037,12 @@ static void i8042_controller_reset(void)
 
 #define DELAY do { mdelay(1); if (++delay > 10) return delay; } while(0)
 
-static long i8042_panic_blink(long count)
+static long i8042_panic_blink(int state)
 {
         long delay = 0;
-        static long last_blink;
-        static char led;
-
-        /*
-         * We expect frequency to be about 1/2s. KDB uses about 1s.
-         * Make sure they are different.
-         */
-        if (!i8042_blink_frequency)
-                return 0;
-        if (count - last_blink < i8042_blink_frequency)
-                return 0;
+        char led;
 
-        led ^= 0x01 | 0x04;
+        led = (state) ? 0x01 | 0x04 : 0;
         while (i8042_read_status() & I8042_STR_IBF)
                 DELAY;
         dbg("%02x -> i8042 (panic blink)", 0xed);
@@ -1070,7 +1055,6 @@ static long i8042_panic_blink(long count)
         dbg("%02x -> i8042 (panic blink)", led);
         i8042_write_data(led);
         DELAY;
-        last_blink = count;
         return delay;
 }
 
@@ -1079,7 +1063,7 @@ static long i8042_panic_blink(long count)
 #ifdef CONFIG_X86
 static void i8042_dritek_enable(void)
 {
-        char param = 0x90;
+        unsigned char param = 0x90;
         int error;
 
         error = i8042_command(&param, 0x1059);
@@ -1093,23 +1077,11 @@ static void i8042_dritek_enable(void)
 #ifdef CONFIG_PM
 
 /*
- * Here we try to restore the original BIOS settings to avoid
- * upsetting it.
- */
-
-static int i8042_pm_reset(struct device *dev)
-{
-        i8042_controller_reset();
-
-        return 0;
-}
-
-/*
  * Here we try to reset everything back to a state we had
  * before suspending.
  */
 
-static int i8042_pm_restore(struct device *dev)
+static int i8042_controller_resume(bool force_reset)
 {
         int error;
 
@@ -1117,9 +1089,11 @@ static int i8042_pm_restore(struct device *dev)
         if (error)
                 return error;
 
-        error = i8042_controller_selftest();
-        if (error)
-                return error;
+        if (i8042_reset || force_reset) {
+                error = i8042_controller_selftest();
+                if (error)
+                        return error;
+        }
 
 /*
  * Restore original CTR value and disable all ports
@@ -1161,9 +1135,44 @@ static int i8042_pm_restore(struct device *dev)
         return 0;
 }
 
+/*
+ * Here we try to restore the original BIOS settings to avoid
+ * upsetting it.
+ */
+
+static int i8042_pm_reset(struct device *dev)
+{
+        i8042_controller_reset();
+
+        return 0;
+}
+
+static int i8042_pm_resume(struct device *dev)
+{
+        /*
+         * On resume from S2R we always try to reset the controller
+         * to bring it in a sane state. (In case of S2D we expect
+         * BIOS to reset the controller for us.)
+         */
+        return i8042_controller_resume(true);
+}
+
+static int i8042_pm_thaw(struct device *dev)
+{
+        i8042_interrupt(0, NULL);
+
+        return 0;
+}
+
+static int i8042_pm_restore(struct device *dev)
+{
+        return i8042_controller_resume(false);
+}
+
 static const struct dev_pm_ops i8042_pm_ops = {
         .suspend        = i8042_pm_reset,
-        .resume         = i8042_pm_restore,
+        .resume         = i8042_pm_resume,
+        .thaw           = i8042_pm_thaw,
         .poweroff       = i8042_pm_reset,
         .restore        = i8042_pm_restore,
 };
@@ -1378,9 +1387,13 @@ static int __init i8042_probe(struct platform_device *dev)
 {
         int error;
 
-        error = i8042_controller_selftest();
-        if (error)
-                return error;
+        i8042_platform_device = dev;
+
+        if (i8042_reset) {
+                error = i8042_controller_selftest();
+                if (error)
+                        return error;
+        }
 
         error = i8042_controller_init();
         if (error)
@@ -1413,6 +1426,7 @@ static int __init i8042_probe(struct platform_device *dev)
         i8042_free_aux_ports(); /* in case KBD failed but AUX not */
         i8042_free_irqs();
         i8042_controller_reset();
+        i8042_platform_device = NULL;
 
         return error;
 }
@@ -1422,6 +1436,7 @@ static int __devexit i8042_remove(struct platform_device *dev)
         i8042_unregister_ports();
         i8042_free_irqs();
         i8042_controller_reset();
+        i8042_platform_device = NULL;
 
         return 0;
 }
@@ -1440,6 +1455,7 @@ static struct platform_driver i8042_driver = {
 
 static int __init i8042_init(void)
 {
+        struct platform_device *pdev;
         int err;
 
         dbg_init();
@@ -1452,38 +1468,25 @@ static int __init i8042_init(void)
         if (err)
                 goto err_platform_exit;
 
-        i8042_platform_device = platform_device_alloc("i8042", -1);
-        if (!i8042_platform_device) {
-                err = -ENOMEM;
+        pdev = platform_create_bundle(&i8042_driver, i8042_probe, NULL, 0, NULL, 0);
+        if (IS_ERR(pdev)) {
+                err = PTR_ERR(pdev);
                 goto err_platform_exit;
         }
 
-        err = platform_device_add(i8042_platform_device);
-        if (err)
-                goto err_free_device;
-
-        err = platform_driver_probe(&i8042_driver, i8042_probe);
-        if (err)
-                goto err_del_device;
-
         panic_blink = i8042_panic_blink;
 
         return 0;
 
- err_del_device:
-        platform_device_del(i8042_platform_device);
- err_free_device:
-        platform_device_put(i8042_platform_device);
  err_platform_exit:
         i8042_platform_exit();
-
         return err;
 }
 
 static void __exit i8042_exit(void)
 {
-        platform_driver_unregister(&i8042_driver);
         platform_device_unregister(i8042_platform_device);
+        platform_driver_unregister(&i8042_driver);
         i8042_platform_exit();
 
         panic_blink = NULL;
diff --git a/drivers/input/serio/libps2.c b/drivers/input/serio/libps2.c
index f3876acc3e83..980af94ba9c8 100644
--- a/drivers/input/serio/libps2.c
+++ b/drivers/input/serio/libps2.c
@@ -14,7 +14,6 @@
 #include <linux/delay.h>
 #include <linux/module.h>
 #include <linux/sched.h>
-#include <linux/slab.h>
 #include <linux/interrupt.h>
 #include <linux/input.h>
 #include <linux/serio.h>
diff --git a/drivers/input/serio/parkbd.c b/drivers/input/serio/parkbd.c
index b089977e0ef9..26b45936f9fd 100644
--- a/drivers/input/serio/parkbd.c
+++ b/drivers/input/serio/parkbd.c
@@ -46,6 +46,7 @@
 
 #include <linux/module.h>
 #include <linux/parport.h>
+#include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/serio.h>
 
diff --git a/drivers/input/serio/pcips2.c b/drivers/input/serio/pcips2.c
index 1dacbe0d9348..43494742541c 100644
--- a/drivers/input/serio/pcips2.c
+++ b/drivers/input/serio/pcips2.c
@@ -15,6 +15,7 @@
 #include <linux/ioport.h>
 #include <linux/input.h>
 #include <linux/pci.h>
+#include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/serio.h>
 #include <linux/delay.h>
@@ -186,7 +187,7 @@ static void __devexit pcips2_remove(struct pci_dev *dev)
         pci_disable_device(dev);
 }
 
-static struct pci_device_id pcips2_ids[] = {
+static const struct pci_device_id pcips2_ids[] = {
         {
                 .vendor         = 0x14f2,       /* MOBILITY */
                 .device         = 0x0123,       /* Keyboard */
diff --git a/drivers/input/serio/ps2mult.c b/drivers/input/serio/ps2mult.c
new file mode 100644
index 000000000000..6bce22e4e495
--- /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(serio);
+        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/q40kbd.c b/drivers/input/serio/q40kbd.c
index e36a0901646c..5eb84b3b67fb 100644
--- a/drivers/input/serio/q40kbd.c
+++ b/drivers/input/serio/q40kbd.c
@@ -36,6 +36,7 @@
 #include <linux/err.h>
 #include <linux/bitops.h>
 #include <linux/platform_device.h>
+#include <linux/slab.h>
 
 #include <asm/io.h>
 #include <asm/uaccess.h>
diff --git a/drivers/input/serio/rpckbd.c b/drivers/input/serio/rpckbd.c
index ed045c99f84b..9da6fbcaaa7e 100644
--- a/drivers/input/serio/rpckbd.c
+++ b/drivers/input/serio/rpckbd.c
@@ -34,6 +34,7 @@
 #include <linux/err.h>
 #include <linux/platform_device.h>
 #include <linux/io.h>
+#include <linux/slab.h>
 
 #include <asm/irq.h>
 #include <mach/hardware.h>
diff --git a/drivers/input/serio/serio.c b/drivers/input/serio/serio.c
index e0f30186d513..405bf214527c 100644
--- a/drivers/input/serio/serio.c
+++ b/drivers/input/serio/serio.c
@@ -26,6 +26,8 @@
  * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/stddef.h>
 #include <linux/module.h>
 #include <linux/serio.h>
@@ -35,7 +37,6 @@
 #include <linux/slab.h>
 #include <linux/kthread.h>
 #include <linux/mutex.h>
-#include <linux/freezer.h>
 
 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
 MODULE_DESCRIPTION("Serio abstraction core");
@@ -54,7 +55,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)
@@ -119,11 +120,10 @@ static int serio_bind_driver(struct serio *serio, struct serio_driver *drv)
 
                 error = device_bind_driver(&serio->dev);
                 if (error) {
-                        printk(KERN_WARNING
-                                "serio: device_bind_driver() failed "
-                                "for %s (%s) and %s, error: %d\n",
-                                serio->phys, serio->name,
-                                drv->description, error);
+                        dev_warn(&serio->dev,
+                                 "device_bind_driver() failed for %s (%s) and %s, error: %d\n",
+                                 serio->phys, serio->name,
+                                 drv->description, error);
                         serio_disconnect_driver(serio);
                         serio->dev.driver = NULL;
                         return error;
@@ -138,9 +138,9 @@ static void serio_find_driver(struct serio *serio)
 
         error = device_attach(&serio->dev);
         if (error < 0)
-                printk(KERN_WARNING
-                        "serio: device_attach() failed for %s (%s), error: %d\n",
-                        serio->phys, serio->name, error);
+                dev_warn(&serio->dev,
+                         "device_attach() failed for %s (%s), error: %d\n",
+                         serio->phys, serio->name, error);
 }
 
 
@@ -151,7 +151,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,
 };
@@ -194,17 +194,14 @@ static int serio_queue_event(void *object, struct module *owner,
 
         event = kmalloc(sizeof(struct serio_event), GFP_ATOMIC);
         if (!event) {
-                printk(KERN_ERR
-                        "serio: Not enough memory to queue event %d\n",
-                        event_type);
+                pr_err("Not enough memory to queue event %d\n", event_type);
                 retval = -ENOMEM;
                 goto out;
         }
 
         if (!try_module_get(owner)) {
-                printk(KERN_WARNING
-                        "serio: Can't get module reference, dropping event %d\n",
-                        event_type);
+                pr_warning("Can't get module reference, dropping event %d\n",
+                           event_type);
                 kfree(event);
                 retval = -EINVAL;
                 goto out;
@@ -230,14 +227,12 @@ static void serio_free_event(struct serio_event *event)
 
 static void serio_remove_duplicate_events(struct serio_event *event)
 {
-        struct list_head *node, *next;
-        struct serio_event *e;
+        struct serio_event *e, *next;
         unsigned long flags;
 
         spin_lock_irqsave(&serio_event_lock, flags);
 
-        list_for_each_safe(node, next, &serio_event_list) {
-                e = list_entry(node, struct serio_event, node);
+        list_for_each_entry_safe(e, next, &serio_event_list, node) {
                 if (event->object == e->object) {
                         /*
                          * If this event is of different type we should not
@@ -247,7 +242,7 @@ static void serio_remove_duplicate_events(struct serio_event *event)
                         if (event->type != e->type)
                                 break;
 
-                        list_del_init(node);
+                        list_del_init(&e->node);
                         serio_free_event(e);
                 }
         }
@@ -258,23 +253,18 @@ static void serio_remove_duplicate_events(struct serio_event *event)
 
 static struct serio_event *serio_get_event(void)
 {
-        struct serio_event *event;
-        struct list_head *node;
+        struct serio_event *event = NULL;
         unsigned long flags;
 
         spin_lock_irqsave(&serio_event_lock, flags);
 
-        if (list_empty(&serio_event_list)) {
-                spin_unlock_irqrestore(&serio_event_lock, flags);
-                return NULL;
+        if (!list_empty(&serio_event_list)) {
+                event = list_first_entry(&serio_event_list,
+                                         struct serio_event, node);
+                list_del_init(&event->node);
         }
 
-        node = serio_event_list.next;
-        event = list_entry(node, struct serio_event, node);
-        list_del_init(node);
-
         spin_unlock_irqrestore(&serio_event_lock, flags);
-
         return event;
 }
 
@@ -287,29 +277,27 @@ static void serio_handle_event(void)
         while ((event = serio_get_event())) {
 
                 switch (event->type) {
-                        case SERIO_REGISTER_PORT:
-                                serio_add_port(event->object);
-                                break;
 
-                        case SERIO_RECONNECT_PORT:
-                                serio_reconnect_port(event->object);
-                                break;
+                case SERIO_REGISTER_PORT:
+                        serio_add_port(event->object);
+                        break;
 
-                        case SERIO_RESCAN_PORT:
-                                serio_disconnect_port(event->object);
-                                serio_find_driver(event->object);
-                                break;
+                case SERIO_RECONNECT_PORT:
+                        serio_reconnect_port(event->object);
+                        break;
 
-                        case SERIO_RECONNECT_CHAIN:
-                                serio_reconnect_chain(event->object);
-                                break;
+                case SERIO_RESCAN_PORT:
+                        serio_disconnect_port(event->object);
+                        serio_find_driver(event->object);
+                        break;
 
-                        case SERIO_ATTACH_DRIVER:
-                                serio_attach_driver(event->object);
-                                break;
+                case SERIO_RECONNECT_SUBTREE:
+                        serio_reconnect_subtree(event->object);
+                        break;
 
-                        default:
-                                break;
+                case SERIO_ATTACH_DRIVER:
+                        serio_attach_driver(event->object);
+                        break;
                 }
 
                 serio_remove_duplicate_events(event);
@@ -325,16 +313,14 @@ static void serio_handle_event(void)
  */
 static void serio_remove_pending_events(void *object)
 {
-        struct list_head *node, *next;
-        struct serio_event *event;
+        struct serio_event *event, *next;
         unsigned long flags;
 
         spin_lock_irqsave(&serio_event_lock, flags);
 
-        list_for_each_safe(node, next, &serio_event_list) {
-                event = list_entry(node, struct serio_event, node);
+        list_for_each_entry_safe(event, next, &serio_event_list, node) {
                 if (event->object == object) {
-                        list_del_init(node);
+                        list_del_init(&event->node);
                         serio_free_event(event);
                 }
         }
@@ -343,12 +329,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)
 {
@@ -380,7 +364,6 @@ static int serio_thread(void *nothing)
                         kthread_should_stop() || !list_empty(&serio_event_list));
         } while (!kthread_should_stop());
 
-        printk(KERN_DEBUG "serio: kseriod exiting\n");
         return 0;
 }
 
@@ -445,6 +428,11 @@ static struct attribute_group serio_id_attr_group = {
         .attrs  = serio_device_id_attrs,
 };
 
+static const struct attribute_group *serio_device_attr_groups[] = {
+        &serio_id_attr_group,
+        NULL
+};
+
 static ssize_t serio_rebind_driver(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 {
         struct serio *serio = to_serio_port(dev);
@@ -458,7 +446,7 @@ 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);
@@ -525,6 +513,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);
@@ -532,6 +522,7 @@ static void serio_init_port(struct serio *serio)
                         (long)atomic_inc_return(&serio_no) - 1);
         serio->dev.bus = &serio_bus;
         serio->dev.release = serio_release_port;
+        serio->dev.groups = serio_device_attr_groups;
         if (serio->parent) {
                 serio->dev.parent = &serio->parent->dev;
                 serio->depth = serio->parent->depth + 1;
@@ -546,42 +537,36 @@ 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);
+
         if (serio->start)
                 serio->start(serio);
+
         error = device_add(&serio->dev);
         if (error)
-                printk(KERN_ERR
-                        "serio: device_add() failed for %s (%s), error: %d\n",
+                dev_err(&serio->dev,
+                        "device_add() failed for %s (%s), error: %d\n",
                         serio->phys, serio->name, error);
-        else {
-                serio->registered = true;
-                error = sysfs_create_group(&serio->dev.kobj, &serio_id_attr_group);
-                if (error)
-                        printk(KERN_ERR
-                                "serio: sysfs_create_group() failed for %s (%s), error: %d\n",
-                                serio->phys, serio->name, error);
-        }
 }
 
 /*
- * 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);
         }
@@ -591,16 +576,13 @@ 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;
         }
 
-        if (serio->registered) {
-                sysfs_remove_group(&serio->dev.kobj, &serio_id_attr_group);
+        if (device_is_registered(&serio->dev))
                 device_del(&serio->dev);
-                serio->registered = false;
-        }
 
         list_del_init(&serio->node);
         serio_remove_pending_events(serio);
@@ -626,46 +608,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;
+                        }
                 }
-                serio = serio->child;
-        } while (serio);
+
+                /*
+                 * 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;
+                }
+        } 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);
 }
@@ -678,7 +696,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);
 
@@ -706,14 +724,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);
 }
@@ -798,9 +818,8 @@ static void serio_attach_driver(struct serio_driver *drv)
 
         error = driver_attach(&drv->driver);
         if (error)
-                printk(KERN_WARNING
-                        "serio: driver_attach() failed for %s with error %d\n",
-                        drv->driver.name, error);
+                pr_warning("driver_attach() failed for %s with error %d\n",
+                           drv->driver.name, error);
 }
 
 int __serio_register_driver(struct serio_driver *drv, struct module *owner, const char *mod_name)
@@ -820,8 +839,7 @@ int __serio_register_driver(struct serio_driver *drv, struct module *owner, cons
 
         error = driver_register(&drv->driver);
         if (error) {
-                printk(KERN_ERR
-                        "serio: driver_register() failed for %s, error: %d\n",
+                pr_err("driver_register() failed for %s, error: %d\n",
                         drv->driver.name, error);
                 return error;
         }
@@ -987,7 +1005,7 @@ irqreturn_t serio_interrupt(struct serio *serio,
 
         if (likely(serio->drv)) {
                 ret = serio->drv->interrupt(serio, data, dfl);
-        } else if (!dfl && serio->registered) {
+        } else if (!dfl && device_is_registered(&serio->dev)) {
                 serio_rescan(serio);
                 ret = IRQ_HANDLED;
         }
@@ -1018,7 +1036,7 @@ static int __init serio_init(void)
 
         error = bus_register(&serio_bus);
         if (error) {
-                printk(KERN_ERR "serio: failed to register serio bus, error: %d\n", error);
+                pr_err("Failed to register serio bus, error: %d\n", error);
                 return error;
         }
 
@@ -1026,7 +1044,7 @@ static int __init serio_init(void)
         if (IS_ERR(serio_task)) {
                 bus_unregister(&serio_bus);
                 error = PTR_ERR(serio_task);
-                printk(KERN_ERR "serio: Failed to start kseriod, error: %d\n", error);
+                pr_err("Failed to start kseriod, error: %d\n", error);
                 return error;
         }
 
diff --git a/drivers/input/serio/serio_raw.c b/drivers/input/serio/serio_raw.c
index 27fdaaffbb40..cd82bb125915 100644
--- a/drivers/input/serio/serio_raw.c
+++ b/drivers/input/serio/serio_raw.c
@@ -81,12 +81,12 @@ static int serio_raw_open(struct inode *inode, struct file *file)
         struct serio_raw_list *list;
         int retval = 0;
 
-        lock_kernel();
         retval = mutex_lock_interruptible(&serio_raw_mutex);
         if (retval)
-                goto out_bkl;
+                return retval;
 
-        if (!(serio_raw = serio_raw_locate(iminor(inode)))) {
+        serio_raw = serio_raw_locate(iminor(inode));
+        if (!serio_raw) {
                 retval = -ENODEV;
                 goto out;
         }
@@ -96,7 +96,8 @@ static int serio_raw_open(struct inode *inode, struct file *file)
                 goto out;
         }
 
-        if (!(list = kzalloc(sizeof(struct serio_raw_list), GFP_KERNEL))) {
+        list = kzalloc(sizeof(struct serio_raw_list), GFP_KERNEL);
+        if (!list) {
                 retval = -ENOMEM;
                 goto out;
         }
@@ -109,8 +110,6 @@ static int serio_raw_open(struct inode *inode, struct file *file)
 
 out:
         mutex_unlock(&serio_raw_mutex);
-out_bkl:
-        unlock_kernel();
         return retval;
 }
 
@@ -244,6 +243,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..6e362de3f412 100644
--- a/drivers/input/serio/serport.c
+++ b/drivers/input/serio/serport.c
@@ -165,6 +165,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 ebb22f88c842..bb14449fb022 100644
--- a/drivers/input/serio/xilinx_ps2.c
+++ b/drivers/input/serio/xilinx_ps2.c
@@ -19,6 +19,7 @@
 #include <linux/serio.h>
 #include <linux/interrupt.h>
 #include <linux/errno.h>
+#include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/list.h>
 #include <linux/io.h>
@@ -231,7 +232,7 @@ static void sxps2_close(struct serio *pserio)
  * 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 of_device *ofdev,
+static int __devinit xps2_of_probe(struct platform_device *ofdev,
                                    const struct of_device_id *match)
 {
         struct resource r_irq; /* Interrupt resources */
@@ -243,17 +244,17 @@ static int __devinit xps2_of_probe(struct of_device *ofdev,
         int error;
 
         dev_info(dev, "Device Tree Probing \'%s\'\n",
-                        ofdev->node->name);
+                        ofdev->dev.of_node->name);
 
         /* Get iospace for the device */
-        error = of_address_to_resource(ofdev->node, 0, &r_mem);
+        error = of_address_to_resource(ofdev->dev.of_node, 0, &r_mem);
         if (error) {
                 dev_err(dev, "invalid address\n");
                 return error;
         }
 
         /* Get IRQ for the device */
-        if (of_irq_to_resource(ofdev->node, 0, &r_irq) == NO_IRQ) {
+        if (of_irq_to_resource(ofdev->dev.of_node, 0, &r_irq) == NO_IRQ) {
                 dev_err(dev, "no IRQ found\n");
                 return -ENODEV;
         }
@@ -270,7 +271,7 @@ static int __devinit xps2_of_probe(struct of_device *ofdev,
         drvdata->irq = r_irq.start;
 
         phys_addr = r_mem.start;
-        remap_size = r_mem.end - r_mem.start + 1;
+        remap_size = resource_size(&r_mem);
         if (!request_mem_region(phys_addr, remap_size, DRIVER_NAME)) {
                 dev_err(dev, "Couldn't lock memory region at 0x%08llX\n",
                         (unsigned long long)phys_addr);
@@ -331,7 +332,7 @@ failed1:
  * if the driver module is being unloaded. It frees any resources allocated to
  * the device.
  */
-static int __devexit xps2_of_remove(struct of_device *of_dev)
+static int __devexit xps2_of_remove(struct platform_device *of_dev)
 {
         struct device *dev = &of_dev->dev;
         struct xps2data *drvdata = dev_get_drvdata(dev);
@@ -341,10 +342,10 @@ static int __devexit xps2_of_remove(struct of_device *of_dev)
         iounmap(drvdata->base_address);
 
         /* Get iospace of the device */
-        if (of_address_to_resource(of_dev->node, 0, &r_mem))
+        if (of_address_to_resource(of_dev->dev.of_node, 0, &r_mem))
                 dev_err(dev, "invalid address\n");
         else
-                release_mem_region(r_mem.start, r_mem.end - r_mem.start + 1);
+                release_mem_region(r_mem.start, resource_size(&r_mem));
 
         kfree(drvdata);
 
@@ -354,15 +355,18 @@ static int __devexit xps2_of_remove(struct of_device *of_dev)
 }
 
 /* Match table for of_platform binding */
-static struct of_device_id xps2_of_match[] __devinitdata = {
+static const struct of_device_id xps2_of_match[] __devinitconst = {
         { .compatible = "xlnx,xps-ps2-1.00.a", },
         { /* end of list */ },
 };
 MODULE_DEVICE_TABLE(of, xps2_of_match);
 
 static struct of_platform_driver xps2_of_driver = {
-        .name           = DRIVER_NAME,
-        .match_table    = xps2_of_match,
+        .driver = {
+                .name = DRIVER_NAME,
+                .owner = THIS_MODULE,
+                .of_match_table = xps2_of_match,
+        },
         .probe          = xps2_of_probe,
         .remove         = __devexit_p(xps2_of_remove),
 };
diff --git a/drivers/input/sparse-keymap.c b/drivers/input/sparse-keymap.c
index fbd3987af57f..a29a7812bd46 100644
--- a/drivers/input/sparse-keymap.c
+++ b/drivers/input/sparse-keymap.c
@@ -15,12 +15,44 @@
 
 #include <linux/input.h>
 #include <linux/input/sparse-keymap.h>
+#include <linux/slab.h>
 
 MODULE_AUTHOR("Dmitry Torokhov <dtor@mail.ru>");
 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
@@ -63,37 +95,59 @@ struct key_entry *sparse_keymap_entry_from_keycode(struct input_dev *dev,
 }
 EXPORT_SYMBOL(sparse_keymap_entry_from_keycode);
 
-static int sparse_keymap_getkeycode(struct input_dev *dev,
-                                    int scancode, int *keycode)
+static struct key_entry *sparse_keymap_locate(struct input_dev *dev,
+                                        const struct input_keymap_entry *ke)
 {
-        const struct key_entry *key =
-                        sparse_keymap_entry_from_scancode(dev, scancode);
+        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;
 
-        if (key && key->type == KE_KEY) {
-                *keycode = key->keycode;
-                return 0;
+        return key;
+}
+
+static int sparse_keymap_getkeycode(struct input_dev *dev,
+                                    struct input_keymap_entry *ke)
+{
+        const struct key_entry *key;
+
+        if (dev->keycode) {
+                key = sparse_keymap_locate(dev, ke);
+                if (key && key->type == KE_KEY) {
+                        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;
+                }
         }
 
         return -EINVAL;
 }
 
 static int sparse_keymap_setkeycode(struct input_dev *dev,
-                                    int scancode, int keycode)
+                                    const struct input_keymap_entry *ke,
+                                    unsigned int *old_keycode)
 {
         struct key_entry *key;
-        int old_keycode;
-
-        if (keycode < 0 || keycode > KEY_MAX)
-                return -EINVAL;
-
-        key = sparse_keymap_entry_from_scancode(dev, scancode);
-        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);
-                return 0;
+
+        if (dev->keycode) {
+                key = sparse_keymap_locate(dev, ke);
+                if (key && key->type == KE_KEY) {
+                        *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;
+                }
         }
 
         return -EINVAL;
@@ -155,15 +209,14 @@ int sparse_keymap_setup(struct input_dev *dev,
 
         dev->keycode = map;
         dev->keycodemax = map_size;
-        dev->getkeycode = sparse_keymap_getkeycode;
-        dev->setkeycode = sparse_keymap_setkeycode;
+        dev->getkeycode_new = sparse_keymap_getkeycode;
+        dev->setkeycode_new = sparse_keymap_setkeycode;
 
         return 0;
 
  err_out:
-        kfree(keymap);
+        kfree(map);
         return error;
-
 }
 EXPORT_SYMBOL(sparse_keymap_setup);
 
@@ -173,14 +226,27 @@ EXPORT_SYMBOL(sparse_keymap_setup);
  *
  * This function is used to free memory allocated by sparse keymap
  * in an input device that was set up by sparse_keymap_setup().
+ * NOTE: It is safe to cal this function while input device is
+ * still registered (however the drivers should care not to try to
+ * use freed keymap and thus have to shut off interrups/polling
+ * before freeing the keymap).
  */
 void sparse_keymap_free(struct input_dev *dev)
 {
+        unsigned long flags;
+
+        /*
+         * Take event lock to prevent racing with input_get_keycode()
+         * and input_set_keycode() if we are called while input device
+         * is still registered.
+         */
+        spin_lock_irqsave(&dev->event_lock, flags);
+
         kfree(dev->keycode);
         dev->keycode = NULL;
         dev->keycodemax = 0;
-        dev->getkeycode = NULL;
-        dev->setkeycode = NULL;
+
+        spin_unlock_irqrestore(&dev->event_lock, flags);
 }
 EXPORT_SYMBOL(sparse_keymap_free);
 
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 670c61c5a516..aea9a9399a36 100644
--- a/drivers/input/tablet/acecad.c
+++ b/drivers/input/tablet/acecad.c
@@ -66,18 +66,18 @@ static void usb_acecad_irq(struct urb *urb)
         int prox, status;
 
         switch (urb->status) {
-                case 0:
-                        /* success */
-                        break;
-                case -ECONNRESET:
-                case -ENOENT:
-                case -ESHUTDOWN:
-                        /* this urb is terminated, clean up */
-                        dbg("%s - urb shutting down with status: %d", __func__, urb->status);
-                        return;
-                default:
-                        dbg("%s - nonzero urb status received: %d", __func__, urb->status);
-                        goto resubmit;
+        case 0:
+                /* success */
+                break;
+        case -ECONNRESET:
+        case -ENOENT:
+        case -ESHUTDOWN:
+                /* this urb is terminated, clean up */
+                dbg("%s - urb shutting down with status: %d", __func__, urb->status);
+                return;
+        default:
+                dbg("%s - nonzero urb status received: %d", __func__, urb->status);
+                goto resubmit;
         }
 
         prox = (data[0] & 0x04) >> 2;
@@ -135,7 +135,7 @@ static int usb_acecad_probe(struct usb_interface *intf, const struct usb_device_
         struct usb_acecad *acecad;
         struct input_dev *input_dev;
         int pipe, maxp;
-        int err = -ENOMEM;
+        int err;
 
         if (interface->desc.bNumEndpoints != 1)
                 return -ENODEV;
@@ -155,7 +155,7 @@ static int usb_acecad_probe(struct usb_interface *intf, const struct usb_device_
                 goto fail1;
         }
 
-        acecad->data = usb_buffer_alloc(dev, 8, GFP_KERNEL, &acecad->data_dma);
+        acecad->data = usb_alloc_coherent(dev, 8, GFP_KERNEL, &acecad->data_dma);
         if (!acecad->data) {
                 err= -ENOMEM;
                 goto fail1;
@@ -193,40 +193,34 @@ static int usb_acecad_probe(struct usb_interface *intf, const struct usb_device_
         input_dev->close = usb_acecad_close;
 
         input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
-        input_dev->absbit[0] = BIT_MASK(ABS_X) | BIT_MASK(ABS_Y) |
-                BIT_MASK(ABS_PRESSURE);
-        input_dev->keybit[BIT_WORD(BTN_LEFT)] = BIT_MASK(BTN_LEFT) |
-                BIT_MASK(BTN_RIGHT) | BIT_MASK(BTN_MIDDLE);
         input_dev->keybit[BIT_WORD(BTN_DIGI)] = BIT_MASK(BTN_TOOL_PEN) |
                 BIT_MASK(BTN_TOUCH) | BIT_MASK(BTN_STYLUS) |
                 BIT_MASK(BTN_STYLUS2);
 
         switch (id->driver_info) {
-                case 0:
-                        input_dev->absmax[ABS_X] = 5000;
-                        input_dev->absmax[ABS_Y] = 3750;
-                        input_dev->absmax[ABS_PRESSURE] = 512;
-                        if (!strlen(acecad->name))
-                                snprintf(acecad->name, sizeof(acecad->name),
-                                        "USB Acecad Flair Tablet %04x:%04x",
-                                        le16_to_cpu(dev->descriptor.idVendor),
-                                        le16_to_cpu(dev->descriptor.idProduct));
-                        break;
-                case 1:
-                        input_dev->absmax[ABS_X] = 3000;
-                        input_dev->absmax[ABS_Y] = 2250;
-                        input_dev->absmax[ABS_PRESSURE] = 1024;
-                        if (!strlen(acecad->name))
-                                snprintf(acecad->name, sizeof(acecad->name),
-                                        "USB Acecad 302 Tablet %04x:%04x",
-                                        le16_to_cpu(dev->descriptor.idVendor),
-                                        le16_to_cpu(dev->descriptor.idProduct));
-                        break;
+        case 0:
+                input_set_abs_params(input_dev, ABS_X, 0, 5000, 4, 0);
+                input_set_abs_params(input_dev, ABS_Y, 0, 3750, 4, 0);
+                input_set_abs_params(input_dev, ABS_PRESSURE, 0, 512, 0, 0);
+                if (!strlen(acecad->name))
+                        snprintf(acecad->name, sizeof(acecad->name),
+                                "USB Acecad Flair Tablet %04x:%04x",
+                                le16_to_cpu(dev->descriptor.idVendor),
+                                le16_to_cpu(dev->descriptor.idProduct));
+                break;
+
+        case 1:
+                input_set_abs_params(input_dev, ABS_X, 0, 53000, 4, 0);
+                input_set_abs_params(input_dev, ABS_Y, 0, 2250, 4, 0);
+                input_set_abs_params(input_dev, ABS_PRESSURE, 0, 1024, 0, 0);
+                if (!strlen(acecad->name))
+                        snprintf(acecad->name, sizeof(acecad->name),
+                                "USB Acecad 302 Tablet %04x:%04x",
+                                le16_to_cpu(dev->descriptor.idVendor),
+                                le16_to_cpu(dev->descriptor.idProduct));
+                break;
         }
 
-        input_dev->absfuzz[ABS_X] = 4;
-        input_dev->absfuzz[ABS_Y] = 4;
-
         usb_fill_int_urb(acecad->irq, dev, pipe,
                         acecad->data, maxp > 8 ? 8 : maxp,
                         usb_acecad_irq, acecad, endpoint->bInterval);
@@ -241,7 +235,7 @@ static int usb_acecad_probe(struct usb_interface *intf, const struct usb_device_
 
         return 0;
 
- fail2: usb_buffer_free(dev, 8, acecad->data, acecad->data_dma);
+ fail2: usb_free_coherent(dev, 8, acecad->data, acecad->data_dma);
  fail1: input_free_device(input_dev);
         kfree(acecad);
         return err;
@@ -252,13 +246,11 @@ static void usb_acecad_disconnect(struct usb_interface *intf)
         struct usb_acecad *acecad = usb_get_intfdata(intf);
 
         usb_set_intfdata(intf, NULL);
-        if (acecad) {
-                usb_kill_urb(acecad->irq);
-                input_unregister_device(acecad->input);
-                usb_free_urb(acecad->irq);
-                usb_buffer_free(interface_to_usbdev(intf), 10, acecad->data, acecad->data_dma);
-                kfree(acecad);
-        }
+
+        input_unregister_device(acecad->input);
+        usb_free_urb(acecad->irq);
+        usb_free_coherent(acecad->usbdev, 8, acecad->data, acecad->data_dma);
+        kfree(acecad);
 }
 
 static struct usb_device_id usb_acecad_id_table [] = {
diff --git a/drivers/input/tablet/aiptek.c b/drivers/input/tablet/aiptek.c
index 7d005a3616d7..57b25b84d1fc 100644
--- a/drivers/input/tablet/aiptek.c
+++ b/drivers/input/tablet/aiptek.c
@@ -362,7 +362,7 @@ static const int macroKeyEvents[] = {
 };
 
 /***********************************************************************
- * Map values to strings and back. Every map shoudl have the following
+ * Map values to strings and back. Every map should have the following
  * as its last element: { NULL, AIPTEK_INVALID_VALUE }.
  */
 #define AIPTEK_INVALID_VALUE    -1
@@ -987,20 +987,17 @@ static int aiptek_program_tablet(struct aiptek *aiptek)
         /* Query getXextension */
         if ((ret = aiptek_query(aiptek, 0x01, 0x00)) < 0)
                 return ret;
-        aiptek->inputdev->absmin[ABS_X] = 0;
-        aiptek->inputdev->absmax[ABS_X] = ret - 1;
+        input_set_abs_params(aiptek->inputdev, ABS_X, 0, ret - 1, 0, 0);
 
         /* Query getYextension */
         if ((ret = aiptek_query(aiptek, 0x01, 0x01)) < 0)
                 return ret;
-        aiptek->inputdev->absmin[ABS_Y] = 0;
-        aiptek->inputdev->absmax[ABS_Y] = ret - 1;
+        input_set_abs_params(aiptek->inputdev, ABS_Y, 0, ret - 1, 0, 0);
 
         /* Query getPressureLevels */
         if ((ret = aiptek_query(aiptek, 0x08, 0x00)) < 0)
                 return ret;
-        aiptek->inputdev->absmin[ABS_PRESSURE] = 0;
-        aiptek->inputdev->absmax[ABS_PRESSURE] = ret - 1;
+        input_set_abs_params(aiptek->inputdev, ABS_PRESSURE, 0, ret - 1, 0, 0);
 
         /* Depending on whether we are in absolute or relative mode, we will
          * do a switchToTablet(absolute) or switchToMouse(relative) command.
@@ -1054,8 +1051,8 @@ static ssize_t show_tabletSize(struct device *dev, struct device_attribute *attr
         struct aiptek *aiptek = dev_get_drvdata(dev);
 
         return snprintf(buf, PAGE_SIZE, "%dx%d\n",
-                        aiptek->inputdev->absmax[ABS_X] + 1,
-                        aiptek->inputdev->absmax[ABS_Y] + 1);
+                        input_abs_get_max(aiptek->inputdev, ABS_X) + 1,
+                        input_abs_get_max(aiptek->inputdev, ABS_Y) + 1);
 }
 
 /* These structs define the sysfs files, param #1 is the name of the
@@ -1711,8 +1708,8 @@ aiptek_probe(struct usb_interface *intf, const struct usb_device_id *id)
                 goto fail1;
         }
 
-        aiptek->data = usb_buffer_alloc(usbdev, AIPTEK_PACKET_LENGTH,
-                                        GFP_ATOMIC, &aiptek->data_dma);
+        aiptek->data = usb_alloc_coherent(usbdev, AIPTEK_PACKET_LENGTH,
+                                          GFP_ATOMIC, &aiptek->data_dma);
         if (!aiptek->data) {
                 dev_warn(&intf->dev, "cannot allocate usb buffer\n");
                 goto fail1;
@@ -1843,7 +1840,7 @@ aiptek_probe(struct usb_interface *intf, const struct usb_device_id *id)
         for (i = 0; i < ARRAY_SIZE(speeds); ++i) {
                 aiptek->curSetting.programmableDelay = speeds[i];
                 (void)aiptek_program_tablet(aiptek);
-                if (aiptek->inputdev->absmax[ABS_X] > 0) {
+                if (input_abs_get_max(aiptek->inputdev, ABS_X) > 0) {
                         dev_info(&intf->dev,
                                  "Aiptek using %d ms programming speed\n",
                                  aiptek->curSetting.programmableDelay);
@@ -1884,8 +1881,8 @@ aiptek_probe(struct usb_interface *intf, const struct usb_device_id *id)
 
  fail4: sysfs_remove_group(&intf->dev.kobj, &aiptek_attribute_group);
  fail3: usb_free_urb(aiptek->urb);
- fail2: usb_buffer_free(usbdev, AIPTEK_PACKET_LENGTH, aiptek->data,
-                        aiptek->data_dma);
+ fail2: usb_free_coherent(usbdev, AIPTEK_PACKET_LENGTH, aiptek->data,
+                          aiptek->data_dma);
  fail1: usb_set_intfdata(intf, NULL);
         input_free_device(inputdev);
         kfree(aiptek);
@@ -1909,9 +1906,9 @@ static void aiptek_disconnect(struct usb_interface *intf)
                 input_unregister_device(aiptek->inputdev);
                 sysfs_remove_group(&intf->dev.kobj, &aiptek_attribute_group);
                 usb_free_urb(aiptek->urb);
-                usb_buffer_free(interface_to_usbdev(intf),
-                                AIPTEK_PACKET_LENGTH,
-                                aiptek->data, aiptek->data_dma);
+                usb_free_coherent(interface_to_usbdev(intf),
+                                  AIPTEK_PACKET_LENGTH,
+                                  aiptek->data, aiptek->data_dma);
                 kfree(aiptek);
         }
 }
diff --git a/drivers/input/tablet/gtco.c b/drivers/input/tablet/gtco.c
index 3d32d3f4e486..8ea6afe2e992 100644
--- a/drivers/input/tablet/gtco.c
+++ b/drivers/input/tablet/gtco.c
@@ -92,7 +92,7 @@ Scott Hill shill@gtcocalcomp.com
 /* DATA STRUCTURES */
 
 /* Device table */
-static struct usb_device_id gtco_usbid_table [] = {
+static const struct usb_device_id gtco_usbid_table[] = {
         { USB_DEVICE(VENDOR_ID_GTCO, PID_400) },
         { USB_DEVICE(VENDOR_ID_GTCO, PID_401) },
         { USB_DEVICE(VENDOR_ID_GTCO, PID_1000) },
@@ -850,8 +850,8 @@ static int gtco_probe(struct usb_interface *usbinterface,
         gtco->usbdev = usb_get_dev(interface_to_usbdev(usbinterface));
 
         /* Allocate some data for incoming reports */
-        gtco->buffer = usb_buffer_alloc(gtco->usbdev, REPORT_MAX_SIZE,
-                                        GFP_KERNEL, &gtco->buf_dma);
+        gtco->buffer = usb_alloc_coherent(gtco->usbdev, REPORT_MAX_SIZE,
+                                          GFP_KERNEL, &gtco->buf_dma);
         if (!gtco->buffer) {
                 err("No more memory for us buffers");
                 error = -ENOMEM;
@@ -982,8 +982,8 @@ static int gtco_probe(struct usb_interface *usbinterface,
  err_free_urb:
         usb_free_urb(gtco->urbinfo);
  err_free_buf:
-        usb_buffer_free(gtco->usbdev, REPORT_MAX_SIZE,
-                        gtco->buffer, gtco->buf_dma);
+        usb_free_coherent(gtco->usbdev, REPORT_MAX_SIZE,
+                          gtco->buffer, gtco->buf_dma);
  err_free_devs:
         input_free_device(input_dev);
         kfree(gtco);
@@ -1005,8 +1005,8 @@ static void gtco_disconnect(struct usb_interface *interface)
                 input_unregister_device(gtco->inputdevice);
                 usb_kill_urb(gtco->urbinfo);
                 usb_free_urb(gtco->urbinfo);
-                usb_buffer_free(gtco->usbdev, REPORT_MAX_SIZE,
-                                gtco->buffer, gtco->buf_dma);
+                usb_free_coherent(gtco->usbdev, REPORT_MAX_SIZE,
+                                  gtco->buffer, gtco->buf_dma);
                 kfree(gtco);
         }
 
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/kbtab.c b/drivers/input/tablet/kbtab.c
index 6682b17bf844..290f4e57b589 100644
--- a/drivers/input/tablet/kbtab.c
+++ b/drivers/input/tablet/kbtab.c
@@ -34,10 +34,6 @@ struct kbtab {
         struct input_dev *dev;
         struct usb_device *usbdev;
         struct urb *irq;
-        int x, y;
-        int button;
-        int pressure;
-        __u32 serial[2];
         char phys[32];
 };
 
@@ -46,6 +42,7 @@ static void kbtab_irq(struct urb *urb)
         struct kbtab *kbtab = urb->context;
         unsigned char *data = kbtab->data;
         struct input_dev *dev = kbtab->dev;
+        int pressure;
         int retval;
 
         switch (urb->status) {
@@ -63,31 +60,27 @@ static void kbtab_irq(struct urb *urb)
                 goto exit;
         }
 
-        kbtab->x = get_unaligned_le16(&data[1]);
-        kbtab->y = get_unaligned_le16(&data[3]);
-
-        kbtab->pressure = (data[5]);
 
         input_report_key(dev, BTN_TOOL_PEN, 1);
 
-        input_report_abs(dev, ABS_X, kbtab->x);
-        input_report_abs(dev, ABS_Y, kbtab->y);
+        input_report_abs(dev, ABS_X, get_unaligned_le16(&data[1]));
+        input_report_abs(dev, ABS_Y, get_unaligned_le16(&data[3]));
 
         /*input_report_key(dev, BTN_TOUCH , data[0] & 0x01);*/
         input_report_key(dev, BTN_RIGHT, data[0] & 0x02);
 
-        if (-1 == kb_pressure_click) {
-                input_report_abs(dev, ABS_PRESSURE, kbtab->pressure);
-        } else {
-                input_report_key(dev, BTN_LEFT, (kbtab->pressure > kb_pressure_click) ? 1 : 0);
-        };
+        pressure = data[5];
+        if (kb_pressure_click == -1)
+                input_report_abs(dev, ABS_PRESSURE, pressure);
+        else
+                input_report_key(dev, BTN_LEFT, pressure > kb_pressure_click ? 1 : 0);
 
         input_sync(dev);
 
  exit:
-        retval = usb_submit_urb (urb, GFP_ATOMIC);
+        retval = usb_submit_urb(urb, GFP_ATOMIC);
         if (retval)
-                err ("%s - usb_submit_urb failed with result %d",
+                err("%s - usb_submit_urb failed with result %d",
                      __func__, retval);
 }
 
@@ -129,7 +122,7 @@ static int kbtab_probe(struct usb_interface *intf, const struct usb_device_id *i
         if (!kbtab || !input_dev)
                 goto fail1;
 
-        kbtab->data = usb_buffer_alloc(dev, 8, GFP_KERNEL, &kbtab->data_dma);
+        kbtab->data = usb_alloc_coherent(dev, 8, GFP_KERNEL, &kbtab->data_dma);
         if (!kbtab->data)
                 goto fail1;
 
@@ -153,13 +146,11 @@ static int kbtab_probe(struct usb_interface *intf, const struct usb_device_id *i
         input_dev->open = kbtab_open;
         input_dev->close = kbtab_close;
 
-        input_dev->evbit[0] |= BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS) |
-                BIT_MASK(EV_MSC);
-        input_dev->keybit[BIT_WORD(BTN_LEFT)] |= BIT_MASK(BTN_LEFT) |
-                BIT_MASK(BTN_RIGHT) | BIT_MASK(BTN_MIDDLE);
-        input_dev->keybit[BIT_WORD(BTN_DIGI)] |= BIT_MASK(BTN_TOOL_PEN) |
-                BIT_MASK(BTN_TOUCH);
-        input_dev->mscbit[0] |= BIT_MASK(MSC_SERIAL);
+        input_dev->evbit[0] |= BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
+        input_dev->keybit[BIT_WORD(BTN_LEFT)] |=
+                BIT_MASK(BTN_LEFT) | BIT_MASK(BTN_RIGHT);
+        input_dev->keybit[BIT_WORD(BTN_DIGI)] |=
+                BIT_MASK(BTN_TOOL_PEN) | BIT_MASK(BTN_TOUCH);
         input_set_abs_params(input_dev, ABS_X, 0, 0x2000, 4, 0);
         input_set_abs_params(input_dev, ABS_Y, 0, 0x1750, 4, 0);
         input_set_abs_params(input_dev, ABS_PRESSURE, 0, 0xff, 0, 0);
@@ -182,7 +173,7 @@ static int kbtab_probe(struct usb_interface *intf, const struct usb_device_id *i
         return 0;
 
  fail3: usb_free_urb(kbtab->irq);
- fail2: usb_buffer_free(dev, 10, kbtab->data, kbtab->data_dma);
+ fail2: usb_free_coherent(dev, 8, kbtab->data, kbtab->data_dma);
  fail1: input_free_device(input_dev);
         kfree(kbtab);
         return error;
@@ -193,13 +184,11 @@ static void kbtab_disconnect(struct usb_interface *intf)
         struct kbtab *kbtab = usb_get_intfdata(intf);
 
         usb_set_intfdata(intf, NULL);
-        if (kbtab) {
-                usb_kill_urb(kbtab->irq);
-                input_unregister_device(kbtab->dev);
-                usb_free_urb(kbtab->irq);
-                usb_buffer_free(interface_to_usbdev(intf), 10, kbtab->data, kbtab->data_dma);
-                kfree(kbtab);
-        }
+
+        input_unregister_device(kbtab->dev);
+        usb_free_urb(kbtab->irq);
+        usb_free_coherent(kbtab->usbdev, 8, kbtab->data, kbtab->data_dma);
+        kfree(kbtab);
 }
 
 static struct usb_driver kbtab_driver = {
diff --git a/drivers/input/tablet/wacom.h b/drivers/input/tablet/wacom.h
index 16310f368dab..de5adb109030 100644
--- a/drivers/input/tablet/wacom.h
+++ b/drivers/input/tablet/wacom.h
@@ -85,6 +85,7 @@
 #include <linux/kernel.h>
 #include <linux/slab.h>
 #include <linux/module.h>
+#include <linux/mod_devicetable.h>
 #include <linux/init.h>
 #include <linux/usb/input.h>
 #include <asm/unaligned.h>
@@ -105,44 +106,19 @@ MODULE_LICENSE(DRIVER_LICENSE);
 
 struct wacom {
         dma_addr_t data_dma;
-        struct input_dev *dev;
         struct usb_device *usbdev;
         struct usb_interface *intf;
         struct urb *irq;
-        struct wacom_wac *wacom_wac;
+        struct wacom_wac wacom_wac;
         struct mutex lock;
-        unsigned int open:1;
+        bool open;
         char phys[32];
 };
 
-struct wacom_combo {
-        struct wacom *wacom;
-        struct urb *urb;
-};
-
-extern int wacom_wac_irq(struct wacom_wac * wacom_wac, void * wcombo);
-extern void wacom_report_abs(void *wcombo, unsigned int abs_type, int abs_data);
-extern void wacom_report_rel(void *wcombo, unsigned int rel_type, int rel_data);
-extern void wacom_report_key(void *wcombo, unsigned int key_type, int key_data);
-extern void wacom_input_event(void *wcombo, unsigned int type, unsigned int code, int value);
-extern void wacom_input_sync(void *wcombo);
-extern void wacom_init_input_dev(struct input_dev *input_dev, struct wacom_wac *wacom_wac);
-extern void input_dev_g4(struct input_dev *input_dev, struct wacom_wac *wacom_wac);
-extern void input_dev_g(struct input_dev *input_dev, struct wacom_wac *wacom_wac);
-extern void input_dev_i3s(struct input_dev *input_dev, struct wacom_wac *wacom_wac);
-extern void input_dev_i3(struct input_dev *input_dev, struct wacom_wac *wacom_wac);
-extern void input_dev_i(struct input_dev *input_dev, struct wacom_wac *wacom_wac);
-extern void input_dev_i4s(struct input_dev *input_dev, struct wacom_wac *wacom_wac);
-extern void input_dev_i4(struct input_dev *input_dev, struct wacom_wac *wacom_wac);
-extern void input_dev_pl(struct input_dev *input_dev, struct wacom_wac *wacom_wac);
-extern void input_dev_pt(struct input_dev *input_dev, struct wacom_wac *wacom_wac);
-extern void input_dev_tpc(struct input_dev *input_dev, struct wacom_wac *wacom_wac);
-extern void input_dev_tpc2fg(struct input_dev *input_dev, struct wacom_wac *wacom_wac);
-extern void input_dev_mo(struct input_dev *input_dev, struct wacom_wac *wacom_wac);
-extern void input_dev_bee(struct input_dev *input_dev, struct wacom_wac *wacom_wac);
-extern __u16 wacom_le16_to_cpu(unsigned char *data);
-extern __u16 wacom_be16_to_cpu(unsigned char *data);
-extern struct wacom_features *get_wacom_feature(const struct usb_device_id *id);
-extern const struct usb_device_id *get_device_table(void);
+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 072f33b3b2b0..fc381498b798 100644
--- a/drivers/input/tablet/wacom_sys.c
+++ b/drivers/input/tablet/wacom_sys.c
@@ -11,8 +11,8 @@
  * (at your option) any later version.
  */
 
-#include "wacom.h"
 #include "wacom_wac.h"
+#include "wacom.h"
 
 /* defines to get HID report descriptor */
 #define HID_DEVICET_HID         (USB_TYPE_CLASS | 0x01)
@@ -70,15 +70,9 @@ static int usb_set_report(struct usb_interface *intf, unsigned char type,
                 buf, size, 1000);
 }
 
-static struct input_dev * get_input_dev(struct wacom_combo *wcombo)
-{
-        return wcombo->wacom->dev;
-}
-
 static void wacom_sys_irq(struct urb *urb)
 {
         struct wacom *wacom = urb->context;
-        struct wacom_combo wcombo;
         int retval;
 
         switch (urb->status) {
@@ -96,207 +90,55 @@ static void wacom_sys_irq(struct urb *urb)
                 goto exit;
         }
 
-        wcombo.wacom = wacom;
-        wcombo.urb = urb;
-
-        if (wacom_wac_irq(wacom->wacom_wac, (void *)&wcombo))
-                input_sync(get_input_dev(&wcombo));
+        wacom_wac_irq(&wacom->wacom_wac, urb->actual_length);
 
  exit:
         usb_mark_last_busy(wacom->usbdev);
-        retval = usb_submit_urb (urb, GFP_ATOMIC);
+        retval = usb_submit_urb(urb, GFP_ATOMIC);
         if (retval)
                 err ("%s - usb_submit_urb failed with result %d",
                      __func__, retval);
 }
 
-void wacom_report_key(void *wcombo, unsigned int key_type, int key_data)
-{
-        input_report_key(get_input_dev((struct wacom_combo *)wcombo), key_type, key_data);
-}
-
-void wacom_report_abs(void *wcombo, unsigned int abs_type, int abs_data)
-{
-        input_report_abs(get_input_dev((struct wacom_combo *)wcombo), abs_type, abs_data);
-}
-
-void wacom_report_rel(void *wcombo, unsigned int rel_type, int rel_data)
-{
-        input_report_rel(get_input_dev((struct wacom_combo *)wcombo), rel_type, rel_data);
-}
-
-void wacom_input_event(void *wcombo, unsigned int type, unsigned int code, int value)
-{
-        input_event(get_input_dev((struct wacom_combo *)wcombo), type, code, value);
-}
-
-__u16 wacom_be16_to_cpu(unsigned char *data)
-{
-        __u16 value;
-        value = be16_to_cpu(*(__be16 *) data);
-        return value;
-}
-
-__u16 wacom_le16_to_cpu(unsigned char *data)
-{
-        __u16 value;
-        value = le16_to_cpu(*(__le16 *) data);
-        return value;
-}
-
-void wacom_input_sync(void *wcombo)
-{
-        input_sync(get_input_dev((struct wacom_combo *)wcombo));
-}
-
 static int wacom_open(struct input_dev *dev)
 {
         struct wacom *wacom = input_get_drvdata(dev);
+        int retval = 0;
 
-        mutex_lock(&wacom->lock);
-
-        wacom->irq->dev = wacom->usbdev;
-
-        if (usb_autopm_get_interface(wacom->intf) < 0) {
-                mutex_unlock(&wacom->lock);
+        if (usb_autopm_get_interface(wacom->intf) < 0)
                 return -EIO;
-        }
+
+        mutex_lock(&wacom->lock);
 
         if (usb_submit_urb(wacom->irq, GFP_KERNEL)) {
-                usb_autopm_put_interface(wacom->intf);
-                mutex_unlock(&wacom->lock);
-                return -EIO;
+                retval = -EIO;
+                goto out;
         }
 
-        wacom->open = 1;
+        wacom->open = true;
         wacom->intf->needs_remote_wakeup = 1;
 
+out:
         mutex_unlock(&wacom->lock);
-        return 0;
+        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);
-        wacom->open = 0;
+        wacom->open = false;
         wacom->intf->needs_remote_wakeup = 0;
         mutex_unlock(&wacom->lock);
-}
 
-void input_dev_mo(struct input_dev *input_dev, struct wacom_wac *wacom_wac)
-{
-        input_dev->keybit[BIT_WORD(BTN_MISC)] |= BIT_MASK(BTN_1) |
-                BIT_MASK(BTN_5);
-        input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
-}
-
-void input_dev_g4(struct input_dev *input_dev, struct wacom_wac *wacom_wac)
-{
-        input_dev->evbit[0] |= BIT_MASK(EV_MSC);
-        input_dev->mscbit[0] |= BIT_MASK(MSC_SERIAL);
-        input_dev->keybit[BIT_WORD(BTN_DIGI)] |= BIT_MASK(BTN_TOOL_FINGER);
-        input_dev->keybit[BIT_WORD(BTN_MISC)] |= BIT_MASK(BTN_0) |
-                BIT_MASK(BTN_4);
-}
-
-void input_dev_g(struct input_dev *input_dev, struct wacom_wac *wacom_wac)
-{
-        input_dev->evbit[0] |= BIT_MASK(EV_REL);
-        input_dev->relbit[0] |= BIT_MASK(REL_WHEEL);
-        input_dev->keybit[BIT_WORD(BTN_MOUSE)] |= BIT_MASK(BTN_LEFT) |
-                BIT_MASK(BTN_RIGHT) | BIT_MASK(BTN_MIDDLE);
-        input_dev->keybit[BIT_WORD(BTN_DIGI)] |= BIT_MASK(BTN_TOOL_RUBBER) |
-                BIT_MASK(BTN_TOOL_PEN) | BIT_MASK(BTN_STYLUS) |
-                BIT_MASK(BTN_TOOL_MOUSE) | BIT_MASK(BTN_STYLUS2);
-        input_set_abs_params(input_dev, ABS_DISTANCE, 0, wacom_wac->features->distance_max, 0, 0);
-}
-
-void input_dev_i3s(struct input_dev *input_dev, struct wacom_wac *wacom_wac)
-{
-        input_dev->keybit[BIT_WORD(BTN_DIGI)] |= BIT_MASK(BTN_TOOL_FINGER);
-        input_dev->keybit[BIT_WORD(BTN_MISC)] |= BIT_MASK(BTN_0) |
-                BIT_MASK(BTN_1) | BIT_MASK(BTN_2) | BIT_MASK(BTN_3);
-        input_set_abs_params(input_dev, ABS_RX, 0, 4096, 0, 0);
-        input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
-}
-
-void input_dev_i3(struct input_dev *input_dev, struct wacom_wac *wacom_wac)
-{
-        input_dev->keybit[BIT_WORD(BTN_MISC)] |= BIT_MASK(BTN_4) |
-                BIT_MASK(BTN_5) | BIT_MASK(BTN_6) | BIT_MASK(BTN_7);
-        input_set_abs_params(input_dev, ABS_RY, 0, 4096, 0, 0);
-}
-
-void input_dev_i4s(struct input_dev *input_dev, struct wacom_wac *wacom_wac)
-{
-        input_dev->keybit[BIT_WORD(BTN_DIGI)] |= BIT_MASK(BTN_TOOL_FINGER);
-        input_dev->keybit[BIT_WORD(BTN_MISC)] |= BIT_MASK(BTN_0) | BIT_MASK(BTN_1) | BIT_MASK(BTN_2) | BIT_MASK(BTN_3);
-        input_dev->keybit[BIT_WORD(BTN_MISC)] |= BIT_MASK(BTN_4) | BIT_MASK(BTN_5) | BIT_MASK(BTN_6);
-        input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
-}
-
-void input_dev_i4(struct input_dev *input_dev, struct wacom_wac *wacom_wac)
-{
-        input_dev->keybit[BIT_WORD(BTN_MISC)] |= BIT_MASK(BTN_7) | BIT_MASK(BTN_8);
-}
-
-void input_dev_bee(struct input_dev *input_dev, struct wacom_wac *wacom_wac)
-{
-        input_dev->keybit[BIT_WORD(BTN_MISC)] |= BIT_MASK(BTN_8) | BIT_MASK(BTN_9);
-}
-
-void input_dev_i(struct input_dev *input_dev, struct wacom_wac *wacom_wac)
-{
-        input_dev->evbit[0] |= BIT_MASK(EV_MSC) | BIT_MASK(EV_REL);
-        input_dev->mscbit[0] |= BIT_MASK(MSC_SERIAL);
-        input_dev->relbit[0] |= BIT_MASK(REL_WHEEL);
-        input_dev->keybit[BIT_WORD(BTN_MOUSE)] |= BIT_MASK(BTN_LEFT) |
-                BIT_MASK(BTN_RIGHT) | BIT_MASK(BTN_MIDDLE) |
-                BIT_MASK(BTN_SIDE) | BIT_MASK(BTN_EXTRA);
-        input_dev->keybit[BIT_WORD(BTN_DIGI)] |= BIT_MASK(BTN_TOOL_RUBBER) |
-                BIT_MASK(BTN_TOOL_PEN) | BIT_MASK(BTN_STYLUS) |
-                BIT_MASK(BTN_TOOL_MOUSE) | BIT_MASK(BTN_TOOL_BRUSH) |
-                BIT_MASK(BTN_TOOL_PENCIL) | BIT_MASK(BTN_TOOL_AIRBRUSH) |
-                BIT_MASK(BTN_TOOL_LENS) | BIT_MASK(BTN_STYLUS2);
-        input_set_abs_params(input_dev, ABS_DISTANCE, 0, wacom_wac->features->distance_max, 0, 0);
-        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);
-        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 input_dev_pl(struct input_dev *input_dev, struct wacom_wac *wacom_wac)
-{
-        input_dev->keybit[BIT_WORD(BTN_DIGI)] |= BIT_MASK(BTN_TOOL_PEN) |
-                BIT_MASK(BTN_STYLUS) | BIT_MASK(BTN_STYLUS2);
-}
-
-void input_dev_pt(struct input_dev *input_dev, struct wacom_wac *wacom_wac)
-{
-        input_dev->keybit[BIT_WORD(BTN_DIGI)] |= BIT_MASK(BTN_TOOL_RUBBER);
-}
-
-void input_dev_tpc(struct input_dev *input_dev, struct wacom_wac *wacom_wac)
-{
-        if (wacom_wac->features->device_type == BTN_TOOL_DOUBLETAP ||
-            wacom_wac->features->device_type == BTN_TOOL_TRIPLETAP) {
-                input_set_abs_params(input_dev, ABS_RX, 0, wacom_wac->features->x_phy, 0, 0);
-                input_set_abs_params(input_dev, ABS_RY, 0, wacom_wac->features->y_phy, 0, 0);
-                input_dev->keybit[BIT_WORD(BTN_DIGI)] |= BIT_MASK(BTN_TOOL_DOUBLETAP);
-        }
-}
-
-void input_dev_tpc2fg(struct input_dev *input_dev, struct wacom_wac *wacom_wac)
-{
-        if (wacom_wac->features->device_type == BTN_TOOL_TRIPLETAP) {
-                input_dev->keybit[BIT_WORD(BTN_DIGI)] |= BIT_MASK(BTN_TOOL_TRIPLETAP);
-                input_dev->evbit[0] |= BIT_MASK(EV_MSC);
-                input_dev->mscbit[0] |= BIT_MASK(MSC_SERIAL);
-        }
+        if (!autopm_error)
+                usb_autopm_put_interface(wacom->intf);
 }
 
 static int wacom_parse_hid(struct usb_interface *intf, struct hid_descriptor *hid_desc,
@@ -357,20 +199,33 @@ static int wacom_parse_hid(struct usb_interface *intf, struct hid_descriptor *hi
                                                         features->pktlen = WACOM_PKGLEN_TPC2FG;
                                                         features->device_type = BTN_TOOL_TRIPLETAP;
                                                 }
-                                                features->x_max =
-                                                        wacom_le16_to_cpu(&report[i + 3]);
-                                                features->x_phy =
-                                                        wacom_le16_to_cpu(&report[i + 6]);
-                                                features->unit = report[i + 9];
-                                                features->unitExpo = report[i + 11];
-                                                i += 12;
+                                                if (features->type == BAMBOO_PT) {
+                                                        /* need to reset back */
+                                                        features->pktlen = WACOM_PKGLEN_BBTOUCH;
+                                                        features->device_type = BTN_TOOL_TRIPLETAP;
+                                                        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;
+                                                }
                                         } else if (pen) {
                                                 /* penabled only accepts exact bytes of data */
                                                 if (features->type == TABLETPC2FG)
-                                                        features->pktlen = WACOM_PKGLEN_PENABLED;
+                                                        features->pktlen = WACOM_PKGLEN_GRAPHIRE;
+                                                if (features->type == BAMBOO_PT)
+                                                        features->pktlen = WACOM_PKGLEN_BBFUN;
                                                 features->device_type = BTN_TOOL_PEN;
                                                 features->x_max =
-                                                        wacom_le16_to_cpu(&report[i + 3]);
+                                                        get_unaligned_le16(&report[i + 3]);
                                                 i += 4;
                                         }
                                 } else if (usage == WCM_DIGITIZER) {
@@ -392,24 +247,35 @@ static int wacom_parse_hid(struct usb_interface *intf, struct hid_descriptor *hi
                                                         features->pktlen = WACOM_PKGLEN_TPC2FG;
                                                         features->device_type = BTN_TOOL_TRIPLETAP;
                                                         features->y_max =
-                                                                wacom_le16_to_cpu(&report[i + 3]);
+                                                                get_unaligned_le16(&report[i + 3]);
                                                         features->y_phy =
-                                                                wacom_le16_to_cpu(&report[i + 6]);
+                                                                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_TRIPLETAP;
+                                                        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;
                                                         features->y_phy =
-                                                                wacom_le16_to_cpu(&report[i + 3]);
+                                                                get_unaligned_le16(&report[i + 3]);
                                                         i += 4;
                                                 }
                                         } else if (pen) {
                                                 /* penabled only accepts exact bytes of data */
                                                 if (features->type == TABLETPC2FG)
-                                                        features->pktlen = WACOM_PKGLEN_PENABLED;
+                                                        features->pktlen = WACOM_PKGLEN_GRAPHIRE;
+                                                if (features->type == BAMBOO_PT)
+                                                        features->pktlen = WACOM_PKGLEN_BBFUN;
                                                 features->device_type = BTN_TOOL_PEN;
                                                 features->y_max =
-                                                        wacom_le16_to_cpu(&report[i + 3]);
+                                                        get_unaligned_le16(&report[i + 3]);
                                                 i += 4;
                                         }
                                 }
@@ -428,7 +294,7 @@ static int wacom_parse_hid(struct usb_interface *intf, struct hid_descriptor *hi
                         case HID_USAGE_UNDEFINED:
                                 if (usage == WCM_DESKTOP && finger) /* capacity */
                                         features->pressure_max =
-                                                wacom_le16_to_cpu(&report[i + 3]);
+                                                get_unaligned_le16(&report[i + 3]);
                                 i += 4;
                                 break;
                         }
@@ -457,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;
@@ -470,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;
@@ -495,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)) {
@@ -514,16 +386,85 @@ 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;
 }
 
+struct wacom_usbdev_data {
+        struct list_head list;
+        struct kref kref;
+        struct usb_device *dev;
+        struct wacom_shared shared;
+};
+
+static LIST_HEAD(wacom_udev_list);
+static DEFINE_MUTEX(wacom_udev_list_lock);
+
+static struct wacom_usbdev_data *wacom_get_usbdev_data(struct usb_device *dev)
+{
+        struct wacom_usbdev_data *data;
+
+        list_for_each_entry(data, &wacom_udev_list, list) {
+                if (data->dev == dev) {
+                        kref_get(&data->kref);
+                        return data;
+                }
+        }
+
+        return NULL;
+}
+
+static int wacom_add_shared_data(struct wacom_wac *wacom,
+                                 struct usb_device *dev)
+{
+        struct wacom_usbdev_data *data;
+        int retval = 0;
+
+        mutex_lock(&wacom_udev_list_lock);
+
+        data = wacom_get_usbdev_data(dev);
+        if (!data) {
+                data = kzalloc(sizeof(struct wacom_usbdev_data), GFP_KERNEL);
+                if (!data) {
+                        retval = -ENOMEM;
+                        goto out;
+                }
+
+                kref_init(&data->kref);
+                data->dev = dev;
+                list_add_tail(&data->list, &wacom_udev_list);
+        }
+
+        wacom->shared = &data->shared;
+
+out:
+        mutex_unlock(&wacom_udev_list_lock);
+        return retval;
+}
+
+static void wacom_release_shared_data(struct kref *kref)
+{
+        struct wacom_usbdev_data *data =
+                container_of(kref, struct wacom_usbdev_data, kref);
+
+        mutex_lock(&wacom_udev_list_lock);
+        list_del(&data->list);
+        mutex_unlock(&wacom_udev_list_lock);
+
+        kfree(data);
+}
+
+static void wacom_remove_shared_data(struct wacom_wac *wacom)
+{
+        struct wacom_usbdev_data *data;
+
+        if (wacom->shared) {
+                data = container_of(wacom->shared, struct wacom_usbdev_data, shared);
+                kref_put(&data->kref, wacom_release_shared_data);
+                wacom->shared = NULL;
+        }
+}
+
 static int wacom_probe(struct usb_interface *intf, const struct usb_device_id *id)
 {
         struct usb_device *dev = interface_to_usbdev(intf);
@@ -532,42 +473,46 @@ static int wacom_probe(struct usb_interface *intf, const struct usb_device_id *i
         struct wacom_wac *wacom_wac;
         struct wacom_features *features;
         struct input_dev *input_dev;
-        int error = -ENOMEM;
+        int error;
+
+        if (!id->driver_info)
+                return -EINVAL;
 
         wacom = kzalloc(sizeof(struct wacom), GFP_KERNEL);
-        wacom_wac = kzalloc(sizeof(struct wacom_wac), GFP_KERNEL);
         input_dev = input_allocate_device();
-        if (!wacom || !input_dev || !wacom_wac)
+        if (!wacom || !input_dev) {
+                error = -ENOMEM;
                 goto fail1;
+        }
 
-        wacom_wac->data = usb_buffer_alloc(dev, WACOM_PKGLEN_MAX, GFP_KERNEL, &wacom->data_dma);
-        if (!wacom_wac->data)
+        wacom_wac = &wacom->wacom_wac;
+        wacom_wac->features = *((struct wacom_features *)id->driver_info);
+        features = &wacom_wac->features;
+        if (features->pktlen > WACOM_PKGLEN_MAX) {
+                error = -EINVAL;
                 goto fail1;
+        }
+
+        wacom_wac->data = usb_alloc_coherent(dev, WACOM_PKGLEN_MAX,
+                                             GFP_KERNEL, &wacom->data_dma);
+        if (!wacom_wac->data) {
+                error = -ENOMEM;
+                goto fail1;
+        }
 
         wacom->irq = usb_alloc_urb(0, GFP_KERNEL);
-        if (!wacom->irq)
+        if (!wacom->irq) {
+                error = -ENOMEM;
                 goto fail2;
+        }
 
         wacom->usbdev = dev;
-        wacom->dev = input_dev;
         wacom->intf = intf;
         mutex_init(&wacom->lock);
         usb_make_path(dev, wacom->phys, sizeof(wacom->phys));
         strlcat(wacom->phys, "/input0", sizeof(wacom->phys));
 
-        wacom_wac->features = features = get_wacom_feature(id);
-        BUG_ON(features->pktlen > WACOM_PKGLEN_MAX);
-
-        input_dev->name = wacom_wac->features->name;
-        wacom->wacom_wac = wacom_wac;
-        usb_to_input_id(dev, &input_dev->id);
-
-        input_dev->dev.parent = &intf->dev;
-
-        input_set_drvdata(input_dev, wacom);
-
-        input_dev->open = wacom_open;
-        input_dev->close = wacom_close;
+        wacom_wac->input = input_dev;
 
         endpoint = &intf->cur_altsetting->endpoint[0].desc;
 
@@ -576,15 +521,30 @@ static int wacom_probe(struct usb_interface *intf, const struct usb_device_id *i
         if (error)
                 goto fail2;
 
-        input_dev->evbit[0] |= BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
-        input_dev->keybit[BIT_WORD(BTN_DIGI)] |= BIT_MASK(BTN_TOUCH);
+        wacom_setup_device_quirks(features);
 
-        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_dev->absbit[BIT_WORD(ABS_MISC)] |= BIT_MASK(ABS_MISC);
+        strlcpy(wacom_wac->name, features->name, sizeof(wacom_wac->name));
 
-        wacom_init_input_dev(input_dev, wacom_wac);
+        if (features->quirks & WACOM_QUIRK_MULTI_INPUT) {
+                /* Append the device type to the name */
+                strlcat(wacom_wac->name,
+                        features->device_type == BTN_TOOL_PEN ?
+                                " Pen" : " Finger",
+                        sizeof(wacom_wac->name));
+
+                error = wacom_add_shared_data(wacom_wac, dev);
+                if (error)
+                        goto fail3;
+        }
+
+        input_dev->name = wacom_wac->name;
+        input_dev->dev.parent = &intf->dev;
+        input_dev->open = wacom_open;
+        input_dev->close = wacom_close;
+        usb_to_input_id(dev, &input_dev->id);
+        input_set_drvdata(input_dev, wacom);
+
+        wacom_setup_input_capabilities(input_dev, wacom_wac);
 
         usb_fill_int_urb(wacom->irq, dev,
                          usb_rcvintpipe(dev, endpoint->bEndpointAddress),
@@ -593,9 +553,9 @@ static int wacom_probe(struct usb_interface *intf, const struct usb_device_id *i
         wacom->irq->transfer_dma = wacom->data_dma;
         wacom->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 
-        error = input_register_device(wacom->dev);
+        error = input_register_device(input_dev);
         if (error)
-                goto fail3;
+                goto fail4;
 
         /* Note that if query fails it is not a hard failure */
         wacom_query_tablet_data(intf, features);
@@ -603,11 +563,11 @@ static int wacom_probe(struct usb_interface *intf, const struct usb_device_id *i
         usb_set_intfdata(intf, wacom);
         return 0;
 
+ fail4: wacom_remove_shared_data(wacom_wac);
  fail3: usb_free_urb(wacom->irq);
- fail2: usb_buffer_free(dev, WACOM_PKGLEN_MAX, wacom_wac->data, wacom->data_dma);
+ fail2: usb_free_coherent(dev, WACOM_PKGLEN_MAX, wacom_wac->data, wacom->data_dma);
  fail1: input_free_device(input_dev);
         kfree(wacom);
-        kfree(wacom_wac);
         return error;
 }
 
@@ -618,11 +578,11 @@ static void wacom_disconnect(struct usb_interface *intf)
         usb_set_intfdata(intf, NULL);
 
         usb_kill_urb(wacom->irq);
-        input_unregister_device(wacom->dev);
+        input_unregister_device(wacom->wacom_wac.input);
         usb_free_urb(wacom->irq);
-        usb_buffer_free(interface_to_usbdev(intf), WACOM_PKGLEN_MAX,
-                        wacom->wacom_wac->data, wacom->data_dma);
-        kfree(wacom->wacom_wac);
+        usb_free_coherent(interface_to_usbdev(intf), WACOM_PKGLEN_MAX,
+                        wacom->wacom_wac.data, wacom->data_dma);
+        wacom_remove_shared_data(&wacom->wacom_wac);
         kfree(wacom);
 }
 
@@ -640,17 +600,19 @@ static int wacom_suspend(struct usb_interface *intf, pm_message_t message)
 static int wacom_resume(struct usb_interface *intf)
 {
         struct wacom *wacom = usb_get_intfdata(intf);
-        struct wacom_features *features = wacom->wacom_wac->features;
+        struct wacom_features *features = &wacom->wacom_wac.features;
         int rv;
 
         mutex_lock(&wacom->lock);
-        if (wacom->open) {
+
+        /* switch to wacom mode first */
+        wacom_query_tablet_data(intf, features);
+
+        if (wacom->open)
                 rv = usb_submit_urb(wacom->irq, GFP_NOIO);
-                /* switch to wacom mode if needed */
-                if (!wacom_retrieve_hid_descriptor(intf, features))
-                        wacom_query_tablet_data(intf, features);
-        } else
+        else
                 rv = 0;
+
         mutex_unlock(&wacom->lock);
 
         return rv;
@@ -663,6 +625,7 @@ static int wacom_reset_resume(struct usb_interface *intf)
 
 static struct usb_driver wacom_driver = {
         .name =         "wacom",
+        .id_table =     wacom_ids,
         .probe =        wacom_probe,
         .disconnect =   wacom_disconnect,
         .suspend =      wacom_suspend,
@@ -674,7 +637,7 @@ static struct usb_driver wacom_driver = {
 static int __init wacom_init(void)
 {
         int result;
-        wacom_driver.id_table = get_device_table();
+
         result = usb_register(&wacom_driver);
         if (result == 0)
                 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
diff --git a/drivers/input/tablet/wacom_wac.c b/drivers/input/tablet/wacom_wac.c
index 1056f149fe31..b3252ef1e279 100644
--- a/drivers/input/tablet/wacom_wac.c
+++ b/drivers/input/tablet/wacom_wac.c
@@ -11,51 +11,58 @@
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  */
-#include "wacom.h"
+
 #include "wacom_wac.h"
+#include "wacom.h"
 
-static int wacom_penpartner_irq(struct wacom_wac *wacom, void *wcombo)
+static int wacom_penpartner_irq(struct wacom_wac *wacom)
 {
         unsigned char *data = wacom->data;
+        struct input_dev *input = wacom->input;
 
         switch (data[0]) {
-                case 1:
-                        if (data[5] & 0x80) {
-                                wacom->tool[0] = (data[5] & 0x20) ? BTN_TOOL_RUBBER : BTN_TOOL_PEN;
-                                wacom->id[0] = (data[5] & 0x20) ? ERASER_DEVICE_ID : STYLUS_DEVICE_ID;
-                                wacom_report_key(wcombo, wacom->tool[0], 1);
-                                wacom_report_abs(wcombo, ABS_MISC, wacom->id[0]); /* report tool id */
-                                wacom_report_abs(wcombo, ABS_X, wacom_le16_to_cpu(&data[1]));
-                                wacom_report_abs(wcombo, ABS_Y, wacom_le16_to_cpu(&data[3]));
-                                wacom_report_abs(wcombo, ABS_PRESSURE, (signed char)data[6] + 127);
-                                wacom_report_key(wcombo, BTN_TOUCH, ((signed char)data[6] > -127));
-                                wacom_report_key(wcombo, BTN_STYLUS, (data[5] & 0x40));
-                        } else {
-                                wacom_report_key(wcombo, wacom->tool[0], 0);
-                                wacom_report_abs(wcombo, ABS_MISC, 0); /* report tool id */
-                                wacom_report_abs(wcombo, ABS_PRESSURE, -1);
-                                wacom_report_key(wcombo, BTN_TOUCH, 0);
-                        }
-                        break;
-                case 2:
-                        wacom_report_key(wcombo, BTN_TOOL_PEN, 1);
-                        wacom_report_abs(wcombo, ABS_MISC, STYLUS_DEVICE_ID); /* report tool id */
-                        wacom_report_abs(wcombo, ABS_X, wacom_le16_to_cpu(&data[1]));
-                        wacom_report_abs(wcombo, ABS_Y, wacom_le16_to_cpu(&data[3]));
-                        wacom_report_abs(wcombo, ABS_PRESSURE, (signed char)data[6] + 127);
-                        wacom_report_key(wcombo, BTN_TOUCH, ((signed char)data[6] > -80) && !(data[5] & 0x20));
-                        wacom_report_key(wcombo, BTN_STYLUS, (data[5] & 0x40));
-                        break;
-                default:
-                        printk(KERN_INFO "wacom_penpartner_irq: received unknown report #%d\n", data[0]);
-                        return 0;
+        case 1:
+                if (data[5] & 0x80) {
+                        wacom->tool[0] = (data[5] & 0x20) ? BTN_TOOL_RUBBER : BTN_TOOL_PEN;
+                        wacom->id[0] = (data[5] & 0x20) ? ERASER_DEVICE_ID : STYLUS_DEVICE_ID;
+                        input_report_key(input, wacom->tool[0], 1);
+                        input_report_abs(input, ABS_MISC, wacom->id[0]); /* report tool id */
+                        input_report_abs(input, ABS_X, get_unaligned_le16(&data[1]));
+                        input_report_abs(input, ABS_Y, get_unaligned_le16(&data[3]));
+                        input_report_abs(input, ABS_PRESSURE, (signed char)data[6] + 127);
+                        input_report_key(input, BTN_TOUCH, ((signed char)data[6] > -127));
+                        input_report_key(input, BTN_STYLUS, (data[5] & 0x40));
+                } else {
+                        input_report_key(input, wacom->tool[0], 0);
+                        input_report_abs(input, ABS_MISC, 0); /* report tool id */
+                        input_report_abs(input, ABS_PRESSURE, -1);
+                        input_report_key(input, BTN_TOUCH, 0);
+                }
+                break;
+
+        case 2:
+                input_report_key(input, BTN_TOOL_PEN, 1);
+                input_report_abs(input, ABS_MISC, STYLUS_DEVICE_ID); /* report tool id */
+                input_report_abs(input, ABS_X, get_unaligned_le16(&data[1]));
+                input_report_abs(input, ABS_Y, get_unaligned_le16(&data[3]));
+                input_report_abs(input, ABS_PRESSURE, (signed char)data[6] + 127);
+                input_report_key(input, BTN_TOUCH, ((signed char)data[6] > -80) && !(data[5] & 0x20));
+                input_report_key(input, BTN_STYLUS, (data[5] & 0x40));
+                break;
+
+        default:
+                printk(KERN_INFO "wacom_penpartner_irq: received unknown report #%d\n", data[0]);
+                return 0;
         }
+
         return 1;
 }
 
-static int wacom_pl_irq(struct wacom_wac *wacom, void *wcombo)
+static int wacom_pl_irq(struct wacom_wac *wacom)
 {
+        struct wacom_features *features = &wacom->features;
         unsigned char *data = wacom->data;
+        struct input_dev *input = wacom->input;
         int prox, pressure;
 
         if (data[0] != WACOM_REPORT_PENABLED) {
@@ -68,9 +75,9 @@ static int wacom_pl_irq(struct wacom_wac *wacom, void *wcombo)
         if (prox) {
                 wacom->id[0] = ERASER_DEVICE_ID;
                 pressure = (signed char)((data[7] << 1) | ((data[4] >> 2) & 1));
-                if (wacom->features->pressure_max > 255)
+                if (features->pressure_max > 255)
                         pressure = (pressure << 1) | ((data[4] >> 6) & 1);
-                pressure += (wacom->features->pressure_max + 1) / 2;
+                pressure += (features->pressure_max + 1) / 2;
 
                 /*
                  * if going from out of proximity into proximity select between the eraser
@@ -89,8 +96,8 @@ static int wacom_pl_irq(struct wacom_wac *wacom, void *wcombo)
                         /* was entered with stylus2 pressed */
                         if (wacom->tool[1] == BTN_TOOL_RUBBER && !(data[4] & 0x20)) {
                                 /* report out proximity for previous tool */
-                                wacom_report_key(wcombo, wacom->tool[1], 0);
-                                wacom_input_sync(wcombo);
+                                input_report_key(input, wacom->tool[1], 0);
+                                input_sync(input);
                                 wacom->tool[1] = BTN_TOOL_PEN;
                                 return 0;
                         }
@@ -100,32 +107,33 @@ static int wacom_pl_irq(struct wacom_wac *wacom, void *wcombo)
                         wacom->tool[1] = BTN_TOOL_PEN;
                         wacom->id[0] = STYLUS_DEVICE_ID;
                 }
-                wacom_report_key(wcombo, wacom->tool[1], prox); /* report in proximity for tool */
-                wacom_report_abs(wcombo, ABS_MISC, wacom->id[0]); /* report tool id */
-                wacom_report_abs(wcombo, ABS_X, data[3] | (data[2] << 7) | ((data[1] & 0x03) << 14));
-                wacom_report_abs(wcombo, ABS_Y, data[6] | (data[5] << 7) | ((data[4] & 0x03) << 14));
-                wacom_report_abs(wcombo, ABS_PRESSURE, pressure);
-
-                wacom_report_key(wcombo, BTN_TOUCH, data[4] & 0x08);
-                wacom_report_key(wcombo, BTN_STYLUS, data[4] & 0x10);
+                input_report_key(input, wacom->tool[1], prox); /* report in proximity for tool */
+                input_report_abs(input, ABS_MISC, wacom->id[0]); /* report tool id */
+                input_report_abs(input, ABS_X, data[3] | (data[2] << 7) | ((data[1] & 0x03) << 14));
+                input_report_abs(input, ABS_Y, data[6] | (data[5] << 7) | ((data[4] & 0x03) << 14));
+                input_report_abs(input, ABS_PRESSURE, pressure);
+
+                input_report_key(input, BTN_TOUCH, data[4] & 0x08);
+                input_report_key(input, BTN_STYLUS, data[4] & 0x10);
                 /* Only allow the stylus2 button to be reported for the pen tool. */
-                wacom_report_key(wcombo, BTN_STYLUS2, (wacom->tool[1] == BTN_TOOL_PEN) && (data[4] & 0x20));
+                input_report_key(input, BTN_STYLUS2, (wacom->tool[1] == BTN_TOOL_PEN) && (data[4] & 0x20));
         } else {
                 /* report proximity-out of a (valid) tool */
                 if (wacom->tool[1] != BTN_TOOL_RUBBER) {
                         /* Unknown tool selected default to pen tool */
                         wacom->tool[1] = BTN_TOOL_PEN;
                 }
-                wacom_report_key(wcombo, wacom->tool[1], prox);
+                input_report_key(input, wacom->tool[1], prox);
         }
 
         wacom->tool[0] = prox; /* Save proximity state */
         return 1;
 }
 
-static int wacom_ptu_irq(struct wacom_wac *wacom, void *wcombo)
+static int wacom_ptu_irq(struct wacom_wac *wacom)
 {
         unsigned char *data = wacom->data;
+        struct input_dev *input = wacom->input;
 
         if (data[0] != WACOM_REPORT_PENABLED) {
                 printk(KERN_INFO "wacom_ptu_irq: received unknown report #%d\n", data[0]);
@@ -133,39 +141,74 @@ static int wacom_ptu_irq(struct wacom_wac *wacom, void *wcombo)
         }
 
         if (data[1] & 0x04) {
-                wacom_report_key(wcombo, BTN_TOOL_RUBBER, data[1] & 0x20);
-                wacom_report_key(wcombo, BTN_TOUCH, data[1] & 0x08);
+                input_report_key(input, BTN_TOOL_RUBBER, data[1] & 0x20);
+                input_report_key(input, BTN_TOUCH, data[1] & 0x08);
                 wacom->id[0] = ERASER_DEVICE_ID;
         } else {
-                wacom_report_key(wcombo, BTN_TOOL_PEN, data[1] & 0x20);
-                wacom_report_key(wcombo, BTN_TOUCH, data[1] & 0x01);
+                input_report_key(input, BTN_TOOL_PEN, data[1] & 0x20);
+                input_report_key(input, BTN_TOUCH, data[1] & 0x01);
                 wacom->id[0] = STYLUS_DEVICE_ID;
         }
-        wacom_report_abs(wcombo, ABS_MISC, wacom->id[0]); /* report tool id */
-        wacom_report_abs(wcombo, ABS_X, wacom_le16_to_cpu(&data[2]));
-        wacom_report_abs(wcombo, ABS_Y, wacom_le16_to_cpu(&data[4]));
-        wacom_report_abs(wcombo, ABS_PRESSURE, wacom_le16_to_cpu(&data[6]));
-        wacom_report_key(wcombo, BTN_STYLUS, data[1] & 0x02);
-        wacom_report_key(wcombo, BTN_STYLUS2, data[1] & 0x10);
+        input_report_abs(input, ABS_MISC, wacom->id[0]); /* report tool id */
+        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_STYLUS, data[1] & 0x02);
+        input_report_key(input, BTN_STYLUS2, data[1] & 0x10);
+        return 1;
+}
+
+static int wacom_dtu_irq(struct wacom_wac *wacom)
+{
+        struct wacom_features *features = &wacom->features;
+        char *data = wacom->data;
+        struct input_dev *input = wacom->input;
+        int prox = data[1] & 0x20, pressure;
+
+        dbg("wacom_dtu_irq: received report #%d", data[0]);
+
+        if (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_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;
+        input_report_key(input, wacom->tool[0], prox);
+        input_report_abs(input, ABS_MISC, wacom->id[0]);
         return 1;
 }
 
-static int wacom_graphire_irq(struct wacom_wac *wacom, void *wcombo)
+static int wacom_graphire_irq(struct wacom_wac *wacom)
 {
+        struct wacom_features *features = &wacom->features;
         unsigned char *data = wacom->data;
-        int x, y, rw;
-        static int penData = 0;
+        struct input_dev *input = wacom->input;
+        int prox;
+        int rw = 0;
+        int retval = 0;
 
         if (data[0] != WACOM_REPORT_PENABLED) {
                 dbg("wacom_graphire_irq: received unknown report #%d", data[0]);
-                return 0;
+                goto exit;
         }
 
-        if (data[1] & 0x80) {
-                /* in prox and not a pad data */
-                penData = 1;
-
-                switch ((data[1] >> 5) & 3) {
+        prox = data[1] & 0x80;
+        if (prox || wacom->id[0]) {
+                if (prox) {
+                        switch ((data[1] >> 5) & 3) {
 
                         case 0: /* Pen */
                                 wacom->tool[0] = BTN_TOOL_PEN;
@@ -178,133 +221,93 @@ static int wacom_graphire_irq(struct wacom_wac *wacom, void *wcombo)
                                 break;
 
                         case 2: /* Mouse with wheel */
-                                wacom_report_key(wcombo, BTN_MIDDLE, data[1] & 0x04);
-                                if (wacom->features->type == WACOM_G4 ||
-                                                wacom->features->type == WACOM_MO) {
-                                        rw = data[7] & 0x04 ? (data[7] & 0x03)-4 : (data[7] & 0x03);
-                                        wacom_report_rel(wcombo, REL_WHEEL, -rw);
-                                } else
-                                        wacom_report_rel(wcombo, REL_WHEEL, -(signed char) data[6]);
+                                input_report_key(input, BTN_MIDDLE, data[1] & 0x04);
                                 /* fall through */
 
                         case 3: /* Mouse without wheel */
                                 wacom->tool[0] = BTN_TOOL_MOUSE;
                                 wacom->id[0] = CURSOR_DEVICE_ID;
-                                wacom_report_key(wcombo, BTN_LEFT, data[1] & 0x01);
-                                wacom_report_key(wcombo, BTN_RIGHT, data[1] & 0x02);
-                                if (wacom->features->type == WACOM_G4 ||
-                                                wacom->features->type == WACOM_MO)
-                                        wacom_report_abs(wcombo, ABS_DISTANCE, data[6] & 0x3f);
-                                else
-                                        wacom_report_abs(wcombo, ABS_DISTANCE, data[7] & 0x3f);
                                 break;
+                        }
                 }
-                x = wacom_le16_to_cpu(&data[2]);
-                y = wacom_le16_to_cpu(&data[4]);
-                wacom_report_abs(wcombo, ABS_X, x);
-                wacom_report_abs(wcombo, ABS_Y, y);
+                input_report_abs(input, ABS_X, le16_to_cpup((__le16 *)&data[2]));
+                input_report_abs(input, ABS_Y, le16_to_cpup((__le16 *)&data[4]));
                 if (wacom->tool[0] != BTN_TOOL_MOUSE) {
-                        wacom_report_abs(wcombo, ABS_PRESSURE, data[6] | ((data[7] & 0x01) << 8));
-                        wacom_report_key(wcombo, BTN_TOUCH, data[1] & 0x01);
-                        wacom_report_key(wcombo, BTN_STYLUS, data[1] & 0x02);
-                        wacom_report_key(wcombo, BTN_STYLUS2, data[1] & 0x04);
-                }
-                wacom_report_abs(wcombo, ABS_MISC, wacom->id[0]); /* report tool id */
-                wacom_report_key(wcombo, wacom->tool[0], 1);
-        } else if (wacom->id[0]) {
-                wacom_report_abs(wcombo, ABS_X, 0);
-                wacom_report_abs(wcombo, ABS_Y, 0);
-                if (wacom->tool[0] == BTN_TOOL_MOUSE) {
-                        wacom_report_key(wcombo, BTN_LEFT, 0);
-                        wacom_report_key(wcombo, BTN_RIGHT, 0);
-                        wacom_report_abs(wcombo, ABS_DISTANCE, 0);
+                        input_report_abs(input, ABS_PRESSURE, data[6] | ((data[7] & 0x01) << 8));
+                        input_report_key(input, BTN_TOUCH, data[1] & 0x01);
+                        input_report_key(input, BTN_STYLUS, data[1] & 0x02);
+                        input_report_key(input, BTN_STYLUS2, data[1] & 0x04);
                 } else {
-                        wacom_report_abs(wcombo, ABS_PRESSURE, 0);
-                        wacom_report_key(wcombo, BTN_TOUCH, 0);
-                        wacom_report_key(wcombo, BTN_STYLUS, 0);
-                        wacom_report_key(wcombo, BTN_STYLUS2, 0);
+                        input_report_key(input, BTN_LEFT, data[1] & 0x01);
+                        input_report_key(input, BTN_RIGHT, data[1] & 0x02);
+                        if (features->type == WACOM_G4 ||
+                                        features->type == WACOM_MO) {
+                                input_report_abs(input, ABS_DISTANCE, data[6] & 0x3f);
+                                rw = (data[7] & 0x04) - (data[7] & 0x03);
+                        } else {
+                                input_report_abs(input, ABS_DISTANCE, data[7] & 0x3f);
+                                rw = -(signed char)data[6];
+                        }
+                        input_report_rel(input, REL_WHEEL, rw);
                 }
-                wacom->id[0] = 0;
-                wacom_report_abs(wcombo, ABS_MISC, 0); /* reset tool id */
-                wacom_report_key(wcombo, wacom->tool[0], 0);
+
+                if (!prox)
+                        wacom->id[0] = 0;
+                input_report_abs(input, ABS_MISC, wacom->id[0]); /* report tool id */
+                input_report_key(input, wacom->tool[0], prox);
+                input_sync(input); /* sync last event */
         }
 
         /* send pad data */
-        switch (wacom->features->type) {
-            case WACOM_G4:
-                if (data[7] & 0xf8) {
-                        if (penData) {
-                                wacom_input_sync(wcombo); /* sync last event */
-                                if (!wacom->id[0])
-                                        penData = 0;
-                        }
+        switch (features->type) {
+        case WACOM_G4:
+                prox = data[7] & 0xf8;
+                if (prox || wacom->id[1]) {
                         wacom->id[1] = PAD_DEVICE_ID;
-                        wacom_report_key(wcombo, BTN_0, (data[7] & 0x40));
-                        wacom_report_key(wcombo, BTN_4, (data[7] & 0x80));
+                        input_report_key(input, BTN_0, (data[7] & 0x40));
+                        input_report_key(input, BTN_4, (data[7] & 0x80));
                         rw = ((data[7] & 0x18) >> 3) - ((data[7] & 0x20) >> 3);
-                        wacom_report_rel(wcombo, REL_WHEEL, rw);
-                        wacom_report_key(wcombo, BTN_TOOL_FINGER, 0xf0);
-                        wacom_report_abs(wcombo, ABS_MISC, wacom->id[1]);
-                        wacom_input_event(wcombo, EV_MSC, MSC_SERIAL, 0xf0);
-                } else if (wacom->id[1]) {
-                        if (penData) {
-                                wacom_input_sync(wcombo); /* sync last event */
-                                if (!wacom->id[0])
-                                        penData = 0;
-                        }
-                        wacom->id[1] = 0;
-                        wacom_report_key(wcombo, BTN_0, (data[7] & 0x40));
-                        wacom_report_key(wcombo, BTN_4, (data[7] & 0x80));
-                        wacom_report_rel(wcombo, REL_WHEEL, 0);
-                        wacom_report_key(wcombo, BTN_TOOL_FINGER, 0);
-                        wacom_report_abs(wcombo, ABS_MISC, 0);
-                        wacom_input_event(wcombo, EV_MSC, MSC_SERIAL, 0xf0);
+                        input_report_rel(input, REL_WHEEL, rw);
+                        input_report_key(input, BTN_TOOL_FINGER, 0xf0);
+                        if (!prox)
+                                wacom->id[1] = 0;
+                        input_report_abs(input, ABS_MISC, wacom->id[1]);
+                        input_event(input, EV_MSC, MSC_SERIAL, 0xf0);
+                        retval = 1;
                 }
                 break;
-            case WACOM_MO:
-                if ((data[7] & 0xf8) || (data[8] & 0xff)) {
-                        if (penData) {
-                                wacom_input_sync(wcombo); /* sync last event */
-                                if (!wacom->id[0])
-                                        penData = 0;
-                        }
+
+        case WACOM_MO:
+                prox = (data[7] & 0xf8) || data[8];
+                if (prox || wacom->id[1]) {
                         wacom->id[1] = PAD_DEVICE_ID;
-                        wacom_report_key(wcombo, BTN_0, (data[7] & 0x08));
-                        wacom_report_key(wcombo, BTN_1, (data[7] & 0x20));
-                        wacom_report_key(wcombo, BTN_4, (data[7] & 0x10));
-                        wacom_report_key(wcombo, BTN_5, (data[7] & 0x40));
-                        wacom_report_abs(wcombo, ABS_WHEEL, (data[8] & 0x7f));
-                        wacom_report_key(wcombo, BTN_TOOL_FINGER, 0xf0);
-                        wacom_report_abs(wcombo, ABS_MISC, wacom->id[1]);
-                        wacom_input_event(wcombo, EV_MSC, MSC_SERIAL, 0xf0);
-                } else if (wacom->id[1]) {
-                        if (penData) {
-                                wacom_input_sync(wcombo); /* sync last event */
-                                if (!wacom->id[0])
-                                        penData = 0;
-                        }
-                        wacom->id[1] = 0;
-                        wacom_report_key(wcombo, BTN_0, (data[7] & 0x08));
-                        wacom_report_key(wcombo, BTN_1, (data[7] & 0x20));
-                        wacom_report_key(wcombo, BTN_4, (data[7] & 0x10));
-                        wacom_report_key(wcombo, BTN_5, (data[7] & 0x40));
-                        wacom_report_abs(wcombo, ABS_WHEEL, (data[8] & 0x7f));
-                        wacom_report_key(wcombo, BTN_TOOL_FINGER, 0);
-                        wacom_report_abs(wcombo, ABS_MISC, 0);
-                        wacom_input_event(wcombo, EV_MSC, MSC_SERIAL, 0xf0);
+                        input_report_key(input, BTN_0, (data[7] & 0x08));
+                        input_report_key(input, BTN_1, (data[7] & 0x20));
+                        input_report_key(input, BTN_4, (data[7] & 0x10));
+                        input_report_key(input, BTN_5, (data[7] & 0x40));
+                        input_report_abs(input, ABS_WHEEL, (data[8] & 0x7f));
+                        input_report_key(input, BTN_TOOL_FINGER, 0xf0);
+                        if (!prox)
+                                wacom->id[1] = 0;
+                        input_report_abs(input, ABS_MISC, wacom->id[1]);
+                        input_event(input, EV_MSC, MSC_SERIAL, 0xf0);
                 }
+                retval = 1;
                 break;
         }
-        return 1;
+exit:
+        return retval;
 }
 
-static int wacom_intuos_inout(struct wacom_wac *wacom, void *wcombo)
+static int wacom_intuos_inout(struct wacom_wac *wacom)
 {
+        struct wacom_features *features = &wacom->features;
         unsigned char *data = wacom->data;
+        struct input_dev *input = wacom->input;
         int idx = 0;
 
         /* tool number */
-        if (wacom->features->type == INTUOS)
+        if (features->type == INTUOS)
                 idx = data[1] & 0x01;
 
         /* Enter report */
@@ -314,139 +317,159 @@ static int wacom_intuos_inout(struct wacom_wac *wacom, void *wcombo)
                         (data[4] << 20) + (data[5] << 12) +
                         (data[6] << 4) + (data[7] >> 4);
 
-                wacom->id[idx] = (data[2] << 4) | (data[3] >> 4);
-                switch (wacom->id[idx]) {
-                        case 0x812: /* Inking pen */
-                        case 0x801: /* Intuos3 Inking pen */
-                        case 0x20802: /* Intuos4 Classic Pen */
-                        case 0x012:
-                                wacom->tool[idx] = BTN_TOOL_PENCIL;
-                                break;
-                        case 0x822: /* Pen */
-                        case 0x842:
-                        case 0x852:
-                        case 0x823: /* Intuos3 Grip Pen */
-                        case 0x813: /* Intuos3 Classic Pen */
-                        case 0x885: /* Intuos3 Marker Pen */
-                        case 0x802: /* Intuos4 Grip Pen Eraser */
-                        case 0x804: /* Intuos4 Marker Pen */
-                        case 0x40802: /* Intuos4 Classic Pen */
-                        case 0x022:
-                                wacom->tool[idx] = BTN_TOOL_PEN;
-                                break;
-                        case 0x832: /* Stroke pen */
-                        case 0x032:
-                                wacom->tool[idx] = BTN_TOOL_BRUSH;
-                                break;
-                        case 0x007: /* Mouse 4D and 2D */
-                        case 0x09c:
-                        case 0x094:
-                        case 0x017: /* Intuos3 2D Mouse */
-                        case 0x806: /* Intuos4 Mouse */
-                                wacom->tool[idx] = BTN_TOOL_MOUSE;
-                                break;
-                        case 0x096: /* Lens cursor */
-                        case 0x097: /* Intuos3 Lens cursor */
-                        case 0x006: /* Intuos4 Lens cursor */
-                                wacom->tool[idx] = BTN_TOOL_LENS;
-                                break;
-                        case 0x82a: /* Eraser */
-                        case 0x85a:
-                        case 0x91a:
-                        case 0xd1a:
-                        case 0x0fa:
-                        case 0x82b: /* Intuos3 Grip Pen Eraser */
-                        case 0x81b: /* Intuos3 Classic Pen Eraser */
-                        case 0x91b: /* Intuos3 Airbrush Eraser */
-                        case 0x80c: /* Intuos4 Marker Pen Eraser */
-                        case 0x80a: /* Intuos4 Grip Pen Eraser */
-                        case 0x4080a: /* Intuos4 Classic Pen Eraser */
-                        case 0x90a: /* Intuos4 Airbrush Eraser */
-                                wacom->tool[idx] = BTN_TOOL_RUBBER;
-                                break;
-                        case 0xd12:
-                        case 0x912:
-                        case 0x112:
-                        case 0x913: /* Intuos3 Airbrush */
-                        case 0x902: /* Intuos4 Airbrush */
-                                wacom->tool[idx] = BTN_TOOL_AIRBRUSH;
-                                break;
-                        default: /* Unknown tool */
-                                wacom->tool[idx] = BTN_TOOL_PEN;
+                wacom->id[idx] = (data[2] << 4) | (data[3] >> 4) |
+                        ((data[7] & 0x0f) << 20) | ((data[8] & 0xf0) << 12);
+
+                switch (wacom->id[idx] & 0xfffff) {
+                case 0x812: /* Inking pen */
+                case 0x801: /* Intuos3 Inking pen */
+                case 0x20802: /* Intuos4 Inking Pen */
+                case 0x012:
+                        wacom->tool[idx] = BTN_TOOL_PENCIL;
+                        break;
+
+                case 0x822: /* Pen */
+                case 0x842:
+                case 0x852:
+                case 0x823: /* Intuos3 Grip Pen */
+                case 0x813: /* Intuos3 Classic Pen */
+                case 0x885: /* Intuos3 Marker Pen */
+                case 0x802: /* Intuos4 General Pen */
+                case 0x804: /* Intuos4 Marker Pen */
+                case 0x40802: /* Intuos4 Classic Pen */
+                case 0x022:
+                        wacom->tool[idx] = BTN_TOOL_PEN;
+                        break;
+
+                case 0x832: /* Stroke pen */
+                case 0x032:
+                        wacom->tool[idx] = BTN_TOOL_BRUSH;
+                        break;
+
+                case 0x007: /* Mouse 4D and 2D */
+                case 0x09c:
+                case 0x094:
+                case 0x017: /* Intuos3 2D Mouse */
+                case 0x806: /* Intuos4 Mouse */
+                        wacom->tool[idx] = BTN_TOOL_MOUSE;
+                        break;
+
+                case 0x096: /* Lens cursor */
+                case 0x097: /* Intuos3 Lens cursor */
+                case 0x006: /* Intuos4 Lens cursor */
+                        wacom->tool[idx] = BTN_TOOL_LENS;
+                        break;
+
+                case 0x82a: /* Eraser */
+                case 0x85a:
+                case 0x91a:
+                case 0xd1a:
+                case 0x0fa:
+                case 0x82b: /* Intuos3 Grip Pen Eraser */
+                case 0x81b: /* Intuos3 Classic Pen Eraser */
+                case 0x91b: /* Intuos3 Airbrush Eraser */
+                case 0x80c: /* Intuos4 Marker Pen Eraser */
+                case 0x80a: /* Intuos4 General Pen Eraser */
+                case 0x4080a: /* Intuos4 Classic Pen Eraser */
+                case 0x90a: /* Intuos4 Airbrush Eraser */
+                        wacom->tool[idx] = BTN_TOOL_RUBBER;
+                        break;
+
+                case 0xd12:
+                case 0x912:
+                case 0x112:
+                case 0x913: /* Intuos3 Airbrush */
+                case 0x902: /* Intuos4 Airbrush */
+                        wacom->tool[idx] = BTN_TOOL_AIRBRUSH;
+                        break;
+
+                default: /* Unknown tool */
+                        wacom->tool[idx] = BTN_TOOL_PEN;
+                        break;
                 }
                 return 1;
         }
 
+        /* older I4 styli don't work with new Cintiqs */
+        if (!((wacom->id[idx] >> 20) & 0x01) &&
+                        (features->type == WACOM_21UX2))
+                return 1;
+
         /* Exit report */
         if ((data[1] & 0xfe) == 0x80) {
                 /*
                  * Reset all states otherwise we lose the initial states
                  * when in-prox next time
                  */
-                wacom_report_abs(wcombo, ABS_X, 0);
-                wacom_report_abs(wcombo, ABS_Y, 0);
-                wacom_report_abs(wcombo, ABS_DISTANCE, 0);
-                wacom_report_abs(wcombo, ABS_TILT_X, 0);
-                wacom_report_abs(wcombo, ABS_TILT_Y, 0);
+                input_report_abs(input, ABS_X, 0);
+                input_report_abs(input, ABS_Y, 0);
+                input_report_abs(input, ABS_DISTANCE, 0);
+                input_report_abs(input, ABS_TILT_X, 0);
+                input_report_abs(input, ABS_TILT_Y, 0);
                 if (wacom->tool[idx] >= BTN_TOOL_MOUSE) {
-                        wacom_report_key(wcombo, BTN_LEFT, 0);
-                        wacom_report_key(wcombo, BTN_MIDDLE, 0);
-                        wacom_report_key(wcombo, BTN_RIGHT, 0);
-                        wacom_report_key(wcombo, BTN_SIDE, 0);
-                        wacom_report_key(wcombo, BTN_EXTRA, 0);
-                        wacom_report_abs(wcombo, ABS_THROTTLE, 0);
-                        wacom_report_abs(wcombo, ABS_RZ, 0);
+                        input_report_key(input, BTN_LEFT, 0);
+                        input_report_key(input, BTN_MIDDLE, 0);
+                        input_report_key(input, BTN_RIGHT, 0);
+                        input_report_key(input, BTN_SIDE, 0);
+                        input_report_key(input, BTN_EXTRA, 0);
+                        input_report_abs(input, ABS_THROTTLE, 0);
+                        input_report_abs(input, ABS_RZ, 0);
                 } else {
-                        wacom_report_abs(wcombo, ABS_PRESSURE, 0);
-                        wacom_report_key(wcombo, BTN_STYLUS, 0);
-                        wacom_report_key(wcombo, BTN_STYLUS2, 0);
-                        wacom_report_key(wcombo, BTN_TOUCH, 0);
-                        wacom_report_abs(wcombo, ABS_WHEEL, 0);
-                        if (wacom->features->type >= INTUOS3S)
-                                wacom_report_abs(wcombo, ABS_Z, 0);
+                        input_report_abs(input, ABS_PRESSURE, 0);
+                        input_report_key(input, BTN_STYLUS, 0);
+                        input_report_key(input, BTN_STYLUS2, 0);
+                        input_report_key(input, BTN_TOUCH, 0);
+                        input_report_abs(input, ABS_WHEEL, 0);
+                        if (features->type >= INTUOS3S)
+                                input_report_abs(input, ABS_Z, 0);
                 }
-                wacom_report_key(wcombo, wacom->tool[idx], 0);
-                wacom_report_abs(wcombo, ABS_MISC, 0); /* reset tool id */
-                wacom_input_event(wcombo, EV_MSC, MSC_SERIAL, wacom->serial[idx]);
+                input_report_key(input, wacom->tool[idx], 0);
+                input_report_abs(input, ABS_MISC, 0); /* reset tool id */
+                input_event(input, EV_MSC, MSC_SERIAL, wacom->serial[idx]);
                 wacom->id[idx] = 0;
                 return 2;
         }
         return 0;
 }
 
-static void wacom_intuos_general(struct wacom_wac *wacom, void *wcombo)
+static void wacom_intuos_general(struct wacom_wac *wacom)
 {
+        struct wacom_features *features = &wacom->features;
         unsigned char *data = wacom->data;
+        struct input_dev *input = wacom->input;
         unsigned int t;
 
         /* general pen packet */
         if ((data[1] & 0xb8) == 0xa0) {
                 t = (data[6] << 2) | ((data[7] >> 6) & 3);
-                if (wacom->features->type >= INTUOS4S && wacom->features->type <= INTUOS4L)
+                if ((features->type >= INTUOS4S && features->type <= INTUOS4L) ||
+                    features->type == WACOM_21UX2) {
                         t = (t << 1) | (data[1] & 1);
-                wacom_report_abs(wcombo, ABS_PRESSURE, t);
-                wacom_report_abs(wcombo, ABS_TILT_X,
+                }
+                input_report_abs(input, ABS_PRESSURE, t);
+                input_report_abs(input, ABS_TILT_X,
                                 ((data[7] << 1) & 0x7e) | (data[8] >> 7));
-                wacom_report_abs(wcombo, ABS_TILT_Y, data[8] & 0x7f);
-                wacom_report_key(wcombo, BTN_STYLUS, data[1] & 2);
-                wacom_report_key(wcombo, BTN_STYLUS2, data[1] & 4);
-                wacom_report_key(wcombo, BTN_TOUCH, t > 10);
+                input_report_abs(input, ABS_TILT_Y, data[8] & 0x7f);
+                input_report_key(input, BTN_STYLUS, data[1] & 2);
+                input_report_key(input, BTN_STYLUS2, data[1] & 4);
+                input_report_key(input, BTN_TOUCH, t > 10);
         }
 
         /* airbrush second packet */
         if ((data[1] & 0xbc) == 0xb4) {
-                wacom_report_abs(wcombo, ABS_WHEEL,
+                input_report_abs(input, ABS_WHEEL,
                                 (data[6] << 2) | ((data[7] >> 6) & 3));
-                wacom_report_abs(wcombo, ABS_TILT_X,
+                input_report_abs(input, ABS_TILT_X,
                                 ((data[7] << 1) & 0x7e) | (data[8] >> 7));
-                wacom_report_abs(wcombo, ABS_TILT_Y, data[8] & 0x7f);
+                input_report_abs(input, ABS_TILT_Y, data[8] & 0x7f);
         }
-        return;
 }
 
-static int wacom_intuos_irq(struct wacom_wac *wacom, void *wcombo)
+static int wacom_intuos_irq(struct wacom_wac *wacom)
 {
+        struct wacom_features *features = &wacom->features;
         unsigned char *data = wacom->data;
+        struct input_dev *input = wacom->input;
         unsigned int t;
         int idx = 0, result;
 
@@ -457,7 +480,7 @@ static int wacom_intuos_irq(struct wacom_wac *wacom, void *wcombo)
         }
 
         /* tool number */
-        if (wacom->features->type == INTUOS)
+        if (features->type == INTUOS)
                 idx = data[1] & 0x01;
 
         /* pad packets. Works as a second tool and is always in prox */
@@ -466,269 +489,311 @@ static int wacom_intuos_irq(struct wacom_wac *wacom, void *wcombo)
                 if (wacom->tool[1] != BTN_TOOL_FINGER)
                         wacom->tool[1] = BTN_TOOL_FINGER;
 
-                if (wacom->features->type >= INTUOS4S && wacom->features->type <= INTUOS4L) {
-                        wacom_report_key(wcombo, BTN_0, (data[2] & 0x01));
-                        wacom_report_key(wcombo, BTN_1, (data[3] & 0x01));
-                        wacom_report_key(wcombo, BTN_2, (data[3] & 0x02));
-                        wacom_report_key(wcombo, BTN_3, (data[3] & 0x04));
-                        wacom_report_key(wcombo, BTN_4, (data[3] & 0x08));
-                        wacom_report_key(wcombo, BTN_5, (data[3] & 0x10));
-                        wacom_report_key(wcombo, BTN_6, (data[3] & 0x20));
+                if (features->type >= INTUOS4S && features->type <= INTUOS4L) {
+                        input_report_key(input, BTN_0, (data[2] & 0x01));
+                        input_report_key(input, BTN_1, (data[3] & 0x01));
+                        input_report_key(input, BTN_2, (data[3] & 0x02));
+                        input_report_key(input, BTN_3, (data[3] & 0x04));
+                        input_report_key(input, BTN_4, (data[3] & 0x08));
+                        input_report_key(input, BTN_5, (data[3] & 0x10));
+                        input_report_key(input, BTN_6, (data[3] & 0x20));
                         if (data[1] & 0x80) {
-                                wacom_report_abs(wcombo, ABS_WHEEL, (data[1] & 0x7f));
+                                input_report_abs(input, ABS_WHEEL, (data[1] & 0x7f));
                         } else {
                                 /* Out of proximity, clear wheel value. */
-                                wacom_report_abs(wcombo, ABS_WHEEL, 0);
+                                input_report_abs(input, ABS_WHEEL, 0);
                         }
-                        if (wacom->features->type != INTUOS4S) {
-                                wacom_report_key(wcombo, BTN_7, (data[3] & 0x40));
-                                wacom_report_key(wcombo, BTN_8, (data[3] & 0x80));
+                        if (features->type != INTUOS4S) {
+                                input_report_key(input, BTN_7, (data[3] & 0x40));
+                                input_report_key(input, BTN_8, (data[3] & 0x80));
                         }
                         if (data[1] | (data[2] & 0x01) | data[3]) {
-                                wacom_report_key(wcombo, wacom->tool[1], 1);
-                                wacom_report_abs(wcombo, ABS_MISC, PAD_DEVICE_ID);
+                                input_report_key(input, wacom->tool[1], 1);
+                                input_report_abs(input, ABS_MISC, PAD_DEVICE_ID);
                         } else {
-                                wacom_report_key(wcombo, wacom->tool[1], 0);
-                                wacom_report_abs(wcombo, ABS_MISC, 0);
+                                input_report_key(input, wacom->tool[1], 0);
+                                input_report_abs(input, ABS_MISC, 0);
                         }
                 } else {
-                        wacom_report_key(wcombo, BTN_0, (data[5] & 0x01));
-                        wacom_report_key(wcombo, BTN_1, (data[5] & 0x02));
-                        wacom_report_key(wcombo, BTN_2, (data[5] & 0x04));
-                        wacom_report_key(wcombo, BTN_3, (data[5] & 0x08));
-                        wacom_report_key(wcombo, BTN_4, (data[6] & 0x01));
-                        wacom_report_key(wcombo, BTN_5, (data[6] & 0x02));
-                        wacom_report_key(wcombo, BTN_6, (data[6] & 0x04));
-                        wacom_report_key(wcombo, BTN_7, (data[6] & 0x08));
-                        wacom_report_key(wcombo, BTN_8, (data[5] & 0x10));
-                        wacom_report_key(wcombo, BTN_9, (data[6] & 0x10));
-                        wacom_report_abs(wcombo, ABS_RX, ((data[1] & 0x1f) << 8) | data[2]);
-                        wacom_report_abs(wcombo, ABS_RY, ((data[3] & 0x1f) << 8) | data[4]);
-
-                        if ((data[5] & 0x1f) | (data[6] & 0x1f) | (data[1] & 0x1f) |
-                                data[2] | (data[3] & 0x1f) | data[4]) {
-                                wacom_report_key(wcombo, wacom->tool[1], 1);
-                                wacom_report_abs(wcombo, ABS_MISC, PAD_DEVICE_ID);
+                        if (features->type == WACOM_21UX2) {
+                                input_report_key(input, BTN_0, (data[5] & 0x01));
+                                input_report_key(input, BTN_1, (data[6] & 0x01));
+                                input_report_key(input, BTN_2, (data[6] & 0x02));
+                                input_report_key(input, BTN_3, (data[6] & 0x04));
+                                input_report_key(input, BTN_4, (data[6] & 0x08));
+                                input_report_key(input, BTN_5, (data[6] & 0x10));
+                                input_report_key(input, BTN_6, (data[6] & 0x20));
+                                input_report_key(input, BTN_7, (data[6] & 0x40));
+                                input_report_key(input, BTN_8, (data[6] & 0x80));
+                                input_report_key(input, BTN_9, (data[7] & 0x01));
+                                input_report_key(input, BTN_A, (data[8] & 0x01));
+                                input_report_key(input, BTN_B, (data[8] & 0x02));
+                                input_report_key(input, BTN_C, (data[8] & 0x04));
+                                input_report_key(input, BTN_X, (data[8] & 0x08));
+                                input_report_key(input, BTN_Y, (data[8] & 0x10));
+                                input_report_key(input, BTN_Z, (data[8] & 0x20));
+                                input_report_key(input, BTN_BASE, (data[8] & 0x40));
+                                input_report_key(input, BTN_BASE2, (data[8] & 0x80));
+                        } else {
+                                input_report_key(input, BTN_0, (data[5] & 0x01));
+                                input_report_key(input, BTN_1, (data[5] & 0x02));
+                                input_report_key(input, BTN_2, (data[5] & 0x04));
+                                input_report_key(input, BTN_3, (data[5] & 0x08));
+                                input_report_key(input, BTN_4, (data[6] & 0x01));
+                                input_report_key(input, BTN_5, (data[6] & 0x02));
+                                input_report_key(input, BTN_6, (data[6] & 0x04));
+                                input_report_key(input, BTN_7, (data[6] & 0x08));
+                                input_report_key(input, BTN_8, (data[5] & 0x10));
+                                input_report_key(input, BTN_9, (data[6] & 0x10));
+                        }
+                        input_report_abs(input, ABS_RX, ((data[1] & 0x1f) << 8) | data[2]);
+                        input_report_abs(input, ABS_RY, ((data[3] & 0x1f) << 8) | data[4]);
+
+                        if ((data[5] & 0x1f) | data[6] | (data[1] & 0x1f) |
+                                data[2] | (data[3] & 0x1f) | data[4] | data[8] |
+                                (data[7] & 0x01)) {
+                                input_report_key(input, wacom->tool[1], 1);
+                                input_report_abs(input, ABS_MISC, PAD_DEVICE_ID);
                         } else {
-                                wacom_report_key(wcombo, wacom->tool[1], 0);
-                                wacom_report_abs(wcombo, ABS_MISC, 0);
+                                input_report_key(input, wacom->tool[1], 0);
+                                input_report_abs(input, ABS_MISC, 0);
                         }
                 }
-                wacom_input_event(wcombo, EV_MSC, MSC_SERIAL, 0xffffffff);
+                input_event(input, EV_MSC, MSC_SERIAL, 0xffffffff);
                 return 1;
         }
 
         /* process in/out prox events */
-        result = wacom_intuos_inout(wacom, wcombo);
+        result = wacom_intuos_inout(wacom);
         if (result)
-                return result-1;
+                return result - 1;
 
         /* don't proceed if we don't know the ID */
         if (!wacom->id[idx])
                 return 0;
 
         /* Only large Intuos support Lense Cursor */
-        if ((wacom->tool[idx] == BTN_TOOL_LENS)
-                        && ((wacom->features->type == INTUOS3)
-                        || (wacom->features->type == INTUOS3S)
-                        || (wacom->features->type == INTUOS4)
-                        || (wacom->features->type == INTUOS4S)))
+        if (wacom->tool[idx] == BTN_TOOL_LENS &&
+            (features->type == INTUOS3 ||
+             features->type == INTUOS3S ||
+             features->type == INTUOS4 ||
+             features->type == INTUOS4S)) {
+
                 return 0;
+        }
 
         /* Cintiq doesn't send data when RDY bit isn't set */
-        if ((wacom->features->type == CINTIQ) && !(data[1] & 0x40))
+        if (features->type == CINTIQ && !(data[1] & 0x40))
                  return 0;
 
-        if (wacom->features->type >= INTUOS3S) {
-                wacom_report_abs(wcombo, ABS_X, (data[2] << 9) | (data[3] << 1) | ((data[9] >> 1) & 1));
-                wacom_report_abs(wcombo, ABS_Y, (data[4] << 9) | (data[5] << 1) | (data[9] & 1));
-                wacom_report_abs(wcombo, ABS_DISTANCE, ((data[9] >> 2) & 0x3f));
+        if (features->type >= INTUOS3S) {
+                input_report_abs(input, ABS_X, (data[2] << 9) | (data[3] << 1) | ((data[9] >> 1) & 1));
+                input_report_abs(input, ABS_Y, (data[4] << 9) | (data[5] << 1) | (data[9] & 1));
+                input_report_abs(input, ABS_DISTANCE, ((data[9] >> 2) & 0x3f));
         } else {
-                wacom_report_abs(wcombo, ABS_X, wacom_be16_to_cpu(&data[2]));
-                wacom_report_abs(wcombo, ABS_Y, wacom_be16_to_cpu(&data[4]));
-                wacom_report_abs(wcombo, ABS_DISTANCE, ((data[9] >> 3) & 0x1f));
+                input_report_abs(input, ABS_X, be16_to_cpup((__be16 *)&data[2]));
+                input_report_abs(input, ABS_Y, be16_to_cpup((__be16 *)&data[4]));
+                input_report_abs(input, ABS_DISTANCE, ((data[9] >> 3) & 0x1f));
         }
 
         /* process general packets */
-        wacom_intuos_general(wacom, wcombo);
+        wacom_intuos_general(wacom);
 
         /* 4D mouse, 2D mouse, marker pen rotation, tilt mouse, or Lens cursor packets */
         if ((data[1] & 0xbc) == 0xa8 || (data[1] & 0xbe) == 0xb0 || (data[1] & 0xbc) == 0xac) {
 
                 if (data[1] & 0x02) {
                         /* Rotation packet */
-                        if (wacom->features->type >= INTUOS3S) {
+                        if (features->type >= INTUOS3S) {
                                 /* I3 marker pen rotation */
                                 t = (data[6] << 3) | ((data[7] >> 5) & 7);
                                 t = (data[7] & 0x20) ? ((t > 900) ? ((t-1) / 2 - 1350) :
                                         ((t-1) / 2 + 450)) : (450 - t / 2) ;
-                                wacom_report_abs(wcombo, ABS_Z, t);
+                                input_report_abs(input, ABS_Z, t);
                         } else {
                                 /* 4D mouse rotation packet */
                                 t = (data[6] << 3) | ((data[7] >> 5) & 7);
-                                wacom_report_abs(wcombo, ABS_RZ, (data[7] & 0x20) ?
+                                input_report_abs(input, ABS_RZ, (data[7] & 0x20) ?
                                         ((t - 1) / 2) : -t / 2);
                         }
 
-                } else if (!(data[1] & 0x10) && wacom->features->type < INTUOS3S) {
+                } else if (!(data[1] & 0x10) && features->type < INTUOS3S) {
                         /* 4D mouse packet */
-                        wacom_report_key(wcombo, BTN_LEFT,   data[8] & 0x01);
-                        wacom_report_key(wcombo, BTN_MIDDLE, data[8] & 0x02);
-                        wacom_report_key(wcombo, BTN_RIGHT,  data[8] & 0x04);
+                        input_report_key(input, BTN_LEFT,   data[8] & 0x01);
+                        input_report_key(input, BTN_MIDDLE, data[8] & 0x02);
+                        input_report_key(input, BTN_RIGHT,  data[8] & 0x04);
 
-                        wacom_report_key(wcombo, BTN_SIDE,   data[8] & 0x20);
-                        wacom_report_key(wcombo, BTN_EXTRA,  data[8] & 0x10);
+                        input_report_key(input, BTN_SIDE,   data[8] & 0x20);
+                        input_report_key(input, BTN_EXTRA,  data[8] & 0x10);
                         t = (data[6] << 2) | ((data[7] >> 6) & 3);
-                        wacom_report_abs(wcombo, ABS_THROTTLE, (data[8] & 0x08) ? -t : t);
+                        input_report_abs(input, ABS_THROTTLE, (data[8] & 0x08) ? -t : t);
 
                 } else if (wacom->tool[idx] == BTN_TOOL_MOUSE) {
                         /* I4 mouse */
-                        if (wacom->features->type >= INTUOS4S && wacom->features->type <= INTUOS4L) {
-                                wacom_report_key(wcombo, BTN_LEFT,   data[6] & 0x01);
-                                wacom_report_key(wcombo, BTN_MIDDLE, data[6] & 0x02);
-                                wacom_report_key(wcombo, BTN_RIGHT,  data[6] & 0x04);
-                                wacom_report_rel(wcombo, REL_WHEEL, ((data[7] & 0x80) >> 7)
+                        if (features->type >= INTUOS4S && features->type <= INTUOS4L) {
+                                input_report_key(input, BTN_LEFT,   data[6] & 0x01);
+                                input_report_key(input, BTN_MIDDLE, data[6] & 0x02);
+                                input_report_key(input, BTN_RIGHT,  data[6] & 0x04);
+                                input_report_rel(input, REL_WHEEL, ((data[7] & 0x80) >> 7)
                                                  - ((data[7] & 0x40) >> 6));
-                                wacom_report_key(wcombo, BTN_SIDE,   data[6] & 0x08);
-                                wacom_report_key(wcombo, BTN_EXTRA,  data[6] & 0x10);
+                                input_report_key(input, BTN_SIDE,   data[6] & 0x08);
+                                input_report_key(input, BTN_EXTRA,  data[6] & 0x10);
 
-                                wacom_report_abs(wcombo, ABS_TILT_X,
+                                input_report_abs(input, ABS_TILT_X,
                                         ((data[7] << 1) & 0x7e) | (data[8] >> 7));
-                                wacom_report_abs(wcombo, ABS_TILT_Y, data[8] & 0x7f);
+                                input_report_abs(input, ABS_TILT_Y, data[8] & 0x7f);
                         } else {
                                 /* 2D mouse packet */
-                                wacom_report_key(wcombo, BTN_LEFT,   data[8] & 0x04);
-                                wacom_report_key(wcombo, BTN_MIDDLE, data[8] & 0x08);
-                                wacom_report_key(wcombo, BTN_RIGHT,  data[8] & 0x10);
-                                wacom_report_rel(wcombo, REL_WHEEL, (data[8] & 0x01)
+                                input_report_key(input, BTN_LEFT,   data[8] & 0x04);
+                                input_report_key(input, BTN_MIDDLE, data[8] & 0x08);
+                                input_report_key(input, BTN_RIGHT,  data[8] & 0x10);
+                                input_report_rel(input, REL_WHEEL, (data[8] & 0x01)
                                                  - ((data[8] & 0x02) >> 1));
 
                                 /* I3 2D mouse side buttons */
-                                if (wacom->features->type >= INTUOS3S && wacom->features->type <= INTUOS3L) {
-                                        wacom_report_key(wcombo, BTN_SIDE,   data[8] & 0x40);
-                                        wacom_report_key(wcombo, BTN_EXTRA,  data[8] & 0x20);
+                                if (features->type >= INTUOS3S && features->type <= INTUOS3L) {
+                                        input_report_key(input, BTN_SIDE,   data[8] & 0x40);
+                                        input_report_key(input, BTN_EXTRA,  data[8] & 0x20);
                                 }
                         }
-                } else if ((wacom->features->type < INTUOS3S || wacom->features->type == INTUOS3L ||
-                                wacom->features->type == INTUOS4L) &&
+                } else if ((features->type < INTUOS3S || features->type == INTUOS3L ||
+                                features->type == INTUOS4L) &&
                            wacom->tool[idx] == BTN_TOOL_LENS) {
                         /* Lens cursor packets */
-                        wacom_report_key(wcombo, BTN_LEFT,   data[8] & 0x01);
-                        wacom_report_key(wcombo, BTN_MIDDLE, data[8] & 0x02);
-                        wacom_report_key(wcombo, BTN_RIGHT,  data[8] & 0x04);
-                        wacom_report_key(wcombo, BTN_SIDE,   data[8] & 0x10);
-                        wacom_report_key(wcombo, BTN_EXTRA,  data[8] & 0x08);
+                        input_report_key(input, BTN_LEFT,   data[8] & 0x01);
+                        input_report_key(input, BTN_MIDDLE, data[8] & 0x02);
+                        input_report_key(input, BTN_RIGHT,  data[8] & 0x04);
+                        input_report_key(input, BTN_SIDE,   data[8] & 0x10);
+                        input_report_key(input, BTN_EXTRA,  data[8] & 0x08);
                 }
         }
 
-        wacom_report_abs(wcombo, ABS_MISC, wacom->id[idx]); /* report tool id */
-        wacom_report_key(wcombo, wacom->tool[idx], 1);
-        wacom_input_event(wcombo, EV_MSC, MSC_SERIAL, wacom->serial[idx]);
+        input_report_abs(input, ABS_MISC, wacom->id[idx]); /* report tool id */
+        input_report_key(input, wacom->tool[idx], 1);
+        input_event(input, EV_MSC, MSC_SERIAL, wacom->serial[idx]);
         return 1;
 }
 
 
-static void wacom_tpc_finger_in(struct wacom_wac *wacom, void *wcombo, char *data, int idx)
+static void wacom_tpc_finger_in(struct wacom_wac *wacom, char *data, int idx)
 {
-        wacom_report_abs(wcombo, ABS_X,
-                (data[2 + idx * 2] & 0xff) | ((data[3 + idx * 2] & 0x7f) << 8));
-        wacom_report_abs(wcombo, ABS_Y,
-                (data[6 + idx * 2] & 0xff) | ((data[7 + idx * 2] & 0x7f) << 8));
-        wacom_report_abs(wcombo, ABS_MISC, wacom->id[0]);
-        wacom_report_key(wcombo, wacom->tool[idx], 1);
-        if (idx)
-                wacom_input_event(wcombo, EV_MSC, MSC_SERIAL, 0xf0);
-        else
-                wacom_report_key(wcombo, BTN_TOUCH, 1);
+        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;
+
+        /*
+         * 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++;
+
+                if (y == input_abs_get_val(input, ABS_Y))
+                        y++;
+        }
+
+        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);
+
+        wacom->last_finger = finger;
 }
 
-static void wacom_tpc_touch_out(struct wacom_wac *wacom, void *wcombo, int idx)
+static void wacom_tpc_touch_out(struct wacom_wac *wacom, int idx)
 {
-        wacom_report_abs(wcombo, ABS_X, 0);
-        wacom_report_abs(wcombo, ABS_Y, 0);
-        wacom_report_abs(wcombo, ABS_MISC, 0);
-        wacom_report_key(wcombo, wacom->tool[idx], 0);
-        if (idx)
-                wacom_input_event(wcombo, EV_MSC, MSC_SERIAL, 0xf0);
-        else
-                wacom_report_key(wcombo, BTN_TOUCH, 0);
-        return;
+        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);
 }
 
-static void wacom_tpc_touch_in(struct wacom_wac *wacom, void *wcombo)
+static void wacom_tpc_touch_in(struct wacom_wac *wacom, size_t len)
 {
         char *data = wacom->data;
-        struct urb *urb = ((struct wacom_combo *)wcombo)->urb;
-        static int firstFinger = 0;
-        static int secondFinger = 0;
+        struct input_dev *input = wacom->input;
 
-        wacom->tool[0] = BTN_TOOL_DOUBLETAP;
+        wacom->tool[1] = BTN_TOOL_DOUBLETAP;
         wacom->id[0] = TOUCH_DEVICE_ID;
-        wacom->tool[1] = BTN_TOOL_TRIPLETAP;
+        wacom->tool[2] = BTN_TOOL_TRIPLETAP;
+
+        if (len != WACOM_PKGLEN_TPC1FG) {
 
-        if (urb->actual_length != WACOM_PKGLEN_TPC1FG) {
                 switch (data[0]) {
-                        case WACOM_REPORT_TPC1FG:
-                                wacom_report_abs(wcombo, ABS_X, wacom_le16_to_cpu(&data[2]));
-                                wacom_report_abs(wcombo, ABS_Y, wacom_le16_to_cpu(&data[4]));
-                                wacom_report_abs(wcombo, ABS_PRESSURE, wacom_le16_to_cpu(&data[6]));
-                                wacom_report_key(wcombo, BTN_TOUCH, wacom_le16_to_cpu(&data[6]));
-                                wacom_report_abs(wcombo, ABS_MISC, wacom->id[0]);
-                                wacom_report_key(wcombo, wacom->tool[0], 1);
-                                break;
-                        case WACOM_REPORT_TPC2FG:
-                                /* keep this byte to send proper out-prox event */
-                                wacom->id[1] = data[1] & 0x03;
-
-                                if (data[1] & 0x01) {
-                                        wacom_tpc_finger_in(wacom, wcombo, data, 0);
-                                        firstFinger = 1;
-                                } else if (firstFinger) {
-                                        wacom_tpc_touch_out(wacom, wcombo, 0);
-                                }
 
-                                if (data[1] & 0x02) {
-                                        /* sync first finger data */
-                                        if (firstFinger)
-                                                wacom_input_sync(wcombo);
+                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;
 
-                                        wacom_tpc_finger_in(wacom, wcombo, data, 1);
-                                        secondFinger = 1;
-                                } else if (secondFinger) {
-                                        /* sync first finger data */
-                                        if (firstFinger)
-                                                wacom_input_sync(wcombo);
+                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);
 
-                                        wacom_tpc_touch_out(wacom, wcombo, 1);
-                                        secondFinger = 0;
-                                }
-                                if (!(data[1] & 0x01))
-                                        firstFinger = 0;
-                                break;
+                        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 {
-                wacom_report_abs(wcombo, ABS_X, wacom_le16_to_cpu(&data[1]));
-                wacom_report_abs(wcombo, ABS_Y, wacom_le16_to_cpu(&data[3]));
-                wacom_report_key(wcombo, BTN_TOUCH, 1);
-                wacom_report_abs(wcombo, ABS_MISC, wacom->id[0]);
-                wacom_report_key(wcombo, wacom->tool[0], 1);
+                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);
         }
-        return;
 }
 
-static int wacom_tpc_irq(struct wacom_wac *wacom, void *wcombo)
+static int wacom_tpc_irq(struct wacom_wac *wacom, size_t len)
 {
+        struct wacom_features *features = &wacom->features;
         char *data = wacom->data;
-        int prox = 0, pressure, idx = -1;
-        static int stylusInProx, touchInProx = 1, touchOut;
-        struct urb *urb = ((struct wacom_combo *)wcombo)->urb;
+        struct input_dev *input = wacom->input;
+        int prox = 0, pressure;
+        int retval = 0;
 
         dbg("wacom_tpc_irq: received report #%d", data[0]);
 
-        if (urb->actual_length == WACOM_PKGLEN_TPC1FG || /* single touch */
+        if (len == WACOM_PKGLEN_TPC1FG ||                /* single touch */
             data[0] == WACOM_REPORT_TPC1FG ||            /* single touch */
             data[0] == WACOM_REPORT_TPC2FG) {            /* 2FG touch */
-                if (urb->actual_length == WACOM_PKGLEN_TPC1FG) {  /* with touch */
+
+                if (wacom->shared->stylus_in_proximity) {
+                        if (wacom->id[1] & 0x01)
+                                wacom_tpc_touch_out(wacom, 0);
+
+                        if (wacom->id[1] & 0x02)
+                                wacom_tpc_touch_out(wacom, 1);
+
+                        wacom->id[1] = 0;
+                        return 0;
+                }
+
+                if (len == WACOM_PKGLEN_TPC1FG) {       /* with touch */
                         prox = data[0] & 0x01;
                 } else {  /* with capacity */
                         if (data[0] == WACOM_REPORT_TPC1FG)
@@ -739,317 +804,715 @@ static int wacom_tpc_irq(struct wacom_wac *wacom, void *wcombo)
                                 prox = data[1] & 0x03;
                 }
 
-                if (!stylusInProx) { /* stylus not in prox */
-                        if (prox) {
-                                if (touchInProx) {
-                                        wacom_tpc_touch_in(wacom, wcombo);
-                                        touchOut = 1;
-                                        return 1;
-                                }
-                        } else {
+                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 (data[0] == WACOM_REPORT_TPC2FG) {
-                                        idx = (wacom->id[1] & 0x01) - 1;
-                                        if (idx == 0) {
-                                                wacom_tpc_touch_out(wacom, wcombo, idx);
-                                                /* sync first finger event */
-                                                if (wacom->id[1] & 0x02)
-                                                        wacom_input_sync(wcombo);
-                                        }
-                                        idx = (wacom->id[1] & 0x02) - 1;
-                                        if (idx == 1)
-                                                wacom_tpc_touch_out(wacom, wcombo, idx);
-                                } else /* one finger touch */
-                                        wacom_tpc_touch_out(wacom, wcombo, 0);
-                                touchOut = 0;
-                                touchInProx = 1;
-                                return 1;
-                        }
-                } else if (touchOut || !prox) { /* force touch out-prox */
-                        wacom_tpc_touch_out(wacom, wcombo, 0);
-                        touchOut = 0;
-                        touchInProx = 1;
-                        return 1;
+                                if (wacom->id[1] & 0x01)
+                                        wacom_tpc_touch_out(wacom, 0);
+
+                                if (wacom->id[1] & 0x02)
+                                        wacom_tpc_touch_out(wacom, 1);
+                        } else
+                                /* one finger touch */
+                                wacom_tpc_touch_out(wacom, 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;
 
-                touchInProx = 0;
+                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;
 
-                if (prox) { /* in prox */
-                        if (!wacom->id[0]) {
-                                /* 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;
+                        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;
+        }
+        return retval;
+}
+
+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 sp = 0, sx = 0, sy = 0, count = 0;
+        int i;
+
+        for (i = 0; i < 2; i++) {
+                int p = data[9 * i + 2];
+                input_mt_slot(input, i);
+                /*
+                 * 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 (p && !wacom->shared->stylus_in_proximity) {
+                        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;
                         }
-                        wacom_report_key(wcombo, BTN_STYLUS, data[1] & 0x02);
-                        wacom_report_key(wcombo, BTN_STYLUS2, data[1] & 0x10);
-                        wacom_report_abs(wcombo, ABS_X, wacom_le16_to_cpu(&data[2]));
-                        wacom_report_abs(wcombo, ABS_Y, wacom_le16_to_cpu(&data[4]));
-                        pressure = ((data[7] & 0x01) << 8) | data[6];
-                        if (pressure < 0)
-                                pressure = wacom->features->pressure_max + pressure + 1;
-                        wacom_report_abs(wcombo, ABS_PRESSURE, pressure);
-                        wacom_report_key(wcombo, BTN_TOUCH, data[1] & 0x05);
+                        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 (wacom->id[i] < 0)
+                                wacom->id[i] = wacom->trk_id++ & MAX_TRACKING_ID;
+                        if (!count++)
+                                sp = p, sx = x, sy = y;
                 } else {
-                        wacom_report_abs(wcombo, ABS_X, 0);
-                        wacom_report_abs(wcombo, ABS_Y, 0);
-                        wacom_report_abs(wcombo, ABS_PRESSURE, 0);
-                        wacom_report_key(wcombo, BTN_STYLUS, 0);
-                        wacom_report_key(wcombo, BTN_STYLUS2, 0);
-                        wacom_report_key(wcombo, BTN_TOUCH, 0);
-                        wacom->id[0] = 0;
-                        /* pen is out so touch can be enabled now */
-                        touchInProx = 1;
+                        wacom->id[i] = -1;
                 }
-                wacom_report_key(wcombo, wacom->tool[0], prox);
-                wacom_report_abs(wcombo, ABS_MISC, wacom->id[0]);
-                stylusInProx = prox;
-                return 1;
+                input_report_abs(input, ABS_MT_TRACKING_ID, wacom->id[i]);
         }
+
+        input_report_key(input, BTN_TOUCH, count > 0);
+        input_report_key(input, BTN_TOOL_FINGER, count == 1);
+        input_report_key(input, BTN_TOOL_DOUBLETAP, count == 2);
+
+        input_report_abs(input, ABS_PRESSURE, sp);
+        input_report_abs(input, ABS_X, sx);
+        input_report_abs(input, ABS_Y, sy);
+
+        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);
+
+        input_sync(input);
+
         return 0;
 }
 
-int wacom_wac_irq(struct wacom_wac *wacom_wac, void *wcombo)
+static int wacom_bpt_pen(struct wacom_wac *wacom)
 {
-        switch (wacom_wac->features->type) {
-                case PENPARTNER:
-                        return wacom_penpartner_irq(wacom_wac, wcombo);
-
-                case PL:
-                        return wacom_pl_irq(wacom_wac, wcombo);
-
-                case WACOM_G4:
-                case GRAPHIRE:
-                case WACOM_MO:
-                        return wacom_graphire_irq(wacom_wac, wcombo);
-
-                case PTU:
-                        return wacom_ptu_irq(wacom_wac, wcombo);
-
-                case INTUOS:
-                case INTUOS3S:
-                case INTUOS3:
-                case INTUOS3L:
-                case INTUOS4S:
-                case INTUOS4:
-                case INTUOS4L:
-                case CINTIQ:
-                case WACOM_BEE:
-                        return wacom_intuos_irq(wacom_wac, wcombo);
-
-                case TABLETPC:
-                case TABLETPC2FG:
-                        return wacom_tpc_irq(wacom_wac, wcombo);
-
-                default:
-                        return 0;
+        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;
+                }
+                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;
         }
+
+        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_init_input_dev(struct input_dev *input_dev, struct wacom_wac *wacom_wac)
+void wacom_wac_irq(struct wacom_wac *wacom_wac, size_t len)
 {
-        switch (wacom_wac->features->type) {
-                case WACOM_MO:
-                        input_dev_mo(input_dev, wacom_wac);
-                case WACOM_G4:
-                        input_dev_g4(input_dev, wacom_wac);
-                        /* fall through */
-                case GRAPHIRE:
-                        input_dev_g(input_dev, wacom_wac);
-                        break;
-                case WACOM_BEE:
-                        input_dev_bee(input_dev, wacom_wac);
-                case INTUOS3:
-                case INTUOS3L:
-                case CINTIQ:
-                        input_dev_i3(input_dev, wacom_wac);
-                        /* fall through */
-                case INTUOS3S:
-                        input_dev_i3s(input_dev, wacom_wac);
-                        /* fall through */
-                case INTUOS:
-                        input_dev_i(input_dev, wacom_wac);
-                        break;
-                case INTUOS4:
-                case INTUOS4L:
-                        input_dev_i4(input_dev, wacom_wac);
-                        /* fall through */
-                case INTUOS4S:
-                        input_dev_i4s(input_dev, wacom_wac);
-                        input_dev_i(input_dev, wacom_wac);
-                        break;
-                case TABLETPC2FG:
-                        input_dev_tpc2fg(input_dev, wacom_wac);
-                        /* fall through */
-                case TABLETPC:
-                        input_dev_tpc(input_dev, wacom_wac);
-                        if (wacom_wac->features->device_type != BTN_TOOL_PEN)
-                                break;  /* no need to process stylus stuff */
-
-                        /* fall through */
-                case PL:
-                case PTU:
-                        input_dev_pl(input_dev, wacom_wac);
-                        /* fall through */
-                case PENPARTNER:
-                        input_dev_pt(input_dev, wacom_wac);
-                        break;
+        bool sync;
+
+        switch (wacom_wac->features.type) {
+        case PENPARTNER:
+                sync = wacom_penpartner_irq(wacom_wac);
+                break;
+
+        case PL:
+                sync = wacom_pl_irq(wacom_wac);
+                break;
+
+        case WACOM_G4:
+        case GRAPHIRE:
+        case WACOM_MO:
+                sync = wacom_graphire_irq(wacom_wac);
+                break;
+
+        case PTU:
+                sync = wacom_ptu_irq(wacom_wac);
+                break;
+
+        case DTU:
+                sync = wacom_dtu_irq(wacom_wac);
+                break;
+
+        case INTUOS:
+        case INTUOS3S:
+        case INTUOS3:
+        case INTUOS3L:
+        case INTUOS4S:
+        case INTUOS4:
+        case INTUOS4L:
+        case CINTIQ:
+        case WACOM_BEE:
+        case WACOM_21UX2:
+                sync = wacom_intuos_irq(wacom_wac);
+                break;
+
+        case TABLETPC:
+        case TABLETPC2FG:
+                sync = wacom_tpc_irq(wacom_wac, len);
+                break;
+
+        case BAMBOO_PT:
+                sync = wacom_bpt_irq(wacom_wac, len);
+                break;
+
+        default:
+                sync = false;
+                break;
         }
-        return;
+
+        if (sync)
+                input_sync(wacom_wac->input);
 }
 
-static struct wacom_features wacom_features[] = {
-        { "Wacom Penpartner",     WACOM_PKGLEN_PENPRTN,    5040,  3780,  255,  0, PENPARTNER },
-        { "Wacom Graphire",       WACOM_PKGLEN_GRAPHIRE,  10206,  7422,  511, 63, GRAPHIRE },
-        { "Wacom Graphire2 4x5",  WACOM_PKGLEN_GRAPHIRE,  10206,  7422,  511, 63, GRAPHIRE },
-        { "Wacom Graphire2 5x7",  WACOM_PKGLEN_GRAPHIRE,  13918, 10206,  511, 63, GRAPHIRE },
-        { "Wacom Graphire3",      WACOM_PKGLEN_GRAPHIRE,  10208,  7424,  511, 63, GRAPHIRE },
-        { "Wacom Graphire3 6x8",  WACOM_PKGLEN_GRAPHIRE,  16704, 12064,  511, 63, GRAPHIRE },
-        { "Wacom Graphire4 4x5",  WACOM_PKGLEN_GRAPHIRE,  10208,  7424,  511, 63, WACOM_G4 },
-        { "Wacom Graphire4 6x8",  WACOM_PKGLEN_GRAPHIRE,  16704, 12064,  511, 63, WACOM_G4 },
-        { "Wacom BambooFun 4x5",  WACOM_PKGLEN_BBFUN,     14760,  9225,  511, 63, WACOM_MO },
-        { "Wacom BambooFun 6x8",  WACOM_PKGLEN_BBFUN,     21648, 13530,  511, 63, WACOM_MO },
-        { "Wacom Bamboo1 Medium", WACOM_PKGLEN_GRAPHIRE,  16704, 12064,  511, 63, GRAPHIRE },
-        { "Wacom Volito",         WACOM_PKGLEN_GRAPHIRE,   5104,  3712,  511, 63, GRAPHIRE },
-        { "Wacom PenStation2",    WACOM_PKGLEN_GRAPHIRE,   3250,  2320,  255, 63, GRAPHIRE },
-        { "Wacom Volito2 4x5",    WACOM_PKGLEN_GRAPHIRE,   5104,  3712,  511, 63, GRAPHIRE },
-        { "Wacom Volito2 2x3",    WACOM_PKGLEN_GRAPHIRE,   3248,  2320,  511, 63, GRAPHIRE },
-        { "Wacom PenPartner2",    WACOM_PKGLEN_GRAPHIRE,   3250,  2320,  511, 63, GRAPHIRE },
-        { "Wacom Bamboo",         WACOM_PKGLEN_BBFUN,     14760,  9225,  511, 63, WACOM_MO },
-        { "Wacom Bamboo1",        WACOM_PKGLEN_GRAPHIRE,   5104,  3712,  511, 63, GRAPHIRE },
-        { "Wacom Intuos 4x5",     WACOM_PKGLEN_INTUOS,    12700, 10600, 1023, 31, INTUOS },
-        { "Wacom Intuos 6x8",     WACOM_PKGLEN_INTUOS,    20320, 16240, 1023, 31, INTUOS },
-        { "Wacom Intuos 9x12",    WACOM_PKGLEN_INTUOS,    30480, 24060, 1023, 31, INTUOS },
-        { "Wacom Intuos 12x12",   WACOM_PKGLEN_INTUOS,    30480, 31680, 1023, 31, INTUOS },
-        { "Wacom Intuos 12x18",   WACOM_PKGLEN_INTUOS,    45720, 31680, 1023, 31, INTUOS },
-        { "Wacom PL400",          WACOM_PKGLEN_GRAPHIRE,   5408,  4056,  255,  0, PL },
-        { "Wacom PL500",          WACOM_PKGLEN_GRAPHIRE,   6144,  4608,  255,  0, PL },
-        { "Wacom PL600",          WACOM_PKGLEN_GRAPHIRE,   6126,  4604,  255,  0, PL },
-        { "Wacom PL600SX",        WACOM_PKGLEN_GRAPHIRE,   6260,  5016,  255,  0, PL },
-        { "Wacom PL550",          WACOM_PKGLEN_GRAPHIRE,   6144,  4608,  511,  0, PL },
-        { "Wacom PL800",          WACOM_PKGLEN_GRAPHIRE,   7220,  5780,  511,  0, PL },
-        { "Wacom PL700",          WACOM_PKGLEN_GRAPHIRE,   6758,  5406,  511,  0, PL },
-        { "Wacom PL510",          WACOM_PKGLEN_GRAPHIRE,   6282,  4762,  511,  0, PL },
-        { "Wacom DTU710",         WACOM_PKGLEN_GRAPHIRE,  34080, 27660,  511,  0, PL },
-        { "Wacom DTF521",         WACOM_PKGLEN_GRAPHIRE,   6282,  4762,  511,  0, PL },
-        { "Wacom DTF720",         WACOM_PKGLEN_GRAPHIRE,   6858,  5506,  511,  0, PL },
-        { "Wacom DTF720a",        WACOM_PKGLEN_GRAPHIRE,   6858,  5506,  511,  0, PL },
-        { "Wacom Cintiq Partner", WACOM_PKGLEN_GRAPHIRE,  20480, 15360,  511,  0, PTU },
-        { "Wacom Intuos2 4x5",    WACOM_PKGLEN_INTUOS,    12700, 10600, 1023, 31, INTUOS },
-        { "Wacom Intuos2 6x8",    WACOM_PKGLEN_INTUOS,    20320, 16240, 1023, 31, INTUOS },
-        { "Wacom Intuos2 9x12",   WACOM_PKGLEN_INTUOS,    30480, 24060, 1023, 31, INTUOS },
-        { "Wacom Intuos2 12x12",  WACOM_PKGLEN_INTUOS,    30480, 31680, 1023, 31, INTUOS },
-        { "Wacom Intuos2 12x18",  WACOM_PKGLEN_INTUOS,    45720, 31680, 1023, 31, INTUOS },
-        { "Wacom Intuos3 4x5",    WACOM_PKGLEN_INTUOS,    25400, 20320, 1023, 63, INTUOS3S },
-        { "Wacom Intuos3 6x8",    WACOM_PKGLEN_INTUOS,    40640, 30480, 1023, 63, INTUOS3 },
-        { "Wacom Intuos3 9x12",   WACOM_PKGLEN_INTUOS,    60960, 45720, 1023, 63, INTUOS3 },
-        { "Wacom Intuos3 12x12",  WACOM_PKGLEN_INTUOS,    60960, 60960, 1023, 63, INTUOS3L },
-        { "Wacom Intuos3 12x19",  WACOM_PKGLEN_INTUOS,    97536, 60960, 1023, 63, INTUOS3L },
-        { "Wacom Intuos3 6x11",   WACOM_PKGLEN_INTUOS,    54204, 31750, 1023, 63, INTUOS3 },
-        { "Wacom Intuos3 4x6",    WACOM_PKGLEN_INTUOS,    31496, 19685, 1023, 63, INTUOS3S },
-        { "Wacom Intuos4 4x6",    WACOM_PKGLEN_INTUOS,    31496, 19685, 2047, 63, INTUOS4S },
-        { "Wacom Intuos4 6x9",    WACOM_PKGLEN_INTUOS,    44704, 27940, 2047, 63, INTUOS4 },
-        { "Wacom Intuos4 8x13",   WACOM_PKGLEN_INTUOS,    65024, 40640, 2047, 63, INTUOS4L },
-        { "Wacom Intuos4 12x19",  WACOM_PKGLEN_INTUOS,    97536, 60960, 2047, 63, INTUOS4L },
-        { "Wacom Cintiq 21UX",    WACOM_PKGLEN_INTUOS,    87200, 65600, 1023, 63, CINTIQ },
-        { "Wacom Cintiq 20WSX",   WACOM_PKGLEN_INTUOS,    86680, 54180, 1023, 63, WACOM_BEE },
-        { "Wacom Cintiq 12WX",    WACOM_PKGLEN_INTUOS,    53020, 33440, 1023, 63, WACOM_BEE },
-        { "Wacom DTU1931",        WACOM_PKGLEN_GRAPHIRE,  37832, 30305,  511,  0, PL },
-        { "Wacom ISDv4 90",       WACOM_PKGLEN_GRAPHIRE,  26202, 16325,  255,  0, TABLETPC },
-        { "Wacom ISDv4 93",       WACOM_PKGLEN_GRAPHIRE,  26202, 16325,  255,  0, TABLETPC },
-        { "Wacom ISDv4 9A",       WACOM_PKGLEN_GRAPHIRE,  26202, 16325,  255,  0, TABLETPC },
-        { "Wacom ISDv4 9F",       WACOM_PKGLEN_PENABLED,  26202, 16325,  255,  0, TABLETPC },
-        { "Wacom ISDv4 E2",       WACOM_PKGLEN_TPC2FG,    26202, 16325,  255,  0, TABLETPC2FG },
-        { "Wacom ISDv4 E3",       WACOM_PKGLEN_TPC2FG,    26202, 16325,  255,  0, TABLETPC2FG },
-        { "Wacom Intuos2 6x8",    WACOM_PKGLEN_INTUOS,    20320, 16240, 1023, 31, INTUOS },
-        { }
-};
+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);
+
+        __set_bit(BTN_TOOL_RUBBER, input_dev->keybit);
+        __set_bit(BTN_TOOL_PEN, 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_STYLUS, input_dev->keybit);
+        __set_bit(BTN_STYLUS2, input_dev->keybit);
+
+        input_set_abs_params(input_dev, ABS_DISTANCE,
+                             0, wacom_wac->features.distance_max, 0, 0);
+        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 struct usb_device_id wacom_ids[] = {
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x00) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x10) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x11) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x12) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x13) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x14) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x15) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x16) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x17) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x18) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x19) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x60) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x61) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x62) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x63) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x64) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x65) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x69) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x20) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x21) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x22) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x23) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x24) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x30) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x31) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x32) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x33) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x34) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x35) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x37) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x38) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x39) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0xC4) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0xC0) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0xC2) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x03) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x41) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x42) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x43) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x44) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x45) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0xB0) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0xB1) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0xB2) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0xB3) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0xB4) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0xB5) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0xB7) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0xB8) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0xB9) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0xBA) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0xBB) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x3F) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0xC5) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0xC6) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0xC7) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x90) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x93) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x9A) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x9F) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0xE2) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0xE3) },
-        { USB_DEVICE(USB_VENDOR_ID_WACOM, 0x47) },
-        { }
-};
+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);
 
-const struct usb_device_id *get_device_table(void)
+        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)
 {
-        const struct usb_device_id *id_table = wacom_ids;
 
-        return id_table;
+        /* 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;
+        }
+
+        /* 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_TRIPLETAP) {
+                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;
+        }
 }
 
-struct wacom_features * get_wacom_feature(const struct usb_device_id *id)
+void wacom_setup_input_capabilities(struct input_dev *input_dev,
+                                    struct wacom_wac *wacom_wac)
 {
-        int index = id - wacom_ids;
-        struct wacom_features *wf = &wacom_features[index];
+        struct wacom_features *features = &wacom_wac->features;
+        int i;
+
+        input_dev->evbit[0] |= BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
+
+        __set_bit(BTN_TOUCH, input_dev->keybit);
+
+        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);
+
+        __set_bit(ABS_MISC, input_dev->absbit);
+
+        switch (wacom_wac->features.type) {
+        case WACOM_MO:
+                __set_bit(BTN_1, input_dev->keybit);
+                __set_bit(BTN_5, input_dev->keybit);
+
+                input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0);
+                /* fall through */
+
+        case WACOM_G4:
+                input_set_capability(input_dev, EV_MSC, MSC_SERIAL);
+
+                __set_bit(BTN_TOOL_FINGER, input_dev->keybit);
+                __set_bit(BTN_0, input_dev->keybit);
+                __set_bit(BTN_4, input_dev->keybit);
+                /* fall through */
+
+        case GRAPHIRE:
+                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_TOOL_RUBBER, input_dev->keybit);
+                __set_bit(BTN_TOOL_PEN, input_dev->keybit);
+                __set_bit(BTN_TOOL_MOUSE, input_dev->keybit);
+                __set_bit(BTN_STYLUS, input_dev->keybit);
+                __set_bit(BTN_STYLUS2, input_dev->keybit);
+                break;
+
+        case WACOM_21UX2:
+                __set_bit(BTN_A, input_dev->keybit);
+                __set_bit(BTN_B, input_dev->keybit);
+                __set_bit(BTN_C, input_dev->keybit);
+                __set_bit(BTN_X, input_dev->keybit);
+                __set_bit(BTN_Y, input_dev->keybit);
+                __set_bit(BTN_Z, input_dev->keybit);
+                __set_bit(BTN_BASE, input_dev->keybit);
+                __set_bit(BTN_BASE2, input_dev->keybit);
+                /* fall through */
+
+        case WACOM_BEE:
+                __set_bit(BTN_8, input_dev->keybit);
+                __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:
+                __set_bit(BTN_4, input_dev->keybit);
+                __set_bit(BTN_5, input_dev->keybit);
+                __set_bit(BTN_6, input_dev->keybit);
+                __set_bit(BTN_7, input_dev->keybit);
+
+                input_set_abs_params(input_dev, ABS_RY, 0, 4096, 0, 0);
+                /* fall through */
+
+        case INTUOS3S:
+                __set_bit(BTN_0, input_dev->keybit);
+                __set_bit(BTN_1, input_dev->keybit);
+                __set_bit(BTN_2, input_dev->keybit);
+                __set_bit(BTN_3, 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_Z, -900, 899, 0, 0);
+                /* fall through */
+
+        case INTUOS:
+                wacom_setup_intuos(wacom_wac);
+                break;
+
+        case INTUOS4:
+        case INTUOS4L:
+                __set_bit(BTN_7, input_dev->keybit);
+                __set_bit(BTN_8, input_dev->keybit);
+                /* fall through */
+
+        case INTUOS4S:
+                for (i = 0; i < 7; i++)
+                        __set_bit(BTN_0 + i, input_dev->keybit);
+                __set_bit(BTN_TOOL_FINGER, input_dev->keybit);
+
+                input_set_abs_params(input_dev, ABS_Z, -900, 899, 0, 0);
+                wacom_setup_intuos(wacom_wac);
+                break;
 
-        return wf;
+        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);
+                }
+                /* 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);
+                }
+
+                if (features->device_type != BTN_TOOL_PEN)
+                        break;  /* no need to process stylus stuff */
+
+                /* fall through */
+
+        case PL:
+        case PTU:
+        case DTU:
+                __set_bit(BTN_TOOL_PEN, input_dev->keybit);
+                __set_bit(BTN_STYLUS, input_dev->keybit);
+                __set_bit(BTN_STYLUS2, input_dev->keybit);
+                /* fall through */
+
+        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_TRIPLETAP) {
+                        __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_create_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);
+                        input_set_abs_params(input_dev, ABS_MT_TRACKING_ID, 0,
+                                             MAX_TRACKING_ID, 0, 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 };
+static const struct wacom_features wacom_features_0x10 =
+        { "Wacom Graphire",       WACOM_PKGLEN_GRAPHIRE,  10206,  7422,  511, 63, GRAPHIRE };
+static const struct wacom_features wacom_features_0x11 =
+        { "Wacom Graphire2 4x5",  WACOM_PKGLEN_GRAPHIRE,  10206,  7422,  511, 63, GRAPHIRE };
+static const struct wacom_features wacom_features_0x12 =
+        { "Wacom Graphire2 5x7",  WACOM_PKGLEN_GRAPHIRE,  13918, 10206,  511, 63, GRAPHIRE };
+static const struct wacom_features wacom_features_0x13 =
+        { "Wacom Graphire3",      WACOM_PKGLEN_GRAPHIRE,  10208,  7424,  511, 63, GRAPHIRE };
+static const struct wacom_features wacom_features_0x14 =
+        { "Wacom Graphire3 6x8",  WACOM_PKGLEN_GRAPHIRE,  16704, 12064,  511, 63, GRAPHIRE };
+static const struct wacom_features wacom_features_0x15 =
+        { "Wacom Graphire4 4x5",  WACOM_PKGLEN_GRAPHIRE,  10208,  7424,  511, 63, WACOM_G4 };
+static const struct wacom_features wacom_features_0x16 =
+        { "Wacom Graphire4 6x8",  WACOM_PKGLEN_GRAPHIRE,  16704, 12064,  511, 63, WACOM_G4 };
+static const struct wacom_features wacom_features_0x17 =
+        { "Wacom BambooFun 4x5",  WACOM_PKGLEN_BBFUN,     14760,  9225,  511, 63, WACOM_MO };
+static const struct wacom_features wacom_features_0x18 =
+        { "Wacom BambooFun 6x8",  WACOM_PKGLEN_BBFUN,     21648, 13530,  511, 63, WACOM_MO };
+static const struct wacom_features wacom_features_0x19 =
+        { "Wacom Bamboo1 Medium", WACOM_PKGLEN_GRAPHIRE,  16704, 12064,  511, 63, GRAPHIRE };
+static const struct wacom_features wacom_features_0x60 =
+        { "Wacom Volito",         WACOM_PKGLEN_GRAPHIRE,   5104,  3712,  511, 63, GRAPHIRE };
+static const struct wacom_features wacom_features_0x61 =
+        { "Wacom PenStation2",    WACOM_PKGLEN_GRAPHIRE,   3250,  2320,  255, 63, GRAPHIRE };
+static const struct wacom_features wacom_features_0x62 =
+        { "Wacom Volito2 4x5",    WACOM_PKGLEN_GRAPHIRE,   5104,  3712,  511, 63, GRAPHIRE };
+static const struct wacom_features wacom_features_0x63 =
+        { "Wacom Volito2 2x3",    WACOM_PKGLEN_GRAPHIRE,   3248,  2320,  511, 63, GRAPHIRE };
+static const struct wacom_features wacom_features_0x64 =
+        { "Wacom PenPartner2",    WACOM_PKGLEN_GRAPHIRE,   3250,  2320,  511, 63, GRAPHIRE };
+static const struct wacom_features wacom_features_0x65 =
+        { "Wacom Bamboo",         WACOM_PKGLEN_BBFUN,     14760,  9225,  511, 63, WACOM_MO };
+static const struct wacom_features wacom_features_0x69 =
+        { "Wacom Bamboo1",        WACOM_PKGLEN_GRAPHIRE,   5104,  3712,  511, 63, GRAPHIRE };
+static const struct wacom_features wacom_features_0x20 =
+        { "Wacom Intuos 4x5",     WACOM_PKGLEN_INTUOS,    12700, 10600, 1023, 31, INTUOS };
+static const struct wacom_features wacom_features_0x21 =
+        { "Wacom Intuos 6x8",     WACOM_PKGLEN_INTUOS,    20320, 16240, 1023, 31, INTUOS };
+static const struct wacom_features wacom_features_0x22 =
+        { "Wacom Intuos 9x12",    WACOM_PKGLEN_INTUOS,    30480, 24060, 1023, 31, INTUOS };
+static const struct wacom_features wacom_features_0x23 =
+        { "Wacom Intuos 12x12",   WACOM_PKGLEN_INTUOS,    30480, 31680, 1023, 31, INTUOS };
+static const struct wacom_features wacom_features_0x24 =
+        { "Wacom Intuos 12x18",   WACOM_PKGLEN_INTUOS,    45720, 31680, 1023, 31, INTUOS };
+static const struct wacom_features wacom_features_0x30 =
+        { "Wacom PL400",          WACOM_PKGLEN_GRAPHIRE,   5408,  4056,  255,  0, PL };
+static const struct wacom_features wacom_features_0x31 =
+        { "Wacom PL500",          WACOM_PKGLEN_GRAPHIRE,   6144,  4608,  255,  0, PL };
+static const struct wacom_features wacom_features_0x32 =
+        { "Wacom PL600",          WACOM_PKGLEN_GRAPHIRE,   6126,  4604,  255,  0, PL };
+static const struct wacom_features wacom_features_0x33 =
+        { "Wacom PL600SX",        WACOM_PKGLEN_GRAPHIRE,   6260,  5016,  255,  0, PL };
+static const struct wacom_features wacom_features_0x34 =
+        { "Wacom PL550",          WACOM_PKGLEN_GRAPHIRE,   6144,  4608,  511,  0, PL };
+static const struct wacom_features wacom_features_0x35 =
+        { "Wacom PL800",          WACOM_PKGLEN_GRAPHIRE,   7220,  5780,  511,  0, PL };
+static const struct wacom_features wacom_features_0x37 =
+        { "Wacom PL700",          WACOM_PKGLEN_GRAPHIRE,   6758,  5406,  511,  0, PL };
+static const struct wacom_features wacom_features_0x38 =
+        { "Wacom PL510",          WACOM_PKGLEN_GRAPHIRE,   6282,  4762,  511,  0, PL };
+static const struct wacom_features wacom_features_0x39 =
+        { "Wacom DTU710",         WACOM_PKGLEN_GRAPHIRE,  34080, 27660,  511,  0, PL };
+static const struct wacom_features wacom_features_0xC4 =
+        { "Wacom DTF521",         WACOM_PKGLEN_GRAPHIRE,   6282,  4762,  511,  0, PL };
+static const struct wacom_features wacom_features_0xC0 =
+        { "Wacom DTF720",         WACOM_PKGLEN_GRAPHIRE,   6858,  5506,  511,  0, PL };
+static const struct wacom_features wacom_features_0xC2 =
+        { "Wacom DTF720a",        WACOM_PKGLEN_GRAPHIRE,   6858,  5506,  511,  0, PL };
+static const struct wacom_features wacom_features_0x03 =
+        { "Wacom Cintiq Partner", WACOM_PKGLEN_GRAPHIRE,  20480, 15360,  511,  0, PTU };
+static const struct wacom_features wacom_features_0x41 =
+        { "Wacom Intuos2 4x5",    WACOM_PKGLEN_INTUOS,    12700, 10600, 1023, 31, INTUOS };
+static const struct wacom_features wacom_features_0x42 =
+        { "Wacom Intuos2 6x8",    WACOM_PKGLEN_INTUOS,    20320, 16240, 1023, 31, INTUOS };
+static const struct wacom_features wacom_features_0x43 =
+        { "Wacom Intuos2 9x12",   WACOM_PKGLEN_INTUOS,    30480, 24060, 1023, 31, INTUOS };
+static const struct wacom_features wacom_features_0x44 =
+        { "Wacom Intuos2 12x12",  WACOM_PKGLEN_INTUOS,    30480, 31680, 1023, 31, INTUOS };
+static const struct wacom_features wacom_features_0x45 =
+        { "Wacom Intuos2 12x18",  WACOM_PKGLEN_INTUOS,    45720, 31680, 1023, 31, INTUOS };
+static const struct wacom_features wacom_features_0xB0 =
+        { "Wacom Intuos3 4x5",    WACOM_PKGLEN_INTUOS,    25400, 20320, 1023, 63, INTUOS3S };
+static const struct wacom_features wacom_features_0xB1 =
+        { "Wacom Intuos3 6x8",    WACOM_PKGLEN_INTUOS,    40640, 30480, 1023, 63, INTUOS3 };
+static const struct wacom_features wacom_features_0xB2 =
+        { "Wacom Intuos3 9x12",   WACOM_PKGLEN_INTUOS,    60960, 45720, 1023, 63, INTUOS3 };
+static const struct wacom_features wacom_features_0xB3 =
+        { "Wacom Intuos3 12x12",  WACOM_PKGLEN_INTUOS,    60960, 60960, 1023, 63, INTUOS3L };
+static const struct wacom_features wacom_features_0xB4 =
+        { "Wacom Intuos3 12x19",  WACOM_PKGLEN_INTUOS,    97536, 60960, 1023, 63, INTUOS3L };
+static const struct wacom_features wacom_features_0xB5 =
+        { "Wacom Intuos3 6x11",   WACOM_PKGLEN_INTUOS,    54204, 31750, 1023, 63, INTUOS3 };
+static const struct wacom_features wacom_features_0xB7 =
+        { "Wacom Intuos3 4x6",    WACOM_PKGLEN_INTUOS,    31496, 19685, 1023, 63, INTUOS3S };
+static const struct wacom_features wacom_features_0xB8 =
+        { "Wacom Intuos4 4x6",    WACOM_PKGLEN_INTUOS,    31496, 19685, 2047, 63, INTUOS4S };
+static const struct wacom_features wacom_features_0xB9 =
+        { "Wacom Intuos4 6x9",    WACOM_PKGLEN_INTUOS,    44704, 27940, 2047, 63, INTUOS4 };
+static const struct wacom_features wacom_features_0xBA =
+        { "Wacom Intuos4 8x13",   WACOM_PKGLEN_INTUOS,    65024, 40640, 2047, 63, INTUOS4L };
+static const struct wacom_features wacom_features_0xBB =
+        { "Wacom Intuos4 12x19",  WACOM_PKGLEN_INTUOS,    97536, 60960, 2047, 63, INTUOS4L };
+static const struct wacom_features wacom_features_0xBC =
+        { "Wacom Intuos4 WL",     WACOM_PKGLEN_INTUOS,    40840, 25400, 2047, 63, INTUOS4 };
+static const struct wacom_features wacom_features_0x3F =
+        { "Wacom Cintiq 21UX",    WACOM_PKGLEN_INTUOS,    87200, 65600, 1023, 63, CINTIQ };
+static const struct wacom_features wacom_features_0xC5 =
+        { "Wacom Cintiq 20WSX",   WACOM_PKGLEN_INTUOS,    86680, 54180, 1023, 63, WACOM_BEE };
+static const struct wacom_features wacom_features_0xC6 =
+        { "Wacom Cintiq 12WX",    WACOM_PKGLEN_INTUOS,    53020, 33440, 1023, 63, WACOM_BEE };
+static const struct wacom_features wacom_features_0xC7 =
+        { "Wacom DTU1931",        WACOM_PKGLEN_GRAPHIRE,  37832, 30305,  511,  0, PL };
+static const struct wacom_features wacom_features_0xCE =
+        { "Wacom DTU2231",        WACOM_PKGLEN_GRAPHIRE,  47864, 27011,  511,  0, DTU };
+static const struct wacom_features wacom_features_0xF0 =
+        { "Wacom DTU1631",        WACOM_PKGLEN_GRAPHIRE,  34623, 19553,  511,  0, DTU };
+static const struct wacom_features wacom_features_0xCC =
+        { "Wacom Cintiq 21UX2",   WACOM_PKGLEN_INTUOS,    87200, 65600, 2047, 63, WACOM_21UX2 };
+static const struct wacom_features wacom_features_0x90 =
+        { "Wacom ISDv4 90",       WACOM_PKGLEN_GRAPHIRE,  26202, 16325,  255,  0, TABLETPC };
+static const struct wacom_features wacom_features_0x93 =
+        { "Wacom ISDv4 93",       WACOM_PKGLEN_GRAPHIRE,  26202, 16325,  255,  0, TABLETPC };
+static const struct wacom_features wacom_features_0x9A =
+        { "Wacom ISDv4 9A",       WACOM_PKGLEN_GRAPHIRE,  26202, 16325,  255,  0, TABLETPC };
+static const struct wacom_features wacom_features_0x9F =
+        { "Wacom ISDv4 9F",       WACOM_PKGLEN_GRAPHIRE,  26202, 16325,  255,  0, TABLETPC };
+static const struct wacom_features wacom_features_0xE2 =
+        { "Wacom ISDv4 E2",       WACOM_PKGLEN_TPC2FG,    26202, 16325,  255,  0, TABLETPC2FG };
+static const struct wacom_features wacom_features_0xE3 =
+        { "Wacom ISDv4 E3",       WACOM_PKGLEN_TPC2FG,    26202, 16325,  255,  0, TABLETPC2FG };
+static const struct wacom_features wacom_features_0x47 =
+        { "Wacom Intuos2 6x8",    WACOM_PKGLEN_INTUOS,    20320, 16240, 1023, 31, INTUOS };
+static struct wacom_features wacom_features_0xD0 =
+        { "Wacom Bamboo 2FG",     WACOM_PKGLEN_BBFUN,     14720,  9200, 1023, 63, BAMBOO_PT };
+static struct wacom_features wacom_features_0xD1 =
+        { "Wacom Bamboo 2FG 4x5", WACOM_PKGLEN_BBFUN,     14720,  9200, 1023, 63, BAMBOO_PT };
+static struct wacom_features wacom_features_0xD2 =
+        { "Wacom Bamboo Craft",   WACOM_PKGLEN_BBFUN,     14720,  9200, 1023, 63, BAMBOO_PT };
+static struct wacom_features wacom_features_0xD3 =
+        { "Wacom Bamboo 2FG 6x8", WACOM_PKGLEN_BBFUN,     21648, 13530, 1023, 63, BAMBOO_PT };
+
+#define USB_DEVICE_WACOM(prod)                                  \
+        USB_DEVICE(USB_VENDOR_ID_WACOM, prod),                  \
+        .driver_info = (kernel_ulong_t)&wacom_features_##prod
+
+const struct usb_device_id wacom_ids[] = {
+        { USB_DEVICE_WACOM(0x00) },
+        { USB_DEVICE_WACOM(0x10) },
+        { USB_DEVICE_WACOM(0x11) },
+        { USB_DEVICE_WACOM(0x12) },
+        { USB_DEVICE_WACOM(0x13) },
+        { USB_DEVICE_WACOM(0x14) },
+        { USB_DEVICE_WACOM(0x15) },
+        { USB_DEVICE_WACOM(0x16) },
+        { USB_DEVICE_WACOM(0x17) },
+        { USB_DEVICE_WACOM(0x18) },
+        { USB_DEVICE_WACOM(0x19) },
+        { USB_DEVICE_WACOM(0x60) },
+        { USB_DEVICE_WACOM(0x61) },
+        { USB_DEVICE_WACOM(0x62) },
+        { USB_DEVICE_WACOM(0x63) },
+        { USB_DEVICE_WACOM(0x64) },
+        { USB_DEVICE_WACOM(0x65) },
+        { USB_DEVICE_WACOM(0x69) },
+        { USB_DEVICE_WACOM(0x20) },
+        { USB_DEVICE_WACOM(0x21) },
+        { USB_DEVICE_WACOM(0x22) },
+        { USB_DEVICE_WACOM(0x23) },
+        { USB_DEVICE_WACOM(0x24) },
+        { USB_DEVICE_WACOM(0x30) },
+        { USB_DEVICE_WACOM(0x31) },
+        { USB_DEVICE_WACOM(0x32) },
+        { USB_DEVICE_WACOM(0x33) },
+        { USB_DEVICE_WACOM(0x34) },
+        { USB_DEVICE_WACOM(0x35) },
+        { USB_DEVICE_WACOM(0x37) },
+        { USB_DEVICE_WACOM(0x38) },
+        { USB_DEVICE_WACOM(0x39) },
+        { USB_DEVICE_WACOM(0xC4) },
+        { USB_DEVICE_WACOM(0xC0) },
+        { USB_DEVICE_WACOM(0xC2) },
+        { USB_DEVICE_WACOM(0x03) },
+        { USB_DEVICE_WACOM(0x41) },
+        { USB_DEVICE_WACOM(0x42) },
+        { USB_DEVICE_WACOM(0x43) },
+        { USB_DEVICE_WACOM(0x44) },
+        { USB_DEVICE_WACOM(0x45) },
+        { USB_DEVICE_WACOM(0xB0) },
+        { USB_DEVICE_WACOM(0xB1) },
+        { USB_DEVICE_WACOM(0xB2) },
+        { USB_DEVICE_WACOM(0xB3) },
+        { USB_DEVICE_WACOM(0xB4) },
+        { USB_DEVICE_WACOM(0xB5) },
+        { USB_DEVICE_WACOM(0xB7) },
+        { USB_DEVICE_WACOM(0xB8) },
+        { USB_DEVICE_WACOM(0xB9) },
+        { USB_DEVICE_WACOM(0xBA) },
+        { USB_DEVICE_WACOM(0xBB) },
+        { USB_DEVICE_WACOM(0xBC) },
+        { USB_DEVICE_WACOM(0x3F) },
+        { USB_DEVICE_WACOM(0xC5) },
+        { 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(0xF0) },
+        { USB_DEVICE_WACOM(0xCC) },
+        { USB_DEVICE_WACOM(0x90) },
+        { USB_DEVICE_WACOM(0x93) },
+        { USB_DEVICE_WACOM(0x9A) },
+        { USB_DEVICE_WACOM(0x9F) },
+        { USB_DEVICE_WACOM(0xE2) },
+        { USB_DEVICE_WACOM(0xE3) },
+        { USB_DEVICE_WACOM(0x47) },
+        { }
+};
 MODULE_DEVICE_TABLE(usb, wacom_ids);
diff --git a/drivers/input/tablet/wacom_wac.h b/drivers/input/tablet/wacom_wac.h
index ee01e1902785..00ca01541d89 100644
--- a/drivers/input/tablet/wacom_wac.h
+++ b/drivers/input/tablet/wacom_wac.h
@@ -9,17 +9,19 @@
 #ifndef WACOM_WAC_H
 #define WACOM_WAC_H
 
+#include <linux/types.h>
+
 /* maximum packet length for USB devices */
 #define WACOM_PKGLEN_MAX        32
 
 /* packet length for individual models */
 #define WACOM_PKGLEN_PENPRTN     7
 #define WACOM_PKGLEN_GRAPHIRE    8
-#define WACOM_PKGLEN_BBFUN       9
-#define WACOM_PKGLEN_INTUOS     10
-#define WACOM_PKGLEN_PENABLED    8
+#define WACOM_PKGLEN_BBFUN       9
+#define WACOM_PKGLEN_INTUOS     10
 #define WACOM_PKGLEN_TPC1FG      5
-#define WACOM_PKGLEN_TPC2FG     14
+#define WACOM_PKGLEN_TPC2FG     14
+#define WACOM_PKGLEN_BBTOUCH    20
 
 /* device IDs */
 #define STYLUS_DEVICE_ID        0x02
@@ -36,12 +38,21 @@
 #define WACOM_REPORT_TPC1FG             6
 #define WACOM_REPORT_TPC2FG             13
 
+/* device quirks */
+#define WACOM_QUIRK_MULTI_INPUT         0x0001
+#define WACOM_QUIRK_BBTOUCH_LOWRES      0x0002
+
+/* largest reported tracking id */
+#define MAX_TRACKING_ID                 0xfff
+
 enum {
         PENPARTNER = 0,
         GRAPHIRE,
         WACOM_G4,
         PTU,
         PL,
+        DTU,
+        BAMBOO_PT,
         INTUOS,
         INTUOS3S,
         INTUOS3,
@@ -49,6 +60,7 @@ enum {
         INTUOS4S,
         INTUOS4,
         INTUOS4L,
+        WACOM_21UX2,
         CINTIQ,
         WACOM_BEE,
         WACOM_MO,
@@ -58,7 +70,7 @@ enum {
 };
 
 struct wacom_features {
-        char *name;
+        const char *name;
         int pktlen;
         int x_max;
         int y_max;
@@ -70,14 +82,28 @@ struct wacom_features {
         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;
 };
 
 struct wacom_wac {
+        char name[64];
         unsigned char *data;
-        int tool[2];
-        int id[2];
-        __u32 serial[2];
-        struct wacom_features *features;
+        int tool[3];
+        int id[3];
+        __u32 serial[2];
+        int last_finger;
+        int trk_id;
+        struct wacom_features features;
+        struct wacom_shared *shared;
+        struct input_dev *input;
 };
 
 #endif
diff --git a/drivers/input/touchscreen/88pm860x-ts.c b/drivers/input/touchscreen/88pm860x-ts.c
new file mode 100644
index 000000000000..b3aebc2166ba
--- /dev/null
+++ b/drivers/input/touchscreen/88pm860x-ts.c
@@ -0,0 +1,237 @@
+/*
+ * Touchscreen driver for Marvell 88PM860x
+ *
+ * Copyright (C) 2009 Marvell International Ltd.
+ *      Haojian Zhuang <haojian.zhuang@marvell.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.
+ */
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/i2c.h>
+#include <linux/input.h>
+#include <linux/mfd/88pm860x.h>
+#include <linux/slab.h>
+
+#define MEAS_LEN                (8)
+#define ACCURATE_BIT            (12)
+
+/* touch register */
+#define MEAS_EN3                (0x52)
+
+#define MEAS_TSIX_1             (0x8D)
+#define MEAS_TSIX_2             (0x8E)
+#define MEAS_TSIY_1             (0x8F)
+#define MEAS_TSIY_2             (0x90)
+#define MEAS_TSIZ1_1            (0x91)
+#define MEAS_TSIZ1_2            (0x92)
+#define MEAS_TSIZ2_1            (0x93)
+#define MEAS_TSIZ2_2            (0x94)
+
+/* bit definitions of touch */
+#define MEAS_PD_EN              (1 << 3)
+#define MEAS_TSIX_EN            (1 << 4)
+#define MEAS_TSIY_EN            (1 << 5)
+#define MEAS_TSIZ1_EN           (1 << 6)
+#define MEAS_TSIZ2_EN           (1 << 7)
+
+struct pm860x_touch {
+        struct input_dev *idev;
+        struct i2c_client *i2c;
+        struct pm860x_chip *chip;
+        int irq;
+        int res_x;              /* resistor of Xplate */
+};
+
+static irqreturn_t pm860x_touch_handler(int irq, void *data)
+{
+        struct pm860x_touch *touch = data;
+        struct pm860x_chip *chip = touch->chip;
+        unsigned char buf[MEAS_LEN];
+        int x, y, pen_down;
+        int z1, z2, rt = 0;
+        int ret;
+
+        ret = pm860x_bulk_read(touch->i2c, MEAS_TSIX_1, MEAS_LEN, buf);
+        if (ret < 0)
+                goto out;
+
+        pen_down = buf[1] & (1 << 6);
+        x = ((buf[0] & 0xFF) << 4) | (buf[1] & 0x0F);
+        y = ((buf[2] & 0xFF) << 4) | (buf[3] & 0x0F);
+        z1 = ((buf[4] & 0xFF) << 4) | (buf[5] & 0x0F);
+        z2 = ((buf[6] & 0xFF) << 4) | (buf[7] & 0x0F);
+
+        if (pen_down) {
+                if ((x != 0) && (z1 != 0) && (touch->res_x != 0)) {
+                        rt = z2 / z1 - 1;
+                        rt = (rt * touch->res_x * x) >> ACCURATE_BIT;
+                        dev_dbg(chip->dev, "z1:%d, z2:%d, rt:%d\n",
+                                z1, z2, rt);
+                }
+                input_report_abs(touch->idev, ABS_X, x);
+                input_report_abs(touch->idev, ABS_Y, y);
+                input_report_abs(touch->idev, ABS_PRESSURE, rt);
+                input_report_key(touch->idev, BTN_TOUCH, 1);
+                dev_dbg(chip->dev, "pen down at [%d, %d].\n", x, y);
+        } else {
+                input_report_abs(touch->idev, ABS_PRESSURE, 0);
+                input_report_key(touch->idev, BTN_TOUCH, 0);
+                dev_dbg(chip->dev, "pen release\n");
+        }
+        input_sync(touch->idev);
+
+out:
+        return IRQ_HANDLED;
+}
+
+static int pm860x_touch_open(struct input_dev *dev)
+{
+        struct pm860x_touch *touch = input_get_drvdata(dev);
+        int data, ret;
+
+        data = MEAS_PD_EN | MEAS_TSIX_EN | MEAS_TSIY_EN
+                | MEAS_TSIZ1_EN | MEAS_TSIZ2_EN;
+        ret = pm860x_set_bits(touch->i2c, MEAS_EN3, data, data);
+        if (ret < 0)
+                goto out;
+        return 0;
+out:
+        return ret;
+}
+
+static void pm860x_touch_close(struct input_dev *dev)
+{
+        struct pm860x_touch *touch = input_get_drvdata(dev);
+        int data;
+
+        data = MEAS_PD_EN | MEAS_TSIX_EN | MEAS_TSIY_EN
+                | MEAS_TSIZ1_EN | MEAS_TSIZ2_EN;
+        pm860x_set_bits(touch->i2c, MEAS_EN3, data, 0);
+}
+
+static int __devinit pm860x_touch_probe(struct platform_device *pdev)
+{
+        struct pm860x_chip *chip = dev_get_drvdata(pdev->dev.parent);
+        struct pm860x_platform_data *pm860x_pdata =             \
+                                pdev->dev.parent->platform_data;
+        struct pm860x_touch_pdata *pdata = NULL;
+        struct pm860x_touch *touch;
+        int irq, ret;
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0) {
+                dev_err(&pdev->dev, "No IRQ resource!\n");
+                return -EINVAL;
+        }
+
+        if (!pm860x_pdata) {
+                dev_err(&pdev->dev, "platform data is missing\n");
+                return -EINVAL;
+        }
+
+        pdata = pm860x_pdata->touch;
+        if (!pdata) {
+                dev_err(&pdev->dev, "touchscreen data is missing\n");
+                return -EINVAL;
+        }
+
+        touch = kzalloc(sizeof(struct pm860x_touch), GFP_KERNEL);
+        if (touch == NULL)
+                return -ENOMEM;
+        dev_set_drvdata(&pdev->dev, touch);
+
+        touch->idev = input_allocate_device();
+        if (touch->idev == NULL) {
+                dev_err(&pdev->dev, "Failed to allocate input device!\n");
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        touch->idev->name = "88pm860x-touch";
+        touch->idev->phys = "88pm860x/input0";
+        touch->idev->id.bustype = BUS_I2C;
+        touch->idev->dev.parent = &pdev->dev;
+        touch->idev->open = pm860x_touch_open;
+        touch->idev->close = pm860x_touch_close;
+        touch->chip = chip;
+        touch->i2c = (chip->id == CHIP_PM8607) ? chip->client : chip->companion;
+        touch->irq = irq + chip->irq_base;
+        touch->res_x = pdata->res_x;
+        input_set_drvdata(touch->idev, touch);
+
+        ret = request_threaded_irq(touch->irq, NULL, pm860x_touch_handler,
+                                   IRQF_ONESHOT, "touch", touch);
+        if (ret < 0)
+                goto out_irq;
+
+        __set_bit(EV_ABS, touch->idev->evbit);
+        __set_bit(ABS_X, touch->idev->absbit);
+        __set_bit(ABS_Y, touch->idev->absbit);
+        __set_bit(ABS_PRESSURE, touch->idev->absbit);
+        __set_bit(EV_SYN, touch->idev->evbit);
+        __set_bit(EV_KEY, touch->idev->evbit);
+        __set_bit(BTN_TOUCH, touch->idev->keybit);
+
+        input_set_abs_params(touch->idev, ABS_X, 0, 1 << ACCURATE_BIT, 0, 0);
+        input_set_abs_params(touch->idev, ABS_Y, 0, 1 << ACCURATE_BIT, 0, 0);
+        input_set_abs_params(touch->idev, ABS_PRESSURE, 0, 1 << ACCURATE_BIT,
+                                0, 0);
+
+        ret = input_register_device(touch->idev);
+        if (ret < 0) {
+                dev_err(chip->dev, "Failed to register touch!\n");
+                goto out_rg;
+        }
+
+        platform_set_drvdata(pdev, touch);
+        return 0;
+out_rg:
+        free_irq(touch->irq, touch);
+out_irq:
+        input_free_device(touch->idev);
+out:
+        kfree(touch);
+        return ret;
+}
+
+static int __devexit pm860x_touch_remove(struct platform_device *pdev)
+{
+        struct pm860x_touch *touch = platform_get_drvdata(pdev);
+
+        input_unregister_device(touch->idev);
+        free_irq(touch->irq, touch);
+        platform_set_drvdata(pdev, NULL);
+        kfree(touch);
+        return 0;
+}
+
+static struct platform_driver pm860x_touch_driver = {
+        .driver = {
+                .name   = "88pm860x-touch",
+                .owner  = THIS_MODULE,
+        },
+        .probe  = pm860x_touch_probe,
+        .remove = __devexit_p(pm860x_touch_remove),
+};
+
+static int __init pm860x_touch_init(void)
+{
+        return platform_driver_register(&pm860x_touch_driver);
+}
+module_init(pm860x_touch_init);
+
+static void __exit pm860x_touch_exit(void)
+{
+        platform_driver_unregister(&pm860x_touch_driver);
+}
+module_exit(pm860x_touch_exit);
+
+MODULE_DESCRIPTION("Touchscreen driver for Marvell Semiconductor 88PM860x");
+MODULE_AUTHOR("Haojian Zhuang <haojian.zhuang@marvell.com>");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:88pm860x-touch");
+
diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig
index dfafc76da4fb..06ea8da95c62 100644
--- a/drivers/input/touchscreen/Kconfig
+++ b/drivers/input/touchscreen/Kconfig
@@ -11,18 +11,31 @@ menuconfig INPUT_TOUCHSCREEN
 
 if INPUT_TOUCHSCREEN
 
+config TOUCHSCREEN_88PM860X
+        tristate "Marvell 88PM860x touchscreen"
+        depends on MFD_88PM860X
+        help
+          Say Y here if you have a 88PM860x PMIC and want to enable
+          support for the built-in touchscreen.
+
+          If unsure, say N.
+
+          To compile this driver as a module, choose M here: the
+          module will be called 88pm860x-ts.
+
 config TOUCHSCREEN_ADS7846
-        tristate "ADS7846/TSC2046 and ADS7843 based touchscreens"
+        tristate "ADS7846/TSC2046/AD7873 and AD(S)7843 based touchscreens"
         depends on SPI_MASTER
         depends on HWMON = n || HWMON
         help
           Say Y here if you have a touchscreen interface using the
-          ADS7846/TSC2046 or ADS7843 controller, and your board-specific
-          setup code includes that in its table of SPI devices.
+          ADS7846/TSC2046/AD7873 or ADS7843/AD7843 controller,
+          and your board-specific setup code includes that in its
+          table of SPI devices.
 
           If HWMON is selected, and the driver is told the reference voltage
           on your board, you will also get hwmon interfaces for the voltage
-          (and on ads7846/tsc2046, temperature) sensors of this chip.
+          (and on ads7846/tsc2046/ad7873, temperature) sensors of this chip.
 
           If unsure, say N (but it's safe to say "Y").
 
@@ -42,37 +55,36 @@ config TOUCHSCREEN_AD7877
           To compile this driver as a module, choose M here: the
           module will be called ad7877.
 
-config TOUCHSCREEN_AD7879_I2C
-        tristate "AD7879 based touchscreens: AD7879-1 I2C Interface"
-        depends on I2C
-        select TOUCHSCREEN_AD7879
+config TOUCHSCREEN_AD7879
+        tristate "Analog Devices AD7879-1/AD7889-1 touchscreen interface"
         help
-          Say Y here if you have a touchscreen interface using the
-          AD7879-1/AD7889-1 controller, and your board-specific
-          initialization code includes that in its table of I2C devices.
+          Say Y here if you want to support a touchscreen interface using
+          the AD7879-1/AD7889-1 controller.
 
-          If unsure, say N (but it's safe to say "Y").
+          You should select a bus connection too.
 
           To compile this driver as a module, choose M here: the
           module will be called ad7879.
 
+config TOUCHSCREEN_AD7879_I2C
+        tristate "support I2C bus connection"
+        depends on TOUCHSCREEN_AD7879 && I2C
+        help
+          Say Y here if you have AD7879-1/AD7889-1 hooked to an I2C bus.
+
+          To compile this driver as a module, choose M here: the
+          module will be called ad7879-i2c.
+
 config TOUCHSCREEN_AD7879_SPI
-        tristate "AD7879 based touchscreens: AD7879 SPI Interface"
-        depends on SPI_MASTER && TOUCHSCREEN_AD7879_I2C = n
-        select TOUCHSCREEN_AD7879
+        tristate "support SPI bus connection"
+        depends on TOUCHSCREEN_AD7879 && SPI_MASTER
         help
-          Say Y here if you have a touchscreen interface using the
-          AD7879/AD7889 controller, and your board-specific initialization
-          code includes that in its table of SPI devices.
+          Say Y here if you have AD7879-1/AD7889-1 hooked to a SPI bus.
 
           If unsure, say N (but it's safe to say "Y").
 
           To compile this driver as a module, choose M here: the
-          module will be called ad7879.
-
-config TOUCHSCREEN_AD7879
-        tristate
-        default n
+          module will be called ad7879-spi.
 
 config TOUCHSCREEN_BITSY
         tristate "Compaq iPAQ H3600 (Bitsy) touchscreen"
@@ -86,22 +98,31 @@ config TOUCHSCREEN_BITSY
           To compile this driver as a module, choose M here: the
           module will be called h3600_ts_input.
 
-config TOUCHSCREEN_CORGI
-        tristate "SharpSL (Corgi and Spitz series) touchscreen driver (DEPRECATED)"
-        depends on PXA_SHARPSL
-        select CORGI_SSP_DEPRECATED
-        default y
+config TOUCHSCREEN_BU21013
+        tristate "BU21013 based touch panel controllers"
+        depends on I2C
         help
-          Say Y here to enable the driver for the touchscreen on the
-          Sharp SL-C7xx and SL-Cxx00 series of PDAs.
+          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 corgi_ts.
+          module will be called bu21013_ts.
+
+config TOUCHSCREEN_CY8CTMG110
+        tristate "cy8ctmg110 touchscreen"
+        depends on I2C
+        depends on GPIOLIB
 
-          NOTE: this driver is deprecated, try enable SPI and generic
-          ADS7846-based touchscreen driver.
+        help
+          Say Y here if you have a cy8ctmg110 capacitive touchscreen on
+          an AAVA device.
+
+          If unsure, say N.
+
+          To compile this driver as a module, choose M here: the
+          module will be called cy8ctmg110_ts.
 
 config TOUCHSCREEN_DA9034
         tristate "Touchscreen support for Dialog Semiconductor DA9034"
@@ -123,6 +144,18 @@ config TOUCHSCREEN_DYNAPRO
           To compile this driver as a module, choose M here: the
           module will be called dynapro.
 
+config TOUCHSCREEN_HAMPSHIRE
+        tristate "Hampshire serial touchscreen"
+        select SERIO
+        help
+          Say Y here if you have a Hampshire serial touchscreen connected to
+          your system.
+
+          If unsure, say N.
+
+          To compile this driver as a module, choose M here: the
+          module will be called hampshire.
+
 config TOUCHSCREEN_EETI
         tristate "EETI touchscreen panel support"
         depends on I2C
@@ -146,9 +179,9 @@ config TOUCHSCREEN_FUJITSU
           module will be called fujitsu-ts.
 
 config TOUCHSCREEN_S3C2410
-        tristate "Samsung S3C2410 touchscreen input driver"
-        depends on ARCH_S3C2410
-        select S3C24XX_ADC
+        tristate "Samsung S3C2410/generic touchscreen input driver"
+        depends on ARCH_S3C2410 || SAMSUNG_DEV_TS
+        select S3C_ADC
         help
           Say Y here if you have the s3c2410 touchscreen.
 
@@ -193,6 +226,16 @@ 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_MCS5000
         tristate "MELFAS MCS-5000 touchscreen"
         depends on I2C
@@ -229,6 +272,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
@@ -284,6 +339,18 @@ 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
@@ -295,6 +362,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
@@ -532,9 +608,14 @@ config TOUCHSCREEN_USB_ZYTRONIC
         bool "Zytronic controller" if EMBEDDED
         depends on TOUCHSCREEN_USB_COMPOSITE
 
-config TOUCHSCREEN_USB_ETT_TC5UH
+config TOUCHSCREEN_USB_ETT_TC45USB
+        default y
+        bool "ET&T USB series TC4UM/TC5UH touchscreen controler support" if EMBEDDED
+        depends on TOUCHSCREEN_USB_COMPOSITE
+
+config TOUCHSCREEN_USB_NEXIO
         default y
-        bool "ET&T TC5UH touchscreen controler support" if EMBEDDED
+        bool "NEXIO/iNexio device support" if EMBEDDED
         depends on TOUCHSCREEN_USB_COMPOSITE
 
 config TOUCHSCREEN_TOUCHIT213
@@ -577,4 +658,27 @@ 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"
+        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.
+
+config TOUCHSCREEN_STMPE
+        tristate "STMicroelectronics STMPE touchscreens"
+        depends on MFD_STMPE
+        help
+          Say Y here if you want support for STMicroelectronics
+          STMPE touchscreen controllers.
+
+          To compile this driver as a module, choose M here: the
+          module will be called stmpe-ts.
+
 endif
diff --git a/drivers/input/touchscreen/Makefile b/drivers/input/touchscreen/Makefile
index d61a3b4def9a..7cc1b4f4b677 100644
--- a/drivers/input/touchscreen/Makefile
+++ b/drivers/input/touchscreen/Makefile
@@ -6,18 +6,26 @@
 
 wm97xx-ts-y := wm97xx-core.o
 
+obj-$(CONFIG_TOUCHSCREEN_88PM860X)      += 88pm860x-ts.o
 obj-$(CONFIG_TOUCHSCREEN_AD7877)        += ad7877.o
 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_TSADCC)  += atmel_tsadcc.o
 obj-$(CONFIG_TOUCHSCREEN_BITSY)         += h3600_ts_input.o
-obj-$(CONFIG_TOUCHSCREEN_CORGI)         += corgi_ts.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
+obj-$(CONFIG_TOUCHSCREEN_HAMPSHIRE)     += hampshire.o
 obj-$(CONFIG_TOUCHSCREEN_GUNZE)         += gunze.o
 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_MC13783)       += mc13783_ts.o
 obj-$(CONFIG_TOUCHSCREEN_MCS5000)       += mcs5000_ts.o
 obj-$(CONFIG_TOUCHSCREEN_MIGOR)         += migor_ts.o
@@ -29,7 +37,10 @@ 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_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
@@ -37,7 +48,6 @@ obj-$(CONFIG_TOUCHSCREEN_TSC2007)	+= tsc2007.o
 obj-$(CONFIG_TOUCHSCREEN_UCB1400)       += ucb1400_ts.o
 obj-$(CONFIG_TOUCHSCREEN_WACOM_W8001)   += wacom_w8001.o
 obj-$(CONFIG_TOUCHSCREEN_WM97XX)        += wm97xx-ts.o
-obj-$(CONFIG_TOUCHSCREEN_DA9034)        += da9034-ts.o
 wm97xx-ts-$(CONFIG_TOUCHSCREEN_WM9705)  += wm9705.o
 wm97xx-ts-$(CONFIG_TOUCHSCREEN_WM9712)  += wm9712.o
 wm97xx-ts-$(CONFIG_TOUCHSCREEN_WM9713)  += wm9713.o
@@ -45,3 +55,4 @@ obj-$(CONFIG_TOUCHSCREEN_WM97XX_ATMEL)	+= atmel-wm97xx.o
 obj-$(CONFIG_TOUCHSCREEN_WM97XX_MAINSTONE)      += mainstone-wm97xx.o
 obj-$(CONFIG_TOUCHSCREEN_WM97XX_ZYLONITE)       += zylonite-wm97xx.o
 obj-$(CONFIG_TOUCHSCREEN_W90X900)       += w90p910_ts.o
+obj-$(CONFIG_TOUCHSCREEN_TPS6507X)      += tps6507x-ts.o
diff --git a/drivers/input/touchscreen/ad7877.c b/drivers/input/touchscreen/ad7877.c
index eb83939c705e..a1952fcc083e 100644
--- a/drivers/input/touchscreen/ad7877.c
+++ b/drivers/input/touchscreen/ad7877.c
@@ -46,7 +46,7 @@
 #include <linux/spi/ad7877.h>
 #include <asm/irq.h>
 
-#define TS_PEN_UP_TIMEOUT       msecs_to_jiffies(50)
+#define TS_PEN_UP_TIMEOUT       msecs_to_jiffies(100)
 
 #define MAX_SPI_FREQ_HZ                 20000000
 #define MAX_12BIT                       ((1<<12)-1)
@@ -156,9 +156,14 @@ struct ser_req {
         u16                     reset;
         u16                     ref_on;
         u16                     command;
-        u16                     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.
+         */
+        u16 sample ____cacheline_aligned;
 };
 
 struct ad7877 {
@@ -182,23 +187,26 @@ struct ad7877 {
         u8                      averaging;
         u8                      pen_down_acc_interval;
 
-        u16                     conversion_data[AD7877_NR_SENSE];
-
         struct spi_transfer     xfer[AD7877_NR_SENSE + 2];
         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
+         * transfer buffers to live in their own cache lines.
+         */
+        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");
 
 /*
@@ -221,6 +229,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;
@@ -286,20 +295,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;
@@ -318,7 +332,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;
@@ -345,11 +359,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)
@@ -357,72 +385,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
          */
 
@@ -434,7 +446,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);
         }
 
@@ -444,7 +456,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) \
@@ -464,7 +476,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);
 }
@@ -494,7 +506,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);
 }
@@ -524,7 +536,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);
 }
@@ -555,7 +567,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);
 }
@@ -588,16 +600,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)
@@ -626,22 +657,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);
         }
 }
@@ -670,6 +704,13 @@ static int __devinit ad7877_probe(struct spi_device *spi)
                 return -EINVAL;
         }
 
+        spi->bits_per_word = 16;
+        err = spi_setup(spi);
+        if (err) {
+                dev_dbg(&spi->dev, "spi master doesn't support 16 bits/word\n");
+                return err;
+        }
+
         ts = kzalloc(sizeof(struct ad7877), GFP_KERNEL);
         input_dev = input_allocate_device();
         if (!ts || !input_dev) {
@@ -702,6 +743,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);
@@ -736,8 +779,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;
@@ -747,20 +791,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:
@@ -774,11 +810,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);
diff --git a/drivers/input/touchscreen/ad7879-i2c.c b/drivers/input/touchscreen/ad7879-i2c.c
new file mode 100644
index 000000000000..d82a38ee9a3e
--- /dev/null
+++ b/drivers/input/touchscreen/ad7879-i2c.c
@@ -0,0 +1,143 @@
+/*
+ * AD7879-1/AD7889-1 touchscreen (I2C bus)
+ *
+ * Copyright (C) 2008-2010 Michael Hennerich, Analog Devices Inc.
+ *
+ * Licensed under the GPL-2 or later.
+ */
+
+#include <linux/input.h>        /* BUS_I2C */
+#include <linux/i2c.h>
+#include <linux/module.h>
+#include <linux/types.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)
+{
+        struct ad7879 *ts = i2c_get_clientdata(client);
+
+        ad7879_suspend(ts);
+
+        return 0;
+}
+
+static int ad7879_i2c_resume(struct i2c_client *client)
+{
+        struct ad7879 *ts = i2c_get_clientdata(client);
+
+        ad7879_resume(ts);
+
+        return 0;
+}
+#else
+# define ad7879_i2c_suspend NULL
+# define ad7879_i2c_resume  NULL
+#endif
+
+/* All registers are word-sized.
+ * AD7879 uses a high-byte first convention.
+ */
+static int ad7879_i2c_read(struct device *dev, u8 reg)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+
+        return swab16(i2c_smbus_read_word_data(client, reg));
+}
+
+static int ad7879_i2c_multi_read(struct device *dev,
+                                 u8 first_reg, u8 count, u16 *buf)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        u8 idx;
+
+        i2c_smbus_read_i2c_block_data(client, first_reg, count * 2, (u8 *)buf);
+
+        for (idx = 0; idx < count; ++idx)
+                buf[idx] = swab16(buf[idx]);
+
+        return 0;
+}
+
+static int ad7879_i2c_write(struct device *dev, u8 reg, u16 val)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+
+        return i2c_smbus_write_word_data(client, reg, swab16(val));
+}
+
+static const struct ad7879_bus_ops ad7879_i2c_bus_ops = {
+        .bustype        = BUS_I2C,
+        .read           = ad7879_i2c_read,
+        .multi_read     = ad7879_i2c_multi_read,
+        .write          = ad7879_i2c_write,
+};
+
+static int __devinit ad7879_i2c_probe(struct i2c_client *client,
+                                      const struct i2c_device_id *id)
+{
+        struct ad7879 *ts;
+
+        if (!i2c_check_functionality(client->adapter,
+                                     I2C_FUNC_SMBUS_WORD_DATA)) {
+                dev_err(&client->dev, "SMBUS Word Data not Supported\n");
+                return -EIO;
+        }
+
+        ts = ad7879_probe(&client->dev, AD7879_DEVID, client->irq,
+                          &ad7879_i2c_bus_ops);
+        if (IS_ERR(ts))
+                return PTR_ERR(ts);
+
+        i2c_set_clientdata(client, ts);
+
+        return 0;
+}
+
+static int __devexit ad7879_i2c_remove(struct i2c_client *client)
+{
+        struct ad7879 *ts = i2c_get_clientdata(client);
+
+        ad7879_remove(ts);
+
+        return 0;
+}
+
+static const struct i2c_device_id ad7879_id[] = {
+        { "ad7879", 0 },
+        { "ad7889", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, ad7879_id);
+
+static struct i2c_driver ad7879_i2c_driver = {
+        .driver = {
+                .name   = "ad7879",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = ad7879_i2c_probe,
+        .remove         = __devexit_p(ad7879_i2c_remove),
+        .suspend        = ad7879_i2c_suspend,
+        .resume         = ad7879_i2c_resume,
+        .id_table       = ad7879_id,
+};
+
+static int __init ad7879_i2c_init(void)
+{
+        return i2c_add_driver(&ad7879_i2c_driver);
+}
+module_init(ad7879_i2c_init);
+
+static void __exit ad7879_i2c_exit(void)
+{
+        i2c_del_driver(&ad7879_i2c_driver);
+}
+module_exit(ad7879_i2c_exit);
+
+MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
+MODULE_DESCRIPTION("AD7879(-1) touchscreen I2C bus driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("i2c:ad7879");
diff --git a/drivers/input/touchscreen/ad7879-spi.c b/drivers/input/touchscreen/ad7879-spi.c
new file mode 100644
index 000000000000..59c6e68c4325
--- /dev/null
+++ b/drivers/input/touchscreen/ad7879-spi.c
@@ -0,0 +1,198 @@
+/*
+ * AD7879/AD7889 touchscreen (SPI bus)
+ *
+ * Copyright (C) 2008-2010 Michael Hennerich, Analog Devices Inc.
+ *
+ * Licensed under the GPL-2 or later.
+ */
+
+#include <linux/input.h>        /* BUS_SPI */
+#include <linux/spi/spi.h>
+
+#include "ad7879.h"
+
+#define AD7879_DEVID            0x7A    /* AD7879/AD7889 */
+
+#define MAX_SPI_FREQ_HZ      5000000
+#define AD7879_CMD_MAGIC     0xE000
+#define AD7879_CMD_READ      (1 << 10)
+#define AD7879_CMD(reg)      (AD7879_CMD_MAGIC | ((reg) & 0xF))
+#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)
+{
+        struct ad7879 *ts = spi_get_drvdata(spi);
+
+        ad7879_suspend(ts);
+
+        return 0;
+}
+
+static int ad7879_spi_resume(struct spi_device *spi)
+{
+        struct ad7879 *ts = spi_get_drvdata(spi);
+
+        ad7879_resume(ts);
+
+        return 0;
+}
+#else
+# define ad7879_spi_suspend NULL
+# define ad7879_spi_resume  NULL
+#endif
+
+/*
+ * ad7879_read/write are only used for initial setup and for sysfs controls.
+ * The main traffic is done in ad7879_collect().
+ */
+
+static int ad7879_spi_xfer(struct spi_device *spi,
+                           u16 cmd, u8 count, u16 *tx_buf, u16 *rx_buf)
+{
+        struct spi_message msg;
+        struct spi_transfer *xfers;
+        void *spi_data;
+        u16 *command;
+        u16 *_rx_buf = _rx_buf; /* shut gcc up */
+        u8 idx;
+        int ret;
+
+        xfers = spi_data = kzalloc(sizeof(*xfers) * (count + 2), GFP_KERNEL);
+        if (!spi_data)
+                return -ENOMEM;
+
+        spi_message_init(&msg);
+
+        command = spi_data;
+        command[0] = cmd;
+        if (count == 1) {
+                /* ad7879_spi_{read,write} gave us buf on stack */
+                command[1] = *tx_buf;
+                tx_buf = &command[1];
+                _rx_buf = rx_buf;
+                rx_buf = &command[2];
+        }
+
+        ++xfers;
+        xfers[0].tx_buf = command;
+        xfers[0].len = 2;
+        spi_message_add_tail(&xfers[0], &msg);
+        ++xfers;
+
+        for (idx = 0; idx < count; ++idx) {
+                if (rx_buf)
+                        xfers[idx].rx_buf = &rx_buf[idx];
+                if (tx_buf)
+                        xfers[idx].tx_buf = &tx_buf[idx];
+                xfers[idx].len = 2;
+                spi_message_add_tail(&xfers[idx], &msg);
+        }
+
+        ret = spi_sync(spi, &msg);
+
+        if (count == 1)
+                _rx_buf[0] = command[2];
+
+        kfree(spi_data);
+
+        return ret;
+}
+
+static int ad7879_spi_multi_read(struct device *dev,
+                                 u8 first_reg, u8 count, u16 *buf)
+{
+        struct spi_device *spi = to_spi_device(dev);
+
+        return ad7879_spi_xfer(spi, AD7879_READCMD(first_reg), count, NULL, buf);
+}
+
+static int ad7879_spi_read(struct device *dev, u8 reg)
+{
+        struct spi_device *spi = to_spi_device(dev);
+        u16 ret, dummy;
+
+        return ad7879_spi_xfer(spi, AD7879_READCMD(reg), 1, &dummy, &ret) ? : ret;
+}
+
+static int ad7879_spi_write(struct device *dev, u8 reg, u16 val)
+{
+        struct spi_device *spi = to_spi_device(dev);
+        u16 dummy;
+
+        return ad7879_spi_xfer(spi, AD7879_WRITECMD(reg), 1, &val, &dummy);
+}
+
+static const struct ad7879_bus_ops ad7879_spi_bus_ops = {
+        .bustype        = BUS_SPI,
+        .read           = ad7879_spi_read,
+        .multi_read     = ad7879_spi_multi_read,
+        .write          = ad7879_spi_write,
+};
+
+static int __devinit ad7879_spi_probe(struct spi_device *spi)
+{
+        struct ad7879 *ts;
+        int err;
+
+        /* don't exceed max specified SPI CLK frequency */
+        if (spi->max_speed_hz > MAX_SPI_FREQ_HZ) {
+                dev_err(&spi->dev, "SPI CLK %d Hz?\n", spi->max_speed_hz);
+                return -EINVAL;
+        }
+
+        spi->bits_per_word = 16;
+        err = spi_setup(spi);
+        if (err) {
+                dev_dbg(&spi->dev, "spi master doesn't support 16 bits/word\n");
+                return err;
+        }
+
+        ts = ad7879_probe(&spi->dev, AD7879_DEVID, spi->irq, &ad7879_spi_bus_ops);
+        if (IS_ERR(ts))
+                return PTR_ERR(ts);
+
+        spi_set_drvdata(spi, ts);
+
+        return 0;
+}
+
+static int __devexit ad7879_spi_remove(struct spi_device *spi)
+{
+        struct ad7879 *ts = spi_get_drvdata(spi);
+
+        ad7879_remove(ts);
+        spi_set_drvdata(spi, NULL);
+
+        return 0;
+}
+
+static struct spi_driver ad7879_spi_driver = {
+        .driver = {
+                .name   = "ad7879",
+                .bus    = &spi_bus_type,
+                .owner  = THIS_MODULE,
+        },
+        .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)
+{
+        return spi_register_driver(&ad7879_spi_driver);
+}
+module_init(ad7879_spi_init);
+
+static void __exit ad7879_spi_exit(void)
+{
+        spi_unregister_driver(&ad7879_spi_driver);
+}
+module_exit(ad7879_spi_exit);
+
+MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
+MODULE_DESCRIPTION("AD7879(-1) touchscreen SPI bus driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("spi:ad7879");
diff --git a/drivers/input/touchscreen/ad7879.c b/drivers/input/touchscreen/ad7879.c
index 794d070c6900..ba6f0bd1e762 100644
--- a/drivers/input/touchscreen/ad7879.c
+++ b/drivers/input/touchscreen/ad7879.c
@@ -1,25 +1,9 @@
 /*
- * Copyright (C) 2008-2009 Michael Hennerich, Analog Devices Inc.
+ * AD7879/AD7889 based touchscreen and GPIO driver
  *
- * Description: AD7879/AD7889 based touchscreen, and GPIO driver
- *              (I2C/SPI Interface)
+ * Copyright (C) 2008-2010 Michael Hennerich, Analog Devices Inc.
  *
- * Bugs:        Enter bugs at http://blackfin.uclinux.org/
- *
- * 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, see the file COPYING, or write
- * to the Free Software Foundation, Inc.,
- * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ * Licensed under the GPL-2 or later.
  *
  * History:
  * Copyright (c) 2005 David Brownell
@@ -44,12 +28,12 @@
 #include <linux/interrupt.h>
 #include <linux/irq.h>
 #include <linux/slab.h>
-#include <linux/workqueue.h>
 #include <linux/spi/spi.h>
 #include <linux/i2c.h>
 #include <linux/gpio.h>
 
 #include <linux/spi/ad7879.h>
+#include "ad7879.h"
 
 #define AD7879_REG_ZEROS                0
 #define AD7879_REG_CTRL1                1
@@ -120,30 +104,19 @@ enum {
 #define MAX_12BIT                       ((1<<12)-1)
 #define TS_PEN_UP_TIMEOUT               msecs_to_jiffies(50)
 
-#if defined(CONFIG_TOUCHSCREEN_AD7879_SPI) || defined(CONFIG_TOUCHSCREEN_AD7879_SPI_MODULE)
-#define AD7879_DEVID            0x7A
-typedef struct spi_device       bus_device;
-#elif defined(CONFIG_TOUCHSCREEN_AD7879_I2C) || defined(CONFIG_TOUCHSCREEN_AD7879_I2C_MODULE)
-#define AD7879_DEVID            0x79
-typedef struct i2c_client       bus_device;
-#endif
-
 struct ad7879 {
-        bus_device              *bus;
+        const struct ad7879_bus_ops *bops;
+
+        struct device           *dev;
         struct input_dev        *input;
-        struct work_struct      work;
         struct timer_list       timer;
 #ifdef CONFIG_GPIOLIB
         struct gpio_chip        gc;
-#endif
         struct mutex            mutex;
-        unsigned                disabled:1;     /* P: mutex */
-
-#if defined(CONFIG_TOUCHSCREEN_AD7879_SPI) || defined(CONFIG_TOUCHSCREEN_AD7879_SPI_MODULE)
-        struct spi_message      msg;
-        struct spi_transfer     xfer[AD7879_NR_SENSE + 1];
-        u16                     cmd;
 #endif
+        unsigned int            irq;
+        bool                    disabled;       /* P: input->mutex */
+        bool                    suspended;      /* P: input->mutex */
         u16                     conversion_data[AD7879_NR_SENSE];
         char                    phys[32];
         u8                      first_conversion_delay;
@@ -158,11 +131,22 @@ struct ad7879 {
         u16                     cmd_crtl3;
 };
 
-static int ad7879_read(bus_device *, u8);
-static int ad7879_write(bus_device *, u8, u16);
-static void ad7879_collect(struct ad7879 *);
+static int ad7879_read(struct ad7879 *ts, u8 reg)
+{
+        return ts->bops->read(ts->dev, reg);
+}
+
+static int ad7879_multi_read(struct ad7879 *ts, u8 first_reg, u8 count, u16 *buf)
+{
+        return ts->bops->multi_read(ts->dev, first_reg, count, buf);
+}
 
-static void ad7879_report(struct ad7879 *ts)
+static int ad7879_write(struct ad7879 *ts, u8 reg, u16 val)
+{
+        return ts->bops->write(ts->dev, reg, val);
+}
+
+static int ad7879_report(struct ad7879 *ts)
 {
         struct input_dev *input_dev = ts->input;
         unsigned Rt;
@@ -175,12 +159,14 @@ static void ad7879_report(struct ad7879 *ts)
 
         /*
          * The samples processed here are already preprocessed by the AD7879.
-         * The preprocessing function consists of a median and an averaging filter.
-         * The combination of these two techniques provides a robust solution,
-         * discarding the spurious noise in the signal and keeping only the data of interest.
-         * The size of both filters is programmable. (dev.platform_data, see linux/spi/ad7879.h)
-         * Other user-programmable conversion controls include variable acquisition time,
-         * and first conversion delay. Up to 16 averages can be taken per conversion.
+         * The preprocessing function consists of a median and an averaging
+         * filter.  The combination of these two techniques provides a robust
+         * solution, discarding the spurious noise in the signal and keeping
+         * only the data of interest.  The size of both filters is
+         * programmable. (dev.platform_data, see linux/spi/ad7879.h) Other
+         * user-programmable conversion controls include variable acquisition
+         * time, and first conversion delay. Up to 16 averages can be taken
+         * per conversion.
          */
 
         if (likely(x && z1)) {
@@ -189,21 +175,17 @@ static void ad7879_report(struct ad7879 *ts)
                 Rt /= z1;
                 Rt = (Rt + 2047) >> 12;
 
+                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;
         }
-}
-
-static void ad7879_work(struct work_struct *work)
-{
-        struct ad7879 *ts = container_of(work, struct ad7879, work);
 
-        /* use keventd context to read the result registers */
-        ad7879_collect(ts);
-        ad7879_report(ts);
-        mod_timer(&ts->timer, jiffies + TS_PEN_UP_TIMEOUT);
+        return -EINVAL;
 }
 
 static void ad7879_ts_event_release(struct ad7879 *ts)
@@ -211,6 +193,7 @@ static void ad7879_ts_event_release(struct ad7879 *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);
 }
 
@@ -225,56 +208,98 @@ static irqreturn_t ad7879_irq(int irq, void *handle)
 {
         struct ad7879 *ts = handle;
 
-        /* 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
-         */
+        ad7879_multi_read(ts, AD7879_REG_XPLUS, AD7879_NR_SENSE, ts->conversion_data);
 
-        if (!work_pending(&ts->work))
-                schedule_work(&ts->work);
+        if (!ad7879_report(ts))
+                mod_timer(&ts->timer, jiffies + TS_PEN_UP_TIMEOUT);
 
         return IRQ_HANDLED;
 }
 
-static void ad7879_setup(struct ad7879 *ts)
+static void __ad7879_enable(struct ad7879 *ts)
 {
-        ad7879_write(ts->bus, AD7879_REG_CTRL2, ts->cmd_crtl2);
-        ad7879_write(ts->bus, AD7879_REG_CTRL3, ts->cmd_crtl3);
-        ad7879_write(ts->bus, AD7879_REG_CTRL1, ts->cmd_crtl1);
+        ad7879_write(ts, AD7879_REG_CTRL2, ts->cmd_crtl2);
+        ad7879_write(ts, AD7879_REG_CTRL3, ts->cmd_crtl3);
+        ad7879_write(ts, AD7879_REG_CTRL1, ts->cmd_crtl1);
+
+        enable_irq(ts->irq);
 }
 
-static void ad7879_disable(struct ad7879 *ts)
+static void __ad7879_disable(struct ad7879 *ts)
 {
-        mutex_lock(&ts->mutex);
+        disable_irq(ts->irq);
+
+        if (del_timer_sync(&ts->timer))
+                ad7879_ts_event_release(ts);
+
+        ad7879_write(ts, AD7879_REG_CTRL2, AD7879_PM(AD7879_PM_SHUTDOWN));
+}
 
-        if (!ts->disabled) {
 
-                ts->disabled = 1;
-                disable_irq(ts->bus->irq);
+static int ad7879_open(struct input_dev *input)
+{
+        struct ad7879 *ts = input_get_drvdata(input);
 
-                cancel_work_sync(&ts->work);
+        /* protected by input->mutex */
+        if (!ts->disabled && !ts->suspended)
+                __ad7879_enable(ts);
 
-                if (del_timer_sync(&ts->timer))
-                        ad7879_ts_event_release(ts);
+        return 0;
+}
 
-                ad7879_write(ts->bus, AD7879_REG_CTRL2,
-                             AD7879_PM(AD7879_PM_SHUTDOWN));
-        }
+static void ad7879_close(struct input_dev* input)
+{
+        struct ad7879 *ts = input_get_drvdata(input);
 
-        mutex_unlock(&ts->mutex);
+        /* protected by input->mutex */
+        if (!ts->disabled && !ts->suspended)
+                __ad7879_disable(ts);
 }
 
-static void ad7879_enable(struct ad7879 *ts)
+void ad7879_suspend(struct ad7879 *ts)
 {
-        mutex_lock(&ts->mutex);
+        mutex_lock(&ts->input->mutex);
+
+        if (!ts->suspended && !ts->disabled && ts->input->users)
+                __ad7879_disable(ts);
+
+        ts->suspended = true;
 
-        if (ts->disabled) {
-                ad7879_setup(ts);
-                ts->disabled = 0;
-                enable_irq(ts->bus->irq);
+        mutex_unlock(&ts->input->mutex);
+}
+EXPORT_SYMBOL(ad7879_suspend);
+
+void ad7879_resume(struct ad7879 *ts)
+{
+        mutex_lock(&ts->input->mutex);
+
+        if (ts->suspended && !ts->disabled && ts->input->users)
+                __ad7879_enable(ts);
+
+        ts->suspended = false;
+
+        mutex_unlock(&ts->input->mutex);
+}
+EXPORT_SYMBOL(ad7879_resume);
+
+static void ad7879_toggle(struct ad7879 *ts, bool disable)
+{
+        mutex_lock(&ts->input->mutex);
+
+        if (!ts->suspended && ts->input->users != 0) {
+
+                if (disable) {
+                        if (ts->disabled)
+                                __ad7879_enable(ts);
+                } else {
+                        if (!ts->disabled)
+                                __ad7879_disable(ts);
+                }
         }
 
-        mutex_unlock(&ts->mutex);
+        ts->disabled = disable;
+
+        mutex_unlock(&ts->input->mutex);
 }
 
 static ssize_t ad7879_disable_show(struct device *dev,
@@ -297,10 +322,7 @@ static ssize_t ad7879_disable_store(struct device *dev,
         if (error)
                 return error;
 
-        if (val)
-                ad7879_disable(ts);
-        else
-                ad7879_enable(ts);
+        ad7879_toggle(ts, val);
 
         return count;
 }
@@ -325,7 +347,7 @@ static int ad7879_gpio_direction_input(struct gpio_chip *chip,
 
         mutex_lock(&ts->mutex);
         ts->cmd_crtl2 |= AD7879_GPIO_EN | AD7879_GPIODIR | AD7879_GPIOPOL;
-        err = ad7879_write(ts->bus, AD7879_REG_CTRL2, ts->cmd_crtl2);
+        err = ad7879_write(ts, AD7879_REG_CTRL2, ts->cmd_crtl2);
         mutex_unlock(&ts->mutex);
 
         return err;
@@ -345,7 +367,7 @@ static int ad7879_gpio_direction_output(struct gpio_chip *chip,
         else
                 ts->cmd_crtl2 &= ~AD7879_GPIO_DATA;
 
-        err = ad7879_write(ts->bus, AD7879_REG_CTRL2, ts->cmd_crtl2);
+        err = ad7879_write(ts, AD7879_REG_CTRL2, ts->cmd_crtl2);
         mutex_unlock(&ts->mutex);
 
         return err;
@@ -357,7 +379,7 @@ static int ad7879_gpio_get_value(struct gpio_chip *chip, unsigned gpio)
         u16 val;
 
         mutex_lock(&ts->mutex);
-        val = ad7879_read(ts->bus, AD7879_REG_CTRL2);
+        val = ad7879_read(ts, AD7879_REG_CTRL2);
         mutex_unlock(&ts->mutex);
 
         return !!(val & AD7879_GPIO_DATA);
@@ -374,16 +396,17 @@ static void ad7879_gpio_set_value(struct gpio_chip *chip,
         else
                 ts->cmd_crtl2 &= ~AD7879_GPIO_DATA;
 
-        ad7879_write(ts->bus, AD7879_REG_CTRL2, ts->cmd_crtl2);
+        ad7879_write(ts, AD7879_REG_CTRL2, ts->cmd_crtl2);
         mutex_unlock(&ts->mutex);
 }
 
-static int __devinit ad7879_gpio_add(struct device *dev)
+static int ad7879_gpio_add(struct ad7879 *ts,
+                           const struct ad7879_platform_data *pdata)
 {
-        struct ad7879 *ts = dev_get_drvdata(dev);
-        struct ad7879_platform_data *pdata = dev->platform_data;
         int ret = 0;
 
+        mutex_init(&ts->mutex);
+
         if (pdata->gpio_export) {
                 ts->gc.direction_input = ad7879_gpio_direction_input;
                 ts->gc.direction_output = ad7879_gpio_direction_output;
@@ -394,72 +417,75 @@ static int __devinit ad7879_gpio_add(struct device *dev)
                 ts->gc.ngpio = 1;
                 ts->gc.label = "AD7879-GPIO";
                 ts->gc.owner = THIS_MODULE;
-                ts->gc.dev = dev;
+                ts->gc.dev = ts->dev;
 
                 ret = gpiochip_add(&ts->gc);
                 if (ret)
-                        dev_err(dev, "failed to register gpio %d\n",
+                        dev_err(ts->dev, "failed to register gpio %d\n",
                                 ts->gc.base);
         }
 
         return ret;
 }
 
-/*
- * We mark ad7879_gpio_remove inline so there is a chance the code
- * gets discarded when not needed. We can't do __devinit/__devexit
- * markup since it is used in both probe and remove methods.
- */
-static inline void ad7879_gpio_remove(struct device *dev)
+static void ad7879_gpio_remove(struct ad7879 *ts)
 {
-        struct ad7879 *ts = dev_get_drvdata(dev);
-        struct ad7879_platform_data *pdata = dev->platform_data;
+        const struct ad7879_platform_data *pdata = ts->dev->platform_data;
         int ret;
 
         if (pdata->gpio_export) {
                 ret = gpiochip_remove(&ts->gc);
                 if (ret)
-                        dev_err(dev, "failed to remove gpio %d\n",
+                        dev_err(ts->dev, "failed to remove gpio %d\n",
                                 ts->gc.base);
         }
 }
 #else
-static inline int ad7879_gpio_add(struct device *dev)
+static inline int ad7879_gpio_add(struct ad7879 *ts,
+                                  const struct ad7879_platform_data *pdata)
 {
         return 0;
 }
 
-static inline void ad7879_gpio_remove(struct device *dev)
+static inline void ad7879_gpio_remove(struct ad7879 *ts)
 {
 }
 #endif
 
-static int __devinit ad7879_construct(bus_device *bus, struct ad7879 *ts)
+struct ad7879 *ad7879_probe(struct device *dev, u8 devid, unsigned int irq,
+                            const struct ad7879_bus_ops *bops)
 {
+        struct ad7879_platform_data *pdata = dev->platform_data;
+        struct ad7879 *ts;
         struct input_dev *input_dev;
-        struct ad7879_platform_data *pdata = bus->dev.platform_data;
         int err;
         u16 revid;
 
-        if (!bus->irq) {
-                dev_err(&bus->dev, "no IRQ?\n");
-                return -ENODEV;
+        if (!irq) {
+                dev_err(dev, "no IRQ?\n");
+                err = -EINVAL;
+                goto err_out;
         }
 
         if (!pdata) {
-                dev_err(&bus->dev, "no platform data?\n");
-                return -ENODEV;
+                dev_err(dev, "no platform data?\n");
+                err = -EINVAL;
+                goto err_out;
         }
 
+        ts = kzalloc(sizeof(*ts), GFP_KERNEL);
         input_dev = input_allocate_device();
-        if (!input_dev)
-                return -ENOMEM;
+        if (!ts || !input_dev) {
+                err = -ENOMEM;
+                goto err_free_mem;
+        }
 
+        ts->bops = bops;
+        ts->dev = dev;
         ts->input = input_dev;
+        ts->irq = irq;
 
         setup_timer(&ts->timer, ad7879_timer, (unsigned long) ts);
-        INIT_WORK(&ts->work, ad7879_work);
-        mutex_init(&ts->mutex);
 
         ts->x_plate_ohms = pdata->x_plate_ohms ? : 400;
         ts->pressure_max = pdata->pressure_max ? : ~0;
@@ -470,17 +496,26 @@ static int __devinit ad7879_construct(bus_device *bus, struct ad7879 *ts)
         ts->pen_down_acc_interval = pdata->pen_down_acc_interval;
         ts->median = pdata->median;
 
-        snprintf(ts->phys, sizeof(ts->phys), "%s/input0", dev_name(&bus->dev));
+        snprintf(ts->phys, sizeof(ts->phys), "%s/input0", dev_name(dev));
 
         input_dev->name = "AD7879 Touchscreen";
         input_dev->phys = ts->phys;
-        input_dev->dev.parent = &bus->dev;
+        input_dev->dev.parent = dev;
+        input_dev->id.bustype = bops->bustype;
+
+        input_dev->open = ad7879_open;
+        input_dev->close = ad7879_close;
+
+        input_set_drvdata(input_dev, ts);
 
         __set_bit(EV_ABS, input_dev->evbit);
         __set_bit(ABS_X, input_dev->absbit);
         __set_bit(ABS_Y, input_dev->absbit);
         __set_bit(ABS_PRESSURE, input_dev->absbit);
 
+        __set_bit(EV_KEY, input_dev->evbit);
+        __set_bit(BTN_TOUCH, input_dev->keybit);
+
         input_set_abs_params(input_dev, ABS_X,
                         pdata->x_min ? : 0,
                         pdata->x_max ? : MAX_12BIT,
@@ -492,17 +527,18 @@ static int __devinit ad7879_construct(bus_device *bus, struct ad7879 *ts)
         input_set_abs_params(input_dev, ABS_PRESSURE,
                         pdata->pressure_min, pdata->pressure_max, 0, 0);
 
-        err = ad7879_write(bus, AD7879_REG_CTRL2, AD7879_RESET);
-
+        err = ad7879_write(ts, AD7879_REG_CTRL2, AD7879_RESET);
         if (err < 0) {
-                dev_err(&bus->dev, "Failed to write %s\n", input_dev->name);
+                dev_err(dev, "Failed to write %s\n", input_dev->name);
                 goto err_free_mem;
         }
 
-        revid = ad7879_read(bus, AD7879_REG_REVID);
-
-        if ((revid & 0xFF) != AD7879_DEVID) {
-                dev_err(&bus->dev, "Failed to probe %s\n", input_dev->name);
+        revid = ad7879_read(ts, AD7879_REG_REVID);
+        input_dev->id.product = (revid & 0xff);
+        input_dev->id.version = revid >> 8;
+        if (input_dev->id.product != devid) {
+                dev_err(dev, "Failed to probe %s (%x vs %x)\n",
+                        input_dev->name, devid, revid);
                 err = -ENODEV;
                 goto err_free_mem;
         }
@@ -524,21 +560,21 @@ static int __devinit ad7879_construct(bus_device *bus, struct ad7879 *ts)
                         AD7879_ACQ(ts->acquisition_time) |
                         AD7879_TMR(ts->pen_down_acc_interval);
 
-        ad7879_setup(ts);
-
-        err = request_irq(bus->irq, ad7879_irq,
-                          IRQF_TRIGGER_FALLING, bus->dev.driver->name, ts);
-
+        err = request_threaded_irq(ts->irq, NULL, ad7879_irq,
+                                   IRQF_TRIGGER_FALLING,
+                                   dev_name(dev), ts);
         if (err) {
-                dev_err(&bus->dev, "irq %d busy?\n", bus->irq);
+                dev_err(dev, "irq %d busy?\n", ts->irq);
                 goto err_free_mem;
         }
 
-        err = sysfs_create_group(&bus->dev.kobj, &ad7879_attr_group);
+        __ad7879_disable(ts);
+
+        err = sysfs_create_group(&dev->kobj, &ad7879_attr_group);
         if (err)
                 goto err_free_irq;
 
-        err = ad7879_gpio_add(&bus->dev);
+        err = ad7879_gpio_add(ts, pdata);
         if (err)
                 goto err_remove_attr;
 
@@ -546,324 +582,32 @@ static int __devinit ad7879_construct(bus_device *bus, struct ad7879 *ts)
         if (err)
                 goto err_remove_gpio;
 
-        dev_info(&bus->dev, "Rev.%d touchscreen, irq %d\n",
-                 revid >> 8, bus->irq);
-
-        return 0;
+        return ts;
 
 err_remove_gpio:
-        ad7879_gpio_remove(&bus->dev);
+        ad7879_gpio_remove(ts);
 err_remove_attr:
-        sysfs_remove_group(&bus->dev.kobj, &ad7879_attr_group);
+        sysfs_remove_group(&dev->kobj, &ad7879_attr_group);
 err_free_irq:
-        free_irq(bus->irq, ts);
+        free_irq(ts->irq, ts);
 err_free_mem:
         input_free_device(input_dev);
-
-        return err;
-}
-
-static int __devexit ad7879_destroy(bus_device *bus, struct ad7879 *ts)
-{
-        ad7879_gpio_remove(&bus->dev);
-        ad7879_disable(ts);
-        sysfs_remove_group(&ts->bus->dev.kobj, &ad7879_attr_group);
-        free_irq(ts->bus->irq, ts);
-        input_unregister_device(ts->input);
-        dev_dbg(&bus->dev, "unregistered touchscreen\n");
-
-        return 0;
-}
-
-#ifdef CONFIG_PM
-static int ad7879_suspend(bus_device *bus, pm_message_t message)
-{
-        struct ad7879 *ts = dev_get_drvdata(&bus->dev);
-
-        ad7879_disable(ts);
-
-        return 0;
-}
-
-static int ad7879_resume(bus_device *bus)
-{
-        struct ad7879 *ts = dev_get_drvdata(&bus->dev);
-
-        ad7879_enable(ts);
-
-        return 0;
-}
-#else
-#define ad7879_suspend NULL
-#define ad7879_resume  NULL
-#endif
-
-#if defined(CONFIG_TOUCHSCREEN_AD7879_SPI) || defined(CONFIG_TOUCHSCREEN_AD7879_SPI_MODULE)
-#define MAX_SPI_FREQ_HZ         5000000
-#define AD7879_CMD_MAGIC        0xE000
-#define AD7879_CMD_READ         (1 << 10)
-#define AD7879_WRITECMD(reg)    (AD7879_CMD_MAGIC | (reg & 0xF))
-#define AD7879_READCMD(reg)     (AD7879_CMD_MAGIC | AD7879_CMD_READ | (reg & 0xF))
-
-struct ser_req {
-        u16                     command;
-        u16                     data;
-        struct spi_message      msg;
-        struct spi_transfer     xfer[2];
-};
-
-/*
- * ad7879_read/write are only used for initial setup and for sysfs controls.
- * The main traffic is done in ad7879_collect().
- */
-
-static int ad7879_read(struct spi_device *spi, u8 reg)
-{
-        struct ser_req *req;
-        int status, ret;
-
-        req = kzalloc(sizeof *req, GFP_KERNEL);
-        if (!req)
-                return -ENOMEM;
-
-        spi_message_init(&req->msg);
-
-        req->command = (u16) AD7879_READCMD(reg);
-        req->xfer[0].tx_buf = &req->command;
-        req->xfer[0].len = 2;
-
-        req->xfer[1].rx_buf = &req->data;
-        req->xfer[1].len = 2;
-
-        spi_message_add_tail(&req->xfer[0], &req->msg);
-        spi_message_add_tail(&req->xfer[1], &req->msg);
-
-        status = spi_sync(spi, &req->msg);
-        ret = status ? : req->data;
-
-        kfree(req);
-
-        return ret;
-}
-
-static int ad7879_write(struct spi_device *spi, u8 reg, u16 val)
-{
-        struct ser_req *req;
-        int status;
-
-        req = kzalloc(sizeof *req, GFP_KERNEL);
-        if (!req)
-                return -ENOMEM;
-
-        spi_message_init(&req->msg);
-
-        req->command = (u16) AD7879_WRITECMD(reg);
-        req->xfer[0].tx_buf = &req->command;
-        req->xfer[0].len = 2;
-
-        req->data = val;
-        req->xfer[1].tx_buf = &req->data;
-        req->xfer[1].len = 2;
-
-        spi_message_add_tail(&req->xfer[0], &req->msg);
-        spi_message_add_tail(&req->xfer[1], &req->msg);
-
-        status = spi_sync(spi, &req->msg);
-
-        kfree(req);
-
-        return status;
-}
-
-static void ad7879_collect(struct ad7879 *ts)
-{
-        int status = spi_sync(ts->bus, &ts->msg);
-
-        if (status)
-                dev_err(&ts->bus->dev, "spi_sync --> %d\n", status);
-}
-
-static void ad7879_setup_ts_def_msg(struct ad7879 *ts)
-{
-        struct spi_message *m;
-        int i;
-
-        ts->cmd = (u16) AD7879_READCMD(AD7879_REG_XPLUS);
-
-        m = &ts->msg;
-        spi_message_init(m);
-        ts->xfer[0].tx_buf = &ts->cmd;
-        ts->xfer[0].len = 2;
-
-        spi_message_add_tail(&ts->xfer[0], m);
-
-        for (i = 0; i < AD7879_NR_SENSE; i++) {
-                ts->xfer[i + 1].rx_buf = &ts->conversion_data[i];
-                ts->xfer[i + 1].len = 2;
-                spi_message_add_tail(&ts->xfer[i + 1], m);
-        }
-}
-
-static int __devinit ad7879_probe(struct spi_device *spi)
-{
-        struct ad7879 *ts;
-        int error;
-
-        /* don't exceed max specified SPI CLK frequency */
-        if (spi->max_speed_hz > MAX_SPI_FREQ_HZ) {
-                dev_err(&spi->dev, "SPI CLK %d Hz?\n", spi->max_speed_hz);
-                return -EINVAL;
-        }
-
-        ts = kzalloc(sizeof(struct ad7879), GFP_KERNEL);
-        if (!ts)
-                return -ENOMEM;
-
-        dev_set_drvdata(&spi->dev, ts);
-        ts->bus = spi;
-
-        ad7879_setup_ts_def_msg(ts);
-
-        error = ad7879_construct(spi, ts);
-        if (error) {
-                dev_set_drvdata(&spi->dev, NULL);
-                kfree(ts);
-        }
-
-        return error;
-}
-
-static int __devexit ad7879_remove(struct spi_device *spi)
-{
-        struct ad7879 *ts = dev_get_drvdata(&spi->dev);
-
-        ad7879_destroy(spi, ts);
-        dev_set_drvdata(&spi->dev, NULL);
         kfree(ts);
-
-        return 0;
+err_out:
+        return ERR_PTR(err);
 }
+EXPORT_SYMBOL(ad7879_probe);
 
-static struct spi_driver ad7879_driver = {
-        .driver = {
-                .name   = "ad7879",
-                .bus    = &spi_bus_type,
-                .owner  = THIS_MODULE,
-        },
-        .probe          = ad7879_probe,
-        .remove         = __devexit_p(ad7879_remove),
-        .suspend        = ad7879_suspend,
-        .resume         = ad7879_resume,
-};
-
-static int __init ad7879_init(void)
-{
-        return spi_register_driver(&ad7879_driver);
-}
-module_init(ad7879_init);
-
-static void __exit ad7879_exit(void)
-{
-        spi_unregister_driver(&ad7879_driver);
-}
-module_exit(ad7879_exit);
-
-#elif defined(CONFIG_TOUCHSCREEN_AD7879_I2C) || defined(CONFIG_TOUCHSCREEN_AD7879_I2C_MODULE)
-
-/* All registers are word-sized.
- * AD7879 uses a high-byte first convention.
- */
-static int ad7879_read(struct i2c_client *client, u8 reg)
+void ad7879_remove(struct ad7879 *ts)
 {
-        return swab16(i2c_smbus_read_word_data(client, reg));
-}
-
-static int ad7879_write(struct i2c_client *client, u8 reg, u16 val)
-{
-        return i2c_smbus_write_word_data(client, reg, swab16(val));
-}
-
-static void ad7879_collect(struct ad7879 *ts)
-{
-        int i;
-
-        for (i = 0; i < AD7879_NR_SENSE; i++)
-                ts->conversion_data[i] = ad7879_read(ts->bus,
-                                                     AD7879_REG_XPLUS + i);
-}
-
-static int __devinit ad7879_probe(struct i2c_client *client,
-                                        const struct i2c_device_id *id)
-{
-        struct ad7879 *ts;
-        int error;
-
-        if (!i2c_check_functionality(client->adapter,
-                                        I2C_FUNC_SMBUS_WORD_DATA)) {
-                dev_err(&client->dev, "SMBUS Word Data not Supported\n");
-                return -EIO;
-        }
-
-        ts = kzalloc(sizeof(struct ad7879), GFP_KERNEL);
-        if (!ts)
-                return -ENOMEM;
-
-        i2c_set_clientdata(client, ts);
-        ts->bus = client;
-
-        error = ad7879_construct(client, ts);
-        if (error) {
-                i2c_set_clientdata(client, NULL);
-                kfree(ts);
-        }
-
-        return error;
-}
-
-static int __devexit ad7879_remove(struct i2c_client *client)
-{
-        struct ad7879 *ts = dev_get_drvdata(&client->dev);
-
-        ad7879_destroy(client, ts);
-        i2c_set_clientdata(client, NULL);
+        ad7879_gpio_remove(ts);
+        sysfs_remove_group(&ts->dev->kobj, &ad7879_attr_group);
+        free_irq(ts->irq, ts);
+        input_unregister_device(ts->input);
         kfree(ts);
-
-        return 0;
-}
-
-static const struct i2c_device_id ad7879_id[] = {
-        { "ad7879", 0 },
-        { "ad7889", 0 },
-        { }
-};
-MODULE_DEVICE_TABLE(i2c, ad7879_id);
-
-static struct i2c_driver ad7879_driver = {
-        .driver = {
-                .name   = "ad7879",
-                .owner  = THIS_MODULE,
-        },
-        .probe          = ad7879_probe,
-        .remove         = __devexit_p(ad7879_remove),
-        .suspend        = ad7879_suspend,
-        .resume         = ad7879_resume,
-        .id_table       = ad7879_id,
-};
-
-static int __init ad7879_init(void)
-{
-        return i2c_add_driver(&ad7879_driver);
-}
-module_init(ad7879_init);
-
-static void __exit ad7879_exit(void)
-{
-        i2c_del_driver(&ad7879_driver);
 }
-module_exit(ad7879_exit);
-#endif
+EXPORT_SYMBOL(ad7879_remove);
 
 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
 MODULE_DESCRIPTION("AD7879(-1) touchscreen Driver");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS("spi:ad7879");
diff --git a/drivers/input/touchscreen/ad7879.h b/drivers/input/touchscreen/ad7879.h
new file mode 100644
index 000000000000..6b45a27236c7
--- /dev/null
+++ b/drivers/input/touchscreen/ad7879.h
@@ -0,0 +1,30 @@
+/*
+ * AD7879/AD7889 touchscreen (bus interfaces)
+ *
+ * Copyright (C) 2008-2010 Michael Hennerich, Analog Devices Inc.
+ *
+ * Licensed under the GPL-2 or later.
+ */
+
+#ifndef _AD7879_H_
+#define _AD7879_H_
+
+#include <linux/types.h>
+
+struct ad7879;
+struct device;
+
+struct ad7879_bus_ops {
+        u16 bustype;
+        int (*read)(struct device *dev, u8 reg);
+        int (*multi_read)(struct device *dev, u8 first_reg, u8 count, u16 *buf);
+        int (*write)(struct device *dev, u8 reg, u16 val);
+};
+
+void ad7879_suspend(struct ad7879 *);
+void ad7879_resume(struct ad7879 *);
+struct ad7879 *ad7879_probe(struct device *dev, u8 devid, unsigned irq,
+                            const struct ad7879_bus_ops *bops);
+void ad7879_remove(struct ad7879 *);
+
+#endif
diff --git a/drivers/input/touchscreen/ads7846.c b/drivers/input/touchscreen/ads7846.c
index 52d2ca147d8f..14ea54b78e46 100644
--- a/drivers/input/touchscreen/ads7846.c
+++ b/drivers/input/touchscreen/ads7846.c
@@ -17,9 +17,11 @@
  *  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>
@@ -27,6 +29,7 @@
 #include <linux/gpio.h>
 #include <linux/spi/spi.h>
 #include <linux/spi/ads7846.h>
+#include <linux/regulator/consumer.h>
 #include <asm/irq.h>
 
 /*
@@ -35,6 +38,7 @@
  * TSC2046 is just newer ads7846 silicon.
  * Support for ads7843 tested on Atmel at91sam926x-EK.
  * Support for ads7845 has only been stubbed in.
+ * Support for Analog Devices AD7873 and AD7843 tested.
  *
  * IRQ handling needs a workaround because of a shortcoming in handling
  * edge triggered IRQs on some platforms like the OMAP1/2. These
@@ -50,22 +54,25 @@
  * 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];
 };
 
 /*
@@ -77,6 +84,8 @@ struct ads7846_packet {
         u8                      read_x, read_y, read_z1, read_z2, pwrdown;
         u16                     dummy;          /* for the pwrdown read */
         struct ts_event         tc;
+        /* for ads7845 with mpc5121 psc spi we use 3-byte buffers */
+        u8                      read_x_cmd[3], read_y_cmd[3], pwrdown_cmd[3];
 };
 
 struct ads7846 {
@@ -85,6 +94,7 @@ struct ads7846 {
         char                    name[32];
 
         struct spi_device       *spi;
+        struct regulator        *reg;
 
 #if defined(CONFIG_HWMON) || defined(CONFIG_HWMON_MODULE)
         struct attribute_group  *attr_group;
@@ -103,8 +113,11 @@ struct ads7846 {
 
         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;
@@ -115,14 +128,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;
@@ -158,7 +167,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 */
@@ -186,6 +195,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);
+}
+
 /*--------------------------------------------------------------------------*/
 
 /*
@@ -204,23 +285,23 @@ struct ser_req {
         struct spi_transfer     xfer[6];
 };
 
-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;
-}
+struct ads7845_ser_req {
+        u8                      command[3];
+        u8                      pwrdown[3];
+        u8                      sample[3];
+        struct spi_message      msg;
+        struct spi_transfer     xfer[2];
+};
 
 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;
+        int use_internal;
 
+        req = kzalloc(sizeof *req, GFP_KERNEL);
         if (!req)
                 return -ENOMEM;
 
@@ -267,11 +348,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 */
@@ -284,6 +365,42 @@ static int ads7846_read12_ser(struct device *dev, unsigned command)
         return status;
 }
 
+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;
+        int status;
+
+        req = kzalloc(sizeof *req, GFP_KERNEL);
+        if (!req)
+                return -ENOMEM;
+
+        spi_message_init(&req->msg);
+
+        req->command[0] = (u8) command;
+        req->xfer[0].tx_buf = req->command;
+        req->xfer[0].rx_buf = req->sample;
+        req->xfer[0].len = 3;
+        spi_message_add_tail(&req->xfer[0], &req->msg);
+
+        mutex_lock(&ts->lock);
+        ads7846_stop(ts);
+        status = spi_sync(spi, &req->msg);
+        ads7846_restart(ts);
+        mutex_unlock(&ts->lock);
+
+        if (status == 0) {
+                /* BE12 value, then padding */
+                status = be16_to_cpu(*((u16 *)&req->sample[1]));
+                status = status >> 3;
+                status &= 0x0fff;
+        }
+
+        kfree(req);
+        return status;
+}
+
 #if defined(CONFIG_HWMON) || defined(CONFIG_HWMON_MODULE)
 
 #define SHOW(name, var, adjust) static ssize_t \
@@ -324,6 +441,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;
 }
 
@@ -334,13 +452,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,
@@ -448,17 +566,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);
@@ -466,7 +579,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);
 }
@@ -481,15 +594,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;
 }
 
@@ -519,28 +628,153 @@ 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);
+
+        *(u16 *)t->rx_buf = val;
+}
+
+static void ads7846_read_state(struct ads7846 *ts)
+{
+        struct ads7846_packet *packet = ts->packet;
+        struct spi_message *m;
+        int msg_idx = 0;
+        int val;
+        int action;
+        int error;
+
+        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_rx(void *ads)
+static void ads7846_report_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;
+        unsigned int Rt;
+        u16 x, y, z1, z2;
 
-        /* ads7846_rx_val() did in-place conversion (including byteswap) from
-         * on-the-wire format as part of debouncing to get stable readings.
+        /*
+         * ads7846_get_value() does in-place conversion (including byte swap)
+         * from on-the-wire format as part of debouncing to get stable
+         * readings.
          */
-        x = packet->tc.x;
-        y = packet->tc.y;
-        z1 = packet->tc.z1;
-        z2 = packet->tc.z2;
+        if (ts->model == 7845) {
+                x = *(u16 *)packet->tc.x_buf;
+                y = *(u16 *)packet->tc.y_buf;
+                z1 = 0;
+                z2 = 0;
+        } else {
+                x = packet->tc.x;
+                y = packet->tc.y;
+                z1 = packet->tc.z1;
+                z2 = packet->tc.z2;
+        }
 
         /* range filtering */
         if (x == MAX_12BIT)
@@ -548,6 +782,12 @@ static void ads7846_rx(void *ads)
 
         if (ts->model == 7843) {
                 Rt = ts->pressure_max / 2;
+        } else if (ts->model == 7845) {
+                if (get_pendown_state(ts))
+                        Rt = ts->pressure_max / 2;
+                else
+                        Rt = 0;
+                dev_vdbg(&ts->spi->dev, "x/y: %d/%d, PD %d\n", x, y, Rt);
         } else if (likely(x && z1)) {
                 /* compute touch pressure resistance using equation #2 */
                 Rt = z2;
@@ -560,19 +800,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) {
@@ -581,8 +821,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.
          *
@@ -592,15 +833,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);
@@ -608,232 +849,94 @@ 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;
+        struct ads7846 *ts = handle;
 
-        m = &ts->msg[ts->msg_idx];
-        t = list_entry(m->transfers.prev, struct spi_transfer, transfer_list);
+        /* Start with a small delay before checking pendown state */
+        msleep(TS_POLL_DELAY);
 
-        /* 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;
+        while (!ts->stopped && get_pendown_state(ts)) {
 
-        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);
-}
-
-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)
+static int ads7846_suspend(struct spi_device *spi, pm_message_t message)
 {
-        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(&spi->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;
         }
 
-        /* we know the chip's in lowpower mode since we always
-         * leave it that way after every request
-         */
-}
+        mutex_unlock(&ts->lock);
 
-/* Must be called with ts->lock held */
-static void ads7846_enable(struct ads7846 *ts)
-{
-        if (!ts->disabled)
-                return;
-
-        ts->disabled = 0;
-        ts->irq_disabled = 0;
-        enable_irq(ts->spi->irq);
+        return 0;
 }
 
-static int ads7846_suspend(struct spi_device *spi, pm_message_t message)
+static int ads7846_resume(struct spi_device *spi)
 {
         struct ads7846 *ts = dev_get_drvdata(&spi->dev);
 
-        spin_lock_irq(&ts->lock);
+        mutex_lock(&ts->lock);
 
-        ts->is_suspended = 1;
-        ads7846_disable(ts);
+        if (ts->suspended) {
 
-        spin_unlock_irq(&ts->lock);
+                ts->suspended = false;
 
-        return 0;
-
-}
-
-static int ads7846_resume(struct spi_device *spi)
-{
-        struct ads7846 *ts = dev_get_drvdata(&spi->dev);
-
-        spin_lock_irq(&ts->lock);
+                if (device_may_wakeup(&ts->spi->dev))
+                        disable_irq_wake(ts->spi->irq);
 
-        ts->is_suspended = 0;
-        ads7846_enable(ts);
+                if (!ts->disabled)
+                        __ads7846_enable(ts);
+        }
 
-        spin_unlock_irq(&ts->lock);
+        mutex_unlock(&ts->lock);
 
         return 0;
 }
 
-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;
@@ -855,149 +958,64 @@ static int __devinit setup_pendown(struct spi_device *spi, struct ads7846 *ts)
         err = gpio_request(pdata->gpio_pendown, "ads7846_pendown");
         if (err) {
                 dev_err(&spi->dev, "failed to request pendown GPIO%d\n",
-                                pdata->gpio_pendown);
+                        pdata->gpio_pendown);
                 return err;
         }
 
         ts->gpio_pendown = pdata->gpio_pendown;
+
         return 0;
 }
 
-static int __devinit ads7846_probe(struct spi_device *spi)
+/*
+ * 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 ads7846                  *ts;
-        struct ads7846_packet           *packet;
-        struct input_dev                *input_dev;
-        struct ads7846_platform_data    *pdata = spi->dev.platform_data;
-        struct spi_message              *m;
-        struct spi_transfer             *x;
-        int                             vref;
-        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 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;
+        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;
 
-        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;
+        if (ts->model == 7873) {
+                /*
+                 * The AD7873 is almost identical to the ADS7846
+                 * keep VREF off during differential/ratiometric
+                 * conversion modes.
+                 */
+                ts->model = 7846;
+                vref = 0;
         }
 
-        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);
-
-        vref = pdata->keep_vref_on;
-
-        /* 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;
 
-        /* y- still on; turn on only y+ (and ADC) */
-        packet->read_y = READ_Y(vref);
-        x->tx_buf = &packet->read_y;
-        x->len = 1;
-        spi_message_add_tail(x, m);
+        if (ts->model == 7845) {
+                packet->read_y_cmd[0] = READ_Y(vref);
+                packet->read_y_cmd[1] = 0;
+                packet->read_y_cmd[2] = 0;
+                x->tx_buf = &packet->read_y_cmd[0];
+                x->rx_buf = &packet->tc.y_buf[0];
+                x->len = 3;
+                spi_message_add_tail(x, m);
+        } else {
+                /* y- still on; turn on only y+ (and ADC) */
+                packet->read_y = READ_Y(vref);
+                x->tx_buf = &packet->read_y;
+                x->len = 1;
+                spi_message_add_tail(x, m);
 
-        x++;
-        x->rx_buf = &packet->tc.y;
-        x->len = 2;
-        spi_message_add_tail(x, m);
+                x++;
+                x->rx_buf = &packet->tc.y;
+                x->len = 2;
+                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.
          */
@@ -1015,23 +1033,33 @@ 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;
 
-        /* turn y- off, x+ on, then leave in lowpower */
-        x++;
-        packet->read_x = READ_X(vref);
-        x->tx_buf = &packet->read_x;
-        x->len = 1;
-        spi_message_add_tail(x, m);
+        if (ts->model == 7845) {
+                x++;
+                packet->read_x_cmd[0] = READ_X(vref);
+                packet->read_x_cmd[1] = 0;
+                packet->read_x_cmd[2] = 0;
+                x->tx_buf = &packet->read_x_cmd[0];
+                x->rx_buf = &packet->tc.x_buf[0];
+                x->len = 3;
+                spi_message_add_tail(x, m);
+        } else {
+                /* turn y- off, x+ on, then leave in lowpower */
+                x++;
+                packet->read_x = READ_X(vref);
+                x->tx_buf = &packet->read_x;
+                x->len = 1;
+                spi_message_add_tail(x, m);
 
-        x++;
-        x->rx_buf = &packet->tc.x;
-        x->len = 2;
-        spi_message_add_tail(x, m);
+                x++;
+                x->rx_buf = &packet->tc.x;
+                x->len = 2;
+                spi_message_add_tail(x, m);
+        }
 
         /* ... maybe discard first sample ... */
         if (pdata->settle_delay_usecs) {
@@ -1048,13 +1076,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);
@@ -1082,11 +1109,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);
@@ -1113,43 +1139,179 @@ 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;
 
-        x++;
-        packet->pwrdown = PWRDOWN;
-        x->tx_buf = &packet->pwrdown;
-        x->len = 1;
-        spi_message_add_tail(x, m);
+        if (ts->model == 7845) {
+                x++;
+                packet->pwrdown_cmd[0] = PWRDOWN;
+                packet->pwrdown_cmd[1] = 0;
+                packet->pwrdown_cmd[2] = 0;
+                x->tx_buf = &packet->pwrdown_cmd[0];
+                x->len = 3;
+        } else {
+                x++;
+                packet->pwrdown = PWRDOWN;
+                x->tx_buf = &packet->pwrdown;
+                x->len = 1;
+                spi_message_add_tail(x, m);
+
+                x++;
+                x->rx_buf = &packet->dummy;
+                x->len = 2;
+        }
 
-        x++;
-        x->rx_buf = &packet->dummy;
-        x->len = 2;
         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->last_msg = m;
+        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);
 
-        if (request_irq(spi->irq, ads7846_irq, IRQF_TRIGGER_FALLING,
-                        spi->dev.driver->name, ts)) {
+        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);
+
+        ads7846_setup_spi_msg(ts, pdata);
+
+        ts->reg = regulator_get(&spi->dev, "vcc");
+        if (IS_ERR(ts->reg)) {
+                err = PTR_ERR(ts->reg);
+                dev_err(&spi->dev, "unable to get regulator: %d\n", err);
+                goto err_free_gpio;
+        }
+
+        err = regulator_enable(ts->reg);
+        if (err) {
+                dev_err(&spi->dev, "unable to enable regulator: %d\n", err);
+                goto err_put_regulator;
+        }
+
+        irq_flags = pdata->irq_flags ? : IRQF_TRIGGER_FALLING;
+        irq_flags |= IRQF_ONESHOT;
+
+        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);
-                if (err) {
-                        dev_dbg(&spi->dev, "irq %d busy?\n", spi->irq);
-                        goto err_free_gpio;
-                }
+                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) {
+                dev_dbg(&spi->dev, "irq %d busy?\n", spi->irq);
+                goto err_disable_regulator;
         }
 
         err = ads784x_hwmon_register(spi, ts);
@@ -1158,11 +1320,15 @@ 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.
          */
-        (void) ads7846_read12_ser(&spi->dev,
-                          READ_12BIT_SER(vaux) | ADS_PD10_ALL_ON);
+        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);
 
         err = sysfs_create_group(&spi->dev.kobj, &ads784x_attr_group);
         if (err)
@@ -1172,6 +1338,8 @@ static int __devinit ads7846_probe(struct spi_device *spi)
         if (err)
                 goto err_remove_attr_group;
 
+        device_init_wakeup(&spi->dev, pdata->wakeup);
+
         return 0;
 
  err_remove_attr_group:
@@ -1180,6 +1348,10 @@ static int __devinit ads7846_probe(struct spi_device *spi)
         ads784x_hwmon_unregister(spi, ts);
  err_free_irq:
         free_irq(spi->irq, ts);
+ err_disable_regulator:
+        regulator_disable(ts->reg);
+ err_put_regulator:
+        regulator_put(ts->reg);
  err_free_gpio:
         if (ts->gpio_pendown != -1)
                 gpio_free(ts->gpio_pendown);
@@ -1195,18 +1367,21 @@ 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);
-
-        ads784x_hwmon_unregister(spi, ts);
-        input_unregister_device(ts->input);
+        struct ads7846 *ts = dev_get_drvdata(&spi->dev);
 
-        ads7846_suspend(spi, PMSG_SUSPEND);
+        device_init_wakeup(&spi->dev, false);
 
         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)
                 gpio_free(ts->gpio_pendown);
@@ -1218,6 +1393,7 @@ static int __devexit ads7846_remove(struct spi_device *spi)
         kfree(ts);
 
         dev_dbg(&spi->dev, "unregistered touchscreen\n");
+
         return 0;
 }
 
diff --git a/drivers/input/touchscreen/atmel-wm97xx.c b/drivers/input/touchscreen/atmel-wm97xx.c
index a12242f77e23..fa8e56bd9094 100644
--- a/drivers/input/touchscreen/atmel-wm97xx.c
+++ b/drivers/input/touchscreen/atmel-wm97xx.c
@@ -19,6 +19,7 @@
 #include <linux/timer.h>
 #include <linux/gpio.h>
 #include <linux/io.h>
+#include <linux/slab.h>
 
 #define AC97C_ICA               0x10
 #define AC97C_CBRHR             0x30
diff --git a/drivers/input/touchscreen/bu21013_ts.c b/drivers/input/touchscreen/bu21013_ts.c
new file mode 100644
index 000000000000..ccde58602563
--- /dev/null
+++ b/drivers/input/touchscreen/bu21013_ts.c
@@ -0,0 +1,648 @@
+/*
+ * 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>
+
+#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
+ *
+ * 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;
+};
+
+/**
+ * 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->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_free_mem;
+                }
+        }
+
+        /* 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->x_max_res, 0, 0);
+        input_set_abs_params(in_dev, ABS_MT_POSITION_Y, 0,
+                                                pdata->y_max_res, 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_free_mem:
+        input_free_device(bu21013_data->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);
+        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);
+
+        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 = 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/corgi_ts.c b/drivers/input/touchscreen/corgi_ts.c
deleted file mode 100644
index 94a1919d439d..000000000000
--- a/drivers/input/touchscreen/corgi_ts.c
+++ /dev/null
@@ -1,385 +0,0 @@
-/*
- *  Touchscreen driver for Sharp SL-C7xx and SL-Cxx00 models
- *
- *  Copyright (c) 2004-2005 Richard Purdie
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 2 as
- *  published by the Free Software Foundation.
- *
- */
-
-
-#include <linux/delay.h>
-#include <linux/platform_device.h>
-#include <linux/init.h>
-#include <linux/input.h>
-#include <linux/interrupt.h>
-#include <linux/module.h>
-#include <linux/slab.h>
-#include <linux/irq.h>
-
-#include <mach/sharpsl.h>
-#include <mach/hardware.h>
-#include <mach/pxa2xx-gpio.h>
-
-
-#define PWR_MODE_ACTIVE         0
-#define PWR_MODE_SUSPEND        1
-
-#define X_AXIS_MAX              3830
-#define X_AXIS_MIN              150
-#define Y_AXIS_MAX              3830
-#define Y_AXIS_MIN              190
-#define PRESSURE_MIN            0
-#define PRESSURE_MAX            15000
-
-struct ts_event {
-        short pressure;
-        short x;
-        short y;
-};
-
-struct corgi_ts {
-        struct input_dev *input;
-        struct timer_list timer;
-        struct ts_event tc;
-        int pendown;
-        int power_mode;
-        int irq_gpio;
-        struct corgits_machinfo *machinfo;
-};
-
-#ifdef CONFIG_PXA25x
-#define CCNT(a)         asm volatile ("mrc p14, 0, %0, C1, C0, 0" : "=r"(a))
-#define PMNC_GET(x)     asm volatile ("mrc p14, 0, %0, C0, C0, 0" : "=r"(x))
-#define PMNC_SET(x)     asm volatile ("mcr p14, 0, %0, C0, C0, 0" : : "r"(x))
-#endif
-#ifdef CONFIG_PXA27x
-#define CCNT(a)         asm volatile ("mrc p14, 0, %0, C1, C1, 0" : "=r"(a))
-#define PMNC_GET(x)     asm volatile ("mrc p14, 0, %0, C0, C1, 0" : "=r"(x))
-#define PMNC_SET(x)     asm volatile ("mcr p14, 0, %0, C0, C1, 0" : : "r"(x))
-#endif
-
-/* ADS7846 Touch Screen Controller bit definitions */
-#define ADSCTRL_PD0             (1u << 0)       /* PD0 */
-#define ADSCTRL_PD1             (1u << 1)       /* PD1 */
-#define ADSCTRL_DFR             (1u << 2)       /* SER/DFR */
-#define ADSCTRL_MOD             (1u << 3)       /* Mode */
-#define ADSCTRL_ADR_SH  4       /* Address setting */
-#define ADSCTRL_STS             (1u << 7)       /* Start Bit */
-
-/* External Functions */
-extern unsigned int get_clk_frequency_khz(int info);
-
-static unsigned long calc_waittime(struct corgi_ts *corgi_ts)
-{
-        unsigned long hsync_invperiod = corgi_ts->machinfo->get_hsync_invperiod();
-
-        if (hsync_invperiod)
-                return get_clk_frequency_khz(0)*1000/hsync_invperiod;
-        else
-                return 0;
-}
-
-static int sync_receive_data_send_cmd(struct corgi_ts *corgi_ts, int doRecive, int doSend,
-                unsigned int address, unsigned long wait_time)
-{
-        unsigned long timer1 = 0, timer2, pmnc = 0;
-        int pos = 0;
-
-        if (wait_time && doSend) {
-                PMNC_GET(pmnc);
-                if (!(pmnc & 0x01))
-                        PMNC_SET(0x01);
-
-                /* polling HSync */
-                corgi_ts->machinfo->wait_hsync();
-                /* get CCNT */
-                CCNT(timer1);
-        }
-
-        if (doRecive)
-                pos = corgi_ssp_ads7846_get();
-
-        if (doSend) {
-                int cmd = ADSCTRL_PD0 | ADSCTRL_PD1 | (address << ADSCTRL_ADR_SH) | ADSCTRL_STS;
-                /* dummy command */
-                corgi_ssp_ads7846_put(cmd);
-                corgi_ssp_ads7846_get();
-
-                if (wait_time) {
-                        /* Wait after HSync */
-                        CCNT(timer2);
-                        if (timer2-timer1 > wait_time) {
-                                /* too slow - timeout, try again */
-                                corgi_ts->machinfo->wait_hsync();
-                                /* get CCNT */
-                                CCNT(timer1);
-                                /* Wait after HSync */
-                                CCNT(timer2);
-                        }
-                        while (timer2 - timer1 < wait_time)
-                                CCNT(timer2);
-                }
-                corgi_ssp_ads7846_put(cmd);
-                if (wait_time && !(pmnc & 0x01))
-                        PMNC_SET(pmnc);
-        }
-        return pos;
-}
-
-static int read_xydata(struct corgi_ts *corgi_ts)
-{
-        unsigned int x, y, z1, z2;
-        unsigned long flags, wait_time;
-
-        /* critical section */
-        local_irq_save(flags);
-        corgi_ssp_ads7846_lock();
-        wait_time = calc_waittime(corgi_ts);
-
-        /* Y-axis */
-        sync_receive_data_send_cmd(corgi_ts, 0, 1, 1u, wait_time);
-
-        /* Y-axis */
-        sync_receive_data_send_cmd(corgi_ts, 1, 1, 1u, wait_time);
-
-        /* X-axis */
-        y = sync_receive_data_send_cmd(corgi_ts, 1, 1, 5u, wait_time);
-
-        /* Z1 */
-        x = sync_receive_data_send_cmd(corgi_ts, 1, 1, 3u, wait_time);
-
-        /* Z2 */
-        z1 = sync_receive_data_send_cmd(corgi_ts, 1, 1, 4u, wait_time);
-        z2 = sync_receive_data_send_cmd(corgi_ts, 1, 0, 4u, wait_time);
-
-        /* Power-Down Enable */
-        corgi_ssp_ads7846_put((1u << ADSCTRL_ADR_SH) | ADSCTRL_STS);
-        corgi_ssp_ads7846_get();
-
-        corgi_ssp_ads7846_unlock();
-        local_irq_restore(flags);
-
-        if (x== 0 || y == 0 || z1 == 0 || (x * (z2 - z1) / z1) >= 15000) {
-                corgi_ts->tc.pressure = 0;
-                return 0;
-        }
-
-        corgi_ts->tc.x = x;
-        corgi_ts->tc.y = y;
-        corgi_ts->tc.pressure = (x * (z2 - z1)) / z1;
-        return 1;
-}
-
-static void new_data(struct corgi_ts *corgi_ts)
-{
-        struct input_dev *dev = corgi_ts->input;
-
-        if (corgi_ts->power_mode != PWR_MODE_ACTIVE)
-                return;
-
-        if (!corgi_ts->tc.pressure && corgi_ts->pendown == 0)
-                return;
-
-        input_report_abs(dev, ABS_X, corgi_ts->tc.x);
-        input_report_abs(dev, ABS_Y, corgi_ts->tc.y);
-        input_report_abs(dev, ABS_PRESSURE, corgi_ts->tc.pressure);
-        input_report_key(dev, BTN_TOUCH, corgi_ts->pendown);
-        input_sync(dev);
-}
-
-static void ts_interrupt_main(struct corgi_ts *corgi_ts, int isTimer)
-{
-        if ((GPLR(IRQ_TO_GPIO(corgi_ts->irq_gpio)) & GPIO_bit(IRQ_TO_GPIO(corgi_ts->irq_gpio))) == 0) {
-                /* Disable Interrupt */
-                set_irq_type(corgi_ts->irq_gpio, IRQ_TYPE_NONE);
-                if (read_xydata(corgi_ts)) {
-                        corgi_ts->pendown = 1;
-                        new_data(corgi_ts);
-                }
-                mod_timer(&corgi_ts->timer, jiffies + HZ / 100);
-        } else {
-                if (corgi_ts->pendown == 1 || corgi_ts->pendown == 2) {
-                        mod_timer(&corgi_ts->timer, jiffies + HZ / 100);
-                        corgi_ts->pendown++;
-                        return;
-                }
-
-                if (corgi_ts->pendown) {
-                        corgi_ts->tc.pressure = 0;
-                        new_data(corgi_ts);
-                }
-
-                /* Enable Falling Edge */
-                set_irq_type(corgi_ts->irq_gpio, IRQ_TYPE_EDGE_FALLING);
-                corgi_ts->pendown = 0;
-        }
-}
-
-static void corgi_ts_timer(unsigned long data)
-{
-        struct corgi_ts *corgits_data = (struct corgi_ts *) data;
-
-        ts_interrupt_main(corgits_data, 1);
-}
-
-static irqreturn_t ts_interrupt(int irq, void *dev_id)
-{
-        struct corgi_ts *corgits_data = dev_id;
-
-        ts_interrupt_main(corgits_data, 0);
-        return IRQ_HANDLED;
-}
-
-#ifdef CONFIG_PM
-static int corgits_suspend(struct platform_device *dev, pm_message_t state)
-{
-        struct corgi_ts *corgi_ts = platform_get_drvdata(dev);
-
-        if (corgi_ts->pendown) {
-                del_timer_sync(&corgi_ts->timer);
-                corgi_ts->tc.pressure = 0;
-                new_data(corgi_ts);
-                corgi_ts->pendown = 0;
-        }
-        corgi_ts->power_mode = PWR_MODE_SUSPEND;
-
-        corgi_ssp_ads7846_putget((1u << ADSCTRL_ADR_SH) | ADSCTRL_STS);
-
-        return 0;
-}
-
-static int corgits_resume(struct platform_device *dev)
-{
-        struct corgi_ts *corgi_ts = platform_get_drvdata(dev);
-
-        corgi_ssp_ads7846_putget((4u << ADSCTRL_ADR_SH) | ADSCTRL_STS);
-        /* Enable Falling Edge */
-        set_irq_type(corgi_ts->irq_gpio, IRQ_TYPE_EDGE_FALLING);
-        corgi_ts->power_mode = PWR_MODE_ACTIVE;
-
-        return 0;
-}
-#else
-#define corgits_suspend         NULL
-#define corgits_resume          NULL
-#endif
-
-static int __devinit corgits_probe(struct platform_device *pdev)
-{
-        struct corgi_ts *corgi_ts;
-        struct input_dev *input_dev;
-        int err = -ENOMEM;
-
-        corgi_ts = kzalloc(sizeof(struct corgi_ts), GFP_KERNEL);
-        input_dev = input_allocate_device();
-        if (!corgi_ts || !input_dev)
-                goto fail1;
-
-        platform_set_drvdata(pdev, corgi_ts);
-
-        corgi_ts->machinfo = pdev->dev.platform_data;
-        corgi_ts->irq_gpio = platform_get_irq(pdev, 0);
-
-        if (corgi_ts->irq_gpio < 0) {
-                err = -ENODEV;
-                goto fail1;
-        }
-
-        corgi_ts->input = input_dev;
-
-        init_timer(&corgi_ts->timer);
-        corgi_ts->timer.data = (unsigned long) corgi_ts;
-        corgi_ts->timer.function = corgi_ts_timer;
-
-        input_dev->name = "Corgi Touchscreen";
-        input_dev->phys = "corgits/input0";
-        input_dev->id.bustype = BUS_HOST;
-        input_dev->id.vendor = 0x0001;
-        input_dev->id.product = 0x0002;
-        input_dev->id.version = 0x0100;
-        input_dev->dev.parent = &pdev->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, X_AXIS_MIN, X_AXIS_MAX, 0, 0);
-        input_set_abs_params(input_dev, ABS_Y, Y_AXIS_MIN, Y_AXIS_MAX, 0, 0);
-        input_set_abs_params(input_dev, ABS_PRESSURE, PRESSURE_MIN, PRESSURE_MAX, 0, 0);
-
-        pxa_gpio_mode(IRQ_TO_GPIO(corgi_ts->irq_gpio) | GPIO_IN);
-
-        /* Initiaize ADS7846 Difference Reference mode */
-        corgi_ssp_ads7846_putget((1u << ADSCTRL_ADR_SH) | ADSCTRL_STS);
-        mdelay(5);
-        corgi_ssp_ads7846_putget((3u << ADSCTRL_ADR_SH) | ADSCTRL_STS);
-        mdelay(5);
-        corgi_ssp_ads7846_putget((4u << ADSCTRL_ADR_SH) | ADSCTRL_STS);
-        mdelay(5);
-        corgi_ssp_ads7846_putget((5u << ADSCTRL_ADR_SH) | ADSCTRL_STS);
-        mdelay(5);
-
-        if (request_irq(corgi_ts->irq_gpio, ts_interrupt, IRQF_DISABLED, "ts", corgi_ts)) {
-                err = -EBUSY;
-                goto fail1;
-        }
-
-        err = input_register_device(corgi_ts->input);
-        if (err)
-                goto fail2;
-
-        corgi_ts->power_mode = PWR_MODE_ACTIVE;
-
-        /* Enable Falling Edge */
-        set_irq_type(corgi_ts->irq_gpio, IRQ_TYPE_EDGE_FALLING);
-
-        return 0;
-
- fail2: free_irq(corgi_ts->irq_gpio, corgi_ts);
- fail1: input_free_device(input_dev);
-        kfree(corgi_ts);
-        return err;
-}
-
-static int __devexit corgits_remove(struct platform_device *pdev)
-{
-        struct corgi_ts *corgi_ts = platform_get_drvdata(pdev);
-
-        free_irq(corgi_ts->irq_gpio, corgi_ts);
-        del_timer_sync(&corgi_ts->timer);
-        corgi_ts->machinfo->put_hsync();
-        input_unregister_device(corgi_ts->input);
-        kfree(corgi_ts);
-
-        return 0;
-}
-
-static struct platform_driver corgits_driver = {
-        .probe          = corgits_probe,
-        .remove         = __devexit_p(corgits_remove),
-        .suspend        = corgits_suspend,
-        .resume         = corgits_resume,
-        .driver         = {
-                .name   = "corgi-ts",
-                .owner  = THIS_MODULE,
-        },
-};
-
-static int __init corgits_init(void)
-{
-        return platform_driver_register(&corgits_driver);
-}
-
-static void __exit corgits_exit(void)
-{
-        platform_driver_unregister(&corgits_driver);
-}
-
-module_init(corgits_init);
-module_exit(corgits_exit);
-
-MODULE_AUTHOR("Richard Purdie <rpurdie@rpsys.net>");
-MODULE_DESCRIPTION("Corgi TouchScreen Driver");
-MODULE_LICENSE("GPL");
-MODULE_ALIAS("platform:corgi-ts");
diff --git a/drivers/input/touchscreen/cy8ctmg110_ts.c b/drivers/input/touchscreen/cy8ctmg110_ts.c
new file mode 100644
index 000000000000..d0c3a7229adf
--- /dev/null
+++ b/drivers/input/touchscreen/cy8ctmg110_ts.c
@@ -0,0 +1,363 @@
+/*
+ * Driver for cypress touch screen controller
+ *
+ * Copyright (c) 2009 Aava Mobile
+ *
+ * Some cleanups by Alan Cox <alan@linux.intel.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, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/input.h>
+#include <linux/slab.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/i2c.h>
+#include <linux/gpio.h>
+#include <linux/input/cy8ctmg110_pdata.h>
+
+#define CY8CTMG110_DRIVER_NAME      "cy8ctmg110"
+
+/* Touch coordinates */
+#define CY8CTMG110_X_MIN                0
+#define CY8CTMG110_Y_MIN                0
+#define CY8CTMG110_X_MAX                759
+#define CY8CTMG110_Y_MAX                465
+
+
+/* cy8ctmg110 register definitions */
+#define CY8CTMG110_TOUCH_WAKEUP_TIME    0
+#define CY8CTMG110_TOUCH_SLEEP_TIME     2
+#define CY8CTMG110_TOUCH_X1             3
+#define CY8CTMG110_TOUCH_Y1             5
+#define CY8CTMG110_TOUCH_X2             7
+#define CY8CTMG110_TOUCH_Y2             9
+#define CY8CTMG110_FINGERS              11
+#define CY8CTMG110_GESTURE              12
+#define CY8CTMG110_REG_MAX              13
+
+
+/*
+ * The touch driver structure.
+ */
+struct cy8ctmg110 {
+        struct input_dev *input;
+        char phys[32];
+        struct i2c_client *client;
+        int reset_pin;
+        int irq_pin;
+};
+
+/*
+ * cy8ctmg110_power is the routine that is called when touch hardware
+ * will powered off or on.
+ */
+static void cy8ctmg110_power(struct cy8ctmg110 *ts, bool poweron)
+{
+        if (ts->reset_pin)
+                gpio_direction_output(ts->reset_pin, 1 - poweron);
+}
+
+static int cy8ctmg110_write_regs(struct cy8ctmg110 *tsc, unsigned char reg,
+                unsigned char len, unsigned char *value)
+{
+        struct i2c_client *client = tsc->client;
+        int ret;
+        unsigned char i2c_data[6];
+
+        BUG_ON(len > 5);
+
+        i2c_data[0] = reg;
+        memcpy(i2c_data + 1, value, len);
+
+        ret = i2c_master_send(client, i2c_data, len + 1);
+        if (ret != 1) {
+                dev_err(&client->dev, "i2c write data cmd failed\n");
+                return ret ? ret : -EIO;
+        }
+
+        return 0;
+}
+
+static int cy8ctmg110_read_regs(struct cy8ctmg110 *tsc,
+                unsigned char *data, unsigned char len, unsigned char cmd)
+{
+        struct i2c_client *client = tsc->client;
+        int ret;
+        struct i2c_msg msg[2] = {
+                /* first write slave position to i2c devices */
+                { client->addr, 0, 1, &cmd },
+                /* Second read data from position */
+                { client->addr, I2C_M_RD, len, data }
+        };
+
+        ret = i2c_transfer(client->adapter, msg, 2);
+        if (ret < 0)
+                return ret;
+
+        return 0;
+}
+
+static int cy8ctmg110_touch_pos(struct cy8ctmg110 *tsc)
+{
+        struct input_dev *input = tsc->input;
+        unsigned char reg_p[CY8CTMG110_REG_MAX];
+        int x, y;
+
+        memset(reg_p, 0, CY8CTMG110_REG_MAX);
+
+        /* Reading coordinates */
+        if (cy8ctmg110_read_regs(tsc, reg_p, 9, CY8CTMG110_TOUCH_X1) != 0)
+                return -EIO;
+
+        y = reg_p[2] << 8 | reg_p[3];
+        x = reg_p[0] << 8 | reg_p[1];
+
+        /* Number of touch */
+        if (reg_p[8] == 0) {
+                input_report_key(input, BTN_TOUCH, 0);
+        } else  {
+                input_report_key(input, BTN_TOUCH, 1);
+                input_report_abs(input, ABS_X, x);
+                input_report_abs(input, ABS_Y, y);
+        }
+
+        input_sync(input);
+
+        return 0;
+}
+
+static int cy8ctmg110_set_sleepmode(struct cy8ctmg110 *ts, bool sleep)
+{
+        unsigned char reg_p[3];
+
+        if (sleep) {
+                reg_p[0] = 0x00;
+                reg_p[1] = 0xff;
+                reg_p[2] = 5;
+        } else {
+                reg_p[0] = 0x10;
+                reg_p[1] = 0xff;
+                reg_p[2] = 0;
+        }
+
+        return cy8ctmg110_write_regs(ts, CY8CTMG110_TOUCH_WAKEUP_TIME, 3, reg_p);
+}
+
+static irqreturn_t cy8ctmg110_irq_thread(int irq, void *dev_id)
+{
+        struct cy8ctmg110 *tsc = dev_id;
+
+        cy8ctmg110_touch_pos(tsc);
+
+        return IRQ_HANDLED;
+}
+
+static int __devinit cy8ctmg110_probe(struct i2c_client *client,
+                                        const struct i2c_device_id *id)
+{
+        const struct cy8ctmg110_pdata *pdata = client->dev.platform_data;
+        struct cy8ctmg110 *ts;
+        struct input_dev *input_dev;
+        int err;
+
+        /* No pdata no way forward */
+        if (pdata == NULL) {
+                dev_err(&client->dev, "no pdata\n");
+                return -ENODEV;
+        }
+
+        if (!i2c_check_functionality(client->adapter,
+                                        I2C_FUNC_SMBUS_READ_WORD_DATA))
+                return -EIO;
+
+        ts = kzalloc(sizeof(struct cy8ctmg110), GFP_KERNEL);
+        input_dev = input_allocate_device();
+        if (!ts || !input_dev) {
+                err = -ENOMEM;
+                goto err_free_mem;
+        }
+
+        ts->client = client;
+        ts->input = input_dev;
+
+        snprintf(ts->phys, sizeof(ts->phys),
+                 "%s/input0", dev_name(&client->dev));
+
+        input_dev->name = CY8CTMG110_DRIVER_NAME " Touchscreen";
+        input_dev->phys = ts->phys;
+        input_dev->id.bustype = BUS_I2C;
+        input_dev->dev.parent = &client->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,
+                        CY8CTMG110_X_MIN, CY8CTMG110_X_MAX, 4, 0);
+        input_set_abs_params(input_dev, ABS_Y,
+                        CY8CTMG110_Y_MIN, CY8CTMG110_Y_MAX, 4, 0);
+
+        if (ts->reset_pin) {
+                err = gpio_request(ts->reset_pin, NULL);
+                if (err) {
+                        dev_err(&client->dev,
+                                "Unable to request GPIO pin %d.\n",
+                                ts->reset_pin);
+                        goto err_free_mem;
+                }
+        }
+
+        cy8ctmg110_power(ts, true);
+        cy8ctmg110_set_sleepmode(ts, false);
+
+        err = gpio_request(ts->irq_pin, "touch_irq_key");
+        if (err < 0) {
+                dev_err(&client->dev,
+                        "Failed to request GPIO %d, error %d\n",
+                        ts->irq_pin, err);
+                goto err_shutoff_device;
+        }
+
+        err = gpio_direction_input(ts->irq_pin);
+        if (err < 0) {
+                dev_err(&client->dev,
+                        "Failed to configure input direction for GPIO %d, error %d\n",
+                        ts->irq_pin, err);
+                goto err_free_irq_gpio;
+        }
+
+        client->irq = gpio_to_irq(ts->irq_pin);
+        if (client->irq < 0) {
+                err = client->irq;
+                dev_err(&client->dev,
+                        "Unable to get irq number for GPIO %d, error %d\n",
+                        ts->irq_pin, err);
+                goto err_free_irq_gpio;
+        }
+
+        err = request_threaded_irq(client->irq, NULL, cy8ctmg110_irq_thread,
+                                   IRQF_TRIGGER_RISING, "touch_reset_key", ts);
+        if (err < 0) {
+                dev_err(&client->dev,
+                        "irq %d busy? error %d\n", client->irq, err);
+                goto err_free_irq_gpio;
+        }
+
+        err = input_register_device(input_dev);
+        if (err)
+                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_irq_gpio:
+        gpio_free(ts->irq_pin);
+err_shutoff_device:
+        cy8ctmg110_set_sleepmode(ts, true);
+        cy8ctmg110_power(ts, false);
+        if (ts->reset_pin)
+                gpio_free(ts->reset_pin);
+err_free_mem:
+        input_free_device(input_dev);
+        kfree(ts);
+        return err;
+}
+
+#ifdef CONFIG_PM
+static int cy8ctmg110_suspend(struct i2c_client *client, pm_message_t mesg)
+{
+        struct cy8ctmg110 *ts = i2c_get_clientdata(client);
+
+        if (device_may_wakeup(&client->dev))
+                enable_irq_wake(client->irq);
+        else {
+                cy8ctmg110_set_sleepmode(ts, true);
+                cy8ctmg110_power(ts, false);
+        }
+        return 0;
+}
+
+static int cy8ctmg110_resume(struct i2c_client *client)
+{
+        struct cy8ctmg110 *ts = i2c_get_clientdata(client);
+
+        if (device_may_wakeup(&client->dev))
+                disable_irq_wake(client->irq);
+        else {
+                cy8ctmg110_power(ts, true);
+                cy8ctmg110_set_sleepmode(ts, false);
+        }
+        return 0;
+}
+#endif
+
+static int __devexit cy8ctmg110_remove(struct i2c_client *client)
+{
+        struct cy8ctmg110 *ts = i2c_get_clientdata(client);
+
+        cy8ctmg110_set_sleepmode(ts, true);
+        cy8ctmg110_power(ts, false);
+
+        free_irq(client->irq, ts);
+        input_unregister_device(ts->input);
+        gpio_free(ts->irq_pin);
+        if (ts->reset_pin)
+                gpio_free(ts->reset_pin);
+        kfree(ts);
+
+        return 0;
+}
+
+static struct i2c_device_id cy8ctmg110_idtable[] = {
+        { CY8CTMG110_DRIVER_NAME, 1 },
+        { }
+};
+
+MODULE_DEVICE_TABLE(i2c, cy8ctmg110_idtable);
+
+static struct i2c_driver cy8ctmg110_driver = {
+        .driver         = {
+                .owner  = THIS_MODULE,
+                .name   = CY8CTMG110_DRIVER_NAME,
+        },
+        .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)
+{
+        return i2c_add_driver(&cy8ctmg110_driver);
+}
+
+static void __exit cy8ctmg110_exit(void)
+{
+        i2c_del_driver(&cy8ctmg110_driver);
+}
+
+module_init(cy8ctmg110_init);
+module_exit(cy8ctmg110_exit);
+
+MODULE_AUTHOR("Samuli Konttila <samuli.konttila@aavamobile.com>");
+MODULE_DESCRIPTION("cy8ctmg110 TouchScreen Driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/input/touchscreen/da9034-ts.c b/drivers/input/touchscreen/da9034-ts.c
index 3ffd4c4b170c..2b72a5923c16 100644
--- a/drivers/input/touchscreen/da9034-ts.c
+++ b/drivers/input/touchscreen/da9034-ts.c
@@ -19,6 +19,7 @@
 #include <linux/input.h>
 #include <linux/workqueue.h>
 #include <linux/mfd/da903x.h>
+#include <linux/slab.h>
 
 #define DA9034_MANUAL_CTRL      0x50
 #define DA9034_LDO_ADC_EN       (1 << 4)
diff --git a/drivers/input/touchscreen/eeti_ts.c b/drivers/input/touchscreen/eeti_ts.c
index 9029bd3f34e5..7a3a916f84a8 100644
--- a/drivers/input/touchscreen/eeti_ts.c
+++ b/drivers/input/touchscreen/eeti_ts.c
@@ -33,6 +33,7 @@
 #include <linux/timer.h>
 #include <linux/gpio.h>
 #include <linux/input/eeti_ts.h>
+#include <linux/slab.h>
 
 static int flip_x;
 module_param(flip_x, bool, 0644);
@@ -123,14 +124,25 @@ static irqreturn_t eeti_ts_isr(int irq, void *dev_id)
         return IRQ_HANDLED;
 }
 
-static int eeti_ts_open(struct input_dev *dev)
+static void eeti_ts_start(struct eeti_ts_priv *priv)
 {
-        struct eeti_ts_priv *priv = input_get_drvdata(dev);
-
         enable_irq(priv->irq);
 
         /* Read the events once to arm the IRQ */
         eeti_ts_read(&priv->work);
+}
+
+static void eeti_ts_stop(struct eeti_ts_priv *priv)
+{
+        disable_irq(priv->irq);
+        cancel_work_sync(&priv->work);
+}
+
+static int eeti_ts_open(struct input_dev *dev)
+{
+        struct eeti_ts_priv *priv = input_get_drvdata(dev);
+
+        eeti_ts_start(priv);
 
         return 0;
 }
@@ -139,8 +151,7 @@ static void eeti_ts_close(struct input_dev *dev)
 {
         struct eeti_ts_priv *priv = input_get_drvdata(dev);
 
-        disable_irq(priv->irq);
-        cancel_work_sync(&priv->work);
+        eeti_ts_stop(priv);
 }
 
 static int __devinit eeti_ts_probe(struct i2c_client *client,
@@ -152,10 +163,12 @@ static int __devinit eeti_ts_probe(struct i2c_client *client,
         unsigned int irq_flags;
         int err = -ENOMEM;
 
-        /* In contrast to what's described in the datasheet, there seems
+        /*
+         * In contrast to what's described in the datasheet, there seems
          * to be no way of probing the presence of that device using I2C
          * commands. So we need to blindly believe it is there, and wait
-         * for interrupts to occur. */
+         * for interrupts to occur.
+         */
 
         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
         if (!priv) {
@@ -211,9 +224,11 @@ static int __devinit eeti_ts_probe(struct i2c_client *client,
                 goto err2;
         }
 
-        /* Disable the irq for now. It will be enabled once the input device
-         * is opened. */
-        disable_irq(priv->irq);
+        /*
+         * Disable the device for now. It will be enabled once the
+         * input device is opened.
+         */
+        eeti_ts_stop(priv);
 
         device_init_wakeup(&client->dev, 0);
         return 0;
@@ -223,7 +238,6 @@ err2:
         input = NULL; /* so we dont try to free it below */
 err1:
         input_free_device(input);
-        i2c_set_clientdata(client, NULL);
         kfree(priv);
 err0:
         return err;
@@ -234,8 +248,13 @@ static int __devexit eeti_ts_remove(struct i2c_client *client)
         struct eeti_ts_priv *priv = i2c_get_clientdata(client);
 
         free_irq(priv->irq, priv);
+        /*
+         * eeti_ts_stop() leaves IRQ disabled. We need to re-enable it
+         * so that device still works if we reload the driver.
+         */
+        enable_irq(priv->irq);
+
         input_unregister_device(priv->input);
-        i2c_set_clientdata(client, NULL);
         kfree(priv);
 
         return 0;
@@ -245,6 +264,14 @@ static int __devexit eeti_ts_remove(struct i2c_client *client)
 static int eeti_ts_suspend(struct i2c_client *client, pm_message_t mesg)
 {
         struct eeti_ts_priv *priv = i2c_get_clientdata(client);
+        struct input_dev *input_dev = priv->input;
+
+        mutex_lock(&input_dev->mutex);
+
+        if (input_dev->users)
+                eeti_ts_stop(priv);
+
+        mutex_unlock(&input_dev->mutex);
 
         if (device_may_wakeup(&client->dev))
                 enable_irq_wake(priv->irq);
@@ -255,10 +282,18 @@ static int eeti_ts_suspend(struct i2c_client *client, pm_message_t mesg)
 static int eeti_ts_resume(struct i2c_client *client)
 {
         struct eeti_ts_priv *priv = i2c_get_clientdata(client);
+        struct input_dev *input_dev = priv->input;
 
         if (device_may_wakeup(&client->dev))
                 disable_irq_wake(priv->irq);
 
+        mutex_lock(&input_dev->mutex);
+
+        if (input_dev->users)
+                eeti_ts_start(priv);
+
+        mutex_unlock(&input_dev->mutex);
+
         return 0;
 }
 #else
diff --git a/drivers/input/touchscreen/elo.c b/drivers/input/touchscreen/elo.c
index 8f38c5e55ce6..486d31ba9c09 100644
--- a/drivers/input/touchscreen/elo.c
+++ b/drivers/input/touchscreen/elo.c
@@ -72,45 +72,49 @@ static void elo_process_data_10(struct elo *elo, unsigned char data)
         struct input_dev *dev = elo->dev;
 
         elo->data[elo->idx] = data;
-        switch (elo->idx++) {
-                case 0:
-                        elo->csum = 0xaa;
-                        if (data != ELO10_LEAD_BYTE) {
-                                pr_debug("elo: unsynchronized data: 0x%02x\n", data);
-                                elo->idx = 0;
-                        }
-                        break;
 
-                case 9:
+        switch (elo->idx++) {
+        case 0:
+                elo->csum = 0xaa;
+                if (data != ELO10_LEAD_BYTE) {
+                        dev_dbg(&elo->serio->dev,
+                                "unsynchronized data: 0x%02x\n", data);
                         elo->idx = 0;
-                        if (data != elo->csum) {
-                                pr_debug("elo: bad checksum: 0x%02x, expected 0x%02x\n",
-                                         data, elo->csum);
-                                break;
-                        }
-                        if (elo->data[1] != elo->expected_packet) {
-                                if (elo->data[1] != ELO10_TOUCH_PACKET)
-                                        pr_debug("elo: unexpected packet: 0x%02x\n",
-                                                 elo->data[1]);
-                                break;
-                        }
-                        if (likely(elo->data[1] == ELO10_TOUCH_PACKET)) {
-                                input_report_abs(dev, ABS_X, (elo->data[4] << 8) | elo->data[3]);
-                                input_report_abs(dev, ABS_Y, (elo->data[6] << 8) | elo->data[5]);
-                                if (elo->data[2] & ELO10_PRESSURE)
-                                        input_report_abs(dev, ABS_PRESSURE,
-                                                        (elo->data[8] << 8) | elo->data[7]);
-                                input_report_key(dev, BTN_TOUCH, elo->data[2] & ELO10_TOUCH);
-                                input_sync(dev);
-                        } else if (elo->data[1] == ELO10_ACK_PACKET) {
-                                if (elo->data[2] == '0')
-                                        elo->expected_packet = ELO10_TOUCH_PACKET;
-                                complete(&elo->cmd_done);
-                        } else {
-                                memcpy(elo->response, &elo->data[1], ELO10_PACKET_LEN);
-                                elo->expected_packet = ELO10_ACK_PACKET;
-                        }
+                }
+                break;
+
+        case 9:
+                elo->idx = 0;
+                if (data != elo->csum) {
+                        dev_dbg(&elo->serio->dev,
+                                "bad checksum: 0x%02x, expected 0x%02x\n",
+                                 data, elo->csum);
+                        break;
+                }
+                if (elo->data[1] != elo->expected_packet) {
+                        if (elo->data[1] != ELO10_TOUCH_PACKET)
+                                dev_dbg(&elo->serio->dev,
+                                        "unexpected packet: 0x%02x\n",
+                                         elo->data[1]);
                         break;
+                }
+                if (likely(elo->data[1] == ELO10_TOUCH_PACKET)) {
+                        input_report_abs(dev, ABS_X, (elo->data[4] << 8) | elo->data[3]);
+                        input_report_abs(dev, ABS_Y, (elo->data[6] << 8) | elo->data[5]);
+                        if (elo->data[2] & ELO10_PRESSURE)
+                                input_report_abs(dev, ABS_PRESSURE,
+                                                (elo->data[8] << 8) | elo->data[7]);
+                        input_report_key(dev, BTN_TOUCH, elo->data[2] & ELO10_TOUCH);
+                        input_sync(dev);
+                } else if (elo->data[1] == ELO10_ACK_PACKET) {
+                        if (elo->data[2] == '0')
+                                elo->expected_packet = ELO10_TOUCH_PACKET;
+                        complete(&elo->cmd_done);
+                } else {
+                        memcpy(elo->response, &elo->data[1], ELO10_PACKET_LEN);
+                        elo->expected_packet = ELO10_ACK_PACKET;
+                }
+                break;
         }
         elo->csum += data;
 }
@@ -123,42 +127,53 @@ static void elo_process_data_6(struct elo *elo, unsigned char data)
 
         switch (elo->idx++) {
 
-                case 0: if ((data & 0xc0) != 0xc0) elo->idx = 0; break;
-                case 1: if ((data & 0xc0) != 0x80) elo->idx = 0; break;
-                case 2: if ((data & 0xc0) != 0x40) elo->idx = 0; break;
-
-                case 3:
-                        if (data & 0xc0) {
-                                elo->idx = 0;
-                                break;
-                        }
+        case 0:
+                if ((data & 0xc0) != 0xc0)
+                        elo->idx = 0;
+                break;
 
-                        input_report_abs(dev, ABS_X, ((elo->data[0] & 0x3f) << 6) | (elo->data[1] & 0x3f));
-                        input_report_abs(dev, ABS_Y, ((elo->data[2] & 0x3f) << 6) | (elo->data[3] & 0x3f));
+        case 1:
+                if ((data & 0xc0) != 0x80)
+                        elo->idx = 0;
+                break;
 
-                        if (elo->id == 2) {
-                                input_report_key(dev, BTN_TOUCH, 1);
-                                input_sync(dev);
-                                elo->idx = 0;
-                        }
+        case 2:
+                if ((data & 0xc0) != 0x40)
+                        elo->idx = 0;
+                break;
 
+        case 3:
+                if (data & 0xc0) {
+                        elo->idx = 0;
                         break;
+                }
 
-                case 4:
-                        if (data) {
-                                input_sync(dev);
-                                elo->idx = 0;
-                        }
-                        break;
+                input_report_abs(dev, ABS_X, ((elo->data[0] & 0x3f) << 6) | (elo->data[1] & 0x3f));
+                input_report_abs(dev, ABS_Y, ((elo->data[2] & 0x3f) << 6) | (elo->data[3] & 0x3f));
 
-                case 5:
-                        if ((data & 0xf0) == 0) {
-                                input_report_abs(dev, ABS_PRESSURE, elo->data[5]);
-                                input_report_key(dev, BTN_TOUCH, !!elo->data[5]);
-                        }
+                if (elo->id == 2) {
+                        input_report_key(dev, BTN_TOUCH, 1);
                         input_sync(dev);
                         elo->idx = 0;
-                        break;
+                }
+
+                break;
+
+        case 4:
+                if (data) {
+                        input_sync(dev);
+                        elo->idx = 0;
+                }
+                break;
+
+        case 5:
+                if ((data & 0xf0) == 0) {
+                        input_report_abs(dev, ABS_PRESSURE, elo->data[5]);
+                        input_report_key(dev, BTN_TOUCH, !!elo->data[5]);
+                }
+                input_sync(dev);
+                elo->idx = 0;
+                break;
         }
 }
 
@@ -170,17 +185,17 @@ static void elo_process_data_3(struct elo *elo, unsigned char data)
 
         switch (elo->idx++) {
 
-                case 0:
-                        if ((data & 0x7f) != 0x01)
-                                elo->idx = 0;
-                        break;
-                case 2:
-                        input_report_key(dev, BTN_TOUCH, !(elo->data[1] & 0x80));
-                        input_report_abs(dev, ABS_X, elo->data[1]);
-                        input_report_abs(dev, ABS_Y, elo->data[2]);
-                        input_sync(dev);
+        case 0:
+                if ((data & 0x7f) != 0x01)
                         elo->idx = 0;
-                        break;
+                break;
+        case 2:
+                input_report_key(dev, BTN_TOUCH, !(elo->data[1] & 0x80));
+                input_report_abs(dev, ABS_X, elo->data[1]);
+                input_report_abs(dev, ABS_Y, elo->data[2]);
+                input_sync(dev);
+                elo->idx = 0;
+                break;
         }
 }
 
@@ -189,19 +204,19 @@ static irqreturn_t elo_interrupt(struct serio *serio,
 {
         struct elo *elo = serio_get_drvdata(serio);
 
-        switch(elo->id) {
-                case 0:
-                        elo_process_data_10(elo, data);
-                        break;
-
-                case 1:
-                case 2:
-                        elo_process_data_6(elo, data);
-                        break;
-
-                case 3:
-                        elo_process_data_3(elo, data);
-                        break;
+        switch (elo->id) {
+        case 0:
+                elo_process_data_10(elo, data);
+                break;
+
+        case 1:
+        case 2:
+                elo_process_data_6(elo, data);
+                break;
+
+        case 3:
+                elo_process_data_3(elo, data);
+                break;
         }
 
         return IRQ_HANDLED;
@@ -261,10 +276,10 @@ static int elo_setup_10(struct elo *elo)
         if (packet[3] & ELO10_PRESSURE)
                 input_set_abs_params(dev, ABS_PRESSURE, 0, 255, 0, 0);
 
-        printk(KERN_INFO "elo: %sTouch touchscreen, fw: %02x.%02x, "
-                "features: 0x%02x, controller: 0x%02x\n",
-                elo_types[(packet[1] -'0') & 0x03],
-                packet[5], packet[4], packet[3], packet[7]);
+        dev_info(&elo->serio->dev,
+                 "%sTouch touchscreen, fw: %02x.%02x, features: 0x%02x, controller: 0x%02x\n",
+                 elo_types[(packet[1] -'0') & 0x03],
+                 packet[5], packet[4], packet[3], packet[7]);
 
         return 0;
 }
@@ -330,24 +345,24 @@ static int elo_connect(struct serio *serio, struct serio_driver *drv)
 
         switch (elo->id) {
 
-                case 0: /* 10-byte protocol */
-                        if (elo_setup_10(elo))
-                                goto fail3;
+        case 0: /* 10-byte protocol */
+                if (elo_setup_10(elo))
+                        goto fail3;
 
-                        break;
+                break;
 
-                case 1: /* 6-byte protocol */
-                        input_set_abs_params(input_dev, ABS_PRESSURE, 0, 15, 0, 0);
+        case 1: /* 6-byte protocol */
+                input_set_abs_params(input_dev, ABS_PRESSURE, 0, 15, 0, 0);
 
-                case 2: /* 4-byte protocol */
-                        input_set_abs_params(input_dev, ABS_X, 96, 4000, 0, 0);
-                        input_set_abs_params(input_dev, ABS_Y, 96, 4000, 0, 0);
-                        break;
+        case 2: /* 4-byte protocol */
+                input_set_abs_params(input_dev, ABS_X, 96, 4000, 0, 0);
+                input_set_abs_params(input_dev, ABS_Y, 96, 4000, 0, 0);
+                break;
 
-                case 3: /* 3-byte protocol */
-                        input_set_abs_params(input_dev, ABS_X, 0, 255, 0, 0);
-                        input_set_abs_params(input_dev, ABS_Y, 0, 255, 0, 0);
-                        break;
+        case 3: /* 3-byte protocol */
+                input_set_abs_params(input_dev, ABS_X, 0, 255, 0, 0);
+                input_set_abs_params(input_dev, ABS_Y, 0, 255, 0, 0);
+                break;
         }
 
         err = input_register_device(elo->dev);
diff --git a/drivers/input/touchscreen/hampshire.c b/drivers/input/touchscreen/hampshire.c
new file mode 100644
index 000000000000..2da6cc31bb21
--- /dev/null
+++ b/drivers/input/touchscreen/hampshire.c
@@ -0,0 +1,205 @@
+/*
+ * Hampshire serial touchscreen driver
+ *
+ * Copyright (c) 2010 Adam Bennett
+ * Based on the dynapro driver (c) Tias Guns
+ *
+ */
+
+/*
+ * 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.
+ */
+
+/*
+ * 2010/04/08 Adam Bennett <abennett72@gmail.com>
+ *   Copied dynapro.c and edited for Hampshire 4-byte protocol
+ */
+
+#include <linux/errno.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/input.h>
+#include <linux/serio.h>
+#include <linux/init.h>
+
+#define DRIVER_DESC     "Hampshire serial touchscreen driver"
+
+MODULE_AUTHOR("Adam Bennett <abennett72@gmail.com>");
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_LICENSE("GPL");
+
+/*
+ * Definitions & global arrays.
+ */
+
+#define HAMPSHIRE_FORMAT_TOUCH_BIT 0x40
+#define HAMPSHIRE_FORMAT_LENGTH 4
+#define HAMPSHIRE_RESPONSE_BEGIN_BYTE 0x80
+
+#define HAMPSHIRE_MIN_XC 0
+#define HAMPSHIRE_MAX_XC 0x1000
+#define HAMPSHIRE_MIN_YC 0
+#define HAMPSHIRE_MAX_YC 0x1000
+
+#define HAMPSHIRE_GET_XC(data) (((data[3] & 0x0c) >> 2) | (data[1] << 2) | ((data[0] & 0x38) << 6))
+#define HAMPSHIRE_GET_YC(data) ((data[3] & 0x03) | (data[2] << 2) | ((data[0] & 0x07) << 9))
+#define HAMPSHIRE_GET_TOUCHED(data) (HAMPSHIRE_FORMAT_TOUCH_BIT & data[0])
+
+/*
+ * Per-touchscreen data.
+ */
+
+struct hampshire {
+        struct input_dev *dev;
+        struct serio *serio;
+        int idx;
+        unsigned char data[HAMPSHIRE_FORMAT_LENGTH];
+        char phys[32];
+};
+
+static void hampshire_process_data(struct hampshire *phampshire)
+{
+        struct input_dev *dev = phampshire->dev;
+
+        if (HAMPSHIRE_FORMAT_LENGTH == ++phampshire->idx) {
+                input_report_abs(dev, ABS_X, HAMPSHIRE_GET_XC(phampshire->data));
+                input_report_abs(dev, ABS_Y, HAMPSHIRE_GET_YC(phampshire->data));
+                input_report_key(dev, BTN_TOUCH,
+                                 HAMPSHIRE_GET_TOUCHED(phampshire->data));
+                input_sync(dev);
+
+                phampshire->idx = 0;
+        }
+}
+
+static irqreturn_t hampshire_interrupt(struct serio *serio,
+                unsigned char data, unsigned int flags)
+{
+        struct hampshire *phampshire = serio_get_drvdata(serio);
+
+        phampshire->data[phampshire->idx] = data;
+
+        if (HAMPSHIRE_RESPONSE_BEGIN_BYTE & phampshire->data[0])
+                hampshire_process_data(phampshire);
+        else
+                dev_dbg(&serio->dev, "unknown/unsynchronized data: %x\n",
+                        phampshire->data[0]);
+
+        return IRQ_HANDLED;
+}
+
+static void hampshire_disconnect(struct serio *serio)
+{
+        struct hampshire *phampshire = serio_get_drvdata(serio);
+
+        input_get_device(phampshire->dev);
+        input_unregister_device(phampshire->dev);
+        serio_close(serio);
+        serio_set_drvdata(serio, NULL);
+        input_put_device(phampshire->dev);
+        kfree(phampshire);
+}
+
+/*
+ * hampshire_connect() is the routine that is called when someone adds a
+ * new serio device that supports hampshire protocol and registers it as
+ * an input device. This is usually accomplished using inputattach.
+ */
+
+static int hampshire_connect(struct serio *serio, struct serio_driver *drv)
+{
+        struct hampshire *phampshire;
+        struct input_dev *input_dev;
+        int err;
+
+        phampshire = kzalloc(sizeof(struct hampshire), GFP_KERNEL);
+        input_dev = input_allocate_device();
+        if (!phampshire || !input_dev) {
+                err = -ENOMEM;
+                goto fail1;
+        }
+
+        phampshire->serio = serio;
+        phampshire->dev = input_dev;
+        snprintf(phampshire->phys, sizeof(phampshire->phys),
+                 "%s/input0", serio->phys);
+
+        input_dev->name = "Hampshire Serial TouchScreen";
+        input_dev->phys = phampshire->phys;
+        input_dev->id.bustype = BUS_RS232;
+        input_dev->id.vendor = SERIO_HAMPSHIRE;
+        input_dev->id.product = 0;
+        input_dev->id.version = 0x0001;
+        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);
+        input_set_abs_params(phampshire->dev, ABS_X,
+                             HAMPSHIRE_MIN_XC, HAMPSHIRE_MAX_XC, 0, 0);
+        input_set_abs_params(phampshire->dev, ABS_Y,
+                             HAMPSHIRE_MIN_YC, HAMPSHIRE_MAX_YC, 0, 0);
+
+        serio_set_drvdata(serio, phampshire);
+
+        err = serio_open(serio, drv);
+        if (err)
+                goto fail2;
+
+        err = input_register_device(phampshire->dev);
+        if (err)
+                goto fail3;
+
+        return 0;
+
+ fail3: serio_close(serio);
+ fail2: serio_set_drvdata(serio, NULL);
+ fail1: input_free_device(input_dev);
+        kfree(phampshire);
+        return err;
+}
+
+/*
+ * The serio driver structure.
+ */
+
+static struct serio_device_id hampshire_serio_ids[] = {
+        {
+                .type   = SERIO_RS232,
+                .proto  = SERIO_HAMPSHIRE,
+                .id     = SERIO_ANY,
+                .extra  = SERIO_ANY,
+        },
+        { 0 }
+};
+
+MODULE_DEVICE_TABLE(serio, hampshire_serio_ids);
+
+static struct serio_driver hampshire_drv = {
+        .driver         = {
+                .name   = "hampshire",
+        },
+        .description    = DRIVER_DESC,
+        .id_table       = hampshire_serio_ids,
+        .interrupt      = hampshire_interrupt,
+        .connect        = hampshire_connect,
+        .disconnect     = hampshire_disconnect,
+};
+
+/*
+ * The functions for inserting/removing us as a module.
+ */
+
+static int __init hampshire_init(void)
+{
+        return serio_register_driver(&hampshire_drv);
+}
+
+static void __exit hampshire_exit(void)
+{
+        serio_unregister_driver(&hampshire_drv);
+}
+
+module_init(hampshire_init);
+module_exit(hampshire_exit);
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..c0307b22d86f
--- /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 (continous 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/jornada720_ts.c b/drivers/input/touchscreen/jornada720_ts.c
index c8b7e8a45c4d..4b0a061811ff 100644
--- a/drivers/input/touchscreen/jornada720_ts.c
+++ b/drivers/input/touchscreen/jornada720_ts.c
@@ -18,6 +18,7 @@
 #include <linux/input.h>
 #include <linux/interrupt.h>
 #include <linux/module.h>
+#include <linux/slab.h>
 
 #include <mach/hardware.h>
 #include <mach/jornada720.h>
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 6cdcf2a6e036..b6b8b1c7ecea 100644
--- a/drivers/input/touchscreen/mainstone-wm97xx.c
+++ b/drivers/input/touchscreen/mainstone-wm97xx.c
@@ -153,6 +153,9 @@ static int wm97xx_acc_pen_down(struct wm97xx *wm)
                 if (pressure)
                         p = MODR;
 
+                dev_dbg(wm->dev, "Raw coordinates: x=%x, y=%x, p=%x\n",
+                        x, y, p);
+
                 /* are samples valid */
                 if ((x & WM97XX_ADCSRC_MASK) != WM97XX_ADCSEL_X ||
                     (y & WM97XX_ADCSRC_MASK) != WM97XX_ADCSEL_Y ||
diff --git a/drivers/input/touchscreen/mc13783_ts.c b/drivers/input/touchscreen/mc13783_ts.c
index be115b3b65eb..c5bc62d85bb6 100644
--- a/drivers/input/touchscreen/mc13783_ts.c
+++ b/drivers/input/touchscreen/mc13783_ts.c
@@ -17,6 +17,7 @@
 #include <linux/module.h>
 #include <linux/input.h>
 #include <linux/sched.h>
+#include <linux/slab.h>
 #include <linux/init.h>
 
 #define MC13783_TS_NAME "mc13783-ts"
@@ -44,7 +45,7 @@ static irqreturn_t mc13783_ts_handler(int irq, void *data)
 {
         struct mc13783_ts_priv *priv = data;
 
-        mc13783_ackirq(priv->mc13783, irq);
+        mc13783_irq_ack(priv->mc13783, irq);
 
         /*
          * Kick off reading coordinates. Note that if work happens already
@@ -135,7 +136,7 @@ static int mc13783_ts_open(struct input_dev *dev)
 
         mc13783_lock(priv->mc13783);
 
-        mc13783_ackirq(priv->mc13783, MC13783_IRQ_TS);
+        mc13783_irq_ack(priv->mc13783, MC13783_IRQ_TS);
 
         ret = mc13783_irq_request(priv->mc13783, MC13783_IRQ_TS,
                 mc13783_ts_handler, MC13783_TS_NAME, priv);
diff --git a/drivers/input/touchscreen/mcs5000_ts.c b/drivers/input/touchscreen/mcs5000_ts.c
index 4c28b89757f9..6ee9940aaf5b 100644
--- a/drivers/input/touchscreen/mcs5000_ts.c
+++ b/drivers/input/touchscreen/mcs5000_ts.c
@@ -16,10 +16,11 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/i2c.h>
-#include <linux/i2c/mcs5000_ts.h>
+#include <linux/i2c/mcs.h>
 #include <linux/interrupt.h>
 #include <linux/input.h>
 #include <linux/irq.h>
+#include <linux/slab.h>
 
 /* Registers */
 #define MCS5000_TS_STATUS               0x00
@@ -104,7 +105,7 @@ enum mcs5000_ts_read_offset {
 struct mcs5000_ts_data {
         struct i2c_client *client;
         struct input_dev *input_dev;
-        const struct mcs5000_ts_platform_data *platform_data;
+        const struct mcs_platform_data *platform_data;
 };
 
 static irqreturn_t mcs5000_ts_interrupt(int irq, void *dev_id)
@@ -163,7 +164,7 @@ static irqreturn_t mcs5000_ts_interrupt(int irq, void *dev_id)
 
 static void mcs5000_ts_phys_init(struct mcs5000_ts_data *data)
 {
-        const struct mcs5000_ts_platform_data *platform_data =
+        const struct mcs_platform_data *platform_data =
                 data->platform_data;
         struct i2c_client *client = data->client;
 
@@ -255,7 +256,6 @@ static int __devexit mcs5000_ts_remove(struct i2c_client *client)
         free_irq(client->irq, data);
         input_unregister_device(data->input_dev);
         kfree(data);
-        i2c_set_clientdata(client, NULL);
 
         return 0;
 }
diff --git a/drivers/input/touchscreen/migor_ts.c b/drivers/input/touchscreen/migor_ts.c
index 141dd584330e..defe5dd3627c 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/slab.h>
 #include <asm/io.h>
 #include <linux/i2c.h>
 #include <linux/timer.h>
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/pcap_ts.c b/drivers/input/touchscreen/pcap_ts.c
index b79097e3028a..ea6ef16e59b4 100644
--- a/drivers/input/touchscreen/pcap_ts.c
+++ b/drivers/input/touchscreen/pcap_ts.c
@@ -14,6 +14,7 @@
 #include <linux/init.h>
 #include <linux/fs.h>
 #include <linux/string.h>
+#include <linux/slab.h>
 #include <linux/pm.h>
 #include <linux/timer.h>
 #include <linux/interrupt.h>
diff --git a/drivers/input/touchscreen/qt602240_ts.c b/drivers/input/touchscreen/qt602240_ts.c
new file mode 100644
index 000000000000..66b26ad3032a
--- /dev/null
+++ b/drivers/input/touchscreen/qt602240_ts.c
@@ -0,0 +1,1401 @@
+/*
+ * 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 6386b441ef85..8feb7f3c8be1 100644
--- a/drivers/input/touchscreen/s3c2410_ts.c
+++ b/drivers/input/touchscreen/s3c2410_ts.c
@@ -26,7 +26,6 @@
 #include <linux/errno.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
-#include <linux/slab.h>
 #include <linux/gpio.h>
 #include <linux/input.h>
 #include <linux/init.h>
@@ -38,9 +37,7 @@
 
 #include <plat/adc.h>
 #include <plat/regs-adc.h>
-
-#include <mach/regs-gpio.h>
-#include <mach/ts.h>
+#include <plat/ts.h>
 
 #define TSC_SLEEP  (S3C2410_ADCTSC_PULL_UP_DISABLE | S3C2410_ADCTSC_XY_PST(0))
 
@@ -58,6 +55,8 @@
                          S3C2410_ADCTSC_AUTO_PST | \
                          S3C2410_ADCTSC_XY_PST(0))
 
+#define FEAT_PEN_IRQ    (1 << 0)        /* HAS ADCCLRINTPNDNUP */
+
 /* Per-touchscreen data. */
 
 /**
@@ -72,6 +71,7 @@
  * @irq_tc: The interrupt number for pen up/down interrupt
  * @count: The number of samples collected.
  * @shift: The log2 of the maximum count to read in one go.
+ * @features: The features supported by the TSADC MOdule.
  */
 struct s3c2410ts {
         struct s3c_adc_client *client;
@@ -84,26 +84,12 @@ struct s3c2410ts {
         int irq_tc;
         int count;
         int shift;
+        int features;
 };
 
 static struct s3c2410ts ts;
 
 /**
- * s3c2410_ts_connect - configure gpio for s3c2410 systems
- *
- * Configure the GPIO for the S3C2410 system, where we have external FETs
- * connected to the device (later systems such as the S3C2440 integrate
- * these into the device).
-*/
-static inline void s3c2410_ts_connect(void)
-{
-        s3c2410_gpio_cfgpin(S3C2410_GPG(12), S3C2410_GPG12_XMON);
-        s3c2410_gpio_cfgpin(S3C2410_GPG(13), S3C2410_GPG13_nXPON);
-        s3c2410_gpio_cfgpin(S3C2410_GPG(14), S3C2410_GPG14_YMON);
-        s3c2410_gpio_cfgpin(S3C2410_GPG(15), S3C2410_GPG15_nYPON);
-}
-
-/**
  * get_down - return the down state of the pen
  * @data0: The data read from ADCDAT0 register.
  * @data1: The data read from ADCDAT1 register.
@@ -128,27 +114,29 @@ static void touch_timer_fire(unsigned long data)
 
         down = get_down(data0, data1);
 
-        if (ts.count == (1 << ts.shift)) {
-                ts.xp >>= ts.shift;
-                ts.yp >>= ts.shift;
+        if (down) {
+                if (ts.count == (1 << ts.shift)) {
+                        ts.xp >>= ts.shift;
+                        ts.yp >>= ts.shift;
 
-                dev_dbg(ts.dev, "%s: X=%lu, Y=%lu, count=%d\n",
-                        __func__, ts.xp, ts.yp, ts.count);
+                        dev_dbg(ts.dev, "%s: X=%lu, Y=%lu, count=%d\n",
+                                __func__, ts.xp, ts.yp, ts.count);
 
-                input_report_abs(ts.input, ABS_X, ts.xp);
-                input_report_abs(ts.input, ABS_Y, ts.yp);
+                        input_report_abs(ts.input, ABS_X, ts.xp);
+                        input_report_abs(ts.input, ABS_Y, ts.yp);
 
-                input_report_key(ts.input, BTN_TOUCH, 1);
-                input_sync(ts.input);
+                        input_report_key(ts.input, BTN_TOUCH, 1);
+                        input_sync(ts.input);
 
-                ts.xp = 0;
-                ts.yp = 0;
-                ts.count = 0;
-        }
+                        ts.xp = 0;
+                        ts.yp = 0;
+                        ts.count = 0;
+                }
 
-        if (down) {
                 s3c_adc_start(ts.client, 0, 1 << ts.shift);
         } else {
+                ts.xp = 0;
+                ts.yp = 0;
                 ts.count = 0;
 
                 input_report_key(ts.input, BTN_TOUCH, 0);
@@ -185,7 +173,12 @@ static irqreturn_t stylus_irq(int irq, void *dev_id)
         if (down)
                 s3c_adc_start(ts.client, 0, 1 << ts.shift);
         else
-                dev_info(ts.dev, "%s: count=%d\n", __func__, ts.count);
+                dev_dbg(ts.dev, "%s: count=%d\n", __func__, ts.count);
+
+        if (ts.features & FEAT_PEN_IRQ) {
+                /* Clear pen down/up interrupt */
+                writel(0x0, ts.io + S3C64XX_ADCCLRINTPNDNUP);
+        }
 
         return IRQ_HANDLED;
 }
@@ -295,9 +288,9 @@ static int __devinit s3c2410ts_probe(struct platform_device *pdev)
                 goto err_clk;
         }
 
-        /* Configure the touchscreen external FETs on the S3C2410 */
-        if (!platform_get_device_id(pdev)->driver_data)
-                s3c2410_ts_connect();
+        /* inititalise the gpio */
+        if (info->cfg_gpio)
+                info->cfg_gpio(to_platform_device(ts.dev));
 
         ts.client = s3c_adc_register(pdev, s3c24xx_ts_select,
                                      s3c24xx_ts_conversion, 1);
@@ -333,6 +326,7 @@ static int __devinit s3c2410ts_probe(struct platform_device *pdev)
         ts.input->id.version = 0x0102;
 
         ts.shift = info->oversampling_shift;
+        ts.features = platform_get_device_id(pdev)->driver_data;
 
         ret = request_irq(ts.irq_tc, stylus_irq, IRQF_DISABLED,
                           "s3c2410_ts_pen", ts.input);
@@ -356,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:
@@ -401,6 +395,7 @@ static int s3c2410ts_resume(struct device *dev)
         struct s3c2410_ts_mach_info *info = pdev->dev.platform_data;
 
         clk_enable(ts.clock);
+        enable_irq(ts.irq_tc);
 
         /* Initialise registers */
         if ((info->delay & 0xffff) > 0)
@@ -419,14 +414,15 @@ static struct dev_pm_ops s3c_ts_pmops = {
 
 static struct platform_device_id s3cts_driver_ids[] = {
         { "s3c2410-ts", 0 },
-        { "s3c2440-ts", 1 },
+        { "s3c2440-ts", 0 },
+        { "s3c64xx-ts", FEAT_PEN_IRQ },
         { }
 };
 MODULE_DEVICE_TABLE(platform, s3cts_driver_ids);
 
 static struct platform_driver s3c_ts_driver = {
         .driver         = {
-                .name   = "s3c24xx-ts",
+                .name   = "samsung-ts",
                 .owner  = THIS_MODULE,
 #ifdef CONFIG_PM
                 .pm     = &s3c_ts_pmops,
diff --git a/drivers/input/touchscreen/stmpe-ts.c b/drivers/input/touchscreen/stmpe-ts.c
new file mode 100644
index 000000000000..ae88e13c99ff
--- /dev/null
+++ b/drivers/input/touchscreen/stmpe-ts.c
@@ -0,0 +1,400 @@
+/* STMicroelectronics STMPE811 Touchscreen Driver
+ *
+ * (C) 2010 Luotao Fu <l.fu@pengutronix.de>
+ * 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 as published by the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/sched.h>
+#include <linux/interrupt.h>
+#include <linux/init.h>
+#include <linux/device.h>
+#include <linux/platform_device.h>
+#include <linux/input.h>
+#include <linux/slab.h>
+#include <linux/delay.h>
+#include <linux/i2c.h>
+#include <linux/workqueue.h>
+
+#include <linux/mfd/stmpe.h>
+
+/* Register layouts and functionalities are identical on all stmpexxx variants
+ * with touchscreen controller
+ */
+#define STMPE_REG_INT_STA               0x0B
+#define STMPE_REG_ADC_CTRL1             0x20
+#define STMPE_REG_ADC_CTRL2             0x21
+#define STMPE_REG_TSC_CTRL              0x40
+#define STMPE_REG_TSC_CFG               0x41
+#define STMPE_REG_FIFO_TH               0x4A
+#define STMPE_REG_FIFO_STA              0x4B
+#define STMPE_REG_FIFO_SIZE             0x4C
+#define STMPE_REG_TSC_DATA_XYZ          0x52
+#define STMPE_REG_TSC_FRACTION_Z        0x56
+#define STMPE_REG_TSC_I_DRIVE           0x58
+
+#define OP_MOD_XYZ                      0
+
+#define STMPE_TSC_CTRL_TSC_EN           (1<<0)
+
+#define STMPE_FIFO_STA_RESET            (1<<0)
+
+#define STMPE_IRQ_TOUCH_DET             0
+
+#define SAMPLE_TIME(x)                  ((x & 0xf) << 4)
+#define MOD_12B(x)                      ((x & 0x1) << 3)
+#define REF_SEL(x)                      ((x & 0x1) << 1)
+#define ADC_FREQ(x)                     (x & 0x3)
+#define AVE_CTRL(x)                     ((x & 0x3) << 6)
+#define DET_DELAY(x)                    ((x & 0x7) << 3)
+#define SETTLING(x)                     (x & 0x7)
+#define FRACTION_Z(x)                   (x & 0x7)
+#define I_DRIVE(x)                      (x & 0x1)
+#define OP_MODE(x)                      ((x & 0x7) << 1)
+
+#define STMPE_TS_NAME                   "stmpe-ts"
+#define XY_MASK                         0xfff
+
+struct stmpe_touch {
+        struct stmpe *stmpe;
+        struct input_dev *idev;
+        struct delayed_work work;
+        struct device *dev;
+        u8 sample_time;
+        u8 mod_12b;
+        u8 ref_sel;
+        u8 adc_freq;
+        u8 ave_ctrl;
+        u8 touch_det_delay;
+        u8 settling;
+        u8 fraction_z;
+        u8 i_drive;
+};
+
+static int __stmpe_reset_fifo(struct stmpe *stmpe)
+{
+        int ret;
+
+        ret = stmpe_set_bits(stmpe, STMPE_REG_FIFO_STA,
+                        STMPE_FIFO_STA_RESET, STMPE_FIFO_STA_RESET);
+        if (ret)
+                return ret;
+
+        return stmpe_set_bits(stmpe, STMPE_REG_FIFO_STA,
+                        STMPE_FIFO_STA_RESET, 0);
+}
+
+static void stmpe_work(struct work_struct *work)
+{
+        int int_sta;
+        u32 timeout = 40;
+
+        struct stmpe_touch *ts =
+            container_of(work, struct stmpe_touch, work.work);
+
+        int_sta = stmpe_reg_read(ts->stmpe, STMPE_REG_INT_STA);
+
+        /*
+         * touch_det sometimes get desasserted or just get stuck. This appears
+         * to be a silicon bug, We still have to clearify this with the
+         * manufacture. As a workaround We release the key anyway if the
+         * touch_det keeps coming in after 4ms, while the FIFO contains no value
+         * during the whole time.
+         */
+        while ((int_sta & (1 << STMPE_IRQ_TOUCH_DET)) && (timeout > 0)) {
+                timeout--;
+                int_sta = stmpe_reg_read(ts->stmpe, STMPE_REG_INT_STA);
+                udelay(100);
+        }
+
+        /* reset the FIFO before we report release event */
+        __stmpe_reset_fifo(ts->stmpe);
+
+        input_report_abs(ts->idev, ABS_PRESSURE, 0);
+        input_sync(ts->idev);
+}
+
+static irqreturn_t stmpe_ts_handler(int irq, void *data)
+{
+        u8 data_set[4];
+        int x, y, z;
+        struct stmpe_touch *ts = data;
+
+        /*
+         * Cancel scheduled polling for release if we have new value
+         * available. Wait if the polling is already running.
+         */
+        cancel_delayed_work_sync(&ts->work);
+
+        /*
+         * The FIFO sometimes just crashes and stops generating interrupts. This
+         * appears to be a silicon bug. We still have to clearify this with
+         * the manufacture. As a workaround we disable the TSC while we are
+         * collecting data and flush the FIFO after reading
+         */
+        stmpe_set_bits(ts->stmpe, STMPE_REG_TSC_CTRL,
+                                STMPE_TSC_CTRL_TSC_EN, 0);
+
+        stmpe_block_read(ts->stmpe, STMPE_REG_TSC_DATA_XYZ, 4, data_set);
+
+        x = (data_set[0] << 4) | (data_set[1] >> 4);
+        y = ((data_set[1] & 0xf) << 8) | data_set[2];
+        z = data_set[3];
+
+        input_report_abs(ts->idev, ABS_X, x);
+        input_report_abs(ts->idev, ABS_Y, y);
+        input_report_abs(ts->idev, ABS_PRESSURE, z);
+        input_sync(ts->idev);
+
+       /* flush the FIFO after we have read out our values. */
+        __stmpe_reset_fifo(ts->stmpe);
+
+        /* reenable the tsc */
+        stmpe_set_bits(ts->stmpe, STMPE_REG_TSC_CTRL,
+                        STMPE_TSC_CTRL_TSC_EN, STMPE_TSC_CTRL_TSC_EN);
+
+        /* start polling for touch_det to detect release */
+        schedule_delayed_work(&ts->work, HZ / 50);
+
+        return IRQ_HANDLED;
+}
+
+static int __devinit stmpe_init_hw(struct stmpe_touch *ts)
+{
+        int ret;
+        u8 adc_ctrl1, adc_ctrl1_mask, tsc_cfg, tsc_cfg_mask;
+        struct stmpe *stmpe = ts->stmpe;
+        struct device *dev = ts->dev;
+
+        ret = stmpe_enable(stmpe, STMPE_BLOCK_TOUCHSCREEN | STMPE_BLOCK_ADC);
+        if (ret) {
+                dev_err(dev, "Could not enable clock for ADC and TS\n");
+                return ret;
+        }
+
+        adc_ctrl1 = SAMPLE_TIME(ts->sample_time) | MOD_12B(ts->mod_12b) |
+                REF_SEL(ts->ref_sel);
+        adc_ctrl1_mask = SAMPLE_TIME(0xff) | MOD_12B(0xff) | REF_SEL(0xff);
+
+        ret = stmpe_set_bits(stmpe, STMPE_REG_ADC_CTRL1,
+                        adc_ctrl1_mask, adc_ctrl1);
+        if (ret) {
+                dev_err(dev, "Could not setup ADC\n");
+                return ret;
+        }
+
+        ret = stmpe_set_bits(stmpe, STMPE_REG_ADC_CTRL2,
+                        ADC_FREQ(0xff), ADC_FREQ(ts->adc_freq));
+        if (ret) {
+                dev_err(dev, "Could not setup ADC\n");
+                return ret;
+        }
+
+        tsc_cfg = AVE_CTRL(ts->ave_ctrl) | DET_DELAY(ts->touch_det_delay) |
+                        SETTLING(ts->settling);
+        tsc_cfg_mask = AVE_CTRL(0xff) | DET_DELAY(0xff) | SETTLING(0xff);
+
+        ret = stmpe_set_bits(stmpe, STMPE_REG_TSC_CFG, tsc_cfg_mask, tsc_cfg);
+        if (ret) {
+                dev_err(dev, "Could not config touch\n");
+                return ret;
+        }
+
+        ret = stmpe_set_bits(stmpe, STMPE_REG_TSC_FRACTION_Z,
+                        FRACTION_Z(0xff), FRACTION_Z(ts->fraction_z));
+        if (ret) {
+                dev_err(dev, "Could not config touch\n");
+                return ret;
+        }
+
+        ret = stmpe_set_bits(stmpe, STMPE_REG_TSC_I_DRIVE,
+                        I_DRIVE(0xff), I_DRIVE(ts->i_drive));
+        if (ret) {
+                dev_err(dev, "Could not config touch\n");
+                return ret;
+        }
+
+        /* set FIFO to 1 for single point reading */
+        ret = stmpe_reg_write(stmpe, STMPE_REG_FIFO_TH, 1);
+        if (ret) {
+                dev_err(dev, "Could not set FIFO\n");
+                return ret;
+        }
+
+        ret = stmpe_set_bits(stmpe, STMPE_REG_TSC_CTRL,
+                        OP_MODE(0xff), OP_MODE(OP_MOD_XYZ));
+        if (ret) {
+                dev_err(dev, "Could not set mode\n");
+                return ret;
+        }
+
+        return 0;
+}
+
+static int stmpe_ts_open(struct input_dev *dev)
+{
+        struct stmpe_touch *ts = input_get_drvdata(dev);
+        int ret = 0;
+
+        ret = __stmpe_reset_fifo(ts->stmpe);
+        if (ret)
+                return ret;
+
+        return stmpe_set_bits(ts->stmpe, STMPE_REG_TSC_CTRL,
+                        STMPE_TSC_CTRL_TSC_EN, STMPE_TSC_CTRL_TSC_EN);
+}
+
+static void stmpe_ts_close(struct input_dev *dev)
+{
+        struct stmpe_touch *ts = input_get_drvdata(dev);
+
+        cancel_delayed_work_sync(&ts->work);
+
+        stmpe_set_bits(ts->stmpe, STMPE_REG_TSC_CTRL,
+                        STMPE_TSC_CTRL_TSC_EN, 0);
+}
+
+static int __devinit stmpe_input_probe(struct platform_device *pdev)
+{
+        struct stmpe *stmpe = dev_get_drvdata(pdev->dev.parent);
+        struct stmpe_platform_data *pdata = stmpe->pdata;
+        struct stmpe_touch *ts;
+        struct input_dev *idev;
+        struct stmpe_ts_platform_data *ts_pdata = NULL;
+        int ret;
+        int ts_irq;
+
+        ts_irq = platform_get_irq_byname(pdev, "FIFO_TH");
+        if (ts_irq < 0)
+                return ts_irq;
+
+        ts = kzalloc(sizeof(*ts), GFP_KERNEL);
+        if (!ts) {
+                ret = -ENOMEM;
+                goto err_out;
+        }
+
+        idev = input_allocate_device();
+        if (!idev) {
+                ret = -ENOMEM;
+                goto err_free_ts;
+        }
+
+        platform_set_drvdata(pdev, ts);
+        ts->stmpe = stmpe;
+        ts->idev = idev;
+        ts->dev = &pdev->dev;
+
+        if (pdata)
+                ts_pdata = pdata->ts;
+
+        if (ts_pdata) {
+                ts->sample_time = ts_pdata->sample_time;
+                ts->mod_12b = ts_pdata->mod_12b;
+                ts->ref_sel = ts_pdata->ref_sel;
+                ts->adc_freq = ts_pdata->adc_freq;
+                ts->ave_ctrl = ts_pdata->ave_ctrl;
+                ts->touch_det_delay = ts_pdata->touch_det_delay;
+                ts->settling = ts_pdata->settling;
+                ts->fraction_z = ts_pdata->fraction_z;
+                ts->i_drive = ts_pdata->i_drive;
+        }
+
+        INIT_DELAYED_WORK(&ts->work, stmpe_work);
+
+        ret = request_threaded_irq(ts_irq, NULL, stmpe_ts_handler,
+                        IRQF_ONESHOT, STMPE_TS_NAME, ts);
+        if (ret) {
+                dev_err(&pdev->dev, "Failed to request IRQ %d\n", ts_irq);
+                goto err_free_input;
+        }
+
+        ret = stmpe_init_hw(ts);
+        if (ret)
+                goto err_free_irq;
+
+        idev->name = STMPE_TS_NAME;
+        idev->id.bustype = BUS_I2C;
+        idev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
+        idev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
+
+        idev->open = stmpe_ts_open;
+        idev->close = stmpe_ts_close;
+
+        input_set_drvdata(idev, ts);
+
+        input_set_abs_params(idev, ABS_X, 0, XY_MASK, 0, 0);
+        input_set_abs_params(idev, ABS_Y, 0, XY_MASK, 0, 0);
+        input_set_abs_params(idev, ABS_PRESSURE, 0x0, 0xff, 0, 0);
+
+        ret = input_register_device(idev);
+        if (ret) {
+                dev_err(&pdev->dev, "Could not register input device\n");
+                goto err_free_irq;
+        }
+
+        return ret;
+
+err_free_irq:
+        free_irq(ts_irq, ts);
+err_free_input:
+        input_free_device(idev);
+        platform_set_drvdata(pdev, NULL);
+err_free_ts:
+        kfree(ts);
+err_out:
+        return ret;
+}
+
+static int __devexit stmpe_ts_remove(struct platform_device *pdev)
+{
+        struct stmpe_touch *ts = platform_get_drvdata(pdev);
+        unsigned int ts_irq = platform_get_irq_byname(pdev, "FIFO_TH");
+
+        stmpe_disable(ts->stmpe, STMPE_BLOCK_TOUCHSCREEN);
+
+        free_irq(ts_irq, ts);
+
+        platform_set_drvdata(pdev, NULL);
+
+        input_unregister_device(ts->idev);
+
+        kfree(ts);
+
+        return 0;
+}
+
+static struct platform_driver stmpe_ts_driver = {
+        .driver = {
+                   .name = STMPE_TS_NAME,
+                   .owner = THIS_MODULE,
+                   },
+        .probe = stmpe_input_probe,
+        .remove = __devexit_p(stmpe_ts_remove),
+};
+
+static int __init stmpe_ts_init(void)
+{
+        return platform_driver_register(&stmpe_ts_driver);
+}
+
+module_init(stmpe_ts_init);
+
+static void __exit stmpe_ts_exit(void)
+{
+        platform_driver_unregister(&stmpe_ts_driver);
+}
+
+module_exit(stmpe_ts_exit);
+
+MODULE_AUTHOR("Luotao Fu <l.fu@pengutronix.de>");
+MODULE_DESCRIPTION("STMPEXXX touchscreen driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:" STMPE_TS_NAME);
diff --git a/drivers/input/touchscreen/tnetv107x-ts.c b/drivers/input/touchscreen/tnetv107x-ts.c
new file mode 100644
index 000000000000..cf1dba2e267c
--- /dev/null
+++ b/drivers/input/touchscreen/tnetv107x-ts.c
@@ -0,0 +1,396 @@
+/*
+ * 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/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 (!ts->clk) {
+                dev_err(dev, "cannot claim device clock\n");
+                error = -EINVAL;
+                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
new file mode 100644
index 000000000000..c8c136cf7bbc
--- /dev/null
+++ b/drivers/input/touchscreen/tps6507x-ts.c
@@ -0,0 +1,394 @@
+/*
+ * drivers/input/touchscreen/tps6507x_ts.c
+ *
+ * Touchscreen driver for the tps6507x chip.
+ *
+ * Copyright (c) 2009 RidgeRun (todd.fischer@ridgerun.com)
+ *
+ * Credits:
+ *
+ *    Using code from tsc2007, MtekVision Co., Ltd.
+ *
+ * For licencing details see kernel-base/COPYING
+ *
+ * TPS65070, TPS65073, TPS650731, and TPS650732 support
+ * 10 bit touch screen interface.
+ */
+
+#include <linux/module.h>
+#include <linux/workqueue.h>
+#include <linux/slab.h>
+#include <linux/input.h>
+#include <linux/platform_device.h>
+#include <linux/mfd/tps6507x.h>
+#include <linux/input/tps6507x-ts.h>
+#include <linux/delay.h>
+
+#define TSC_DEFAULT_POLL_PERIOD 30 /* ms */
+#define TPS_DEFAULT_MIN_PRESSURE 0x30
+#define MAX_10BIT ((1 << 10) - 1)
+
+#define TPS6507X_ADCONFIG_CONVERT_TS (TPS6507X_ADCONFIG_AD_ENABLE | \
+                                         TPS6507X_ADCONFIG_START_CONVERSION | \
+                                         TPS6507X_ADCONFIG_INPUT_REAL_TSC)
+#define TPS6507X_ADCONFIG_POWER_DOWN_TS (TPS6507X_ADCONFIG_INPUT_REAL_TSC)
+
+struct ts_event {
+        u16     x;
+        u16     y;
+        u16     pressure;
+};
+
+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;
+        struct tps6507x_dev     *mfd;
+        u16                     model;
+        unsigned                pendown;
+        int                     irq;
+        void                    (*clear_penirq)(void);
+        unsigned long           poll_period;    /* ms */
+        u16                     min_pressure;
+        int                     vref;           /* non-zero to leave vref on */
+};
+
+static int tps6507x_read_u8(struct tps6507x_ts *tsc, u8 reg, u8 *data)
+{
+        int err;
+
+        err = tsc->mfd->read_dev(tsc->mfd, reg, 1, data);
+
+        if (err)
+                return err;
+
+        return 0;
+}
+
+static int tps6507x_write_u8(struct tps6507x_ts *tsc, u8 reg, u8 data)
+{
+        return tsc->mfd->write_dev(tsc->mfd, reg, 1, &data);
+}
+
+static s32 tps6507x_adc_conversion(struct tps6507x_ts *tsc,
+                                   u8 tsc_mode, u16 *value)
+{
+        s32 ret;
+        u8 adc_status;
+        u8 result;
+
+        /* Route input signal to A/D converter */
+
+        ret = tps6507x_write_u8(tsc, TPS6507X_REG_TSCMODE, tsc_mode);
+        if (ret) {
+                dev_err(tsc->dev, "TSC mode read failed\n");
+                goto err;
+        }
+
+        /* Start A/D conversion */
+
+        ret = tps6507x_write_u8(tsc, TPS6507X_REG_ADCONFIG,
+                                TPS6507X_ADCONFIG_CONVERT_TS);
+        if (ret) {
+                dev_err(tsc->dev, "ADC config write failed\n");
+                return ret;
+        }
+
+        do {
+                ret = tps6507x_read_u8(tsc, TPS6507X_REG_ADCONFIG,
+                                       &adc_status);
+                if (ret) {
+                        dev_err(tsc->dev, "ADC config read failed\n");
+                        goto err;
+                }
+        } while (adc_status & TPS6507X_ADCONFIG_START_CONVERSION);
+
+        ret = tps6507x_read_u8(tsc, TPS6507X_REG_ADRESULT_2, &result);
+        if (ret) {
+                dev_err(tsc->dev, "ADC result 2 read failed\n");
+                goto err;
+        }
+
+        *value = (result & TPS6507X_REG_ADRESULT_2_MASK) << 8;
+
+        ret = tps6507x_read_u8(tsc, TPS6507X_REG_ADRESULT_1, &result);
+        if (ret) {
+                dev_err(tsc->dev, "ADC result 1 read failed\n");
+                goto err;
+        }
+
+        *value |= result;
+
+        dev_dbg(tsc->dev, "TSC channel %d = 0x%X\n", tsc_mode, *value);
+
+err:
+        return ret;
+}
+
+/* Need to call tps6507x_adc_standby() after using A/D converter for the
+ * touch screen interrupt to work properly.
+ */
+
+static s32 tps6507x_adc_standby(struct tps6507x_ts *tsc)
+{
+        s32 ret;
+        s32 loops = 0;
+        u8 val;
+
+        ret = tps6507x_write_u8(tsc,  TPS6507X_REG_ADCONFIG,
+                                TPS6507X_ADCONFIG_INPUT_TSC);
+        if (ret)
+                return ret;
+
+        ret = tps6507x_write_u8(tsc, TPS6507X_REG_TSCMODE,
+                                TPS6507X_TSCMODE_STANDBY);
+        if (ret)
+                return ret;
+
+        ret = tps6507x_read_u8(tsc, TPS6507X_REG_INT, &val);
+        if (ret)
+                return ret;
+
+        while (val & TPS6507X_REG_TSC_INT) {
+                mdelay(10);
+                ret = tps6507x_read_u8(tsc, TPS6507X_REG_INT, &val);
+                if (ret)
+                        return ret;
+                loops++;
+        }
+
+        return ret;
+}
+
+static void tps6507x_ts_handler(struct work_struct *work)
+{
+        struct tps6507x_ts *tsc =  container_of(work,
+                                struct tps6507x_ts, work.work);
+        struct input_dev *input_dev = tsc->input_dev;
+        int pendown;
+        int schd;
+        int poll = 0;
+        s32 ret;
+
+        ret =  tps6507x_adc_conversion(tsc, TPS6507X_TSCMODE_PRESSURE,
+                                       &tsc->tc.pressure);
+        if (ret)
+                goto done;
+
+        pendown = tsc->tc.pressure > tsc->min_pressure;
+
+        if (unlikely(!pendown && tsc->pendown)) {
+                dev_dbg(tsc->dev, "UP\n");
+                input_report_key(input_dev, BTN_TOUCH, 0);
+                input_report_abs(input_dev, ABS_PRESSURE, 0);
+                input_sync(input_dev);
+                tsc->pendown = 0;
+        }
+
+        if (pendown) {
+
+                if (!tsc->pendown) {
+                        dev_dbg(tsc->dev, "DOWN\n");
+                        input_report_key(input_dev, BTN_TOUCH, 1);
+                } else
+                        dev_dbg(tsc->dev, "still down\n");
+
+                ret =  tps6507x_adc_conversion(tsc, TPS6507X_TSCMODE_X_POSITION,
+                                               &tsc->tc.x);
+                if (ret)
+                        goto done;
+
+                ret =  tps6507x_adc_conversion(tsc, TPS6507X_TSCMODE_Y_POSITION,
+                                               &tsc->tc.y);
+                if (ret)
+                        goto done;
+
+                input_report_abs(input_dev, ABS_X, tsc->tc.x);
+                input_report_abs(input_dev, ABS_Y, tsc->tc.y);
+                input_report_abs(input_dev, ABS_PRESSURE, tsc->tc.pressure);
+                input_sync(input_dev);
+                tsc->pendown = 1;
+                poll = 1;
+        }
+
+done:
+        /* always poll if not using interrupts */
+        poll = 1;
+
+        if (poll) {
+                schd = queue_delayed_work(tsc->wq, &tsc->work,
+                                          msecs_to_jiffies(tsc->poll_period));
+                if (schd)
+                        tsc->polling = 1;
+                else {
+                        tsc->polling = 0;
+                        dev_err(tsc->dev, "re-schedule failed");
+                }
+        } else
+                tsc->polling = 0;
+
+        ret = tps6507x_adc_standby(tsc);
+}
+
+static int tps6507x_ts_probe(struct platform_device *pdev)
+{
+        int error;
+        struct tps6507x_ts *tsc;
+        struct tps6507x_dev *tps6507x_dev = dev_get_drvdata(pdev->dev.parent);
+        struct touchscreen_init_data *init_data;
+        struct input_dev *input_dev;
+        struct tps6507x_board *tps_board;
+        int schd;
+
+        /**
+         * tps_board points to pmic related constants
+         * coming from the board-evm file.
+         */
+
+        tps_board = (struct tps6507x_board *)tps6507x_dev->dev->platform_data;
+
+        if (!tps_board) {
+                dev_err(tps6507x_dev->dev,
+                        "Could not find tps6507x platform data\n");
+                return -EIO;
+        }
+
+        /**
+         * init_data points to array of regulator_init structures
+         * coming from the board-evm file.
+         */
+
+        init_data = tps_board->tps6507x_ts_init_data;
+
+        tsc = kzalloc(sizeof(struct tps6507x_ts), GFP_KERNEL);
+        if (!tsc) {
+                dev_err(tps6507x_dev->dev, "failed to allocate driver data\n");
+                error = -ENOMEM;
+                goto err0;
+        }
+
+        tps6507x_dev->ts = tsc;
+        tsc->mfd = tps6507x_dev;
+        tsc->dev = tps6507x_dev->dev;
+        input_dev = input_allocate_device();
+        if (!input_dev) {
+                dev_err(tsc->dev, "Failed to allocate input device.\n");
+                error = -ENOMEM;
+                goto err1;
+        }
+
+        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_10BIT, 0, 0);
+        input_set_abs_params(input_dev, ABS_Y, 0, MAX_10BIT, 0, 0);
+        input_set_abs_params(input_dev, ABS_PRESSURE, 0, MAX_10BIT, 0, 0);
+
+        input_dev->name = "TPS6507x Touchscreen";
+        input_dev->id.bustype = BUS_I2C;
+        input_dev->dev.parent = tsc->dev;
+
+        snprintf(tsc->phys, sizeof(tsc->phys),
+                 "%s/input0", dev_name(tsc->dev));
+        input_dev->phys = tsc->phys;
+
+        dev_dbg(tsc->dev, "device: %s\n", input_dev->phys);
+
+        input_set_drvdata(input_dev, tsc);
+
+        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;
+                tsc->vref = init_data->vref;
+                tsc->min_pressure = init_data->min_pressure;
+                input_dev->id.vendor = init_data->vendor;
+                input_dev->id.product = init_data->product;
+                input_dev->id.version = init_data->version;
+        } else {
+                tsc->poll_period = TSC_DEFAULT_POLL_PERIOD;
+                tsc->min_pressure = TPS_DEFAULT_MIN_PRESSURE;
+        }
+
+        error = tps6507x_adc_standby(tsc);
+        if (error)
+                goto err2;
+
+        error = input_register_device(input_dev);
+        if (error)
+                goto err2;
+
+        schd = queue_delayed_work(tsc->wq, &tsc->work,
+                                  msecs_to_jiffies(tsc->poll_period));
+
+        if (schd)
+                tsc->polling = 1;
+        else {
+                tsc->polling = 0;
+                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);
+        tps6507x_dev->ts = NULL;
+err0:
+        return error;
+}
+
+static int __devexit tps6507x_ts_remove(struct platform_device *pdev)
+{
+        struct tps6507x_dev *tps6507x_dev = platform_get_drvdata(pdev);
+        struct tps6507x_ts *tsc = tps6507x_dev->ts;
+        struct input_dev *input_dev = tsc->input_dev;
+
+        cancel_delayed_work_sync(&tsc->work);
+        destroy_workqueue(tsc->wq);
+
+        input_unregister_device(input_dev);
+
+        tps6507x_dev->ts = NULL;
+        kfree(tsc);
+
+        return 0;
+}
+
+static struct platform_driver tps6507x_ts_driver = {
+        .driver = {
+                .name = "tps6507x-ts",
+                .owner = THIS_MODULE,
+        },
+        .probe = tps6507x_ts_probe,
+        .remove = __devexit_p(tps6507x_ts_remove),
+};
+
+static int __init tps6507x_ts_init(void)
+{
+        return platform_driver_register(&tps6507x_ts_driver);
+}
+module_init(tps6507x_ts_init);
+
+static void __exit tps6507x_ts_exit(void)
+{
+        platform_driver_unregister(&tps6507x_ts_driver);
+}
+module_exit(tps6507x_ts_exit);
+
+MODULE_AUTHOR("Todd Fischer <todd.fischer@ridgerun.com>");
+MODULE_DESCRIPTION("TPS6507x - TouchScreen driver");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:tps6507x-tsc");
diff --git a/drivers/input/touchscreen/tsc2007.c b/drivers/input/touchscreen/tsc2007.c
index 7ef0d1420d3c..80467f262331 100644
--- a/drivers/input/touchscreen/tsc2007.c
+++ b/drivers/input/touchscreen/tsc2007.c
@@ -265,7 +265,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;
 
@@ -358,7 +358,7 @@ static int __devexit tsc2007_remove(struct i2c_client *client)
         return 0;
 }
 
-static struct i2c_device_id tsc2007_idtable[] = {
+static const struct i2c_device_id tsc2007_idtable[] = {
         { "tsc2007", 0 },
         { }
 };
diff --git a/drivers/input/touchscreen/ucb1400_ts.c b/drivers/input/touchscreen/ucb1400_ts.c
index 89dcbe7b4b02..028a5363eea1 100644
--- a/drivers/input/touchscreen/ucb1400_ts.c
+++ b/drivers/input/touchscreen/ucb1400_ts.c
@@ -26,7 +26,6 @@
 #include <linux/device.h>
 #include <linux/interrupt.h>
 #include <linux/suspend.h>
-#include <linux/slab.h>
 #include <linux/kthread.h>
 #include <linux/freezer.h>
 #include <linux/ucb1400.h>
diff --git a/drivers/input/touchscreen/usbtouchscreen.c b/drivers/input/touchscreen/usbtouchscreen.c
index 09a5e7341bd5..f45f80f6d336 100644
--- a/drivers/input/touchscreen/usbtouchscreen.c
+++ b/drivers/input/touchscreen/usbtouchscreen.c
@@ -15,6 +15,7 @@
  *  - GoTop Super_Q2/GogoPen/PenPower tablets
  *  - JASTEC USB touch controller/DigiTech DTR-02U
  *  - Zytronic capacitive touchscreen
+ *  - NEXIO/iNexio
  *
  * Copyright (C) 2004-2007 by Daniel Ritz <daniel.ritz@gmx.ch>
  * Copyright (C) by Todd E. Johnson (mtouchusb.c)
@@ -94,7 +95,9 @@ struct usbtouch_device_info {
         int  (*get_pkt_len) (unsigned char *pkt, int len);
 
         int  (*read_data)   (struct usbtouch_usb *usbtouch, unsigned char *pkt);
+        int  (*alloc)       (struct usbtouch_usb *usbtouch);
         int  (*init)        (struct usbtouch_usb *usbtouch);
+        void (*exit)        (struct usbtouch_usb *usbtouch);
 };
 
 /* a usbtouch device */
@@ -104,11 +107,12 @@ struct usbtouch_usb {
         unsigned char *buffer;
         int buf_len;
         struct urb *irq;
-        struct usb_device *udev;
+        struct usb_interface *interface;
         struct input_dev *input;
         struct usbtouch_device_info *type;
         char name[128];
         char phys[64];
+        void *priv;
 
         int x, y;
         int touch, press;
@@ -132,7 +136,8 @@ enum {
         DEVTYPE_JASTEC,
         DEVTYPE_E2I,
         DEVTYPE_ZYTRONIC,
-        DEVTYPE_TC5UH,
+        DEVTYPE_TC45USB,
+        DEVTYPE_NEXIO,
 };
 
 #define USB_DEVICE_HID_CLASS(vend, prod) \
@@ -144,7 +149,7 @@ enum {
         .bInterfaceClass = USB_INTERFACE_CLASS_HID, \
         .bInterfaceProtocol = USB_INTERFACE_PROTOCOL_MOUSE
 
-static struct usb_device_id usbtouch_devices[] = {
+static const struct usb_device_id usbtouch_devices[] = {
 #ifdef CONFIG_TOUCHSCREEN_USB_EGALAX
         /* ignore the HID capable devices, handled by usbhid */
         {USB_DEVICE_HID_CLASS(0x0eef, 0x0001), .driver_info = DEVTYPE_IGNORE},
@@ -218,8 +223,19 @@ static struct usb_device_id usbtouch_devices[] = {
         {USB_DEVICE(0x14c8, 0x0003), .driver_info = DEVTYPE_ZYTRONIC},
 #endif
 
-#ifdef CONFIG_TOUCHSCREEN_USB_ETT_TC5UH
-        {USB_DEVICE(0x0664, 0x0309), .driver_info = DEVTYPE_TC5UH},
+#ifdef CONFIG_TOUCHSCREEN_USB_ETT_TC45USB
+        /* TC5UH */
+        {USB_DEVICE(0x0664, 0x0309), .driver_info = DEVTYPE_TC45USB},
+        /* TC4UM */
+        {USB_DEVICE(0x0664, 0x0306), .driver_info = DEVTYPE_TC45USB},
+#endif
+
+#ifdef CONFIG_TOUCHSCREEN_USB_NEXIO
+        /* data interface only */
+        {USB_DEVICE_AND_INTERFACE_INFO(0x10f0, 0x2002, 0x0a, 0x00, 0x00),
+                .driver_info = DEVTYPE_NEXIO},
+        {USB_DEVICE_AND_INTERFACE_INFO(0x1870, 0x0001, 0x0a, 0x00, 0x00),
+                .driver_info = DEVTYPE_NEXIO},
 #endif
 
         {}
@@ -234,8 +250,9 @@ static struct usb_device_id usbtouch_devices[] = {
 static int e2i_init(struct usbtouch_usb *usbtouch)
 {
         int ret;
+        struct usb_device *udev = interface_to_usbdev(usbtouch->interface);
 
-        ret = usb_control_msg(usbtouch->udev, usb_rcvctrlpipe(usbtouch->udev, 0),
+        ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
                               0x01, 0x02, 0x0000, 0x0081,
                               NULL, 0, USB_CTRL_SET_TIMEOUT);
 
@@ -344,8 +361,9 @@ static int mtouch_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
 static int mtouch_init(struct usbtouch_usb *usbtouch)
 {
         int ret, i;
+        struct usb_device *udev = interface_to_usbdev(usbtouch->interface);
 
-        ret = usb_control_msg(usbtouch->udev, usb_rcvctrlpipe(usbtouch->udev, 0),
+        ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
                               MTOUCHUSB_RESET,
                               USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
                               1, 0, NULL, 0, USB_CTRL_SET_TIMEOUT);
@@ -356,7 +374,7 @@ static int mtouch_init(struct usbtouch_usb *usbtouch)
         msleep(150);
 
         for (i = 0; i < 3; i++) {
-                ret = usb_control_msg(usbtouch->udev, usb_rcvctrlpipe(usbtouch->udev, 0),
+                ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
                                       MTOUCHUSB_ASYNC_REPORT,
                                       USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
                                       1, 1, NULL, 0, USB_CTRL_SET_TIMEOUT);
@@ -489,11 +507,11 @@ static int gunze_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
 
 static int dmc_tsc10_init(struct usbtouch_usb *usbtouch)
 {
-        struct usb_device *dev = usbtouch->udev;
+        struct usb_device *dev = interface_to_usbdev(usbtouch->interface);
         int ret = -ENOMEM;
         unsigned char *buf;
 
-        buf = kmalloc(2, GFP_KERNEL);
+        buf = kmalloc(2, GFP_NOIO);
         if (!buf)
                 goto err_nobuf;
         /* reset */
@@ -560,10 +578,10 @@ static int irtouch_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
 #endif
 
 /*****************************************************************************
- * ET&T TC5UH part
+ * ET&T TC5UH/TC4UM part
  */
-#ifdef CONFIG_TOUCHSCREEN_USB_ETT_TC5UH
-static int tc5uh_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
+#ifdef CONFIG_TOUCHSCREEN_USB_ETT_TC45USB
+static int tc45usb_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
 {
         dev->x = ((pkt[2] & 0x0F) << 8) | pkt[1];
         dev->y = ((pkt[4] & 0x0F) << 8) | pkt[3];
@@ -618,8 +636,8 @@ static int idealtek_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
 #ifdef CONFIG_TOUCHSCREEN_USB_GENERAL_TOUCH
 static int general_touch_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
 {
-        dev->x = ((pkt[2] & 0x0F) << 8) | pkt[1] ;
-        dev->y = ((pkt[4] & 0x0F) << 8) | pkt[3] ;
+        dev->x = (pkt[2] << 8) | pkt[1];
+        dev->y = (pkt[4] << 8) | pkt[3];
         dev->press = pkt[5] & 0xff;
         dev->touch = pkt[0] & 0x01;
 
@@ -690,6 +708,242 @@ static int zytronic_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
 #endif
 
 /*****************************************************************************
+ * NEXIO Part
+ */
+#ifdef CONFIG_TOUCHSCREEN_USB_NEXIO
+
+#define NEXIO_TIMEOUT   5000
+#define NEXIO_BUFSIZE   1024
+#define NEXIO_THRESHOLD 50
+
+struct nexio_priv {
+        struct urb *ack;
+        unsigned char *ack_buf;
+};
+
+struct nexio_touch_packet {
+        u8      flags;          /* 0xe1 = touch, 0xe1 = release */
+        __be16  data_len;       /* total bytes of touch data */
+        __be16  x_len;          /* bytes for X axis */
+        __be16  y_len;          /* bytes for Y axis */
+        u8      data[];
+} __attribute__ ((packed));
+
+static unsigned char nexio_ack_pkt[2] = { 0xaa, 0x02 };
+static unsigned char nexio_init_pkt[4] = { 0x82, 0x04, 0x0a, 0x0f };
+
+static void nexio_ack_complete(struct urb *urb)
+{
+}
+
+static int nexio_alloc(struct usbtouch_usb *usbtouch)
+{
+        struct nexio_priv *priv;
+        int ret = -ENOMEM;
+
+        usbtouch->priv = kmalloc(sizeof(struct nexio_priv), GFP_KERNEL);
+        if (!usbtouch->priv)
+                goto out_buf;
+
+        priv = usbtouch->priv;
+
+        priv->ack_buf = kmemdup(nexio_ack_pkt, sizeof(nexio_ack_pkt),
+                                GFP_KERNEL);
+        if (!priv->ack_buf)
+                goto err_priv;
+
+        priv->ack = usb_alloc_urb(0, GFP_KERNEL);
+        if (!priv->ack) {
+                dbg("%s - usb_alloc_urb failed: usbtouch->ack", __func__);
+                goto err_ack_buf;
+        }
+
+        return 0;
+
+err_ack_buf:
+        kfree(priv->ack_buf);
+err_priv:
+        kfree(priv);
+out_buf:
+        return ret;
+}
+
+static int nexio_init(struct usbtouch_usb *usbtouch)
+{
+        struct usb_device *dev = interface_to_usbdev(usbtouch->interface);
+        struct usb_host_interface *interface = usbtouch->interface->cur_altsetting;
+        struct nexio_priv *priv = usbtouch->priv;
+        int ret = -ENOMEM;
+        int actual_len, i;
+        unsigned char *buf;
+        char *firmware_ver = NULL, *device_name = NULL;
+        int input_ep = 0, output_ep = 0;
+
+        /* find first input and output endpoint */
+        for (i = 0; i < interface->desc.bNumEndpoints; i++) {
+                if (!input_ep &&
+                    usb_endpoint_dir_in(&interface->endpoint[i].desc))
+                        input_ep = interface->endpoint[i].desc.bEndpointAddress;
+                if (!output_ep &&
+                    usb_endpoint_dir_out(&interface->endpoint[i].desc))
+                        output_ep = interface->endpoint[i].desc.bEndpointAddress;
+        }
+        if (!input_ep || !output_ep)
+                return -ENXIO;
+
+        buf = kmalloc(NEXIO_BUFSIZE, GFP_NOIO);
+        if (!buf)
+                goto out_buf;
+
+        /* two empty reads */
+        for (i = 0; i < 2; i++) {
+                ret = usb_bulk_msg(dev, usb_rcvbulkpipe(dev, input_ep),
+                                   buf, NEXIO_BUFSIZE, &actual_len,
+                                   NEXIO_TIMEOUT);
+                if (ret < 0)
+                        goto out_buf;
+        }
+
+        /* send init command */
+        memcpy(buf, nexio_init_pkt, sizeof(nexio_init_pkt));
+        ret = usb_bulk_msg(dev, usb_sndbulkpipe(dev, output_ep),
+                           buf, sizeof(nexio_init_pkt), &actual_len,
+                           NEXIO_TIMEOUT);
+        if (ret < 0)
+                goto out_buf;
+
+        /* read replies */
+        for (i = 0; i < 3; i++) {
+                memset(buf, 0, NEXIO_BUFSIZE);
+                ret = usb_bulk_msg(dev, usb_rcvbulkpipe(dev, input_ep),
+                                   buf, NEXIO_BUFSIZE, &actual_len,
+                                   NEXIO_TIMEOUT);
+                if (ret < 0 || actual_len < 1 || buf[1] != actual_len)
+                        continue;
+                switch (buf[0]) {
+                case 0x83:      /* firmware version */
+                        if (!firmware_ver)
+                                firmware_ver = kstrdup(&buf[2], GFP_NOIO);
+                        break;
+                case 0x84:      /* device name */
+                        if (!device_name)
+                                device_name = kstrdup(&buf[2], GFP_NOIO);
+                        break;
+                }
+        }
+
+        printk(KERN_INFO "Nexio device: %s, firmware version: %s\n",
+               device_name, firmware_ver);
+
+        kfree(firmware_ver);
+        kfree(device_name);
+
+        usb_fill_bulk_urb(priv->ack, dev, usb_sndbulkpipe(dev, output_ep),
+                          priv->ack_buf, sizeof(nexio_ack_pkt),
+                          nexio_ack_complete, usbtouch);
+        ret = 0;
+
+out_buf:
+        kfree(buf);
+        return ret;
+}
+
+static void nexio_exit(struct usbtouch_usb *usbtouch)
+{
+        struct nexio_priv *priv = usbtouch->priv;
+
+        usb_kill_urb(priv->ack);
+        usb_free_urb(priv->ack);
+        kfree(priv->ack_buf);
+        kfree(priv);
+}
+
+static int nexio_read_data(struct usbtouch_usb *usbtouch, unsigned char *pkt)
+{
+        struct nexio_touch_packet *packet = (void *) pkt;
+        struct nexio_priv *priv = usbtouch->priv;
+        unsigned int data_len = be16_to_cpu(packet->data_len);
+        unsigned int x_len = be16_to_cpu(packet->x_len);
+        unsigned int y_len = be16_to_cpu(packet->y_len);
+        int x, y, begin_x, begin_y, end_x, end_y, w, h, ret;
+
+        /* got touch data? */
+        if ((pkt[0] & 0xe0) != 0xe0)
+                return 0;
+
+        if (data_len > 0xff)
+                data_len -= 0x100;
+        if (x_len > 0xff)
+                x_len -= 0x80;
+
+        /* send ACK */
+        ret = usb_submit_urb(priv->ack, GFP_ATOMIC);
+
+        if (!usbtouch->type->max_xc) {
+                usbtouch->type->max_xc = 2 * x_len;
+                input_set_abs_params(usbtouch->input, ABS_X,
+                                     0, usbtouch->type->max_xc, 0, 0);
+                usbtouch->type->max_yc = 2 * y_len;
+                input_set_abs_params(usbtouch->input, ABS_Y,
+                                     0, usbtouch->type->max_yc, 0, 0);
+        }
+        /*
+         * The device reports state of IR sensors on X and Y axes.
+         * Each byte represents "darkness" percentage (0-100) of one element.
+         * 17" touchscreen reports only 64 x 52 bytes so the resolution is low.
+         * This also means that there's a limited multi-touch capability but
+         * it's disabled (and untested) here as there's no X driver for that.
+         */
+        begin_x = end_x = begin_y = end_y = -1;
+        for (x = 0; x < x_len; x++) {
+                if (begin_x == -1 && packet->data[x] > NEXIO_THRESHOLD) {
+                        begin_x = x;
+                        continue;
+                }
+                if (end_x == -1 && begin_x != -1 && packet->data[x] < NEXIO_THRESHOLD) {
+                        end_x = x - 1;
+                        for (y = x_len; y < data_len; y++) {
+                                if (begin_y == -1 && packet->data[y] > NEXIO_THRESHOLD) {
+                                        begin_y = y - x_len;
+                                        continue;
+                                }
+                                if (end_y == -1 &&
+                                    begin_y != -1 && packet->data[y] < NEXIO_THRESHOLD) {
+                                        end_y = y - 1 - x_len;
+                                        w = end_x - begin_x;
+                                        h = end_y - begin_y;
+#if 0
+                                        /* multi-touch */
+                                        input_report_abs(usbtouch->input,
+                                                    ABS_MT_TOUCH_MAJOR, max(w,h));
+                                        input_report_abs(usbtouch->input,
+                                                    ABS_MT_TOUCH_MINOR, min(x,h));
+                                        input_report_abs(usbtouch->input,
+                                                    ABS_MT_POSITION_X, 2*begin_x+w);
+                                        input_report_abs(usbtouch->input,
+                                                    ABS_MT_POSITION_Y, 2*begin_y+h);
+                                        input_report_abs(usbtouch->input,
+                                                    ABS_MT_ORIENTATION, w > h);
+                                        input_mt_sync(usbtouch->input);
+#endif
+                                        /* single touch */
+                                        usbtouch->x = 2 * begin_x + w;
+                                        usbtouch->y = 2 * begin_y + h;
+                                        usbtouch->touch = packet->flags & 0x01;
+                                        begin_y = end_y = -1;
+                                        return 1;
+                                }
+                        }
+                        begin_x = end_x = -1;
+                }
+
+        }
+        return 0;
+}
+#endif
+
+
+/*****************************************************************************
  * the different device descriptors
  */
 #ifdef MULTI_PACKET
@@ -809,9 +1063,9 @@ static struct usbtouch_device_info usbtouch_dev_info[] = {
 #ifdef CONFIG_TOUCHSCREEN_USB_GENERAL_TOUCH
         [DEVTYPE_GENERAL_TOUCH] = {
                 .min_xc         = 0x0,
-                .max_xc         = 0x0500,
+                .max_xc         = 0x7fff,
                 .min_yc         = 0x0,
-                .max_yc         = 0x0500,
+                .max_yc         = 0x7fff,
                 .rept_size      = 7,
                 .read_data      = general_touch_read_data,
         },
@@ -863,14 +1117,25 @@ static struct usbtouch_device_info usbtouch_dev_info[] = {
         },
 #endif
 
-#ifdef CONFIG_TOUCHSCREEN_USB_ETT_TC5UH
-        [DEVTYPE_TC5UH] = {
+#ifdef CONFIG_TOUCHSCREEN_USB_ETT_TC45USB
+        [DEVTYPE_TC45USB] = {
                 .min_xc         = 0x0,
                 .max_xc         = 0x0fff,
                 .min_yc         = 0x0,
                 .max_yc         = 0x0fff,
                 .rept_size      = 5,
-                .read_data      = tc5uh_read_data,
+                .read_data      = tc45usb_read_data,
+        },
+#endif
+
+#ifdef CONFIG_TOUCHSCREEN_USB_NEXIO
+        [DEVTYPE_NEXIO] = {
+                .rept_size      = 1024,
+                .irq_always     = true,
+                .read_data      = nexio_read_data,
+                .alloc          = nexio_alloc,
+                .init           = nexio_init,
+                .exit           = nexio_exit,
         },
 #endif
 };
@@ -998,6 +1263,7 @@ static void usbtouch_irq(struct urb *urb)
         case -ECONNRESET:
         case -ENOENT:
         case -ESHUTDOWN:
+        case -EPIPE:
                 /* this urb is terminated, clean up */
                 dbg("%s - urb shutting down with status: %d",
                     __func__, urb->status);
@@ -1011,6 +1277,7 @@ static void usbtouch_irq(struct urb *urb)
         usbtouch->type->process_pkt(usbtouch, usbtouch->data, urb->actual_length);
 
 exit:
+        usb_mark_last_busy(interface_to_usbdev(usbtouch->interface));
         retval = usb_submit_urb(urb, GFP_ATOMIC);
         if (retval)
                 err("%s - usb_submit_urb failed with result: %d",
@@ -1020,41 +1287,115 @@ exit:
 static int usbtouch_open(struct input_dev *input)
 {
         struct usbtouch_usb *usbtouch = input_get_drvdata(input);
+        int r;
 
-        usbtouch->irq->dev = usbtouch->udev;
+        usbtouch->irq->dev = interface_to_usbdev(usbtouch->interface);
+
+        r = usb_autopm_get_interface(usbtouch->interface) ? -EIO : 0;
+        if (r < 0)
+                goto out;
 
         if (!usbtouch->type->irq_always) {
-                if (usb_submit_urb(usbtouch->irq, GFP_KERNEL))
-                  return -EIO;
+                if (usb_submit_urb(usbtouch->irq, GFP_KERNEL)) {
+                        r = -EIO;
+                        goto out_put;
+                }
         }
 
-        return 0;
+        usbtouch->interface->needs_remote_wakeup = 1;
+out_put:
+        usb_autopm_put_interface(usbtouch->interface);
+out:
+        return r;
 }
 
 static void usbtouch_close(struct input_dev *input)
 {
         struct usbtouch_usb *usbtouch = input_get_drvdata(input);
+        int r;
 
         if (!usbtouch->type->irq_always)
                 usb_kill_urb(usbtouch->irq);
+        r = usb_autopm_get_interface(usbtouch->interface);
+        usbtouch->interface->needs_remote_wakeup = 0;
+        if (!r)
+                usb_autopm_put_interface(usbtouch->interface);
+}
+
+static int usbtouch_suspend
+(struct usb_interface *intf, pm_message_t message)
+{
+        struct usbtouch_usb *usbtouch = usb_get_intfdata(intf);
+
+        usb_kill_urb(usbtouch->irq);
+
+        return 0;
+}
+
+static int usbtouch_resume(struct usb_interface *intf)
+{
+        struct usbtouch_usb *usbtouch = usb_get_intfdata(intf);
+        struct input_dev *input = usbtouch->input;
+        int result = 0;
+
+        mutex_lock(&input->mutex);
+        if (input->users || usbtouch->type->irq_always)
+                result = usb_submit_urb(usbtouch->irq, GFP_NOIO);
+        mutex_unlock(&input->mutex);
+
+        return result;
 }
 
+static int usbtouch_reset_resume(struct usb_interface *intf)
+{
+        struct usbtouch_usb *usbtouch = usb_get_intfdata(intf);
+        struct input_dev *input = usbtouch->input;
+        int err = 0;
+
+        /* reinit the device */
+        if (usbtouch->type->init) {
+                err = usbtouch->type->init(usbtouch);
+                if (err) {
+                        dbg("%s - type->init() failed, err: %d",
+                            __func__, err);
+                        return err;
+                }
+        }
+
+        /* restart IO if needed */
+        mutex_lock(&input->mutex);
+        if (input->users)
+                err = usb_submit_urb(usbtouch->irq, GFP_NOIO);
+        mutex_unlock(&input->mutex);
+
+        return err;
+}
 
 static void usbtouch_free_buffers(struct usb_device *udev,
                                   struct usbtouch_usb *usbtouch)
 {
-        usb_buffer_free(udev, usbtouch->type->rept_size,
-                        usbtouch->data, usbtouch->data_dma);
+        usb_free_coherent(udev, usbtouch->type->rept_size,
+                          usbtouch->data, usbtouch->data_dma);
         kfree(usbtouch->buffer);
 }
 
+static struct usb_endpoint_descriptor *
+usbtouch_get_input_endpoint(struct usb_host_interface *interface)
+{
+        int i;
+
+        for (i = 0; i < interface->desc.bNumEndpoints; i++)
+                if (usb_endpoint_dir_in(&interface->endpoint[i].desc))
+                        return &interface->endpoint[i].desc;
+
+        return NULL;
+}
 
 static int usbtouch_probe(struct usb_interface *intf,
                           const struct usb_device_id *id)
 {
         struct usbtouch_usb *usbtouch;
         struct input_dev *input_dev;
-        struct usb_host_interface *interface;
         struct usb_endpoint_descriptor *endpoint;
         struct usb_device *udev = interface_to_usbdev(intf);
         struct usbtouch_device_info *type;
@@ -1064,8 +1405,9 @@ static int usbtouch_probe(struct usb_interface *intf,
         if (id->driver_info == DEVTYPE_IGNORE)
                 return -ENODEV;
 
-        interface = intf->cur_altsetting;
-        endpoint = &interface->endpoint[0].desc;
+        endpoint = usbtouch_get_input_endpoint(intf->cur_altsetting);
+        if (!endpoint)
+                return -ENXIO;
 
         usbtouch = kzalloc(sizeof(struct usbtouch_usb), GFP_KERNEL);
         input_dev = input_allocate_device();
@@ -1077,8 +1419,8 @@ static int usbtouch_probe(struct usb_interface *intf,
         if (!type->process_pkt)
                 type->process_pkt = usbtouch_process_pkt;
 
-        usbtouch->data = usb_buffer_alloc(udev, type->rept_size,
-                                          GFP_KERNEL, &usbtouch->data_dma);
+        usbtouch->data = usb_alloc_coherent(udev, type->rept_size,
+                                            GFP_KERNEL, &usbtouch->data_dma);
         if (!usbtouch->data)
                 goto out_free;
 
@@ -1094,7 +1436,7 @@ static int usbtouch_probe(struct usb_interface *intf,
                 goto out_free_buffers;
         }
 
-        usbtouch->udev = udev;
+        usbtouch->interface = intf;
         usbtouch->input = input_dev;
 
         if (udev->manufacturer)
@@ -1133,37 +1475,69 @@ static int usbtouch_probe(struct usb_interface *intf,
                 input_set_abs_params(input_dev, ABS_PRESSURE, type->min_press,
                                      type->max_press, 0, 0);
 
-        usb_fill_int_urb(usbtouch->irq, usbtouch->udev,
-                         usb_rcvintpipe(usbtouch->udev, endpoint->bEndpointAddress),
+        if (usb_endpoint_type(endpoint) == USB_ENDPOINT_XFER_INT)
+                usb_fill_int_urb(usbtouch->irq, udev,
+                         usb_rcvintpipe(udev, endpoint->bEndpointAddress),
                          usbtouch->data, type->rept_size,
                          usbtouch_irq, usbtouch, endpoint->bInterval);
+        else
+                usb_fill_bulk_urb(usbtouch->irq, udev,
+                         usb_rcvbulkpipe(udev, endpoint->bEndpointAddress),
+                         usbtouch->data, type->rept_size,
+                         usbtouch_irq, usbtouch);
 
-        usbtouch->irq->dev = usbtouch->udev;
+        usbtouch->irq->dev = udev;
         usbtouch->irq->transfer_dma = usbtouch->data_dma;
         usbtouch->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 
-        /* device specific init */
+        /* device specific allocations */
+        if (type->alloc) {
+                err = type->alloc(usbtouch);
+                if (err) {
+                        dbg("%s - type->alloc() failed, err: %d", __func__, err);
+                        goto out_free_urb;
+                }
+        }
+
+        /* device specific initialisation*/
         if (type->init) {
                 err = type->init(usbtouch);
                 if (err) {
                         dbg("%s - type->init() failed, err: %d", __func__, err);
-                        goto out_free_buffers;
+                        goto out_do_exit;
                 }
         }
 
         err = input_register_device(usbtouch->input);
         if (err) {
                 dbg("%s - input_register_device failed, err: %d", __func__, err);
-                goto out_free_buffers;
+                goto out_do_exit;
         }
 
         usb_set_intfdata(intf, usbtouch);
 
-        if (usbtouch->type->irq_always)
-                usb_submit_urb(usbtouch->irq, GFP_KERNEL);
+        if (usbtouch->type->irq_always) {
+                /* this can't fail */
+                usb_autopm_get_interface(intf);
+                err = usb_submit_urb(usbtouch->irq, GFP_KERNEL);
+                if (err) {
+                        usb_autopm_put_interface(intf);
+                        err("%s - usb_submit_urb failed with result: %d",
+                            __func__, err);
+                        goto out_unregister_input;
+                }
+        }
 
         return 0;
 
+out_unregister_input:
+        input_unregister_device(input_dev);
+        input_dev = NULL;
+out_do_exit:
+        if (type->exit)
+                type->exit(usbtouch);
+out_free_urb:
+        usb_free_urb(usbtouch->irq);
 out_free_buffers:
         usbtouch_free_buffers(udev, usbtouch);
 out_free:
@@ -1186,6 +1560,8 @@ static void usbtouch_disconnect(struct usb_interface *intf)
         /* this will stop IO via close */
         input_unregister_device(usbtouch->input);
         usb_free_urb(usbtouch->irq);
+        if (usbtouch->type->exit)
+                usbtouch->type->exit(usbtouch);
         usbtouch_free_buffers(interface_to_usbdev(intf), usbtouch);
         kfree(usbtouch);
 }
@@ -1196,7 +1572,11 @@ static struct usb_driver usbtouch_driver = {
         .name           = "usbtouchscreen",
         .probe          = usbtouch_probe,
         .disconnect     = usbtouch_disconnect,
+        .suspend        = usbtouch_suspend,
+        .resume         = usbtouch_resume,
+        .reset_resume   = usbtouch_reset_resume,
         .id_table       = usbtouch_devices,
+        .supports_autosuspend = 1,
 };
 
 static int __init usbtouch_init(void)
diff --git a/drivers/input/touchscreen/w90p910_ts.c b/drivers/input/touchscreen/w90p910_ts.c
index 6ccbdbbf33fe..7a45d68c3516 100644
--- a/drivers/input/touchscreen/w90p910_ts.c
+++ b/drivers/input/touchscreen/w90p910_ts.c
@@ -16,6 +16,7 @@
 #include <linux/clk.h>
 #include <linux/input.h>
 #include <linux/interrupt.h>
+#include <linux/slab.h>
 
 /* ADC controller bit defines */
 #define ADC_DELAY       0xf00
@@ -232,7 +233,7 @@ static int __devinit w90x900ts_probe(struct platform_device *pdev)
         w90p910_ts->state = TS_IDLE;
         spin_lock_init(&w90p910_ts->lock);
         setup_timer(&w90p910_ts->timer, w90p910_check_pen_up,
-                    (unsigned long)&w90p910_ts);
+                    (unsigned long)w90p910_ts);
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (!res) {
diff --git a/drivers/input/touchscreen/wacom_w8001.c b/drivers/input/touchscreen/wacom_w8001.c
index 56dc35c94bb1..9ae4c7b16ba7 100644
--- a/drivers/input/touchscreen/wacom_w8001.c
+++ b/drivers/input/touchscreen/wacom_w8001.c
@@ -2,6 +2,7 @@
  * Wacom W8001 penabled serial touchscreen driver
  *
  * Copyright (c) 2008 Jaya Kumar
+ * Copyright (c) 2010 Red Hat, Inc.
  *
  * 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
@@ -30,11 +31,24 @@ 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_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
+
+#define MAX_TRACKING_ID         0xFF    /* arbitrarily chosen */
 
 struct w8001_coord {
         u8 rdy;
@@ -48,6 +62,15 @@ struct w8001_coord {
         u8 tilt_y;
 };
 
+/* touch query reply packet */
+struct w8001_touch_query {
+        u8 panel_res;
+        u8 capacity_res;
+        u8 sensor_id;
+        u16 x;
+        u16 y;
+};
+
 /*
  * Per-touchscreen data.
  */
@@ -62,6 +85,9 @@ struct w8001 {
         unsigned char response[W8001_MAX_LENGTH];
         unsigned char data[W8001_MAX_LENGTH];
         char phys[32];
+        int type;
+        unsigned int pktlen;
+        int trkid[2];
 };
 
 static void parse_data(u8 *data, struct w8001_coord *coord)
@@ -88,11 +114,98 @@ static void parse_data(u8 *data, struct w8001_coord *coord)
         coord->tilt_y = data[8] & 0x7F;
 }
 
+static void parse_touch(struct w8001 *w8001)
+{
+        static int trkid;
+        struct input_dev *dev = w8001->dev;
+        unsigned char *data = w8001->data;
+        int i;
+
+        for (i = 0; i < 2; i++) {
+                input_mt_slot(dev, i);
+
+                if (data[0] & (1 << i)) {
+                        int x = (data[6 * i + 1] << 7) | (data[6 * i + 2]);
+                        int y = (data[6 * i + 3] << 7) | (data[6 * i + 4]);
+                        /* data[5,6] and [11,12] is finger capacity */
+
+                        input_report_abs(dev, ABS_MT_POSITION_X, x);
+                        input_report_abs(dev, ABS_MT_POSITION_Y, y);
+                        input_report_abs(dev, ABS_MT_TOOL_TYPE, MT_TOOL_FINGER);
+                        if (w8001->trkid[i] < 0)
+                                w8001->trkid[i] = trkid++ & MAX_TRACKING_ID;
+                } else {
+                        w8001->trkid[i] = -1;
+                }
+                input_report_abs(dev, ABS_MT_TRACKING_ID, w8001->trkid[i]);
+        }
+
+        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;
+}
+
+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.
+         */
+
+        if (!w8001->type) {
+                w8001->type = coord->f2 ? BTN_TOOL_RUBBER : BTN_TOOL_PEN;
+        } else if (w8001->type == 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;
+                }
+        } else {
+                input_report_key(dev, BTN_STYLUS2, coord->f2);
+        }
+
+        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 = 0;
+}
+
 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 +218,45 @@ static irqreturn_t w8001_interrupt(struct serio *serio,
                 }
                 break;
 
-        case 8:
+        case W8001_PKTLEN_TOUCH93 - 1:
+        case W8001_PKTLEN_TOUCH9A - 1:
+                /* ignore one-finger touch packet. */
+                if (w8001->pktlen == w8001->idx)
+                        w8001->idx = 0;
+                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);
+                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_touch(w8001);
+                break;
         }
 
         return IRQ_HANDLED;
@@ -167,6 +299,38 @@ static int w8001_setup(struct w8001 *w8001)
         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);
 
+        error = w8001_command(w8001, W8001_CMD_TOUCHQUERY, true);
+        if (!error) {
+                struct w8001_touch_query touch;
+
+                parse_touchquery(w8001->response, &touch);
+
+                switch (touch.sensor_id) {
+                case 0:
+                case 2:
+                        w8001->pktlen = W8001_PKTLEN_TOUCH93;
+                        break;
+                case 1:
+                case 3:
+                case 4:
+                        w8001->pktlen = W8001_PKTLEN_TOUCH9A;
+                        break;
+                case 5:
+                        w8001->pktlen = W8001_PKTLEN_TOUCH2FG;
+
+                        input_mt_create_slots(dev, 2);
+                        input_set_abs_params(dev, ABS_MT_TRACKING_ID,
+                                                0, MAX_TRACKING_ID, 0, 0);
+                        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, 0, 0, 0);
+                        break;
+                }
+        }
+
         return w8001_command(w8001, W8001_CMD_START, false);
 }
 
@@ -208,6 +372,7 @@ static int w8001_connect(struct serio *serio, struct serio_driver *drv)
         w8001->serio = serio;
         w8001->id = serio->id.id;
         w8001->dev = input_dev;
+        w8001->trkid[0] = w8001->trkid[1] = -1;
         init_completion(&w8001->cmd_done);
         snprintf(w8001->phys, sizeof(w8001->phys), "%s/input0", serio->phys);
 
@@ -221,6 +386,10 @@ static int w8001_connect(struct serio *serio, struct serio_driver *drv)
 
         input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
         input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
+        input_dev->keybit[BIT_WORD(BTN_TOOL_PEN)] |= BIT_MASK(BTN_TOOL_PEN);
+        input_dev->keybit[BIT_WORD(BTN_TOOL_RUBBER)] |= BIT_MASK(BTN_TOOL_RUBBER);
+        input_dev->keybit[BIT_WORD(BTN_STYLUS)] |= BIT_MASK(BTN_STYLUS);
+        input_dev->keybit[BIT_WORD(BTN_STYLUS2)] |= BIT_MASK(BTN_STYLUS2);
 
         serio_set_drvdata(serio, w8001);
         err = serio_open(serio, drv);
diff --git a/drivers/input/touchscreen/wm97xx-core.c b/drivers/input/touchscreen/wm97xx-core.c
index f944918466e5..6b75c9f660ae 100644
--- a/drivers/input/touchscreen/wm97xx-core.c
+++ b/drivers/input/touchscreen/wm97xx-core.c
@@ -48,6 +48,7 @@
 #include <linux/wm97xx.h>
 #include <linux/uaccess.h>
 #include <linux/io.h>
+#include <linux/slab.h>
 
 #define TS_NAME                 "wm97xx"
 #define WM_CORE_VERSION         "1.00"
@@ -124,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);
@@ -142,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);
@@ -151,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);
 
@@ -199,7 +211,7 @@ void wm97xx_set_gpio(struct wm97xx *wm, u32 gpio,
         mutex_lock(&wm->codec_mutex);
         reg = wm97xx_reg_read(wm, AC97_GPIO_STATUS);
 
-        if (status & WM97XX_GPIO_HIGH)
+        if (status == WM97XX_GPIO_HIGH)
                 reg |= gpio;
         else
                 reg &= ~gpio;
@@ -683,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 eca54dbdf493..048849867643 100644
--- a/drivers/input/touchscreen/zylonite-wm97xx.c
+++ b/drivers/input/touchscreen/zylonite-wm97xx.c
@@ -118,6 +118,9 @@ static int wm97xx_acc_pen_down(struct wm97xx *wm)
                 if (pressure)
                         p = MODR;
 
+                dev_dbg(wm->dev, "Raw coordinates: x=%x, y=%x, p=%x\n",
+                        x, y, p);
+
                 /* are samples valid */
                 if ((x & WM97XX_ADCSRC_MASK) != WM97XX_ADCSEL_X ||
                     (y & WM97XX_ADCSRC_MASK) != WM97XX_ADCSEL_Y ||
diff --git a/drivers/input/xen-kbdfront.c b/drivers/input/xen-kbdfront.c
index c721c0a23eb8..ebb11907d402 100644
--- a/drivers/input/xen-kbdfront.c
+++ b/drivers/input/xen-kbdfront.c
@@ -21,6 +21,7 @@
 #include <linux/errno.h>
 #include <linux/module.h>
 #include <linux/input.h>
+#include <linux/slab.h>
 
 #include <asm/xen/hypervisor.h>
 
@@ -321,7 +322,7 @@ InitWait:
         }
 }
 
-static struct xenbus_device_id xenkbd_ids[] = {
+static const struct xenbus_device_id xenkbd_ids[] = {
         { "vkbd" },
         { "" }
 };
@@ -338,7 +339,7 @@ static struct xenbus_driver xenkbd_driver = {
 
 static int __init xenkbd_init(void)
 {
-        if (!xen_domain())
+        if (!xen_pv_domain())
                 return -ENODEV;
 
         /* Nothing to do if running in dom0. */