Merge branch 'for-2.6.36' into for-2.6.37

Fairly simple conflicts, the most serious ones are the i.MX ones which I
suspect now need another rename.

Conflicts:
	arch/arm/mach-mx2/clock_imx27.c
	arch/arm/mach-mx2/devices.c
	arch/arm/mach-omap2/board-rx51-peripherals.c
	arch/arm/mach-omap2/board-zoom2.c
	sound/soc/fsl/mpc5200_dma.c
	sound/soc/fsl/mpc5200_dma.h
	sound/soc/fsl/mpc8610_hpcd.c
	sound/soc/pxa/spitz.c

85 files changed, 7024 insertions, 1207 deletions

diff --git a/drivers/input/evdev.c b/drivers/input/evdev.c
index 2ee6c7a68bdc..c908c5f83645 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,7 +24,6 @@
 #include "input-compat.h"
 
 struct evdev {
-        int exist;
         int open;
         int minor;
         struct input_handle handle;
@@ -33,16 +33,18 @@ struct evdev {
         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);
@@ -334,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);
@@ -382,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
@@ -466,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;
@@ -491,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
@@ -502,7 +530,7 @@ 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
 
@@ -516,8 +544,10 @@ static long evdev_do_ioctl(struct file *file, unsigned int cmd,
         struct ff_effect effect;
         int __user *ip = (int __user *)p;
         unsigned int i, t, u, v;
+        unsigned int size;
         int error;
 
+        /* First we check for fixed-length commands */
         switch (cmd) {
 
         case EVIOCGVERSION:
@@ -584,108 +614,102 @@ static long evdev_do_ioctl(struct file *file, unsigned int cmd,
                         return evdev_grab(evdev, client);
                 else
                         return evdev_ungrab(evdev, client);
+        }
 
-        default:
-
-                if (_IOC_TYPE(cmd) != 'E')
-                        return -EINVAL;
+        size = _IOC_SIZE(cmd);
 
-                if (_IOC_DIR(cmd) == _IOC_READ) {
+        /* Now check variable-length commands */
+#define EVIOC_MASK_SIZE(nr)     ((nr) & ~(_IOC_SIZEMASK << _IOC_SIZESHIFT))
 
-                        if ((_IOC_NR(cmd) & ~EV_MAX) == _IOC_NR(EVIOCGBIT(0, 0)))
-                                return handle_eviocgbit(dev, cmd, p, compat_mode);
+        switch (EVIOC_MASK_SIZE(cmd)) {
 
-                        if (_IOC_NR(cmd) == _IOC_NR(EVIOCGKEY(0)))
-                                return bits_to_user(dev->key, KEY_MAX, _IOC_SIZE(cmd),
-                                                    p, compat_mode);
+        case EVIOCGKEY(0):
+                return bits_to_user(dev->key, KEY_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 EVIOCGLED(0):
+                return bits_to_user(dev->led, LED_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 EVIOCGSND(0):
+                return bits_to_user(dev->snd, SND_MAX, size, p, compat_mode);
 
-                        if (_IOC_NR(cmd) == _IOC_NR(EVIOCGSW(0)))
-                                return bits_to_user(dev->sw, SW_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(EVIOCGNAME(0)))
-                                return str_to_user(dev->name, _IOC_SIZE(cmd), p);
+        case EVIOCGNAME(0):
+                return str_to_user(dev->name, size, p);
 
-                        if (_IOC_NR(cmd) == _IOC_NR(EVIOCGPHYS(0)))
-                                return str_to_user(dev->phys, _IOC_SIZE(cmd), p);
+        case EVIOCGPHYS(0):
+                return str_to_user(dev->phys, size, p);
 
-                        if (_IOC_NR(cmd) == _IOC_NR(EVIOCGUNIQ(0)))
-                                return str_to_user(dev->uniq, _IOC_SIZE(cmd), p);
+        case EVIOCGUNIQ(0):
+                return str_to_user(dev->uniq, size, p);
 
-                        if ((_IOC_NR(cmd) & ~ABS_MAX) == _IOC_NR(EVIOCGABS(0))) {
+        case EVIOC_MASK_SIZE(EVIOCSFF):
+                if (input_ff_effect_from_user(p, size, &effect))
+                        return -EFAULT;
 
-                                t = _IOC_NR(cmd) & ABS_MAX;
+                error = input_ff_upload(dev, &effect, file);
 
-                                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];
+                if (put_user(effect.id, &(((struct ff_effect __user *)p)->id)))
+                        return -EFAULT;
 
-                                if (copy_to_user(p, &abs, min_t(size_t,
-                                                                _IOC_SIZE(cmd),
-                                                                sizeof(struct input_absinfo))))
-                                        return -EFAULT;
+                return error;
+        }
 
-                                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;
+                        t = _IOC_NR(cmd) & ABS_MAX;
+                        abs = dev->absinfo[t];
 
-                                error = input_ff_upload(dev, &effect, file);
+                        if (copy_to_user(p, &abs, min_t(size_t,
+                                        size, sizeof(struct input_absinfo))))
+                                return -EFAULT;
 
-                                if (put_user(effect.id, &(((struct ff_effect __user *)p)->id)))
-                                        return -EFAULT;
+                        return 0;
+                }
+        }
 
-                                return error;
-                        }
+        if (_IOC_DIR(cmd) == _IOC_READ) {
 
-                        if ((_IOC_NR(cmd) & ~ABS_MAX) == _IOC_NR(EVIOCSABS(0))) {
+                if ((_IOC_NR(cmd) & ~ABS_MAX) == _IOC_NR(EVIOCSABS(0))) {
 
-                                t = _IOC_NR(cmd) & ABS_MAX;
+                        t = _IOC_NR(cmd) & ABS_MAX;
 
-                                if (copy_from_user(&abs, p, min_t(size_t,
-                                                                  _IOC_SIZE(cmd),
-                                                                  sizeof(struct input_absinfo))))
-                                        return -EFAULT;
+                        if (copy_from_user(&abs, p, min_t(size_t,
+                                        size, sizeof(struct input_absinfo))))
+                                return -EFAULT;
 
-                                /*
-                                 * Take event lock to ensure that we are not
-                                 * changing device parameters in the middle
-                                 * of event.
-                                 */
-                                spin_lock_irq(&dev->event_lock);
+                        if (size < sizeof(struct input_absinfo))
+                                abs.resolution = 0;
 
-                                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;
+                        /* We can't change number of reserved MT slots */
+                        if (t == ABS_MT_SLOT)
+                                return -EINVAL;
 
-                                spin_unlock_irq(&dev->event_lock);
+                        /*
+                         * 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 0;
                 }
         }
+
         return -EINVAL;
 }
 
@@ -768,7 +792,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);
 }
 
@@ -817,7 +841,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/input.c b/drivers/input/input.c
index 9c79bd56b51a..a9b025f4147a 100644
--- a/drivers/input/input.c
+++ b/drivers/input/input.c
@@ -33,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);
 
@@ -181,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 actiual 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 multitouch 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)
 {
@@ -196,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;
                 }
@@ -233,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;
-                        }
+                if (is_event_supported(code, dev->absbit, ABS_MAX))
+                        disposition = input_handle_abs_event(dev, code, &value);
 
-                        value = input_defuzz_abs_event(value,
-                                        dev->abs[code], dev->absfuzz[code]);
-
-                        if (dev->abs[code] != value) {
-                                dev->abs[code] = value;
-                                disposition = INPUT_PASS_TO_HANDLERS;
-                        }
-                }
                 break;
 
         case EV_REL:
@@ -298,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);
@@ -372,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
  *
@@ -528,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
@@ -552,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;
@@ -684,7 +750,7 @@ int input_set_keycode(struct input_dev *dev,
                       unsigned int scancode, unsigned int keycode)
 {
         unsigned long flags;
-        int old_keycode;
+        unsigned int old_keycode;
         int retval;
 
         if (keycode > KEY_MAX)
@@ -1278,6 +1344,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);
@@ -1433,6 +1501,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;
@@ -1518,6 +1595,45 @@ 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.
+ */
+int input_mt_create_slots(struct input_dev *dev, unsigned int num_slots)
+{
+        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);
+
+        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...)
@@ -1926,20 +2042,10 @@ static const struct file_operations input_fops = {
         .open = input_open_file,
 };
 
-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 34157bb97ed6..d85bd8a7967d 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,6 +45,7 @@ struct joydev {
         spinlock_t client_lock; /* protects client_list */
         struct mutex mutex;
         struct device dev;
+        bool exist;
 
         struct js_corr corr[ABS_CNT];
         struct JS_DATA_SAVE_TYPE glue;
@@ -530,7 +530,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. */
@@ -562,12 +562,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;
 
@@ -760,7 +759,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);
 }
 
@@ -817,10 +816,9 @@ 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;
@@ -849,25 +847,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 = (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 = (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
+                        - 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);
                 }
         }
 
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/gamecon.c b/drivers/input/joystick/gamecon.c
index fbd62abb66f9..0ffaf2c77a19 100644
--- a/drivers/input/joystick/gamecon.c
+++ b/drivers/input/joystick/gamecon.c
@@ -89,7 +89,6 @@ struct gc_pad {
 struct gc {
         struct pardevice *pd;
         struct gc_pad pads[GC_MAX_DEVICES];
-        struct input_dev *dev[GC_MAX_DEVICES];
         struct timer_list timer;
         int pad_count[GC_MAX];
         int used;
@@ -387,7 +386,7 @@ static void gc_nes_process_packet(struct gc *gc)
         for (i = 0; i < GC_MAX_DEVICES; i++) {
 
                 pad = &gc->pads[i];
-                dev = gc->dev[i];
+                dev = pad->dev;
                 s = gc_status_bit[i];
 
                 switch (pad->type) {
@@ -579,7 +578,7 @@ static void gc_psx_command(struct gc *gc, int b, unsigned char *data)
                 read = parport_read_status(port) ^ 0x80;
 
                 for (j = 0; j < GC_MAX_DEVICES; j++) {
-                        struct gc_pad *pad = &gc->pads[i];
+                        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;
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/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/xpad.c b/drivers/input/joystick/xpad.c
index c1087ce4cef9..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
@@ -88,6 +89,9 @@
    but we map them to axes when possible to simplify things */
 #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
@@ -102,6 +106,10 @@ 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;
@@ -114,7 +122,7 @@ static const struct xpad_device {
         { 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 },
+        { 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 },
@@ -140,6 +148,7 @@ static const struct xpad_device {
         { 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 },
@@ -151,6 +160,7 @@ static const struct xpad_device {
         { 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_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 }
 };
@@ -158,7 +168,7 @@ static const struct xpad_device {
 /* 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 */
 };
 
@@ -168,10 +178,10 @@ static const signed short xpad_btn[] = {
         -1                      /* terminating entry */
 };
 
-/* used when dpad is mapped to nuttons */
+/* 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 */
 };
 
@@ -279,17 +289,19 @@ 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 */
         if (xpad->mapping & MAP_TRIGGERS_TO_BUTTONS) {
@@ -302,10 +314,11 @@ static void xpad_process_packet(struct usb_xpad *xpad, u16 cmd, unsigned char *d
 
         /* digital pad */
         if (xpad->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 */
+                /* 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));
@@ -315,7 +328,7 @@ static void xpad_process_packet(struct usb_xpad *xpad, u16 cmd, unsigned char *d
 
         /* 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);
 
@@ -349,11 +362,11 @@ static void xpad360_process_packet(struct usb_xpad *xpad,
 
         /* digital pad */
         if (xpad->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 */
+                /* 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));
@@ -363,7 +376,7 @@ static void xpad360_process_packet(struct usb_xpad *xpad,
 
         /* 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);
@@ -378,17 +391,19 @@ 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 */
         if (xpad->mapping & MAP_TRIGGERS_TO_BUTTONS) {
@@ -814,6 +829,8 @@ static int xpad_probe(struct usb_interface *intf, const struct usb_device_id *id
                         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;
@@ -830,16 +847,20 @@ 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 standard buttons and axes */
+        /* set up standard buttons */
         for (i = 0; xpad_common_btn[i] >= 0; i++)
                 __set_bit(xpad_common_btn[i], input_dev->keybit);
 
-        for (i = 0; xpad_abs[i] >= 0; i++)
-                xpad_set_up_abs(input_dev, xpad_abs[i]);
-
-        /* Now set up model-specific ones */
+        /* 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);
diff --git a/drivers/input/keyboard/Kconfig b/drivers/input/keyboard/Kconfig
index d8fa5d724c57..9cc488d21490 100644
--- a/drivers/input/keyboard/Kconfig
+++ b/drivers/input/keyboard/Kconfig
@@ -73,7 +73,7 @@ config KEYBOARD_ATKBD
         default y
         select SERIO
         select SERIO_LIBPS2
-        select SERIO_I8042 if X86 && !X86_MRST
+        select SERIO_I8042 if X86
         select SERIO_GSCPS2 if GSC
         help
           Say Y here if you want to use a standard AT or PS/2 keyboard. Usually
@@ -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
@@ -297,6 +297,18 @@ 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
@@ -342,6 +354,15 @@ config KEYBOARD_PXA930_ROTARY
           To compile this driver as a module, choose M here: the
           module will be called pxa930_rotary.
 
+config KEYBOARD_SAMSUNG
+        tristate "Samsung keypad support"
+        depends on SAMSUNG_DEV_KEYPAD
+        help
+          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 samsung-keypad.
+
 config KEYBOARD_STOWAWAY
         tristate "Stowaway keyboard"
         select SERIO
@@ -374,6 +395,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
diff --git a/drivers/input/keyboard/Makefile b/drivers/input/keyboard/Makefile
index 4596d0c6f922..504b591be0cd 100644
--- a/drivers/input/keyboard/Makefile
+++ b/drivers/input/keyboard/Makefile
@@ -26,13 +26,16 @@ 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_OMAP)             += omap-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_STMPE)            += stmpe-keypad.o
 obj-$(CONFIG_KEYBOARD_STOWAWAY)         += stowaway.o
 obj-$(CONFIG_KEYBOARD_SUNKBD)           += sunkbd.o
 obj-$(CONFIG_KEYBOARD_TWL4030)          += twl4030_keypad.o
diff --git a/drivers/input/keyboard/adp5588-keys.c b/drivers/input/keyboard/adp5588-keys.c
index 4771ab172b59..d6918cb966c0 100644
--- a/drivers/input/keyboard/adp5588-keys.c
+++ b/drivers/input/keyboard/adp5588-keys.c
@@ -19,6 +19,7 @@
 #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>
@@ -54,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
@@ -67,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)
@@ -84,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);
 
@@ -99,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);
                 }
         }
@@ -128,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);
@@ -144,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 */
@@ -158,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;
@@ -189,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;
@@ -233,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);
 
@@ -243,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");
@@ -261,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);
 
@@ -287,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;
diff --git a/drivers/input/keyboard/gpio_keys.c b/drivers/input/keyboard/gpio_keys.c
index b8213fd13c3f..6069abe31e42 100644
--- a/drivers/input/keyboard/gpio_keys.c
+++ b/drivers/input/keyboard/gpio_keys.c
@@ -31,6 +31,7 @@ struct gpio_button_data {
         struct input_dev *input;
         struct timer_list timer;
         struct work_struct work;
+        int timer_debounce;     /* in msecs */
         bool disabled;
 };
 
@@ -38,6 +39,8 @@ 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];
 };
 
@@ -109,7 +112,7 @@ static void gpio_keys_disable_button(struct gpio_button_data *bdata)
                  * Disable IRQ and possible debouncing timer.
                  */
                 disable_irq(gpio_to_irq(bdata->button->gpio));
-                if (bdata->button->debounce_interval)
+                if (bdata->timer_debounce)
                         del_timer_sync(&bdata->timer);
 
                 bdata->disabled = true;
@@ -347,9 +350,9 @@ 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);
 
@@ -383,6 +386,14 @@ static int __devinit gpio_keys_setup_key(struct platform_device *pdev,
                 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;
@@ -414,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;
@@ -435,13 +461,18 @@ static int __devinit gpio_keys_probe(struct platform_device *pdev)
 
         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;
@@ -498,7 +529,7 @@ static int __devinit gpio_keys_probe(struct platform_device *pdev)
  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);
@@ -526,7 +557,7 @@ static int __devexit gpio_keys_remove(struct platform_device *pdev)
         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..dcc86b97a153 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_min(dev, ABS_X + i))
+                                input_abs_set_min(dev, ABS_X + i, val);
+                        if (val > input_abs_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_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_max(input_dev, ABS_X + i) / 10;
+                        input_abs_set_min(input_dev, ABS_X + i,
+                                input_abs_min(input_dev, ABS_X + i) + diff)
+                        input_abs_set_max(input_dev, ABS_X + i,
+                                input_abs_max(input_dev, ABS_X + i) - diff)
                 }
 #endif
 
diff --git a/drivers/input/keyboard/lm8323.c b/drivers/input/keyboard/lm8323.c
index bc696931fed7..f7c2a166576b 100644
--- a/drivers/input/keyboard/lm8323.c
+++ b/drivers/input/keyboard/lm8323.c
@@ -642,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];
@@ -710,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;
         }
@@ -764,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);
@@ -778,8 +780,6 @@ static int __devexit lm8323_remove(struct i2c_client *client)
         struct lm8323_chip *lm = i2c_get_clientdata(client);
         int i;
 
-        i2c_set_clientdata(client, NULL);
-
         disable_irq_wake(client->irq);
         free_irq(client->irq, lm);
         cancel_work_sync(&lm->work);
diff --git a/drivers/input/keyboard/matrix_keypad.c b/drivers/input/keyboard/matrix_keypad.c
index b443e088fd3c..b02e4268e18f 100644
--- a/drivers/input/keyboard/matrix_keypad.c
+++ b/drivers/input/keyboard/matrix_keypad.c
@@ -37,6 +37,7 @@ struct matrix_keypad {
         spinlock_t lock;
         bool scan_pending;
         bool stopped;
+        bool gpio_all_disabled;
 };
 
 /*
@@ -87,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)
@@ -96,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]));
+        }
 }
 
 /*
@@ -216,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);
 
@@ -296,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;
+                        }
                 }
         }
 
@@ -418,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 7fc8185e5c1b..9091ff5ea808 100644
--- a/drivers/input/keyboard/max7359_keypad.c
+++ b/drivers/input/keyboard/max7359_keypad.c
@@ -265,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/qt2160.c b/drivers/input/keyboard/qt2160.c
index 31f30087b591..fac695157e8a 100644
--- a/drivers/input/keyboard/qt2160.c
+++ b/drivers/input/keyboard/qt2160.c
@@ -358,7 +358,6 @@ static int __devexit qt2160_remove(struct i2c_client *client)
         input_unregister_device(qt2160->input);
         kfree(qt2160);
 
-        i2c_set_clientdata(client, NULL);
         return 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/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
index 493c93f25e2a..00137bebcf97 100644
--- a/drivers/input/keyboard/tca6416-keypad.c
+++ b/drivers/input/keyboard/tca6416-keypad.c
@@ -316,8 +316,6 @@ static int __devexit tca6416_keypad_remove(struct i2c_client *client)
         input_unregister_device(chip->input);
         kfree(chip);
 
-        i2c_set_clientdata(client, NULL);
-
         return 0;
 }
 
diff --git a/drivers/input/keyboard/twl4030_keypad.c b/drivers/input/keyboard/twl4030_keypad.c
index 7aa59e07b689..fb16b5e5ea13 100644
--- a/drivers/input/keyboard/twl4030_keypad.c
+++ b/drivers/input/keyboard/twl4030_keypad.c
@@ -51,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];
@@ -182,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;
@@ -191,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)
@@ -225,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)))
diff --git a/drivers/input/keyboard/w90p910_keypad.c b/drivers/input/keyboard/w90p910_keypad.c
index 4ef764cc493c..ee2bf6bcf291 100644
--- a/drivers/input/keyboard/w90p910_keypad.c
+++ b/drivers/input/keyboard/w90p910_keypad.c
@@ -258,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/Kconfig b/drivers/input/misc/Kconfig
index c44b9eafc556..b49e23379723 100644
--- a/drivers/input/misc/Kconfig
+++ b/drivers/input/misc/Kconfig
@@ -327,6 +327,17 @@ config INPUT_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
@@ -390,4 +401,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 71fe57d8023f..19ccca78fa76 100644
--- a/drivers/input/misc/Makefile
+++ b/drivers/input/misc/Makefile
@@ -8,6 +8,9 @@ obj-$(CONFIG_INPUT_88PM860X_ONKEY)	+= 88pm860x_onkey.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
@@ -26,6 +29,7 @@ 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
diff --git a/drivers/input/misc/ad714x-i2c.c b/drivers/input/misc/ad714x-i2c.c
index e9adbe49f6a4..2bef8fa56c94 100644
--- a/drivers/input/misc/ad714x-i2c.c
+++ b/drivers/input/misc/ad714x-i2c.c
@@ -97,7 +97,6 @@ static int __devexit ad714x_i2c_remove(struct i2c_client *client)
         struct ad714x_chip *chip = i2c_get_clientdata(client);
 
         ad714x_remove(chip);
-        i2c_set_clientdata(client, NULL);
 
         return 0;
 }
diff --git a/drivers/input/misc/ad714x.c b/drivers/input/misc/ad714x.c
index 0fe27baf5e72..c431d09e401a 100644
--- a/drivers/input/misc/ad714x.c
+++ b/drivers/input/misc/ad714x.c
@@ -1118,7 +1118,7 @@ struct ad714x_chip *ad714x_probe(struct device *dev, u16 bus_type, int irq,
         if (error)
                 goto err_free_mem;
 
-        /* initilize and request sw/hw resources */
+        /* initialize and request sw/hw resources */
 
         ad714x_hw_init(ad714x);
         mutex_init(&ad714x->mutex);
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/ati_remote2.c b/drivers/input/misc/ati_remote2.c
index e148749b5851..23257652b8e8 100644
--- a/drivers/input/misc/ati_remote2.c
+++ b/drivers/input/misc/ati_remote2.c
@@ -38,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;
@@ -59,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__);
 
@@ -89,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>");
 
diff --git a/drivers/input/misc/atlas_btns.c b/drivers/input/misc/atlas_btns.c
index dfaa9a045ed8..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>
@@ -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/hp_sdc_rtc.c b/drivers/input/misc/hp_sdc_rtc.c
index e00a1cc79c0a..c19066479057 100644
--- a/drivers/input/misc/hp_sdc_rtc.c
+++ b/drivers/input/misc/hp_sdc_rtc.c
@@ -678,7 +678,7 @@ static const struct file_operations hp_sdc_rtc_fops = {
         .llseek =               no_llseek,
         .read =                 hp_sdc_rtc_read,
         .poll =                 hp_sdc_rtc_poll,
-        .unlocked_ioctl =       hp_sdc_rtc_ioctl,
+        .unlocked_ioctl =       hp_sdc_rtc_unlocked_ioctl,
         .open =                 hp_sdc_rtc_open,
         .fasync =               hp_sdc_rtc_fasync,
 };
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/pcf8574_keypad.c b/drivers/input/misc/pcf8574_keypad.c
index 5c3ac4e0b055..4b42ffc0532a 100644
--- a/drivers/input/misc/pcf8574_keypad.c
+++ b/drivers/input/misc/pcf8574_keypad.c
@@ -69,7 +69,7 @@ static irqreturn_t pcf8574_kp_irq_handler(int irq, void *dev_id)
         unsigned char nextstate = read_state(lp);
 
         if (lp->laststate != nextstate) {
-                int key_down = nextstate <= ARRAY_SIZE(lp->btncode);
+                int key_down = nextstate < ARRAY_SIZE(lp->btncode);
                 unsigned short keycode = key_down ?
                         lp->btncode[nextstate] : lp->btncode[lp->laststate];
 
@@ -168,8 +168,6 @@ static int __devexit pcf8574_kp_remove(struct i2c_client *client)
         input_unregister_device(lp->idev);
         kfree(lp);
 
-        i2c_set_clientdata(client, NULL);
-
         return 0;
 }
 
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/sparcspkr.c b/drivers/input/misc/sparcspkr.c
index 1dacae4b43f0..8e130bf7d32b 100644
--- a/drivers/input/misc/sparcspkr.c
+++ b/drivers/input/misc/sparcspkr.c
@@ -173,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;
@@ -184,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;
@@ -231,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;
@@ -269,7 +269,7 @@ static struct of_platform_driver bbc_beep_driver = {
         .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;
@@ -312,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;
@@ -353,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;
@@ -368,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/uinput.c b/drivers/input/misc/uinput.c
index b71eb55f2dbc..bb53fd33cd1c 100644
--- a/drivers/input/misc/uinput.c
+++ b/drivers/input/misc/uinput.c
@@ -304,21 +304,25 @@ static int uinput_validate_absbits(struct input_dev *dev)
                 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;
                 }
@@ -343,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))
@@ -387,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_CNT;
-        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 */
diff --git a/drivers/input/misc/wistron_btns.c b/drivers/input/misc/wistron_btns.c
index 4dac8b79fcd4..12501de0c5cd 100644
--- a/drivers/input/misc/wistron_btns.c
+++ b/drivers/input/misc/wistron_btns.c
@@ -1347,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)
@@ -1371,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/mouse/Kconfig b/drivers/input/mouse/Kconfig
index eeb58c1cac16..c714ca2407f8 100644
--- a/drivers/input/mouse/Kconfig
+++ b/drivers/input/mouse/Kconfig
@@ -17,7 +17,7 @@ config MOUSE_PS2
         default y
         select SERIO
         select SERIO_LIBPS2
-        select SERIO_I8042 if X86 && !X86_MRST
+        select SERIO_I8042 if X86
         select SERIO_GSCPS2 if GSC
         help
           Say Y here if you have a PS/2 mouse connected to your system. This
diff --git a/drivers/input/mouse/appletouch.c b/drivers/input/mouse/appletouch.c
index 05edd75abca0..a9cf76831634 100644
--- a/drivers/input/mouse/appletouch.c
+++ b/drivers/input/mouse/appletouch.c
@@ -205,8 +205,8 @@ struct atp {
         bool                    overflow_warned;
         int                     x_old;          /* last reported x/y, */
         int                     y_old;          /* used for smoothing */
-        u8                      xy_cur[ATP_XSENSORS + ATP_YSENSORS];
-        u8                      xy_old[ATP_XSENSORS + ATP_YSENSORS];
+        signed char             xy_cur[ATP_XSENSORS + ATP_YSENSORS];
+        signed char             xy_old[ATP_XSENSORS + ATP_YSENSORS];
         int                     xy_acc[ATP_XSENSORS + ATP_YSENSORS];
         int                     idlecount;      /* number of empty packets */
         struct work_struct      work;
@@ -531,7 +531,7 @@ static void atp_complete_geyser_1_2(struct urb *urb)
 
         for (i = 0; i < ATP_XSENSORS + ATP_YSENSORS; i++) {
                 /* accumulate the change */
-                int change = dev->xy_old[i] - dev->xy_cur[i];
+                signed char change = dev->xy_old[i] - dev->xy_cur[i];
                 dev->xy_acc[i] -= change;
 
                 /* prevent down drifting */
diff --git a/drivers/input/mouse/bcm5974.c b/drivers/input/mouse/bcm5974.c
index 6dedded27222..ea67c49146a3 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 */
@@ -580,23 +582,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)
diff --git a/drivers/input/mouse/elantech.c b/drivers/input/mouse/elantech.c
index b18862b2a70e..48311204ba51 100644
--- a/drivers/input/mouse/elantech.c
+++ b/drivers/input/mouse/elantech.c
@@ -185,7 +185,6 @@ 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 < 0x020000) {
                 /*
@@ -203,10 +202,13 @@ static void elantech_report_absolute_v1(struct psmouse *psmouse)
         }
 
         if (etd->jumpy_cursor) {
-                /* Discard packets that are likely to have bogus coordinates */
-                if (fingers > old_fingers) {
+                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");
-                        goto discard_packet_v1;
+                        return;
                 }
         }
 
@@ -238,9 +240,6 @@ static void elantech_report_absolute_v1(struct psmouse *psmouse)
         }
 
         input_sync(dev);
-
- discard_packet_v1:
-        old_fingers = fingers;
 }
 
 /*
@@ -258,6 +257,14 @@ 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:  .   .   .   .   .  x10 x9  x8
@@ -310,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);
 
@@ -467,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);
@@ -733,13 +742,13 @@ int elantech_init(struct psmouse *psmouse)
         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 == 0x020022) {
-                pr_info("firmware version 2.0.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)) {
diff --git a/drivers/input/mouse/elantech.h b/drivers/input/mouse/elantech.h
index ac57bde1bb9f..aa4aac5d2198 100644
--- a/drivers/input/mouse/elantech.h
+++ b/drivers/input/mouse/elantech.h
@@ -100,10 +100,11 @@ struct elantech_data {
         unsigned char reg_26;
         unsigned char debug;
         unsigned char capabilities;
-        unsigned char paritycheck;
-        unsigned char jumpy_cursor;
+        bool paritycheck;
+        bool jumpy_cursor;
         unsigned char hw_version;
-        unsigned int  fw_version;
+        unsigned int fw_version;
+        unsigned int single_finger_reports;
         unsigned char parity[256];
 };
 
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 979c50215282..73a7af2542a8 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.");
 
@@ -1679,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;
 
@@ -1696,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/synaptics.c b/drivers/input/mouse/synaptics.c
index 40cea334ad13..96b70a43515f 100644
--- a/drivers/input/mouse/synaptics.c
+++ b/drivers/input/mouse/synaptics.c
@@ -141,8 +141,13 @@ static int synaptics_capability(struct psmouse *psmouse)
         priv->capabilities = (cap[0] << 16) | (cap[1] << 8) | cap[2];
         priv->ext_cap = priv->ext_cap_0c = 0;
 
-        if (!SYN_CAP_VALID(priv->capabilities))
+        /*
+         * 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
@@ -206,6 +211,7 @@ static int synaptics_resolution(struct psmouse *psmouse)
         unsigned char max[3];
 
         if (SYN_ID_MAJOR(priv->identity) < 4)
+                return 0;
 
         if (synaptics_send_cmd(psmouse, SYN_QUE_RESOLUTION, res) == 0) {
                 if (res[0] != 0 && (res[1] & 0x80) && res[2] != 0) {
@@ -496,7 +502,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);
@@ -596,7 +604,9 @@ static void set_input_params(struct input_dev *dev, struct synaptics_data *priv)
         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);
@@ -625,8 +635,8 @@ 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 */
diff --git a/drivers/input/mouse/synaptics.h b/drivers/input/mouse/synaptics.h
index 7d4d5e12c0df..b6aa7d20d8a3 100644
--- a/drivers/input/mouse/synaptics.h
+++ b/drivers/input/mouse/synaptics.h
@@ -47,7 +47,7 @@
 #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)
@@ -66,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 */
diff --git a/drivers/input/mouse/synaptics_i2c.c b/drivers/input/mouse/synaptics_i2c.c
index 8291e7399ffa..0ae62f0bcb32 100644
--- a/drivers/input/mouse/synaptics_i2c.c
+++ b/drivers/input/mouse/synaptics_i2c.c
@@ -613,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/mousedev.c b/drivers/input/mousedev.c
index f34b22bce4ff..83c24cca234a 100644
--- a/drivers/input/mousedev.c
+++ b/drivers/input/mousedev.c
@@ -22,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
@@ -57,7 +58,6 @@ struct mousedev_hw_data {
 };
 
 struct mousedev {
-        int exist;
         int open;
         int minor;
         struct input_handle handle;
@@ -66,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;
@@ -134,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_min(dev, ABS_X) -
+                                        input_abs_get_max(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;
@@ -150,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_min(dev, ABS_X) -
+                                        input_abs_get_max(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;
@@ -167,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;
         }
@@ -765,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 = {
@@ -802,7 +815,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);
 }
 
@@ -862,7 +875,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 f34f1dbeb577..3bfe8fafc6ad 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,
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 04e32f2d1241..c5cc4508d6df 100644
--- a/drivers/input/serio/i8042-sparcio.h
+++ b/drivers/input/serio/i8042-sparcio.h
@@ -49,7 +49,7 @@ static inline void i8042_write_command(int val)
 #define OBP_PS2MS_NAME1         "kdmouse"
 #define OBP_PS2MS_NAME2         "mouse"
 
-static int __devinit sparc_i8042_probe(struct 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->dev.of_node;
 
@@ -57,20 +57,20 @@ static int __devinit sparc_i8042_probe(struct of_device *op, const struct of_dev
         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);
 
@@ -116,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;
 
@@ -141,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 6168469ad1a6..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"),
@@ -840,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 6440a8f55686..46e4ba0b9246 100644
--- a/drivers/input/serio/i8042.c
+++ b/drivers/input/serio/i8042.c
@@ -61,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);
@@ -861,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...
@@ -1020,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.
@@ -1032,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.
  *
@@ -1043,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;
+        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;
-
-        led ^= 0x01 | 0x04;
+        led = (state) ? 0x01 | 0x04 : 0;
         while (i8042_read_status() & I8042_STR_IBF)
                 DELAY;
         dbg("%02x -> i8042 (panic blink)", 0xed);
@@ -1071,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;
 }
 
@@ -1094,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;
 
@@ -1118,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
@@ -1162,6 +1135,28 @@ 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);
@@ -1169,9 +1164,14 @@ static int i8042_pm_thaw(struct device *dev)
         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,
@@ -1389,9 +1389,11 @@ static int __init i8042_probe(struct platform_device *dev)
 
         i8042_platform_device = dev;
 
-        error = i8042_controller_selftest();
-        if (error)
-                return error;
+        if (i8042_reset) {
+                error = i8042_controller_selftest();
+                if (error)
+                        return error;
+        }
 
         error = i8042_controller_init();
         if (error)
diff --git a/drivers/input/serio/xilinx_ps2.c b/drivers/input/serio/xilinx_ps2.c
index e2c028d2638f..bb14449fb022 100644
--- a/drivers/input/serio/xilinx_ps2.c
+++ b/drivers/input/serio/xilinx_ps2.c
@@ -232,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 */
@@ -332,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);
diff --git a/drivers/input/tablet/aiptek.c b/drivers/input/tablet/aiptek.c
index 51b80b08d467..57b25b84d1fc 100644
--- a/drivers/input/tablet/aiptek.c
+++ b/drivers/input/tablet/aiptek.c
@@ -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
@@ -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);
diff --git a/drivers/input/tablet/wacom_sys.c b/drivers/input/tablet/wacom_sys.c
index 2dc0c07c0469..42ba3691d908 100644
--- a/drivers/input/tablet/wacom_sys.c
+++ b/drivers/input/tablet/wacom_sys.c
@@ -508,7 +508,6 @@ static int wacom_probe(struct usb_interface *intf, const struct usb_device_id *i
         }
 
         input_dev->name = wacom_wac->name;
-        input_dev->name = wacom_wac->name;
         input_dev->dev.parent = &intf->dev;
         input_dev->open = wacom_open;
         input_dev->close = wacom_close;
diff --git a/drivers/input/tablet/wacom_wac.c b/drivers/input/tablet/wacom_wac.c
index 847fd0135bcf..40d77ba8fdc1 100644
--- a/drivers/input/tablet/wacom_wac.c
+++ b/drivers/input/tablet/wacom_wac.c
@@ -158,6 +158,39 @@ static int wacom_ptu_irq(struct wacom_wac *wacom)
         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)
 {
         struct wacom_features *features = &wacom->features;
@@ -284,12 +317,13 @@ static int wacom_intuos_inout(struct wacom_wac *wacom)
                         (data[4] << 20) + (data[5] << 12) +
                         (data[6] << 4) + (data[7] >> 4);
 
-                wacom->id[idx] = (data[2] << 4) | (data[3] >> 4);
+                wacom->id[idx] = (data[2] << 4) | (data[3] >> 4) |
+                        ((data[7] & 0x0f) << 20) | ((data[8] & 0xf0) << 12);
 
-                switch (wacom->id[idx]) {
+                switch (wacom->id[idx] & 0xfffff) {
                 case 0x812: /* Inking pen */
                 case 0x801: /* Intuos3 Inking pen */
-                case 0x20802: /* Intuos4 Classic Pen */
+                case 0x20802: /* Intuos4 Inking Pen */
                 case 0x012:
                         wacom->tool[idx] = BTN_TOOL_PENCIL;
                         break;
@@ -300,7 +334,7 @@ static int wacom_intuos_inout(struct wacom_wac *wacom)
                 case 0x823: /* Intuos3 Grip Pen */
                 case 0x813: /* Intuos3 Classic Pen */
                 case 0x885: /* Intuos3 Marker Pen */
-                case 0x802: /* Intuos4 Grip Pen Eraser */
+                case 0x802: /* Intuos4 General Pen */
                 case 0x804: /* Intuos4 Marker Pen */
                 case 0x40802: /* Intuos4 Classic Pen */
                 case 0x022:
@@ -335,7 +369,7 @@ static int wacom_intuos_inout(struct wacom_wac *wacom)
                 case 0x81b: /* Intuos3 Classic Pen Eraser */
                 case 0x91b: /* Intuos3 Airbrush Eraser */
                 case 0x80c: /* Intuos4 Marker Pen Eraser */
-                case 0x80a: /* Intuos4 Grip 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;
@@ -356,6 +390,11 @@ static int wacom_intuos_inout(struct wacom_wac *wacom)
                 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) {
                 /*
@@ -474,21 +513,43 @@ static int wacom_intuos_irq(struct wacom_wac *wacom)
                                 input_report_abs(input, ABS_MISC, 0);
                         }
                 } 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));
+                        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] & 0x1f) | (data[1] & 0x1f) |
-                                data[2] | (data[3] & 0x1f) | 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 {
@@ -626,10 +687,10 @@ static void wacom_tpc_finger_in(struct wacom_wac *wacom, char *data, int idx)
          * protocol.
          */
         if (wacom->last_finger != finger) {
-                if (x == input->abs[ABS_X])
+                if (x == input_abs_get_val(input, ABS_X))
                         x++;
 
-                if (y == input->abs[ABS_Y])
+                if (y == input_abs_get_val(input, ABS_Y))
                         y++;
         }
 
@@ -640,7 +701,7 @@ static void wacom_tpc_finger_in(struct wacom_wac *wacom, char *data, int idx)
         if (!idx)
                 input_report_key(input, BTN_TOUCH, 1);
         input_event(input, EV_MSC, MSC_SERIAL, finger);
-        input_sync(wacom->input);
+        input_sync(input);
 
         wacom->last_finger = finger;
 }
@@ -817,6 +878,10 @@ void wacom_wac_irq(struct wacom_wac *wacom_wac, size_t len)
                 sync = wacom_ptu_irq(wacom_wac);
                 break;
 
+        case DTU:
+                sync = wacom_dtu_irq(wacom_wac);
+                break;
+
         case INTUOS:
         case INTUOS3S:
         case INTUOS3:
@@ -826,6 +891,7 @@ void wacom_wac_irq(struct wacom_wac *wacom_wac, size_t len)
         case INTUOS4L:
         case CINTIQ:
         case WACOM_BEE:
+        case WACOM_21UX2:
                 sync = wacom_intuos_irq(wacom_wac);
                 break;
 
@@ -921,6 +987,17 @@ void wacom_setup_input_capabilities(struct input_dev *input_dev,
                 __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);
@@ -990,6 +1067,7 @@ void wacom_setup_input_capabilities(struct input_dev *input_dev,
 
         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);
@@ -1105,6 +1183,8 @@ 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 =
@@ -1113,6 +1193,12 @@ 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 =
@@ -1185,10 +1271,14 @@ const struct usb_device_id wacom_ids[] = {
         { 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(0xF0) },
+        { USB_DEVICE_WACOM(0xCC) },
         { USB_DEVICE_WACOM(0x90) },
         { USB_DEVICE_WACOM(0x93) },
         { USB_DEVICE_WACOM(0x9A) },
diff --git a/drivers/input/tablet/wacom_wac.h b/drivers/input/tablet/wacom_wac.h
index 063f1af3204f..99e1a54cd305 100644
--- a/drivers/input/tablet/wacom_wac.h
+++ b/drivers/input/tablet/wacom_wac.h
@@ -43,6 +43,7 @@ enum {
         WACOM_G4,
         PTU,
         PL,
+        DTU,
         INTUOS,
         INTUOS3S,
         INTUOS3,
@@ -50,6 +51,7 @@ enum {
         INTUOS4S,
         INTUOS4,
         INTUOS4L,
+        WACOM_21UX2,
         CINTIQ,
         WACOM_BEE,
         WACOM_MO,
diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig
index 6703c6b9800a..0069d9703fda 100644
--- a/drivers/input/touchscreen/Kconfig
+++ b/drivers/input/touchscreen/Kconfig
@@ -55,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"
@@ -99,6 +98,20 @@ config TOUCHSCREEN_BITSY
           To compile this driver as a module, choose M here: the
           module will be called h3600_ts_input.
 
+config TOUCHSCREEN_CY8CTMG110
+        tristate "cy8ctmg110 touchscreen"
+        depends on I2C
+        depends on GPIOLIB
+
+        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"
         depends on PMIC_DA903X
@@ -156,7 +169,7 @@ config TOUCHSCREEN_FUJITSU
 config TOUCHSCREEN_S3C2410
         tristate "Samsung S3C2410/generic touchscreen input driver"
         depends on ARCH_S3C2410 || SAMSUNG_DEV_TS
-        select S3C24XX_ADC
+        select S3C_ADC
         help
           Say Y here if you have the s3c2410 touchscreen.
 
@@ -292,6 +305,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
@@ -540,9 +565,9 @@ 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 TC5UH touchscreen controler support" if EMBEDDED
+        bool "ET&T USB series TC4UM/TC5UH touchscreen controler support" if EMBEDDED
         depends on TOUCHSCREEN_USB_COMPOSITE
 
 config TOUCHSCREEN_USB_NEXIO
@@ -603,4 +628,14 @@ config TOUCHSCREEN_TPS6507X
           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 497964a7a214..28217e1dcafd 100644
--- a/drivers/input/touchscreen/Makefile
+++ b/drivers/input/touchscreen/Makefile
@@ -9,9 +9,13 @@ 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_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
@@ -30,7 +34,9 @@ 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_TOUCHIT213)    += touchit213.o
 obj-$(CONFIG_TOUCHSCREEN_TOUCHRIGHT)    += touchright.o
 obj-$(CONFIG_TOUCHSCREEN_TOUCHWIN)      += touchwin.o
@@ -38,7 +44,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
diff --git a/drivers/input/touchscreen/ad7877.c b/drivers/input/touchscreen/ad7877.c
index 0d2d7e54b465..5f0221cffef9 100644
--- a/drivers/input/touchscreen/ad7877.c
+++ b/drivers/input/touchscreen/ad7877.c
@@ -679,6 +679,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) {
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 634f6f6b9b13..16031933a8f6 100644
--- a/drivers/input/touchscreen/ads7846.c
+++ b/drivers/input/touchscreen/ads7846.c
@@ -68,6 +68,8 @@ struct ts_event {
         u16     y;
         u16     z1, z2;
         int     ignore;
+        u8      x_buf[3];
+        u8      y_buf[3];
 };
 
 /*
@@ -79,6 +81,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 {
@@ -207,6 +211,14 @@ struct ser_req {
         struct spi_transfer     xfer[6];
 };
 
+struct ads7845_ser_req {
+        u8                      command[3];
+        u8                      pwrdown[3];
+        u8                      sample[3];
+        struct spi_message      msg;
+        struct spi_transfer     xfer[2];
+};
+
 static void ads7846_enable(struct ads7846 *ts);
 static void ads7846_disable(struct ads7846 *ts);
 
@@ -287,6 +299,41 @@ 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 = kzalloc(sizeof *req, GFP_KERNEL);
+        int                     status;
+
+        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);
+
+        ts->irq_disabled = 1;
+        disable_irq(spi->irq);
+        status = spi_sync(spi, &req->msg);
+        ts->irq_disabled = 0;
+        enable_irq(spi->irq);
+
+        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 \
@@ -540,10 +587,17 @@ static void ads7846_rx(void *ads)
         /* ads7846_rx_val() did in-place conversion (including byteswap) 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)
@@ -551,6 +605,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;
@@ -671,10 +731,14 @@ static void ads7846_rx_val(void *ads)
         m = &ts->msg[ts->msg_idx];
         t = list_entry(m->transfers.prev, struct spi_transfer, transfer_list);
 
-        /* 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;
+        if (ts->model == 7845) {
+                val = be16_to_cpup((__be16 *)&(((char*)t->rx_buf)[1])) >> 3;
+        } else {
+                /* adjust:  on-wire is a must-ignore bit, a BE12 value, then
+                 * padding; built from two 8 bit values written msb-first.
+                 */
+                val = be16_to_cpup((__be16 *)t->rx_buf) >> 3;
+        }
 
         action = ts->filter(ts->filter_data, ts->msg_idx, &val);
         switch (action) {
@@ -878,14 +942,15 @@ static int __devinit setup_pendown(struct spi_device *spi, struct ads7846 *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;
-        struct spi_message              *m;
-        struct spi_transfer             *x;
-        int                             vref;
-        int                             err;
+        struct ads7846 *ts;
+        struct ads7846_packet *packet;
+        struct input_dev *input_dev;
+        const struct ads7846_platform_data *pdata = spi->dev.platform_data;
+        struct spi_message *m;
+        struct spi_transfer *x;
+        unsigned long irq_flags;
+        int vref;
+        int err;
 
         if (!spi->irq) {
                 dev_dbg(&spi->dev, "no IRQ?\n");
@@ -1008,16 +1073,26 @@ static int __devinit ads7846_probe(struct spi_device *spi)
 
         spi_message_init(m);
 
-        /* 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;
          * optionally discard it, using a second one after the signals
@@ -1043,17 +1118,28 @@ static int __devinit ads7846_probe(struct spi_device *spi)
         m++;
         spi_message_init(m);
 
-        /* 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) {
@@ -1144,15 +1230,25 @@ static int __devinit ads7846_probe(struct spi_device *spi)
         m++;
         spi_message_init(m);
 
-        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);
 
@@ -1164,7 +1260,7 @@ static int __devinit ads7846_probe(struct spi_device *spi)
         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: %ld\n", err);
+                dev_err(&spi->dev, "unable to get regulator: %d\n", err);
                 goto err_free_gpio;
         }
 
@@ -1174,17 +1270,22 @@ static int __devinit ads7846_probe(struct spi_device *spi)
                 goto err_put_regulator;
         }
 
-        if (request_irq(spi->irq, ads7846_irq, IRQF_TRIGGER_FALLING,
-                        spi->dev.driver->name, ts)) {
+        irq_flags = pdata->irq_flags ? : IRQF_TRIGGER_FALLING;
+
+        err = request_irq(spi->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_disable_regulator;
-                }
+        }
+
+        if (err) {
+                dev_dbg(&spi->dev, "irq %d busy?\n", spi->irq);
+                goto err_disable_regulator;
         }
 
         err = ads784x_hwmon_register(spi, ts);
@@ -1196,8 +1297,11 @@ static int __devinit ads7846_probe(struct spi_device *spi)
         /* 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)
diff --git a/drivers/input/touchscreen/cy8ctmg110_ts.c b/drivers/input/touchscreen/cy8ctmg110_ts.c
new file mode 100644
index 000000000000..5ec0946938fe
--- /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, 0, 0);
+        input_set_abs_params(input_dev, ABS_Y,
+                        CY8CTMG110_Y_MIN, CY8CTMG110_Y_MAX, 0, 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/eeti_ts.c b/drivers/input/touchscreen/eeti_ts.c
index 75f8b73010fa..7a3a916f84a8 100644
--- a/drivers/input/touchscreen/eeti_ts.c
+++ b/drivers/input/touchscreen/eeti_ts.c
@@ -238,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;
@@ -256,7 +255,6 @@ static int __devexit eeti_ts_remove(struct i2c_client *client)
         enable_irq(priv->irq);
 
         input_unregister_device(priv->input);
-        i2c_set_clientdata(client, NULL);
         kfree(priv);
 
         return 0;
diff --git a/drivers/input/touchscreen/mcs5000_ts.c b/drivers/input/touchscreen/mcs5000_ts.c
index ce8ab0269f6f..6ee9940aaf5b 100644
--- a/drivers/input/touchscreen/mcs5000_ts.c
+++ b/drivers/input/touchscreen/mcs5000_ts.c
@@ -16,7 +16,7 @@
 #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>
@@ -105,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)
@@ -164,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;
 
@@ -256,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/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 ac5d0f9b0cb1..6085d12fd561 100644
--- a/drivers/input/touchscreen/s3c2410_ts.c
+++ b/drivers/input/touchscreen/s3c2410_ts.c
@@ -173,7 +173,7 @@ 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 */
diff --git a/drivers/input/touchscreen/stmpe-ts.c b/drivers/input/touchscreen/stmpe-ts.c
new file mode 100644
index 000000000000..656148ec0027
--- /dev/null
+++ b/drivers/input/touchscreen/stmpe-ts.c
@@ -0,0 +1,397 @@
+/* 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 = 0;
+        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)
+                goto err_out;
+
+        idev = input_allocate_device();
+        if (!idev)
+                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);
+        input_free_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/tps6507x-ts.c b/drivers/input/touchscreen/tps6507x-ts.c
index 5de80a1a730b..a644d18c04dc 100644
--- a/drivers/input/touchscreen/tps6507x-ts.c
+++ b/drivers/input/touchscreen/tps6507x-ts.c
@@ -221,7 +221,7 @@ done:
 
         if (poll) {
                 schd = queue_delayed_work(tsc->wq, &tsc->work,
-                                          tsc->poll_period * HZ / 1000);
+                                          msecs_to_jiffies(tsc->poll_period));
                 if (schd)
                         tsc->polling = 1;
                 else {
@@ -326,7 +326,7 @@ static int tps6507x_ts_probe(struct platform_device *pdev)
                 goto err2;
 
         schd = queue_delayed_work(tsc->wq, &tsc->work,
-                                  tsc->poll_period * HZ / 1000);
+                                  msecs_to_jiffies(tsc->poll_period));
 
         if (schd)
                 tsc->polling = 1;
@@ -339,10 +339,8 @@ static int tps6507x_ts_probe(struct platform_device *pdev)
         return 0;
 
 err2:
-        cancel_delayed_work(&tsc->work);
-        flush_workqueue(tsc->wq);
+        cancel_delayed_work_sync(&tsc->work);
         destroy_workqueue(tsc->wq);
-        tsc->wq = 0;
         input_free_device(input_dev);
 err1:
         kfree(tsc);
@@ -357,13 +355,8 @@ static int __devexit tps6507x_ts_remove(struct platform_device *pdev)
         struct tps6507x_ts *tsc = tps6507x_dev->ts;
         struct input_dev *input_dev = tsc->input_dev;
 
-        if (!tsc)
-                return 0;
-
-        cancel_delayed_work(&tsc->work);
-        flush_workqueue(tsc->wq);
+        cancel_delayed_work_sync(&tsc->work);
         destroy_workqueue(tsc->wq);
-        tsc->wq = 0;
 
         input_free_device(input_dev);
 
diff --git a/drivers/input/touchscreen/tsc2007.c b/drivers/input/touchscreen/tsc2007.c
index 769b479fcaa6..be23780e8a3e 100644
--- a/drivers/input/touchscreen/tsc2007.c
+++ b/drivers/input/touchscreen/tsc2007.c
@@ -347,8 +347,6 @@ static int __devexit tsc2007_remove(struct i2c_client *client)
         struct tsc2007  *ts = i2c_get_clientdata(client);
         struct tsc2007_platform_data *pdata = client->dev.platform_data;
 
-        i2c_set_clientdata(client, NULL);
-
         tsc2007_free_irq(ts);
 
         if (pdata->exit_platform_hw)
diff --git a/drivers/input/touchscreen/usbtouchscreen.c b/drivers/input/touchscreen/usbtouchscreen.c
index 567d57215c28..f45f80f6d336 100644
--- a/drivers/input/touchscreen/usbtouchscreen.c
+++ b/drivers/input/touchscreen/usbtouchscreen.c
@@ -95,6 +95,7 @@ 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);
 };
@@ -135,7 +136,7 @@ enum {
         DEVTYPE_JASTEC,
         DEVTYPE_E2I,
         DEVTYPE_ZYTRONIC,
-        DEVTYPE_TC5UH,
+        DEVTYPE_TC45USB,
         DEVTYPE_NEXIO,
 };
 
@@ -222,8 +223,11 @@ static const 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
@@ -507,7 +511,7 @@ static int dmc_tsc10_init(struct usbtouch_usb *usbtouch)
         int ret = -ENOMEM;
         unsigned char *buf;
 
-        buf = kmalloc(2, GFP_KERNEL);
+        buf = kmalloc(2, GFP_NOIO);
         if (!buf)
                 goto err_nobuf;
         /* reset */
@@ -574,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];
@@ -732,11 +736,43 @@ 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;
+        struct nexio_priv *priv = usbtouch->priv;
         int ret = -ENOMEM;
         int actual_len, i;
         unsigned char *buf;
@@ -755,7 +791,7 @@ static int nexio_init(struct usbtouch_usb *usbtouch)
         if (!input_ep || !output_ep)
                 return -ENXIO;
 
-        buf = kmalloc(NEXIO_BUFSIZE, GFP_KERNEL);
+        buf = kmalloc(NEXIO_BUFSIZE, GFP_NOIO);
         if (!buf)
                 goto out_buf;
 
@@ -787,11 +823,11 @@ static int nexio_init(struct usbtouch_usb *usbtouch)
                 switch (buf[0]) {
                 case 0x83:      /* firmware version */
                         if (!firmware_ver)
-                                firmware_ver = kstrdup(&buf[2], GFP_KERNEL);
+                                firmware_ver = kstrdup(&buf[2], GFP_NOIO);
                         break;
                 case 0x84:      /* device name */
                         if (!device_name)
-                                device_name = kstrdup(&buf[2], GFP_KERNEL);
+                                device_name = kstrdup(&buf[2], GFP_NOIO);
                         break;
                 }
         }
@@ -802,36 +838,11 @@ static int nexio_init(struct usbtouch_usb *usbtouch)
         kfree(firmware_ver);
         kfree(device_name);
 
-        /* prepare ACK URB */
-        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;
-        }
-
         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;
-        goto out_buf;
 
-err_ack_buf:
-        kfree(priv->ack_buf);
-err_priv:
-        kfree(priv);
 out_buf:
         kfree(buf);
         return ret;
@@ -849,29 +860,32 @@ static void nexio_exit(struct usbtouch_usb *usbtouch)
 
 static int nexio_read_data(struct usbtouch_usb *usbtouch, unsigned char *pkt)
 {
-        int x, y, begin_x, begin_y, end_x, end_y, w, h, ret;
         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 (be16_to_cpu(packet->data_len) > 0xff)
-                packet->data_len = cpu_to_be16(be16_to_cpu(packet->data_len) - 0x100);
-        if (be16_to_cpu(packet->x_len) > 0xff)
-                packet->x_len = cpu_to_be16(be16_to_cpu(packet->x_len) - 0x80);
+        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 * be16_to_cpu(packet->x_len);
-                input_set_abs_params(usbtouch->input, ABS_X, 0,
-                                     2 * be16_to_cpu(packet->x_len), 0, 0);
-                usbtouch->type->max_yc = 2 * be16_to_cpu(packet->y_len);
-                input_set_abs_params(usbtouch->input, ABS_Y, 0,
-                                     2 * be16_to_cpu(packet->y_len), 0, 0);
+                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.
@@ -881,22 +895,21 @@ static int nexio_read_data(struct usbtouch_usb *usbtouch, unsigned char *pkt)
          * 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 < be16_to_cpu(packet->x_len); x++) {
+        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 = be16_to_cpu(packet->x_len);
-                             y < be16_to_cpu(packet->data_len); y++) {
+                        for (y = x_len; y < data_len; y++) {
                                 if (begin_y == -1 && packet->data[y] > NEXIO_THRESHOLD) {
-                                        begin_y = y - be16_to_cpu(packet->x_len);
+                                        begin_y = y - x_len;
                                         continue;
                                 }
                                 if (end_y == -1 &&
                                     begin_y != -1 && packet->data[y] < NEXIO_THRESHOLD) {
-                                        end_y = y - 1 - be16_to_cpu(packet->x_len);
+                                        end_y = y - 1 - x_len;
                                         w = end_x - begin_x;
                                         h = end_y - begin_y;
 #if 0
@@ -1104,14 +1117,14 @@ 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
 
@@ -1120,6 +1133,7 @@ static struct usbtouch_device_info usbtouch_dev_info[] = {
                 .rept_size      = 1024,
                 .irq_always     = true,
                 .read_data      = nexio_read_data,
+                .alloc          = nexio_alloc,
                 .init           = nexio_init,
                 .exit           = nexio_exit,
         },
@@ -1263,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",
@@ -1272,25 +1287,89 @@ exit:
 static int usbtouch_open(struct input_dev *input)
 {
         struct usbtouch_usb *usbtouch = input_get_drvdata(input);
+        int r;
 
         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)
@@ -1411,12 +1490,21 @@ static int usbtouch_probe(struct usb_interface *intf,
         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_urb;
+                        goto out_do_exit;
                 }
         }
 
@@ -1429,8 +1517,11 @@ static int usbtouch_probe(struct usb_interface *intf,
         usb_set_intfdata(intf, usbtouch);
 
         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;
@@ -1481,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 cc18265be1a8..7a45d68c3516 100644
--- a/drivers/input/touchscreen/w90p910_ts.c
+++ b/drivers/input/touchscreen/w90p910_ts.c
@@ -233,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/xen-kbdfront.c b/drivers/input/xen-kbdfront.c
index e14081675bb2..ebb11907d402 100644
--- a/drivers/input/xen-kbdfront.c
+++ b/drivers/input/xen-kbdfront.c
@@ -339,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. */