nfs: disintegrate UAPI for nfs

This is to complete part of the Userspace API (UAPI) disintegration for which
the preparatory patches were pulled recently.  After these patches, userspace
headers will be segregated into:

        include/uapi/linux/.../foo.h

for the userspace interface stuff, and:

        include/linux/.../foo.h

for the strictly kernel internal stuff.

Signed-off-by: J. Bruce Fields <bfields@redhat.com>

55 files changed, 1460 insertions, 810 deletions

diff --git a/drivers/input/apm-power.c b/drivers/input/apm-power.c
index e90ee3d30613..650177a3c858 100644
--- a/drivers/input/apm-power.c
+++ b/drivers/input/apm-power.c
@@ -33,7 +33,7 @@ static void system_power_event(unsigned int keycode)
 }
 
 static void apmpower_event(struct input_handle *handle, unsigned int type,
-                        unsigned int code, int value)
+                           unsigned int code, int value)
 {
         /* only react on key down events */
         if (value != 1)
diff --git a/drivers/input/evdev.c b/drivers/input/evdev.c
index 6c58bfff01a3..118d0300f1fb 100644
--- a/drivers/input/evdev.c
+++ b/drivers/input/evdev.c
@@ -54,16 +54,9 @@ struct evdev_client {
 static struct evdev *evdev_table[EVDEV_MINORS];
 static DEFINE_MUTEX(evdev_table_mutex);
 
-static void evdev_pass_event(struct evdev_client *client,
-                             struct input_event *event,
-                             ktime_t mono, ktime_t real)
+static void __pass_event(struct evdev_client *client,
+                         const struct input_event *event)
 {
-        event->time = ktime_to_timeval(client->clkid == CLOCK_MONOTONIC ?
-                                        mono : real);
-
-        /* Interrupts are disabled, just acquire the lock. */
-        spin_lock(&client->buffer_lock);
-
         client->buffer[client->head++] = *event;
         client->head &= client->bufsize - 1;
 
@@ -86,42 +79,74 @@ static void evdev_pass_event(struct evdev_client *client,
                 client->packet_head = client->head;
                 kill_fasync(&client->fasync, SIGIO, POLL_IN);
         }
+}
+
+static void evdev_pass_values(struct evdev_client *client,
+                        const struct input_value *vals, unsigned int count,
+                        ktime_t mono, ktime_t real)
+{
+        struct evdev *evdev = client->evdev;
+        const struct input_value *v;
+        struct input_event event;
+        bool wakeup = false;
+
+        event.time = ktime_to_timeval(client->clkid == CLOCK_MONOTONIC ?
+                                      mono : real);
+
+        /* Interrupts are disabled, just acquire the lock. */
+        spin_lock(&client->buffer_lock);
+
+        for (v = vals; v != vals + count; v++) {
+                event.type = v->type;
+                event.code = v->code;
+                event.value = v->value;
+                __pass_event(client, &event);
+                if (v->type == EV_SYN && v->code == SYN_REPORT)
+                        wakeup = true;
+        }
 
         spin_unlock(&client->buffer_lock);
+
+        if (wakeup)
+                wake_up_interruptible(&evdev->wait);
 }
 
 /*
- * Pass incoming event to all connected clients.
+ * Pass incoming events to all connected clients.
  */
-static void evdev_event(struct input_handle *handle,
-                        unsigned int type, unsigned int code, int value)
+static void evdev_events(struct input_handle *handle,
+                         const struct input_value *vals, unsigned int count)
 {
         struct evdev *evdev = handle->private;
         struct evdev_client *client;
-        struct input_event event;
         ktime_t time_mono, time_real;
 
         time_mono = ktime_get();
         time_real = ktime_sub(time_mono, ktime_get_monotonic_offset());
 
-        event.type = type;
-        event.code = code;
-        event.value = value;
-
         rcu_read_lock();
 
         client = rcu_dereference(evdev->grab);
 
         if (client)
-                evdev_pass_event(client, &event, time_mono, time_real);
+                evdev_pass_values(client, vals, count, time_mono, time_real);
         else
                 list_for_each_entry_rcu(client, &evdev->client_list, node)
-                        evdev_pass_event(client, &event, time_mono, time_real);
+                        evdev_pass_values(client, vals, count,
+                                          time_mono, time_real);
 
         rcu_read_unlock();
+}
 
-        if (type == EV_SYN && code == SYN_REPORT)
-                wake_up_interruptible(&evdev->wait);
+/*
+ * Pass incoming event to all connected clients.
+ */
+static void evdev_event(struct input_handle *handle,
+                        unsigned int type, unsigned int code, int value)
+{
+        struct input_value vals[] = { { type, code, value } };
+
+        evdev_events(handle, vals, 1);
 }
 
 static int evdev_fasync(int fd, struct file *file, int on)
@@ -653,20 +678,22 @@ static int evdev_handle_mt_request(struct input_dev *dev,
                                    unsigned int size,
                                    int __user *ip)
 {
-        const struct input_mt_slot *mt = dev->mt;
+        const struct input_mt *mt = dev->mt;
         unsigned int code;
         int max_slots;
         int i;
 
         if (get_user(code, &ip[0]))
                 return -EFAULT;
-        if (!input_is_mt_value(code))
+        if (!mt || !input_is_mt_value(code))
                 return -EINVAL;
 
         max_slots = (size - sizeof(__u32)) / sizeof(__s32);
-        for (i = 0; i < dev->mtsize && i < max_slots; i++)
-                if (put_user(input_mt_get_value(&mt[i], code), &ip[1 + i]))
+        for (i = 0; i < mt->num_slots && i < max_slots; i++) {
+                int value = input_mt_get_value(&mt->slots[i], code);
+                if (put_user(value, &ip[1 + i]))
                         return -EFAULT;
+        }
 
         return 0;
 }
@@ -1048,6 +1075,7 @@ MODULE_DEVICE_TABLE(input, evdev_ids);
 
 static struct input_handler evdev_handler = {
         .event          = evdev_event,
+        .events         = evdev_events,
         .connect        = evdev_connect,
         .disconnect     = evdev_disconnect,
         .fops           = &evdev_fops,
diff --git a/drivers/input/ff-core.c b/drivers/input/ff-core.c
index 480eb9d9876a..f50f6dd92274 100644
--- a/drivers/input/ff-core.c
+++ b/drivers/input/ff-core.c
@@ -138,8 +138,8 @@ int input_ff_upload(struct input_dev *dev, struct ff_effect *effect,
 
         if (effect->id == -1) {
                 for (id = 0; id < ff->max_effects; id++)
-                     if (!ff->effect_owners[id])
-                        break;
+                        if (!ff->effect_owners[id])
+                                break;
 
                 if (id >= ff->max_effects) {
                         ret = -ENOSPC;
diff --git a/drivers/input/ff-memless.c b/drivers/input/ff-memless.c
index b107922514fb..74c0d8c6002a 100644
--- a/drivers/input/ff-memless.c
+++ b/drivers/input/ff-memless.c
@@ -72,12 +72,14 @@ static const struct ff_envelope *get_envelope(const struct ff_effect *effect)
         static const struct ff_envelope empty_envelope;
 
         switch (effect->type) {
-                case FF_PERIODIC:
-                        return &effect->u.periodic.envelope;
-                case FF_CONSTANT:
-                        return &effect->u.constant.envelope;
-                default:
-                        return &empty_envelope;
+        case FF_PERIODIC:
+                return &effect->u.periodic.envelope;
+
+        case FF_CONSTANT:
+                return &effect->u.constant.envelope;
+
+        default:
+                return &empty_envelope;
         }
 }
 
diff --git a/drivers/input/input-mt.c b/drivers/input/input-mt.c
index 70a16c7da8cc..c0ec7d42c3be 100644
--- a/drivers/input/input-mt.c
+++ b/drivers/input/input-mt.c
@@ -14,6 +14,14 @@
 
 #define TRKID_SGN       ((TRKID_MAX + 1) >> 1)
 
+static void copy_abs(struct input_dev *dev, unsigned int dst, unsigned int src)
+{
+        if (dev->absinfo && test_bit(src, dev->absbit)) {
+                dev->absinfo[dst] = dev->absinfo[src];
+                dev->absbit[BIT_WORD(dst)] |= BIT_MASK(dst);
+        }
+}
+
 /**
  * input_mt_init_slots() - initialize MT input slots
  * @dev: input device supporting MT events and finger tracking
@@ -25,29 +33,63 @@
  * May be called repeatedly. Returns -EINVAL if attempting to
  * reinitialize with a different number of slots.
  */
-int input_mt_init_slots(struct input_dev *dev, unsigned int num_slots)
+int input_mt_init_slots(struct input_dev *dev, unsigned int num_slots,
+                        unsigned int flags)
 {
+        struct input_mt *mt = dev->mt;
         int i;
 
         if (!num_slots)
                 return 0;
-        if (dev->mt)
-                return dev->mtsize != num_slots ? -EINVAL : 0;
+        if (mt)
+                return mt->num_slots != num_slots ? -EINVAL : 0;
 
-        dev->mt = kcalloc(num_slots, sizeof(struct input_mt_slot), GFP_KERNEL);
-        if (!dev->mt)
-                return -ENOMEM;
+        mt = kzalloc(sizeof(*mt) + num_slots * sizeof(*mt->slots), GFP_KERNEL);
+        if (!mt)
+                goto err_mem;
 
-        dev->mtsize = num_slots;
+        mt->num_slots = num_slots;
+        mt->flags = flags;
         input_set_abs_params(dev, ABS_MT_SLOT, 0, num_slots - 1, 0, 0);
         input_set_abs_params(dev, ABS_MT_TRACKING_ID, 0, TRKID_MAX, 0, 0);
-        input_set_events_per_packet(dev, 6 * num_slots);
+
+        if (flags & (INPUT_MT_POINTER | INPUT_MT_DIRECT)) {
+                __set_bit(EV_KEY, dev->evbit);
+                __set_bit(BTN_TOUCH, dev->keybit);
+
+                copy_abs(dev, ABS_X, ABS_MT_POSITION_X);
+                copy_abs(dev, ABS_Y, ABS_MT_POSITION_Y);
+                copy_abs(dev, ABS_PRESSURE, ABS_MT_PRESSURE);
+        }
+        if (flags & INPUT_MT_POINTER) {
+                __set_bit(BTN_TOOL_FINGER, dev->keybit);
+                __set_bit(BTN_TOOL_DOUBLETAP, dev->keybit);
+                if (num_slots >= 3)
+                        __set_bit(BTN_TOOL_TRIPLETAP, dev->keybit);
+                if (num_slots >= 4)
+                        __set_bit(BTN_TOOL_QUADTAP, dev->keybit);
+                if (num_slots >= 5)
+                        __set_bit(BTN_TOOL_QUINTTAP, dev->keybit);
+                __set_bit(INPUT_PROP_POINTER, dev->propbit);
+        }
+        if (flags & INPUT_MT_DIRECT)
+                __set_bit(INPUT_PROP_DIRECT, dev->propbit);
+        if (flags & INPUT_MT_TRACK) {
+                unsigned int n2 = num_slots * num_slots;
+                mt->red = kcalloc(n2, sizeof(*mt->red), GFP_KERNEL);
+                if (!mt->red)
+                        goto err_mem;
+        }
 
         /* Mark slots as 'unused' */
         for (i = 0; i < num_slots; i++)
-                input_mt_set_value(&dev->mt[i], ABS_MT_TRACKING_ID, -1);
+                input_mt_set_value(&mt->slots[i], ABS_MT_TRACKING_ID, -1);
 
+        dev->mt = mt;
         return 0;
+err_mem:
+        kfree(mt);
+        return -ENOMEM;
 }
 EXPORT_SYMBOL(input_mt_init_slots);
 
@@ -60,11 +102,11 @@ EXPORT_SYMBOL(input_mt_init_slots);
  */
 void input_mt_destroy_slots(struct input_dev *dev)
 {
-        kfree(dev->mt);
+        if (dev->mt) {
+                kfree(dev->mt->red);
+                kfree(dev->mt);
+        }
         dev->mt = NULL;
-        dev->mtsize = 0;
-        dev->slot = 0;
-        dev->trkid = 0;
 }
 EXPORT_SYMBOL(input_mt_destroy_slots);
 
@@ -83,18 +125,24 @@ EXPORT_SYMBOL(input_mt_destroy_slots);
 void input_mt_report_slot_state(struct input_dev *dev,
                                 unsigned int tool_type, bool active)
 {
-        struct input_mt_slot *mt;
+        struct input_mt *mt = dev->mt;
+        struct input_mt_slot *slot;
         int id;
 
-        if (!dev->mt || !active) {
+        if (!mt)
+                return;
+
+        slot = &mt->slots[mt->slot];
+        slot->frame = mt->frame;
+
+        if (!active) {
                 input_event(dev, EV_ABS, ABS_MT_TRACKING_ID, -1);
                 return;
         }
 
-        mt = &dev->mt[dev->slot];
-        id = input_mt_get_value(mt, ABS_MT_TRACKING_ID);
-        if (id < 0 || input_mt_get_value(mt, ABS_MT_TOOL_TYPE) != tool_type)
-                id = input_mt_new_trkid(dev);
+        id = input_mt_get_value(slot, ABS_MT_TRACKING_ID);
+        if (id < 0 || input_mt_get_value(slot, ABS_MT_TOOL_TYPE) != tool_type)
+                id = input_mt_new_trkid(mt);
 
         input_event(dev, EV_ABS, ABS_MT_TRACKING_ID, id);
         input_event(dev, EV_ABS, ABS_MT_TOOL_TYPE, tool_type);
@@ -135,13 +183,19 @@ EXPORT_SYMBOL(input_mt_report_finger_count);
  */
 void input_mt_report_pointer_emulation(struct input_dev *dev, bool use_count)
 {
-        struct input_mt_slot *oldest = NULL;
-        int oldid = dev->trkid;
-        int count = 0;
-        int i;
+        struct input_mt *mt = dev->mt;
+        struct input_mt_slot *oldest;
+        int oldid, count, i;
+
+        if (!mt)
+                return;
+
+        oldest = 0;
+        oldid = mt->trkid;
+        count = 0;
 
-        for (i = 0; i < dev->mtsize; ++i) {
-                struct input_mt_slot *ps = &dev->mt[i];
+        for (i = 0; i < mt->num_slots; ++i) {
+                struct input_mt_slot *ps = &mt->slots[i];
                 int id = input_mt_get_value(ps, ABS_MT_TRACKING_ID);
 
                 if (id < 0)
@@ -160,13 +214,208 @@ void input_mt_report_pointer_emulation(struct input_dev *dev, bool use_count)
         if (oldest) {
                 int x = input_mt_get_value(oldest, ABS_MT_POSITION_X);
                 int y = input_mt_get_value(oldest, ABS_MT_POSITION_Y);
-                int p = input_mt_get_value(oldest, ABS_MT_PRESSURE);
 
                 input_event(dev, EV_ABS, ABS_X, x);
                 input_event(dev, EV_ABS, ABS_Y, y);
-                input_event(dev, EV_ABS, ABS_PRESSURE, p);
+
+                if (test_bit(ABS_MT_PRESSURE, dev->absbit)) {
+                        int p = input_mt_get_value(oldest, ABS_MT_PRESSURE);
+                        input_event(dev, EV_ABS, ABS_PRESSURE, p);
+                }
         } else {
-                input_event(dev, EV_ABS, ABS_PRESSURE, 0);
+                if (test_bit(ABS_MT_PRESSURE, dev->absbit))
+                        input_event(dev, EV_ABS, ABS_PRESSURE, 0);
         }
 }
 EXPORT_SYMBOL(input_mt_report_pointer_emulation);
+
+/**
+ * input_mt_sync_frame() - synchronize mt frame
+ * @dev: input device with allocated MT slots
+ *
+ * Close the frame and prepare the internal state for a new one.
+ * Depending on the flags, marks unused slots as inactive and performs
+ * pointer emulation.
+ */
+void input_mt_sync_frame(struct input_dev *dev)
+{
+        struct input_mt *mt = dev->mt;
+        struct input_mt_slot *s;
+
+        if (!mt)
+                return;
+
+        if (mt->flags & INPUT_MT_DROP_UNUSED) {
+                for (s = mt->slots; s != mt->slots + mt->num_slots; s++) {
+                        if (s->frame == mt->frame)
+                                continue;
+                        input_mt_slot(dev, s - mt->slots);
+                        input_event(dev, EV_ABS, ABS_MT_TRACKING_ID, -1);
+                }
+        }
+
+        input_mt_report_pointer_emulation(dev, (mt->flags & INPUT_MT_POINTER));
+
+        mt->frame++;
+}
+EXPORT_SYMBOL(input_mt_sync_frame);
+
+static int adjust_dual(int *begin, int step, int *end, int eq)
+{
+        int f, *p, s, c;
+
+        if (begin == end)
+                return 0;
+
+        f = *begin;
+        p = begin + step;
+        s = p == end ? f + 1 : *p;
+
+        for (; p != end; p += step)
+                if (*p < f)
+                        s = f, f = *p;
+                else if (*p < s)
+                        s = *p;
+
+        c = (f + s + 1) / 2;
+        if (c == 0 || (c > 0 && !eq))
+                return 0;
+        if (s < 0)
+                c *= 2;
+
+        for (p = begin; p != end; p += step)
+                *p -= c;
+
+        return (c < s && s <= 0) || (f >= 0 && f < c);
+}
+
+static void find_reduced_matrix(int *w, int nr, int nc, int nrc)
+{
+        int i, k, sum;
+
+        for (k = 0; k < nrc; k++) {
+                for (i = 0; i < nr; i++)
+                        adjust_dual(w + i, nr, w + i + nrc, nr <= nc);
+                sum = 0;
+                for (i = 0; i < nrc; i += nr)
+                        sum += adjust_dual(w + i, 1, w + i + nr, nc <= nr);
+                if (!sum)
+                        break;
+        }
+}
+
+static int input_mt_set_matrix(struct input_mt *mt,
+                               const struct input_mt_pos *pos, int num_pos)
+{
+        const struct input_mt_pos *p;
+        struct input_mt_slot *s;
+        int *w = mt->red;
+        int x, y;
+
+        for (s = mt->slots; s != mt->slots + mt->num_slots; s++) {
+                if (!input_mt_is_active(s))
+                        continue;
+                x = input_mt_get_value(s, ABS_MT_POSITION_X);
+                y = input_mt_get_value(s, ABS_MT_POSITION_Y);
+                for (p = pos; p != pos + num_pos; p++) {
+                        int dx = x - p->x, dy = y - p->y;
+                        *w++ = dx * dx + dy * dy;
+                }
+        }
+
+        return w - mt->red;
+}
+
+static void input_mt_set_slots(struct input_mt *mt,
+                               int *slots, int num_pos)
+{
+        struct input_mt_slot *s;
+        int *w = mt->red, *p;
+
+        for (p = slots; p != slots + num_pos; p++)
+                *p = -1;
+
+        for (s = mt->slots; s != mt->slots + mt->num_slots; s++) {
+                if (!input_mt_is_active(s))
+                        continue;
+                for (p = slots; p != slots + num_pos; p++)
+                        if (*w++ < 0)
+                                *p = s - mt->slots;
+        }
+
+        for (s = mt->slots; s != mt->slots + mt->num_slots; s++) {
+                if (input_mt_is_active(s))
+                        continue;
+                for (p = slots; p != slots + num_pos; p++)
+                        if (*p < 0) {
+                                *p = s - mt->slots;
+                                break;
+                        }
+        }
+}
+
+/**
+ * input_mt_assign_slots() - perform a best-match assignment
+ * @dev: input device with allocated MT slots
+ * @slots: the slot assignment to be filled
+ * @pos: the position array to match
+ * @num_pos: number of positions
+ *
+ * Performs a best match against the current contacts and returns
+ * the slot assignment list. New contacts are assigned to unused
+ * slots.
+ *
+ * Returns zero on success, or negative error in case of failure.
+ */
+int input_mt_assign_slots(struct input_dev *dev, int *slots,
+                          const struct input_mt_pos *pos, int num_pos)
+{
+        struct input_mt *mt = dev->mt;
+        int nrc;
+
+        if (!mt || !mt->red)
+                return -ENXIO;
+        if (num_pos > mt->num_slots)
+                return -EINVAL;
+        if (num_pos < 1)
+                return 0;
+
+        nrc = input_mt_set_matrix(mt, pos, num_pos);
+        find_reduced_matrix(mt->red, num_pos, nrc / num_pos, nrc);
+        input_mt_set_slots(mt, slots, num_pos);
+
+        return 0;
+}
+EXPORT_SYMBOL(input_mt_assign_slots);
+
+/**
+ * input_mt_get_slot_by_key() - return slot matching key
+ * @dev: input device with allocated MT slots
+ * @key: the key of the sought slot
+ *
+ * Returns the slot of the given key, if it exists, otherwise
+ * set the key on the first unused slot and return.
+ *
+ * If no available slot can be found, -1 is returned.
+ */
+int input_mt_get_slot_by_key(struct input_dev *dev, int key)
+{
+        struct input_mt *mt = dev->mt;
+        struct input_mt_slot *s;
+
+        if (!mt)
+                return -1;
+
+        for (s = mt->slots; s != mt->slots + mt->num_slots; s++)
+                if (input_mt_is_active(s) && s->key == key)
+                        return s - mt->slots;
+
+        for (s = mt->slots; s != mt->slots + mt->num_slots; s++)
+                if (!input_mt_is_active(s)) {
+                        s->key = key;
+                        return s - mt->slots;
+                }
+
+        return -1;
+}
+EXPORT_SYMBOL(input_mt_get_slot_by_key);
diff --git a/drivers/input/input.c b/drivers/input/input.c
index 8921c6180c51..ace3f7c4226d 100644
--- a/drivers/input/input.c
+++ b/drivers/input/input.c
@@ -47,6 +47,8 @@ static DEFINE_MUTEX(input_mutex);
 
 static struct input_handler *input_table[8];
 
+static const struct input_value input_value_sync = { EV_SYN, SYN_REPORT, 1 };
+
 static inline int is_event_supported(unsigned int code,
                                      unsigned long *bm, unsigned int max)
 {
@@ -69,42 +71,102 @@ static int input_defuzz_abs_event(int value, int old_val, int fuzz)
         return value;
 }
 
+static void input_start_autorepeat(struct input_dev *dev, int code)
+{
+        if (test_bit(EV_REP, dev->evbit) &&
+            dev->rep[REP_PERIOD] && dev->rep[REP_DELAY] &&
+            dev->timer.data) {
+                dev->repeat_key = code;
+                mod_timer(&dev->timer,
+                          jiffies + msecs_to_jiffies(dev->rep[REP_DELAY]));
+        }
+}
+
+static void input_stop_autorepeat(struct input_dev *dev)
+{
+        del_timer(&dev->timer);
+}
+
 /*
  * Pass event first through all filters and then, if event has not been
  * filtered out, through all open handles. This function is called with
  * dev->event_lock held and interrupts disabled.
  */
-static void input_pass_event(struct input_dev *dev,
-                             unsigned int type, unsigned int code, int value)
+static unsigned int input_to_handler(struct input_handle *handle,
+                        struct input_value *vals, unsigned int count)
+{
+        struct input_handler *handler = handle->handler;
+        struct input_value *end = vals;
+        struct input_value *v;
+
+        for (v = vals; v != vals + count; v++) {
+                if (handler->filter &&
+                    handler->filter(handle, v->type, v->code, v->value))
+                        continue;
+                if (end != v)
+                        *end = *v;
+                end++;
+        }
+
+        count = end - vals;
+        if (!count)
+                return 0;
+
+        if (handler->events)
+                handler->events(handle, vals, count);
+        else if (handler->event)
+                for (v = vals; v != end; v++)
+                        handler->event(handle, v->type, v->code, v->value);
+
+        return count;
+}
+
+/*
+ * Pass values first through all filters and then, if event has not been
+ * filtered out, through all open handles. This function is called with
+ * dev->event_lock held and interrupts disabled.
+ */
+static void input_pass_values(struct input_dev *dev,
+                              struct input_value *vals, unsigned int count)
 {
-        struct input_handler *handler;
         struct input_handle *handle;
+        struct input_value *v;
+
+        if (!count)
+                return;
 
         rcu_read_lock();
 
         handle = rcu_dereference(dev->grab);
-        if (handle)
-                handle->handler->event(handle, type, code, value);
-        else {
-                bool filtered = false;
-
-                list_for_each_entry_rcu(handle, &dev->h_list, d_node) {
-                        if (!handle->open)
-                                continue;
+        if (handle) {
+                count = input_to_handler(handle, vals, count);
+        } else {
+                list_for_each_entry_rcu(handle, &dev->h_list, d_node)
+                        if (handle->open)
+                                count = input_to_handler(handle, vals, count);
+        }
 
-                        handler = handle->handler;
-                        if (!handler->filter) {
-                                if (filtered)
-                                        break;
+        rcu_read_unlock();
 
-                                handler->event(handle, type, code, value);
+        add_input_randomness(vals->type, vals->code, vals->value);
 
-                        } else if (handler->filter(handle, type, code, value))
-                                filtered = true;
+        /* trigger auto repeat for key events */
+        for (v = vals; v != vals + count; v++) {
+                if (v->type == EV_KEY && v->value != 2) {
+                        if (v->value)
+                                input_start_autorepeat(dev, v->code);
+                        else
+                                input_stop_autorepeat(dev);
                 }
         }
+}
 
-        rcu_read_unlock();
+static void input_pass_event(struct input_dev *dev,
+                             unsigned int type, unsigned int code, int value)
+{
+        struct input_value vals[] = { { type, code, value } };
+
+        input_pass_values(dev, vals, ARRAY_SIZE(vals));
 }
 
 /*
@@ -121,18 +183,12 @@ static void input_repeat_key(unsigned long data)
 
         if (test_bit(dev->repeat_key, dev->key) &&
             is_event_supported(dev->repeat_key, dev->keybit, KEY_MAX)) {
+                struct input_value vals[] =  {
+                        { EV_KEY, dev->repeat_key, 2 },
+                        input_value_sync
+                };
 
-                input_pass_event(dev, EV_KEY, dev->repeat_key, 2);
-
-                if (dev->sync) {
-                        /*
-                         * Only send SYN_REPORT if we are not in a middle
-                         * of driver parsing a new hardware packet.
-                         * Otherwise assume that the driver will send
-                         * SYN_REPORT once it's done.
-                         */
-                        input_pass_event(dev, EV_SYN, SYN_REPORT, 1);
-                }
+                input_pass_values(dev, vals, ARRAY_SIZE(vals));
 
                 if (dev->rep[REP_PERIOD])
                         mod_timer(&dev->timer, jiffies +
@@ -142,30 +198,17 @@ static void input_repeat_key(unsigned long data)
         spin_unlock_irqrestore(&dev->event_lock, flags);
 }
 
-static void input_start_autorepeat(struct input_dev *dev, int code)
-{
-        if (test_bit(EV_REP, dev->evbit) &&
-            dev->rep[REP_PERIOD] && dev->rep[REP_DELAY] &&
-            dev->timer.data) {
-                dev->repeat_key = code;
-                mod_timer(&dev->timer,
-                          jiffies + msecs_to_jiffies(dev->rep[REP_DELAY]));
-        }
-}
-
-static void input_stop_autorepeat(struct input_dev *dev)
-{
-        del_timer(&dev->timer);
-}
-
 #define INPUT_IGNORE_EVENT      0
 #define INPUT_PASS_TO_HANDLERS  1
 #define INPUT_PASS_TO_DEVICE    2
+#define INPUT_SLOT              4
+#define INPUT_FLUSH             8
 #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)
 {
+        struct input_mt *mt = dev->mt;
         bool is_mt_event;
         int *pold;
 
@@ -174,8 +217,8 @@ static int input_handle_abs_event(struct input_dev *dev,
                  * "Stage" the event; we'll flush it later, when we
                  * get actual touch data.
                  */
-                if (*pval >= 0 && *pval < dev->mtsize)
-                        dev->slot = *pval;
+                if (mt && *pval >= 0 && *pval < mt->num_slots)
+                        mt->slot = *pval;
 
                 return INPUT_IGNORE_EVENT;
         }
@@ -184,9 +227,8 @@ static int input_handle_abs_event(struct input_dev *dev,
 
         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 if (mt) {
+                pold = &mt->slots[mt->slot].abs[code - ABS_MT_FIRST];
         } else {
                 /*
                  * Bypass filtering for multi-touch events when
@@ -205,16 +247,16 @@ static int input_handle_abs_event(struct input_dev *dev,
         }
 
         /* 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);
+        if (is_mt_event && mt && mt->slot != input_abs_get_val(dev, ABS_MT_SLOT)) {
+                input_abs_set_val(dev, ABS_MT_SLOT, mt->slot);
+                return INPUT_PASS_TO_HANDLERS | INPUT_SLOT;
         }
 
         return INPUT_PASS_TO_HANDLERS;
 }
 
-static void input_handle_event(struct input_dev *dev,
-                               unsigned int type, unsigned int code, int value)
+static int input_get_disposition(struct input_dev *dev,
+                          unsigned int type, unsigned int code, int value)
 {
         int disposition = INPUT_IGNORE_EVENT;
 
@@ -227,37 +269,34 @@ static void input_handle_event(struct input_dev *dev,
                         break;
 
                 case SYN_REPORT:
-                        if (!dev->sync) {
-                                dev->sync = true;
-                                disposition = INPUT_PASS_TO_HANDLERS;
-                        }
+                        disposition = INPUT_PASS_TO_HANDLERS | INPUT_FLUSH;
                         break;
                 case SYN_MT_REPORT:
-                        dev->sync = false;
                         disposition = INPUT_PASS_TO_HANDLERS;
                         break;
                 }
                 break;
 
         case EV_KEY:
-                if (is_event_supported(code, dev->keybit, KEY_MAX) &&
-                    !!test_bit(code, dev->key) != value) {
+                if (is_event_supported(code, dev->keybit, KEY_MAX)) {
 
-                        if (value != 2) {
-                                __change_bit(code, dev->key);
-                                if (value)
-                                        input_start_autorepeat(dev, code);
-                                else
-                                        input_stop_autorepeat(dev);
+                        /* auto-repeat bypasses state updates */
+                        if (value == 2) {
+                                disposition = INPUT_PASS_TO_HANDLERS;
+                                break;
                         }
 
-                        disposition = INPUT_PASS_TO_HANDLERS;
+                        if (!!test_bit(code, dev->key) != !!value) {
+
+                                __change_bit(code, dev->key);
+                                disposition = INPUT_PASS_TO_HANDLERS;
+                        }
                 }
                 break;
 
         case EV_SW:
                 if (is_event_supported(code, dev->swbit, SW_MAX) &&
-                    !!test_bit(code, dev->sw) != value) {
+                    !!test_bit(code, dev->sw) != !!value) {
 
                         __change_bit(code, dev->sw);
                         disposition = INPUT_PASS_TO_HANDLERS;
@@ -284,7 +323,7 @@ static void input_handle_event(struct input_dev *dev,
 
         case EV_LED:
                 if (is_event_supported(code, dev->ledbit, LED_MAX) &&
-                    !!test_bit(code, dev->led) != value) {
+                    !!test_bit(code, dev->led) != !!value) {
 
                         __change_bit(code, dev->led);
                         disposition = INPUT_PASS_TO_ALL;
@@ -317,14 +356,48 @@ static void input_handle_event(struct input_dev *dev,
                 break;
         }
 
-        if (disposition != INPUT_IGNORE_EVENT && type != EV_SYN)
-                dev->sync = false;
+        return disposition;
+}
+
+static void input_handle_event(struct input_dev *dev,
+                               unsigned int type, unsigned int code, int value)
+{
+        int disposition;
+
+        disposition = input_get_disposition(dev, type, code, value);
 
         if ((disposition & INPUT_PASS_TO_DEVICE) && dev->event)
                 dev->event(dev, type, code, value);
 
-        if (disposition & INPUT_PASS_TO_HANDLERS)
-                input_pass_event(dev, type, code, value);
+        if (!dev->vals)
+                return;
+
+        if (disposition & INPUT_PASS_TO_HANDLERS) {
+                struct input_value *v;
+
+                if (disposition & INPUT_SLOT) {
+                        v = &dev->vals[dev->num_vals++];
+                        v->type = EV_ABS;
+                        v->code = ABS_MT_SLOT;
+                        v->value = dev->mt->slot;
+                }
+
+                v = &dev->vals[dev->num_vals++];
+                v->type = type;
+                v->code = code;
+                v->value = value;
+        }
+
+        if (disposition & INPUT_FLUSH) {
+                if (dev->num_vals >= 2)
+                        input_pass_values(dev, dev->vals, dev->num_vals);
+                dev->num_vals = 0;
+        } else if (dev->num_vals >= dev->max_vals - 2) {
+                dev->vals[dev->num_vals++] = input_value_sync;
+                input_pass_values(dev, dev->vals, dev->num_vals);
+                dev->num_vals = 0;
+        }
+
 }
 
 /**
@@ -352,7 +425,6 @@ void input_event(struct input_dev *dev,
         if (is_event_supported(type, dev->evbit, EV_MAX)) {
 
                 spin_lock_irqsave(&dev->event_lock, flags);
-                add_input_randomness(type, code, value);
                 input_handle_event(dev, type, code, value);
                 spin_unlock_irqrestore(&dev->event_lock, flags);
         }
@@ -831,10 +903,12 @@ int input_set_keycode(struct input_dev *dev,
         if (test_bit(EV_KEY, dev->evbit) &&
             !is_event_supported(old_keycode, dev->keybit, KEY_MAX) &&
             __test_and_clear_bit(old_keycode, dev->key)) {
+                struct input_value vals[] =  {
+                        { EV_KEY, old_keycode, 0 },
+                        input_value_sync
+                };
 
-                input_pass_event(dev, EV_KEY, old_keycode, 0);
-                if (dev->sync)
-                        input_pass_event(dev, EV_SYN, SYN_REPORT, 1);
+                input_pass_values(dev, vals, ARRAY_SIZE(vals));
         }
 
  out:
@@ -844,18 +918,10 @@ int input_set_keycode(struct input_dev *dev,
 }
 EXPORT_SYMBOL(input_set_keycode);
 
-#define MATCH_BIT(bit, max) \
-                for (i = 0; i < BITS_TO_LONGS(max); i++) \
-                        if ((id->bit[i] & dev->bit[i]) != id->bit[i]) \
-                                break; \
-                if (i != BITS_TO_LONGS(max)) \
-                        continue;
-
 static const struct input_device_id *input_match_device(struct input_handler *handler,
                                                         struct input_dev *dev)
 {
         const struct input_device_id *id;
-        int i;
 
         for (id = handler->id_table; id->flags || id->driver_info; id++) {
 
@@ -875,15 +941,32 @@ static const struct input_device_id *input_match_device(struct input_handler *ha
                         if (id->version != dev->id.version)
                                 continue;
 
-                MATCH_BIT(evbit,  EV_MAX);
-                MATCH_BIT(keybit, KEY_MAX);
-                MATCH_BIT(relbit, REL_MAX);
-                MATCH_BIT(absbit, ABS_MAX);
-                MATCH_BIT(mscbit, MSC_MAX);
-                MATCH_BIT(ledbit, LED_MAX);
-                MATCH_BIT(sndbit, SND_MAX);
-                MATCH_BIT(ffbit,  FF_MAX);
-                MATCH_BIT(swbit,  SW_MAX);
+                if (!bitmap_subset(id->evbit, dev->evbit, EV_MAX))
+                        continue;
+
+                if (!bitmap_subset(id->keybit, dev->keybit, KEY_MAX))
+                        continue;
+
+                if (!bitmap_subset(id->relbit, dev->relbit, REL_MAX))
+                        continue;
+
+                if (!bitmap_subset(id->absbit, dev->absbit, ABS_MAX))
+                        continue;
+
+                if (!bitmap_subset(id->mscbit, dev->mscbit, MSC_MAX))
+                        continue;
+
+                if (!bitmap_subset(id->ledbit, dev->ledbit, LED_MAX))
+                        continue;
+
+                if (!bitmap_subset(id->sndbit, dev->sndbit, SND_MAX))
+                        continue;
+
+                if (!bitmap_subset(id->ffbit, dev->ffbit, FF_MAX))
+                        continue;
+
+                if (!bitmap_subset(id->swbit, dev->swbit, SW_MAX))
+                        continue;
 
                 if (!handler->match || handler->match(handler, dev))
                         return id;
@@ -1416,6 +1499,7 @@ static void input_dev_release(struct device *device)
         input_ff_destroy(dev);
         input_mt_destroy_slots(dev);
         kfree(dev->absinfo);
+        kfree(dev->vals);
         kfree(dev);
 
         module_put(THIS_MODULE);
@@ -1751,8 +1835,8 @@ static unsigned int input_estimate_events_per_packet(struct input_dev *dev)
         int i;
         unsigned int events;
 
-        if (dev->mtsize) {
-                mt_slots = dev->mtsize;
+        if (dev->mt) {
+                mt_slots = dev->mt->num_slots;
         } else if (test_bit(ABS_MT_TRACKING_ID, dev->absbit)) {
                 mt_slots = dev->absinfo[ABS_MT_TRACKING_ID].maximum -
                            dev->absinfo[ABS_MT_TRACKING_ID].minimum + 1,
@@ -1778,6 +1862,9 @@ static unsigned int input_estimate_events_per_packet(struct input_dev *dev)
                 if (test_bit(i, dev->relbit))
                         events++;
 
+        /* Make room for KEY and MSC events */
+        events += 7;
+
         return events;
 }
 
@@ -1816,6 +1903,7 @@ int input_register_device(struct input_dev *dev)
 {
         static atomic_t input_no = ATOMIC_INIT(0);
         struct input_handler *handler;
+        unsigned int packet_size;
         const char *path;
         int error;
 
@@ -1828,9 +1916,14 @@ int input_register_device(struct input_dev *dev)
         /* Make sure that bitmasks not mentioned in dev->evbit are clean. */
         input_cleanse_bitmasks(dev);
 
-        if (!dev->hint_events_per_packet)
-                dev->hint_events_per_packet =
-                                input_estimate_events_per_packet(dev);
+        packet_size = input_estimate_events_per_packet(dev);
+        if (dev->hint_events_per_packet < packet_size)
+                dev->hint_events_per_packet = packet_size;
+
+        dev->max_vals = max(dev->hint_events_per_packet, packet_size) + 2;
+        dev->vals = kcalloc(dev->max_vals, sizeof(*dev->vals), GFP_KERNEL);
+        if (!dev->vals)
+                return -ENOMEM;
 
         /*
          * If delay and period are pre-set by the driver, then autorepeating
diff --git a/drivers/input/joydev.c b/drivers/input/joydev.c
index 26043cc6a016..78f323ea1e4b 100644
--- a/drivers/input/joydev.c
+++ b/drivers/input/joydev.c
@@ -711,7 +711,7 @@ static long joydev_ioctl(struct file *file,
 
         case JS_SET_ALL:
                 retval = copy_from_user(&joydev->glue, argp,
-                                        sizeof(joydev->glue)) ? -EFAULT: 0;
+                                        sizeof(joydev->glue)) ? -EFAULT : 0;
                 break;
 
         case JS_GET_ALL:
diff --git a/drivers/input/keyboard/Kconfig b/drivers/input/keyboard/Kconfig
index c50fa75416f8..b4b65af8612a 100644
--- a/drivers/input/keyboard/Kconfig
+++ b/drivers/input/keyboard/Kconfig
@@ -533,7 +533,7 @@ config KEYBOARD_DAVINCI
 
 config KEYBOARD_OMAP
         tristate "TI OMAP keypad support"
-        depends on (ARCH_OMAP1 || ARCH_OMAP2)
+        depends on ARCH_OMAP1
         select INPUT_MATRIXKMAP
         help
           Say Y here if you want to use the OMAP keypad.
diff --git a/drivers/input/keyboard/davinci_keyscan.c b/drivers/input/keyboard/davinci_keyscan.c
index 9d82b3aeff5e..d5bacbb479b0 100644
--- a/drivers/input/keyboard/davinci_keyscan.c
+++ b/drivers/input/keyboard/davinci_keyscan.c
@@ -36,7 +36,7 @@
 
 #include <mach/hardware.h>
 #include <mach/irqs.h>
-#include <mach/keyscan.h>
+#include <linux/platform_data/keyscan-davinci.h>
 
 /* Key scan registers */
 #define DAVINCI_KEYSCAN_KEYCTRL         0x0000
diff --git a/drivers/input/keyboard/ep93xx_keypad.c b/drivers/input/keyboard/ep93xx_keypad.c
index c46fc8185469..7363402de8d4 100644
--- a/drivers/input/keyboard/ep93xx_keypad.c
+++ b/drivers/input/keyboard/ep93xx_keypad.c
@@ -29,7 +29,7 @@
 #include <linux/slab.h>
 
 #include <mach/hardware.h>
-#include <mach/ep93xx_keypad.h>
+#include <linux/platform_data/keypad-ep93xx.h>
 
 /*
  * Keypad Interface Register offsets
diff --git a/drivers/input/keyboard/gpio_keys.c b/drivers/input/keyboard/gpio_keys.c
index cbb1add43d5e..6a68041c261d 100644
--- a/drivers/input/keyboard/gpio_keys.c
+++ b/drivers/input/keyboard/gpio_keys.c
@@ -43,11 +43,9 @@ struct gpio_button_data {
 };
 
 struct gpio_keys_drvdata {
+        const struct gpio_keys_platform_data *pdata;
         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];
 };
 
@@ -171,7 +169,7 @@ static ssize_t gpio_keys_attr_show_helper(struct gpio_keys_drvdata *ddata,
         if (!bits)
                 return -ENOMEM;
 
-        for (i = 0; i < ddata->n_buttons; i++) {
+        for (i = 0; i < ddata->pdata->nbuttons; i++) {
                 struct gpio_button_data *bdata = &ddata->data[i];
 
                 if (bdata->button->type != type)
@@ -219,7 +217,7 @@ static ssize_t gpio_keys_attr_store_helper(struct gpio_keys_drvdata *ddata,
                 goto out;
 
         /* First validate */
-        for (i = 0; i < ddata->n_buttons; i++) {
+        for (i = 0; i < ddata->pdata->nbuttons; i++) {
                 struct gpio_button_data *bdata = &ddata->data[i];
 
                 if (bdata->button->type != type)
@@ -234,7 +232,7 @@ static ssize_t gpio_keys_attr_store_helper(struct gpio_keys_drvdata *ddata,
 
         mutex_lock(&ddata->disable_lock);
 
-        for (i = 0; i < ddata->n_buttons; i++) {
+        for (i = 0; i < ddata->pdata->nbuttons; i++) {
                 struct gpio_button_data *bdata = &ddata->data[i];
 
                 if (bdata->button->type != type)
@@ -346,6 +344,9 @@ static void gpio_keys_gpio_work_func(struct work_struct *work)
                 container_of(work, struct gpio_button_data, work);
 
         gpio_keys_gpio_report_event(bdata);
+
+        if (bdata->button->wakeup)
+                pm_relax(bdata->input->dev.parent);
 }
 
 static void gpio_keys_gpio_timer(unsigned long _data)
@@ -361,6 +362,8 @@ static irqreturn_t gpio_keys_gpio_isr(int irq, void *dev_id)
 
         BUG_ON(irq != bdata->irq);
 
+        if (bdata->button->wakeup)
+                pm_stay_awake(bdata->input->dev.parent);
         if (bdata->timer_debounce)
                 mod_timer(&bdata->timer,
                         jiffies + msecs_to_jiffies(bdata->timer_debounce));
@@ -397,6 +400,9 @@ static irqreturn_t gpio_keys_irq_isr(int irq, void *dev_id)
         spin_lock_irqsave(&bdata->lock, flags);
 
         if (!bdata->key_pressed) {
+                if (bdata->button->wakeup)
+                        pm_wakeup_event(bdata->input->dev.parent, 0);
+
                 input_event(input, EV_KEY, button->code, 1);
                 input_sync(input);
 
@@ -523,56 +529,64 @@ fail:
 static int gpio_keys_open(struct input_dev *input)
 {
         struct gpio_keys_drvdata *ddata = input_get_drvdata(input);
+        const struct gpio_keys_platform_data *pdata = ddata->pdata;
 
-        return ddata->enable ? ddata->enable(input->dev.parent) : 0;
+        return pdata->enable ? pdata->enable(input->dev.parent) : 0;
 }
 
 static void gpio_keys_close(struct input_dev *input)
 {
         struct gpio_keys_drvdata *ddata = input_get_drvdata(input);
+        const struct gpio_keys_platform_data *pdata = ddata->pdata;
 
-        if (ddata->disable)
-                ddata->disable(input->dev.parent);
+        if (pdata->disable)
+                pdata->disable(input->dev.parent);
 }
 
 /*
  * Handlers for alternative sources of platform_data
  */
+
 #ifdef CONFIG_OF
 /*
  * Translate OpenFirmware node properties into platform_data
  */
-static int gpio_keys_get_devtree_pdata(struct device *dev,
-                            struct gpio_keys_platform_data *pdata)
+static struct gpio_keys_platform_data * __devinit
+gpio_keys_get_devtree_pdata(struct device *dev)
 {
         struct device_node *node, *pp;
+        struct gpio_keys_platform_data *pdata;
+        struct gpio_keys_button *button;
+        int error;
+        int nbuttons;
         int i;
-        struct gpio_keys_button *buttons;
-        u32 reg;
 
         node = dev->of_node;
-        if (node == NULL)
-                return -ENODEV;
-
-        memset(pdata, 0, sizeof *pdata);
+        if (!node) {
+                error = -ENODEV;
+                goto err_out;
+        }
 
-        pdata->rep = !!of_get_property(node, "autorepeat", NULL);
+        nbuttons = of_get_child_count(node);
+        if (nbuttons == 0) {
+                error = -ENODEV;
+                goto err_out;
+        }
 
-        /* First count the subnodes */
-        pp = NULL;
-        while ((pp = of_get_next_child(node, pp)))
-                pdata->nbuttons++;
+        pdata = kzalloc(sizeof(*pdata) + nbuttons * (sizeof *button),
+                        GFP_KERNEL);
+        if (!pdata) {
+                error = -ENOMEM;
+                goto err_out;
+        }
 
-        if (pdata->nbuttons == 0)
-                return -ENODEV;
+        pdata->buttons = (struct gpio_keys_button *)(pdata + 1);
+        pdata->nbuttons = nbuttons;
 
-        buttons = kzalloc(pdata->nbuttons * (sizeof *buttons), GFP_KERNEL);
-        if (!buttons)
-                return -ENOMEM;
+        pdata->rep = !!of_get_property(node, "autorepeat", NULL);
 
-        pp = NULL;
         i = 0;
-        while ((pp = of_get_next_child(node, pp))) {
+        for_each_child_of_node(node, pp) {
                 enum of_gpio_flags flags;
 
                 if (!of_find_property(pp, "gpios", NULL)) {
@@ -580,39 +594,42 @@ static int gpio_keys_get_devtree_pdata(struct device *dev,
                         dev_warn(dev, "Found button without gpios\n");
                         continue;
                 }
-                buttons[i].gpio = of_get_gpio_flags(pp, 0, &flags);
-                buttons[i].active_low = flags & OF_GPIO_ACTIVE_LOW;
 
-                if (of_property_read_u32(pp, "linux,code", &reg)) {
-                        dev_err(dev, "Button without keycode: 0x%x\n", buttons[i].gpio);
-                        goto out_fail;
-                }
-                buttons[i].code = reg;
+                button = &pdata->buttons[i++];
 
-                buttons[i].desc = of_get_property(pp, "label", NULL);
+                button->gpio = of_get_gpio_flags(pp, 0, &flags);
+                button->active_low = flags & OF_GPIO_ACTIVE_LOW;
 
-                if (of_property_read_u32(pp, "linux,input-type", &reg) == 0)
-                        buttons[i].type = reg;
-                else
-                        buttons[i].type = EV_KEY;
+                if (of_property_read_u32(pp, "linux,code", &button->code)) {
+                        dev_err(dev, "Button without keycode: 0x%x\n",
+                                button->gpio);
+                        error = -EINVAL;
+                        goto err_free_pdata;
+                }
 
-                buttons[i].wakeup = !!of_get_property(pp, "gpio-key,wakeup", NULL);
+                button->desc = of_get_property(pp, "label", NULL);
 
-                if (of_property_read_u32(pp, "debounce-interval", &reg) == 0)
-                        buttons[i].debounce_interval = reg;
-                else
-                        buttons[i].debounce_interval = 5;
+                if (of_property_read_u32(pp, "linux,input-type", &button->type))
+                        button->type = EV_KEY;
 
-                i++;
+                button->wakeup = !!of_get_property(pp, "gpio-key,wakeup", NULL);
+
+                if (of_property_read_u32(pp, "debounce-interval",
+                                         &button->debounce_interval))
+                        button->debounce_interval = 5;
         }
 
-        pdata->buttons = buttons;
+        if (pdata->nbuttons == 0) {
+                error = -EINVAL;
+                goto err_free_pdata;
+        }
 
-        return 0;
+        return pdata;
 
-out_fail:
-        kfree(buttons);
-        return -ENODEV;
+err_free_pdata:
+        kfree(pdata);
+err_out:
+        return ERR_PTR(error);
 }
 
 static struct of_device_id gpio_keys_of_match[] = {
@@ -623,14 +640,12 @@ MODULE_DEVICE_TABLE(of, gpio_keys_of_match);
 
 #else
 
-static int gpio_keys_get_devtree_pdata(struct device *dev,
-                            struct gpio_keys_platform_data *altp)
+static inline struct gpio_keys_platform_data *
+gpio_keys_get_devtree_pdata(struct device *dev)
 {
-        return -ENODEV;
+        return ERR_PTR(-ENODEV);
 }
 
-#define gpio_keys_of_match NULL
-
 #endif
 
 static void gpio_remove_key(struct gpio_button_data *bdata)
@@ -645,19 +660,17 @@ static void gpio_remove_key(struct gpio_button_data *bdata)
 
 static int __devinit gpio_keys_probe(struct platform_device *pdev)
 {
-        const struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
-        struct gpio_keys_drvdata *ddata;
         struct device *dev = &pdev->dev;
-        struct gpio_keys_platform_data alt_pdata;
+        const struct gpio_keys_platform_data *pdata = dev_get_platdata(dev);
+        struct gpio_keys_drvdata *ddata;
         struct input_dev *input;
         int i, error;
         int wakeup = 0;
 
         if (!pdata) {
-                error = gpio_keys_get_devtree_pdata(dev, &alt_pdata);
-                if (error)
-                        return error;
-                pdata = &alt_pdata;
+                pdata = gpio_keys_get_devtree_pdata(dev);
+                if (IS_ERR(pdata))
+                        return PTR_ERR(pdata);
         }
 
         ddata = kzalloc(sizeof(struct gpio_keys_drvdata) +
@@ -670,10 +683,8 @@ static int __devinit gpio_keys_probe(struct platform_device *pdev)
                 goto fail1;
         }
 
+        ddata->pdata = pdata;
         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);
@@ -742,9 +753,9 @@ static int __devinit gpio_keys_probe(struct platform_device *pdev)
  fail1:
         input_free_device(input);
         kfree(ddata);
-        /* If we have no platform_data, we allocated buttons dynamically. */
-        if (!pdev->dev.platform_data)
-                kfree(pdata->buttons);
+        /* If we have no platform data, we allocated pdata dynamically. */
+        if (!dev_get_platdata(&pdev->dev))
+                kfree(pdata);
 
         return error;
 }
@@ -759,18 +770,14 @@ static int __devexit gpio_keys_remove(struct platform_device *pdev)
 
         device_init_wakeup(&pdev->dev, 0);
 
-        for (i = 0; i < ddata->n_buttons; i++)
+        for (i = 0; i < ddata->pdata->nbuttons; i++)
                 gpio_remove_key(&ddata->data[i]);
 
         input_unregister_device(input);
 
-        /*
-         * If we had no platform_data, we allocated buttons dynamically, and
-         * must free them here. ddata->data[0].button is the pointer to the
-         * beginning of the allocated array.
-         */
-        if (!pdev->dev.platform_data)
-                kfree(ddata->data[0].button);
+        /* If we have no platform data, we allocated pdata dynamically. */
+        if (!dev_get_platdata(&pdev->dev))
+                kfree(ddata->pdata);
 
         kfree(ddata);
 
@@ -784,7 +791,7 @@ static int gpio_keys_suspend(struct device *dev)
         int i;
 
         if (device_may_wakeup(dev)) {
-                for (i = 0; i < ddata->n_buttons; i++) {
+                for (i = 0; i < ddata->pdata->nbuttons; i++) {
                         struct gpio_button_data *bdata = &ddata->data[i];
                         if (bdata->button->wakeup)
                                 enable_irq_wake(bdata->irq);
@@ -799,7 +806,7 @@ static int gpio_keys_resume(struct device *dev)
         struct gpio_keys_drvdata *ddata = dev_get_drvdata(dev);
         int i;
 
-        for (i = 0; i < ddata->n_buttons; i++) {
+        for (i = 0; i < ddata->pdata->nbuttons; i++) {
                 struct gpio_button_data *bdata = &ddata->data[i];
                 if (bdata->button->wakeup && device_may_wakeup(dev))
                         disable_irq_wake(bdata->irq);
@@ -822,7 +829,7 @@ static struct platform_driver gpio_keys_device_driver = {
                 .name   = "gpio-keys",
                 .owner  = THIS_MODULE,
                 .pm     = &gpio_keys_pm_ops,
-                .of_match_table = gpio_keys_of_match,
+                .of_match_table = of_match_ptr(gpio_keys_of_match),
         }
 };
 
diff --git a/drivers/input/keyboard/gpio_keys_polled.c b/drivers/input/keyboard/gpio_keys_polled.c
index 20c8ab172214..f2142de789e7 100644
--- a/drivers/input/keyboard/gpio_keys_polled.c
+++ b/drivers/input/keyboard/gpio_keys_polled.c
@@ -25,6 +25,8 @@
 #include <linux/platform_device.h>
 #include <linux/gpio.h>
 #include <linux/gpio_keys.h>
+#include <linux/of_platform.h>
+#include <linux/of_gpio.h>
 
 #define DRV_NAME        "gpio-keys-polled"
 
@@ -38,7 +40,7 @@ struct gpio_keys_button_data {
 struct gpio_keys_polled_dev {
         struct input_polled_dev *poll_dev;
         struct device *dev;
-        struct gpio_keys_platform_data *pdata;
+        const struct gpio_keys_platform_data *pdata;
         struct gpio_keys_button_data data[0];
 };
 
@@ -67,11 +69,11 @@ static void gpio_keys_polled_check_state(struct input_dev *input,
 static void gpio_keys_polled_poll(struct input_polled_dev *dev)
 {
         struct gpio_keys_polled_dev *bdev = dev->private;
-        struct gpio_keys_platform_data *pdata = bdev->pdata;
+        const struct gpio_keys_platform_data *pdata = bdev->pdata;
         struct input_dev *input = dev->input;
         int i;
 
-        for (i = 0; i < bdev->pdata->nbuttons; i++) {
+        for (i = 0; i < pdata->nbuttons; i++) {
                 struct gpio_keys_button_data *bdata = &bdev->data[i];
 
                 if (bdata->count < bdata->threshold)
@@ -85,7 +87,7 @@ static void gpio_keys_polled_poll(struct input_polled_dev *dev)
 static void gpio_keys_polled_open(struct input_polled_dev *dev)
 {
         struct gpio_keys_polled_dev *bdev = dev->private;
-        struct gpio_keys_platform_data *pdata = bdev->pdata;
+        const struct gpio_keys_platform_data *pdata = bdev->pdata;
 
         if (pdata->enable)
                 pdata->enable(bdev->dev);
@@ -94,31 +96,139 @@ static void gpio_keys_polled_open(struct input_polled_dev *dev)
 static void gpio_keys_polled_close(struct input_polled_dev *dev)
 {
         struct gpio_keys_polled_dev *bdev = dev->private;
-        struct gpio_keys_platform_data *pdata = bdev->pdata;
+        const struct gpio_keys_platform_data *pdata = bdev->pdata;
 
         if (pdata->disable)
                 pdata->disable(bdev->dev);
 }
 
+#ifdef CONFIG_OF
+static struct gpio_keys_platform_data * __devinit
+gpio_keys_polled_get_devtree_pdata(struct device *dev)
+{
+        struct device_node *node, *pp;
+        struct gpio_keys_platform_data *pdata;
+        struct gpio_keys_button *button;
+        int error;
+        int nbuttons;
+        int i;
+
+        node = dev->of_node;
+        if (!node)
+                return NULL;
+
+        nbuttons = of_get_child_count(node);
+        if (nbuttons == 0)
+                return NULL;
+
+        pdata = kzalloc(sizeof(*pdata) + nbuttons * (sizeof *button),
+                        GFP_KERNEL);
+        if (!pdata) {
+                error = -ENOMEM;
+                goto err_out;
+        }
+
+        pdata->buttons = (struct gpio_keys_button *)(pdata + 1);
+        pdata->nbuttons = nbuttons;
+
+        pdata->rep = !!of_get_property(node, "autorepeat", NULL);
+        of_property_read_u32(node, "poll-interval", &pdata->poll_interval);
+
+        i = 0;
+        for_each_child_of_node(node, pp) {
+                enum of_gpio_flags flags;
+
+                if (!of_find_property(pp, "gpios", NULL)) {
+                        pdata->nbuttons--;
+                        dev_warn(dev, "Found button without gpios\n");
+                        continue;
+                }
+
+                button = &pdata->buttons[i++];
+
+                button->gpio = of_get_gpio_flags(pp, 0, &flags);
+                button->active_low = flags & OF_GPIO_ACTIVE_LOW;
+
+                if (of_property_read_u32(pp, "linux,code", &button->code)) {
+                        dev_err(dev, "Button without keycode: 0x%x\n",
+                                button->gpio);
+                        error = -EINVAL;
+                        goto err_free_pdata;
+                }
+
+                button->desc = of_get_property(pp, "label", NULL);
+
+                if (of_property_read_u32(pp, "linux,input-type", &button->type))
+                        button->type = EV_KEY;
+
+                button->wakeup = !!of_get_property(pp, "gpio-key,wakeup", NULL);
+
+                if (of_property_read_u32(pp, "debounce-interval",
+                                         &button->debounce_interval))
+                        button->debounce_interval = 5;
+        }
+
+        if (pdata->nbuttons == 0) {
+                error = -EINVAL;
+                goto err_free_pdata;
+        }
+
+        return pdata;
+
+err_free_pdata:
+        kfree(pdata);
+err_out:
+        return ERR_PTR(error);
+}
+
+static struct of_device_id gpio_keys_polled_of_match[] = {
+        { .compatible = "gpio-keys-polled", },
+        { },
+};
+MODULE_DEVICE_TABLE(of, gpio_keys_polled_of_match);
+
+#else
+
+static inline struct gpio_keys_platform_data *
+gpio_keys_polled_get_devtree_pdata(struct device *dev)
+{
+        return NULL;
+}
+#endif
+
 static int __devinit gpio_keys_polled_probe(struct platform_device *pdev)
 {
-        struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
         struct device *dev = &pdev->dev;
+        const struct gpio_keys_platform_data *pdata = dev_get_platdata(dev);
         struct gpio_keys_polled_dev *bdev;
         struct input_polled_dev *poll_dev;
         struct input_dev *input;
         int error;
         int i;
 
-        if (!pdata || !pdata->poll_interval)
-                return -EINVAL;
+        if (!pdata) {
+                pdata = gpio_keys_polled_get_devtree_pdata(dev);
+                if (IS_ERR(pdata))
+                        return PTR_ERR(pdata);
+                if (!pdata) {
+                        dev_err(dev, "missing platform data\n");
+                        return -EINVAL;
+                }
+        }
+
+        if (!pdata->poll_interval) {
+                dev_err(dev, "missing poll_interval value\n");
+                error = -EINVAL;
+                goto err_free_pdata;
+        }
 
         bdev = kzalloc(sizeof(struct gpio_keys_polled_dev) +
                        pdata->nbuttons * sizeof(struct gpio_keys_button_data),
                        GFP_KERNEL);
         if (!bdev) {
                 dev_err(dev, "no memory for private data\n");
-                return -ENOMEM;
+                error = -ENOMEM;
+                goto err_free_pdata;
         }
 
         poll_dev = input_allocate_polled_device();
@@ -197,7 +307,7 @@ static int __devinit gpio_keys_polled_probe(struct platform_device *pdev)
         /* report initial state of the buttons */
         for (i = 0; i < pdata->nbuttons; i++)
                 gpio_keys_polled_check_state(input, &pdata->buttons[i],
-                                         &bdev->data[i]);
+                                             &bdev->data[i]);
 
         return 0;
 
@@ -209,15 +319,20 @@ err_free_gpio:
 
 err_free_bdev:
         kfree(bdev);
-
         platform_set_drvdata(pdev, NULL);
+
+err_free_pdata:
+        /* If we have no platform_data, we allocated pdata dynamically.  */
+        if (!dev_get_platdata(&pdev->dev))
+                kfree(pdata);
+
         return error;
 }
 
 static int __devexit gpio_keys_polled_remove(struct platform_device *pdev)
 {
         struct gpio_keys_polled_dev *bdev = platform_get_drvdata(pdev);
-        struct gpio_keys_platform_data *pdata = bdev->pdata;
+        const struct gpio_keys_platform_data *pdata = bdev->pdata;
         int i;
 
         input_unregister_polled_device(bdev->poll_dev);
@@ -227,6 +342,13 @@ static int __devexit gpio_keys_polled_remove(struct platform_device *pdev)
 
         input_free_polled_device(bdev->poll_dev);
 
+        /*
+         * If we had no platform_data, we allocated pdata dynamically and
+         * must free it here.
+         */
+        if (!dev_get_platdata(&pdev->dev))
+                kfree(pdata);
+
         kfree(bdev);
         platform_set_drvdata(pdev, NULL);
 
@@ -239,6 +361,7 @@ static struct platform_driver gpio_keys_polled_driver = {
         .driver = {
                 .name   = DRV_NAME,
                 .owner  = THIS_MODULE,
+                .of_match_table = of_match_ptr(gpio_keys_polled_of_match),
         },
 };
 module_platform_driver(gpio_keys_polled_driver);
diff --git a/drivers/input/keyboard/imx_keypad.c b/drivers/input/keyboard/imx_keypad.c
index ff4c0a87a25f..cdc252612c0b 100644
--- a/drivers/input/keyboard/imx_keypad.c
+++ b/drivers/input/keyboard/imx_keypad.c
@@ -358,6 +358,7 @@ static void imx_keypad_inhibit(struct imx_keypad *keypad)
         /* Inhibit KDI and KRI interrupts. */
         reg_val = readw(keypad->mmio_base + KPSR);
         reg_val &= ~(KBD_STAT_KRIE | KBD_STAT_KDIE);
+        reg_val |= KBD_STAT_KPKR | KBD_STAT_KPKD;
         writew(reg_val, keypad->mmio_base + KPSR);
 
         /* Colums as open drain and disable all rows */
@@ -515,7 +516,9 @@ static int __devinit imx_keypad_probe(struct platform_device *pdev)
         input_set_drvdata(input_dev, keypad);
 
         /* Ensure that the keypad will stay dormant until opened */
+        clk_prepare_enable(keypad->clk);
         imx_keypad_inhibit(keypad);
+        clk_disable_unprepare(keypad->clk);
 
         error = request_irq(irq, imx_keypad_irq_handler, 0,
                             pdev->name, keypad);
diff --git a/drivers/input/keyboard/nomadik-ske-keypad.c b/drivers/input/keyboard/nomadik-ske-keypad.c
index a880e7414202..49f5fa64e0b1 100644
--- a/drivers/input/keyboard/nomadik-ske-keypad.c
+++ b/drivers/input/keyboard/nomadik-ske-keypad.c
@@ -20,7 +20,7 @@
 #include <linux/clk.h>
 #include <linux/module.h>
 
-#include <plat/ske.h>
+#include <linux/platform_data/keypad-nomadik-ske.h>
 
 /* SKE_CR bits */
 #define SKE_KPMLT       (0x1 << 6)
diff --git a/drivers/input/keyboard/omap-keypad.c b/drivers/input/keyboard/omap-keypad.c
index a0222db4dc86..4a5fcc8026f5 100644
--- a/drivers/input/keyboard/omap-keypad.c
+++ b/drivers/input/keyboard/omap-keypad.c
@@ -35,13 +35,9 @@
 #include <linux/mutex.h>
 #include <linux/errno.h>
 #include <linux/slab.h>
-#include <asm/gpio.h>
-#include <plat/keypad.h>
-#include <plat/menelaus.h>
-#include <asm/irq.h>
-#include <mach/hardware.h>
-#include <asm/io.h>
-#include <plat/mux.h>
+#include <linux/gpio.h>
+#include <linux/platform_data/gpio-omap.h>
+#include <linux/platform_data/keypad-omap.h>
 
 #undef NEW_BOARD_LEARNING_MODE
 
@@ -96,28 +92,8 @@ static u8 get_row_gpio_val(struct omap_kp *omap_kp)
 
 static irqreturn_t omap_kp_interrupt(int irq, void *dev_id)
 {
-        struct omap_kp *omap_kp = dev_id;
-
         /* disable keyboard interrupt and schedule for handling */
-        if (cpu_is_omap24xx()) {
-                int i;
-
-                for (i = 0; i < omap_kp->rows; i++) {
-                        int gpio_irq = gpio_to_irq(row_gpios[i]);
-                        /*
-                         * The interrupt which we're currently handling should
-                         * be disabled _nosync() to avoid deadlocks waiting
-                         * for this handler to complete.  All others should
-                         * be disabled the regular way for SMP safety.
-                         */
-                        if (gpio_irq == irq)
-                                disable_irq_nosync(gpio_irq);
-                        else
-                                disable_irq(gpio_irq);
-                }
-        } else
-                /* disable keyboard interrupt and schedule for handling */
-                omap_writew(1, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT);
+        omap_writew(1, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT);
 
         tasklet_schedule(&kp_tasklet);
 
@@ -133,33 +109,22 @@ static void omap_kp_scan_keypad(struct omap_kp *omap_kp, unsigned char *state)
 {
         int col = 0;
 
-        /* read the keypad status */
-        if (cpu_is_omap24xx()) {
-                /* read the keypad status */
-                for (col = 0; col < omap_kp->cols; col++) {
-                        set_col_gpio_val(omap_kp, ~(1 << col));
-                        state[col] = ~(get_row_gpio_val(omap_kp)) & 0xff;
-                }
-                set_col_gpio_val(omap_kp, 0);
-
-        } else {
-                /* disable keyboard interrupt and schedule for handling */
-                omap_writew(1, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT);
+        /* disable keyboard interrupt and schedule for handling */
+        omap_writew(1, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT);
 
-                /* read the keypad status */
-                omap_writew(0xff, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBC);
-                for (col = 0; col < omap_kp->cols; col++) {
-                        omap_writew(~(1 << col) & 0xff,
-                                    OMAP1_MPUIO_BASE + OMAP_MPUIO_KBC);
+        /* read the keypad status */
+        omap_writew(0xff, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBC);
+        for (col = 0; col < omap_kp->cols; col++) {
+                omap_writew(~(1 << col) & 0xff,
+                            OMAP1_MPUIO_BASE + OMAP_MPUIO_KBC);
 
-                        udelay(omap_kp->delay);
+                udelay(omap_kp->delay);
 
-                        state[col] = ~omap_readw(OMAP1_MPUIO_BASE +
-                                                 OMAP_MPUIO_KBR_LATCH) & 0xff;
-                }
-                omap_writew(0x00, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBC);
-                udelay(2);
+                state[col] = ~omap_readw(OMAP1_MPUIO_BASE +
+                                         OMAP_MPUIO_KBR_LATCH) & 0xff;
         }
+        omap_writew(0x00, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBC);
+        udelay(2);
 }
 
 static void omap_kp_tasklet(unsigned long data)
@@ -214,7 +179,7 @@ static void omap_kp_tasklet(unsigned long data)
         memcpy(keypad_state, new_state, sizeof(keypad_state));
 
         if (key_down) {
-                int delay = HZ / 20;
+                int delay = HZ / 20;
                 /* some key is pressed - keep irq disabled and use timer
                  * to poll the keypad */
                 if (spurious)
@@ -222,14 +187,8 @@ static void omap_kp_tasklet(unsigned long data)
                 mod_timer(&omap_kp_data->timer, jiffies + delay);
         } else {
                 /* enable interrupts */
-                if (cpu_is_omap24xx()) {
-                        int i;
-                        for (i = 0; i < omap_kp_data->rows; i++)
-                                enable_irq(gpio_to_irq(row_gpios[i]));
-                } else {
-                        omap_writew(0, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT);
-                        kp_cur_group = -1;
-                }
+                omap_writew(0, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT);
+                kp_cur_group = -1;
         }
 }
 
@@ -242,6 +201,7 @@ static ssize_t omap_kp_enable_show(struct device *dev,
 static ssize_t omap_kp_enable_store(struct device *dev, struct device_attribute *attr,
                                     const char *buf, size_t count)
 {
+        struct omap_kp *omap_kp = dev_get_drvdata(dev);
         int state;
 
         if (sscanf(buf, "%u", &state) != 1)
@@ -253,9 +213,9 @@ static ssize_t omap_kp_enable_store(struct device *dev, struct device_attribute
         mutex_lock(&kp_enable_mutex);
         if (state != kp_enable) {
                 if (state)
-                        enable_irq(INT_KEYBOARD);
+                        enable_irq(omap_kp->irq);
                 else
-                        disable_irq(INT_KEYBOARD);
+                        disable_irq(omap_kp->irq);
                 kp_enable = state;
         }
         mutex_unlock(&kp_enable_mutex);
@@ -289,7 +249,7 @@ static int __devinit omap_kp_probe(struct platform_device *pdev)
         struct omap_kp *omap_kp;
         struct input_dev *input_dev;
         struct omap_kp_platform_data *pdata =  pdev->dev.platform_data;
-        int i, col_idx, row_idx, irq_idx, ret;
+        int i, col_idx, row_idx, ret;
         unsigned int row_shift, keycodemax;
 
         if (!pdata->rows || !pdata->cols || !pdata->keymap_data) {
@@ -314,8 +274,7 @@ static int __devinit omap_kp_probe(struct platform_device *pdev)
         omap_kp->input = input_dev;
 
         /* Disable the interrupt for the MPUIO keyboard */
-        if (!cpu_is_omap24xx())
-                omap_writew(1, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT);
+        omap_writew(1, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT);
 
         if (pdata->delay)
                 omap_kp->delay = pdata->delay;
@@ -328,31 +287,8 @@ static int __devinit omap_kp_probe(struct platform_device *pdev)
         omap_kp->rows = pdata->rows;
         omap_kp->cols = pdata->cols;
 
-        if (cpu_is_omap24xx()) {
-                /* Cols: outputs */
-                for (col_idx = 0; col_idx < omap_kp->cols; col_idx++) {
-                        if (gpio_request(col_gpios[col_idx], "omap_kp_col") < 0) {
-                                printk(KERN_ERR "Failed to request"
-                                       "GPIO%d for keypad\n",
-                                       col_gpios[col_idx]);
-                                goto err1;
-                        }
-                        gpio_direction_output(col_gpios[col_idx], 0);
-                }
-                /* Rows: inputs */
-                for (row_idx = 0; row_idx < omap_kp->rows; row_idx++) {
-                        if (gpio_request(row_gpios[row_idx], "omap_kp_row") < 0) {
-                                printk(KERN_ERR "Failed to request"
-                                       "GPIO%d for keypad\n",
-                                       row_gpios[row_idx]);
-                                goto err2;
-                        }
-                        gpio_direction_input(row_gpios[row_idx]);
-                }
-        } else {
-                col_idx = 0;
-                row_idx = 0;
-        }
+        col_idx = 0;
+        row_idx = 0;
 
         setup_timer(&omap_kp->timer, omap_kp_timer, (unsigned long)omap_kp);
 
@@ -394,37 +330,25 @@ static int __devinit omap_kp_probe(struct platform_device *pdev)
 
         /* scan current status and enable interrupt */
         omap_kp_scan_keypad(omap_kp, keypad_state);
-        if (!cpu_is_omap24xx()) {
-                omap_kp->irq = platform_get_irq(pdev, 0);
-                if (omap_kp->irq >= 0) {
-                        if (request_irq(omap_kp->irq, omap_kp_interrupt, 0,
-                                        "omap-keypad", omap_kp) < 0)
-                                goto err4;
-                }
-                omap_writew(0, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT);
-        } else {
-                for (irq_idx = 0; irq_idx < omap_kp->rows; irq_idx++) {
-                        if (request_irq(gpio_to_irq(row_gpios[irq_idx]),
-                                        omap_kp_interrupt,
-                                        IRQF_TRIGGER_FALLING,
-                                        "omap-keypad", omap_kp) < 0)
-                                goto err5;
-                }
+        omap_kp->irq = platform_get_irq(pdev, 0);
+        if (omap_kp->irq >= 0) {
+                if (request_irq(omap_kp->irq, omap_kp_interrupt, 0,
+                                "omap-keypad", omap_kp) < 0)
+                        goto err4;
         }
+        omap_writew(0, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT);
+
         return 0;
-err5:
-        for (i = irq_idx - 1; i >=0; i--)
-                free_irq(row_gpios[i], omap_kp);
+
 err4:
         input_unregister_device(omap_kp->input);
         input_dev = NULL;
 err3:
         device_remove_file(&pdev->dev, &dev_attr_enable);
 err2:
-        for (i = row_idx - 1; i >=0; i--)
+        for (i = row_idx - 1; i >= 0; i--)
                 gpio_free(row_gpios[i]);
-err1:
-        for (i = col_idx - 1; i >=0; i--)
+        for (i = col_idx - 1; i >= 0; i--)
                 gpio_free(col_gpios[i]);
 
         kfree(omap_kp);
@@ -439,18 +363,8 @@ static int __devexit omap_kp_remove(struct platform_device *pdev)
 
         /* disable keypad interrupt handling */
         tasklet_disable(&kp_tasklet);
-        if (cpu_is_omap24xx()) {
-                int i;
-                for (i = 0; i < omap_kp->cols; i++)
-                        gpio_free(col_gpios[i]);
-                for (i = 0; i < omap_kp->rows; i++) {
-                        gpio_free(row_gpios[i]);
-                        free_irq(gpio_to_irq(row_gpios[i]), omap_kp);
-                }
-        } else {
-                omap_writew(1, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT);
-                free_irq(omap_kp->irq, omap_kp);
-        }
+        omap_writew(1, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT);
+        free_irq(omap_kp->irq, omap_kp);
 
         del_timer_sync(&omap_kp->timer);
         tasklet_kill(&kp_tasklet);
diff --git a/drivers/input/keyboard/pxa27x_keypad.c b/drivers/input/keyboard/pxa27x_keypad.c
index 7f7b72464a37..803ff6fe021e 100644
--- a/drivers/input/keyboard/pxa27x_keypad.c
+++ b/drivers/input/keyboard/pxa27x_keypad.c
@@ -32,7 +32,7 @@
 #include <asm/mach/map.h>
 
 #include <mach/hardware.h>
-#include <plat/pxa27x_keypad.h>
+#include <linux/platform_data/keypad-pxa27x.h>
 /*
  * Keypad Controller registers
  */
diff --git a/drivers/input/keyboard/pxa930_rotary.c b/drivers/input/keyboard/pxa930_rotary.c
index d7f1134b789e..41488f9add20 100644
--- a/drivers/input/keyboard/pxa930_rotary.c
+++ b/drivers/input/keyboard/pxa930_rotary.c
@@ -15,7 +15,7 @@
 #include <linux/io.h>
 #include <linux/slab.h>
 
-#include <mach/pxa930_rotary.h>
+#include <linux/platform_data/keyboard-pxa930_rotary.h>
 
 #define SBCR    (0x04)
 #define ERCR    (0x0c)
diff --git a/drivers/input/keyboard/qt2160.c b/drivers/input/keyboard/qt2160.c
index e7a5e36e1203..76b7d430d03a 100644
--- a/drivers/input/keyboard/qt2160.c
+++ b/drivers/input/keyboard/qt2160.c
@@ -156,8 +156,7 @@ static irqreturn_t qt2160_irq(int irq, void *_qt2160)
 
         spin_lock_irqsave(&qt2160->lock, flags);
 
-        __cancel_delayed_work(&qt2160->dwork);
-        schedule_delayed_work(&qt2160->dwork, 0);
+        mod_delayed_work(system_wq, &qt2160->dwork, 0);
 
         spin_unlock_irqrestore(&qt2160->lock, flags);
 
diff --git a/drivers/input/keyboard/samsung-keypad.c b/drivers/input/keyboard/samsung-keypad.c
index a061ba603a29..277e26dc910e 100644
--- a/drivers/input/keyboard/samsung-keypad.c
+++ b/drivers/input/keyboard/samsung-keypad.c
@@ -256,7 +256,7 @@ static struct samsung_keypad_platdata *samsung_keypad_parse_dt(
         struct matrix_keymap_data *keymap_data;
         uint32_t *keymap, num_rows = 0, num_cols = 0;
         struct device_node *np = dev->of_node, *key_np;
-        unsigned int key_count = 0;
+        unsigned int key_count;
 
         pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
         if (!pdata) {
@@ -280,9 +280,7 @@ static struct samsung_keypad_platdata *samsung_keypad_parse_dt(
         }
         pdata->keymap_data = keymap_data;
 
-        for_each_child_of_node(np, key_np)
-                key_count++;
-
+        key_count = of_get_child_count(np);
         keymap_data->keymap_size = key_count;
         keymap = devm_kzalloc(dev, sizeof(uint32_t) * key_count, GFP_KERNEL);
         if (!keymap) {
@@ -662,8 +660,6 @@ static const struct of_device_id samsung_keypad_dt_match[] = {
         {},
 };
 MODULE_DEVICE_TABLE(of, samsung_keypad_dt_match);
-#else
-#define samsung_keypad_dt_match NULL
 #endif
 
 static struct platform_device_id samsung_keypad_driver_ids[] = {
@@ -684,7 +680,7 @@ static struct platform_driver samsung_keypad_driver = {
         .driver         = {
                 .name   = "samsung-keypad",
                 .owner  = THIS_MODULE,
-                .of_match_table = samsung_keypad_dt_match,
+                .of_match_table = of_match_ptr(samsung_keypad_dt_match),
                 .pm     = &samsung_keypad_pm_ops,
         },
         .id_table       = samsung_keypad_driver_ids,
diff --git a/drivers/input/keyboard/spear-keyboard.c b/drivers/input/keyboard/spear-keyboard.c
index 72ef01be3360..c7ca97f44bfb 100644
--- a/drivers/input/keyboard/spear-keyboard.c
+++ b/drivers/input/keyboard/spear-keyboard.c
@@ -24,7 +24,7 @@
 #include <linux/pm_wakeup.h>
 #include <linux/slab.h>
 #include <linux/types.h>
-#include <plat/keyboard.h>
+#include <linux/platform_data/keyboard-spear.h>
 
 /* Keyboard Registers */
 #define MODE_CTL_REG    0x00
diff --git a/drivers/input/keyboard/tegra-kbc.c b/drivers/input/keyboard/tegra-kbc.c
index 2c1c9ed1bd9f..5faaf2553e33 100644
--- a/drivers/input/keyboard/tegra-kbc.c
+++ b/drivers/input/keyboard/tegra-kbc.c
@@ -29,8 +29,8 @@
 #include <linux/of.h>
 #include <linux/clk.h>
 #include <linux/slab.h>
+#include <linux/input/tegra_kbc.h>
 #include <mach/clk.h>
-#include <mach/kbc.h>
 
 #define KBC_MAX_DEBOUNCE_CNT    0x3ffu
 
diff --git a/drivers/input/keyboard/w90p910_keypad.c b/drivers/input/keyboard/w90p910_keypad.c
index 085ede4d972d..e0f6cd1ad0fd 100644
--- a/drivers/input/keyboard/w90p910_keypad.c
+++ b/drivers/input/keyboard/w90p910_keypad.c
@@ -21,7 +21,7 @@
 #include <linux/io.h>
 #include <linux/slab.h>
 
-#include <mach/w90p910_keypad.h>
+#include <linux/platform_data/keypad-w90p910.h>
 
 /* Keypad Interface Control Registers */
 #define KPI_CONF                0x00
diff --git a/drivers/input/misc/ab8500-ponkey.c b/drivers/input/misc/ab8500-ponkey.c
index f06231b7cab1..84ec691c05aa 100644
--- a/drivers/input/misc/ab8500-ponkey.c
+++ b/drivers/input/misc/ab8500-ponkey.c
@@ -74,8 +74,8 @@ static int __devinit ab8500_ponkey_probe(struct platform_device *pdev)
 
         ponkey->idev = input;
         ponkey->ab8500 = ab8500;
-        ponkey->irq_dbf = ab8500_irq_get_virq(ab8500, irq_dbf);
-        ponkey->irq_dbr = ab8500_irq_get_virq(ab8500, irq_dbr);
+        ponkey->irq_dbf = irq_dbf;
+        ponkey->irq_dbr = irq_dbr;
 
         input->name = "AB8500 POn(PowerOn) Key";
         input->dev.parent = &pdev->dev;
diff --git a/drivers/input/misc/atlas_btns.c b/drivers/input/misc/atlas_btns.c
index 601f7372f9c4..26f13131639a 100644
--- a/drivers/input/misc/atlas_btns.c
+++ b/drivers/input/misc/atlas_btns.c
@@ -151,22 +151,7 @@ static struct acpi_driver atlas_acpi_driver = {
                 .remove = atlas_acpi_button_remove,
         },
 };
-
-static int __init atlas_acpi_init(void)
-{
-        if (acpi_disabled)
-                return -ENODEV;
-
-        return acpi_bus_register_driver(&atlas_acpi_driver);
-}
-
-static void __exit atlas_acpi_exit(void)
-{
-        acpi_bus_unregister_driver(&atlas_acpi_driver);
-}
-
-module_init(atlas_acpi_init);
-module_exit(atlas_acpi_exit);
+module_acpi_driver(atlas_acpi_driver);
 
 MODULE_AUTHOR("Jaya Kumar");
 MODULE_LICENSE("GPL");
diff --git a/drivers/input/misc/rotary_encoder.c b/drivers/input/misc/rotary_encoder.c
index f07f784198b9..99a49e4968d2 100644
--- a/drivers/input/misc/rotary_encoder.c
+++ b/drivers/input/misc/rotary_encoder.c
@@ -24,12 +24,14 @@
 #include <linux/gpio.h>
 #include <linux/rotary_encoder.h>
 #include <linux/slab.h>
+#include <linux/of_platform.h>
+#include <linux/of_gpio.h>
 
 #define DRV_NAME "rotary-encoder"
 
 struct rotary_encoder {
         struct input_dev *input;
-        struct rotary_encoder_platform_data *pdata;
+        const struct rotary_encoder_platform_data *pdata;
 
         unsigned int axis;
         unsigned int pos;
@@ -43,7 +45,7 @@ struct rotary_encoder {
         char last_stable;
 };
 
-static int rotary_encoder_get_state(struct rotary_encoder_platform_data *pdata)
+static int rotary_encoder_get_state(const struct rotary_encoder_platform_data *pdata)
 {
         int a = !!gpio_get_value(pdata->gpio_a);
         int b = !!gpio_get_value(pdata->gpio_b);
@@ -56,7 +58,7 @@ static int rotary_encoder_get_state(struct rotary_encoder_platform_data *pdata)
 
 static void rotary_encoder_report_event(struct rotary_encoder *encoder)
 {
-        struct rotary_encoder_platform_data *pdata = encoder->pdata;
+        const struct rotary_encoder_platform_data *pdata = encoder->pdata;
 
         if (pdata->relative_axis) {
                 input_report_rel(encoder->input,
@@ -140,36 +142,89 @@ static irqreturn_t rotary_encoder_half_period_irq(int irq, void *dev_id)
         return IRQ_HANDLED;
 }
 
+#ifdef CONFIG_OF
+static struct of_device_id rotary_encoder_of_match[] = {
+        { .compatible = "rotary-encoder", },
+        { },
+};
+MODULE_DEVICE_TABLE(of, rotary_encoder_of_match);
+
+static struct rotary_encoder_platform_data * __devinit
+rotary_encoder_parse_dt(struct device *dev)
+{
+        const struct of_device_id *of_id =
+                                of_match_device(rotary_encoder_of_match, dev);
+        struct device_node *np = dev->of_node;
+        struct rotary_encoder_platform_data *pdata;
+        enum of_gpio_flags flags;
+
+        if (!of_id || !np)
+                return NULL;
+
+        pdata = kzalloc(sizeof(struct rotary_encoder_platform_data),
+                        GFP_KERNEL);
+        if (!pdata)
+                return ERR_PTR(-ENOMEM);
+
+        of_property_read_u32(np, "rotary-encoder,steps", &pdata->steps);
+        of_property_read_u32(np, "linux,axis", &pdata->axis);
+
+        pdata->gpio_a = of_get_gpio_flags(np, 0, &flags);
+        pdata->inverted_a = flags & OF_GPIO_ACTIVE_LOW;
+
+        pdata->gpio_b = of_get_gpio_flags(np, 1, &flags);
+        pdata->inverted_b = flags & OF_GPIO_ACTIVE_LOW;
+
+        pdata->relative_axis = !!of_get_property(np,
+                                        "rotary-encoder,relative-axis", NULL);
+        pdata->rollover = !!of_get_property(np,
+                                        "rotary-encoder,rollover", NULL);
+        pdata->half_period = !!of_get_property(np,
+                                        "rotary-encoder,half-period", NULL);
+
+        return pdata;
+}
+#else
+static inline struct rotary_encoder_platform_data *
+rotary_encoder_parse_dt(struct device *dev)
+{
+        return NULL;
+}
+#endif
+
 static int __devinit rotary_encoder_probe(struct platform_device *pdev)
 {
-        struct rotary_encoder_platform_data *pdata = pdev->dev.platform_data;
+        struct device *dev = &pdev->dev;
+        const struct rotary_encoder_platform_data *pdata = dev_get_platdata(dev);
         struct rotary_encoder *encoder;
         struct input_dev *input;
         irq_handler_t handler;
         int err;
 
         if (!pdata) {
-                dev_err(&pdev->dev, "missing platform data\n");
-                return -ENOENT;
+                pdata = rotary_encoder_parse_dt(dev);
+                if (IS_ERR(pdata))
+                        return PTR_ERR(pdata);
+
+                if (!pdata) {
+                        dev_err(dev, "missing platform data\n");
+                        return -EINVAL;
+                }
         }
 
         encoder = kzalloc(sizeof(struct rotary_encoder), GFP_KERNEL);
         input = input_allocate_device();
         if (!encoder || !input) {
-                dev_err(&pdev->dev, "failed to allocate memory for device\n");
                 err = -ENOMEM;
                 goto exit_free_mem;
         }
 
         encoder->input = input;
         encoder->pdata = pdata;
-        encoder->irq_a = gpio_to_irq(pdata->gpio_a);
-        encoder->irq_b = gpio_to_irq(pdata->gpio_b);
 
-        /* create and register the input driver */
         input->name = pdev->name;
         input->id.bustype = BUS_HOST;
-        input->dev.parent = &pdev->dev;
+        input->dev.parent = dev;
 
         if (pdata->relative_axis) {
                 input->evbit[0] = BIT_MASK(EV_REL);
@@ -180,40 +235,21 @@ static int __devinit rotary_encoder_probe(struct platform_device *pdev)
                                      pdata->axis, 0, pdata->steps, 0, 1);
         }
 
-        err = input_register_device(input);
-        if (err) {
-                dev_err(&pdev->dev, "failed to register input device\n");
-                goto exit_free_mem;
-        }
-
         /* request the GPIOs */
-        err = gpio_request(pdata->gpio_a, DRV_NAME);
-        if (err) {
-                dev_err(&pdev->dev, "unable to request GPIO %d\n",
-                        pdata->gpio_a);
-                goto exit_unregister_input;
-        }
-
-        err = gpio_direction_input(pdata->gpio_a);
+        err = gpio_request_one(pdata->gpio_a, GPIOF_IN, dev_name(dev));
         if (err) {
-                dev_err(&pdev->dev, "unable to set GPIO %d for input\n",
-                        pdata->gpio_a);
-                goto exit_unregister_input;
+                dev_err(dev, "unable to request GPIO %d\n", pdata->gpio_a);
+                goto exit_free_mem;
         }
 
-        err = gpio_request(pdata->gpio_b, DRV_NAME);
+        err = gpio_request_one(pdata->gpio_b, GPIOF_IN, dev_name(dev));
         if (err) {
-                dev_err(&pdev->dev, "unable to request GPIO %d\n",
-                        pdata->gpio_b);
+                dev_err(dev, "unable to request GPIO %d\n", pdata->gpio_b);
                 goto exit_free_gpio_a;
         }
 
-        err = gpio_direction_input(pdata->gpio_b);
-        if (err) {
-                dev_err(&pdev->dev, "unable to set GPIO %d for input\n",
-                        pdata->gpio_b);
-                goto exit_free_gpio_a;
-        }
+        encoder->irq_a = gpio_to_irq(pdata->gpio_a);
+        encoder->irq_b = gpio_to_irq(pdata->gpio_b);
 
         /* request the IRQs */
         if (pdata->half_period) {
@@ -227,8 +263,7 @@ static int __devinit rotary_encoder_probe(struct platform_device *pdev)
                           IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
                           DRV_NAME, encoder);
         if (err) {
-                dev_err(&pdev->dev, "unable to request IRQ %d\n",
-                        encoder->irq_a);
+                dev_err(dev, "unable to request IRQ %d\n", encoder->irq_a);
                 goto exit_free_gpio_b;
         }
 
@@ -236,43 +271,55 @@ static int __devinit rotary_encoder_probe(struct platform_device *pdev)
                           IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
                           DRV_NAME, encoder);
         if (err) {
-                dev_err(&pdev->dev, "unable to request IRQ %d\n",
-                        encoder->irq_b);
+                dev_err(dev, "unable to request IRQ %d\n", encoder->irq_b);
                 goto exit_free_irq_a;
         }
 
+        err = input_register_device(input);
+        if (err) {
+                dev_err(dev, "failed to register input device\n");
+                goto exit_free_irq_b;
+        }
+
         platform_set_drvdata(pdev, encoder);
 
         return 0;
 
+exit_free_irq_b:
+        free_irq(encoder->irq_b, encoder);
 exit_free_irq_a:
         free_irq(encoder->irq_a, encoder);
 exit_free_gpio_b:
         gpio_free(pdata->gpio_b);
 exit_free_gpio_a:
         gpio_free(pdata->gpio_a);
-exit_unregister_input:
-        input_unregister_device(input);
-        input = NULL; /* so we don't try to free it */
 exit_free_mem:
         input_free_device(input);
         kfree(encoder);
+        if (!dev_get_platdata(&pdev->dev))
+                kfree(pdata);
+
         return err;
 }
 
 static int __devexit rotary_encoder_remove(struct platform_device *pdev)
 {
         struct rotary_encoder *encoder = platform_get_drvdata(pdev);
-        struct rotary_encoder_platform_data *pdata = pdev->dev.platform_data;
+        const struct rotary_encoder_platform_data *pdata = encoder->pdata;
 
         free_irq(encoder->irq_a, encoder);
         free_irq(encoder->irq_b, encoder);
         gpio_free(pdata->gpio_a);
         gpio_free(pdata->gpio_b);
+
         input_unregister_device(encoder->input);
-        platform_set_drvdata(pdev, NULL);
         kfree(encoder);
 
+        if (!dev_get_platdata(&pdev->dev))
+                kfree(pdata);
+
+        platform_set_drvdata(pdev, NULL);
+
         return 0;
 }
 
@@ -282,6 +329,7 @@ static struct platform_driver rotary_encoder_driver = {
         .driver         = {
                 .name   = DRV_NAME,
                 .owner  = THIS_MODULE,
+                .of_match_table = of_match_ptr(rotary_encoder_of_match),
         }
 };
 module_platform_driver(rotary_encoder_driver);
diff --git a/drivers/input/misc/twl4030-pwrbutton.c b/drivers/input/misc/twl4030-pwrbutton.c
index 38e4b507b94c..b3dd96d6448b 100644
--- a/drivers/input/misc/twl4030-pwrbutton.c
+++ b/drivers/input/misc/twl4030-pwrbutton.c
@@ -42,6 +42,7 @@ static irqreturn_t powerbutton_irq(int irq, void *_pwr)
         err = twl_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &value,
                                 STS_HW_CONDITIONS);
         if (!err)  {
+                pm_wakeup_event(pwr->dev.parent, 0);
                 input_report_key(pwr, KEY_POWER, value & PWR_PWRON_IRQ);
                 input_sync(pwr);
         } else {
diff --git a/drivers/input/misc/twl4030-vibra.c b/drivers/input/misc/twl4030-vibra.c
index fc0ed9b43424..2194a3c7236a 100644
--- a/drivers/input/misc/twl4030-vibra.c
+++ b/drivers/input/misc/twl4030-vibra.c
@@ -26,6 +26,7 @@
 #include <linux/module.h>
 #include <linux/jiffies.h>
 #include <linux/platform_device.h>
+#include <linux/of.h>
 #include <linux/workqueue.h>
 #include <linux/i2c/twl.h>
 #include <linux/mfd/twl4030-audio.h>
@@ -194,13 +195,26 @@ static int twl4030_vibra_resume(struct device *dev)
 static SIMPLE_DEV_PM_OPS(twl4030_vibra_pm_ops,
                          twl4030_vibra_suspend, twl4030_vibra_resume);
 
+static bool twl4030_vibra_check_coexist(struct twl4030_vibra_data *pdata,
+                              struct device_node *node)
+{
+        if (pdata && pdata->coexist)
+                return true;
+
+        if (of_find_node_by_name(node, "codec"))
+                return true;
+
+        return false;
+}
+
 static int __devinit twl4030_vibra_probe(struct platform_device *pdev)
 {
         struct twl4030_vibra_data *pdata = pdev->dev.platform_data;
+        struct device_node *twl4030_core_node = pdev->dev.parent->of_node;
         struct vibra_info *info;
         int ret;
 
-        if (!pdata) {
+        if (!pdata && !twl4030_core_node) {
                 dev_dbg(&pdev->dev, "platform_data not available\n");
                 return -EINVAL;
         }
@@ -210,7 +224,7 @@ static int __devinit twl4030_vibra_probe(struct platform_device *pdev)
                 return -ENOMEM;
 
         info->dev = &pdev->dev;
-        info->coexist = pdata->coexist;
+        info->coexist = twl4030_vibra_check_coexist(pdata, twl4030_core_node);
         INIT_WORK(&info->play_work, vibra_play_work);
 
         info->input_dev = input_allocate_device();
diff --git a/drivers/input/misc/uinput.c b/drivers/input/misc/uinput.c
index 736056897e50..a0a4bbaef02c 100644
--- a/drivers/input/misc/uinput.c
+++ b/drivers/input/misc/uinput.c
@@ -40,7 +40,8 @@
 #include <linux/input/mt.h>
 #include "../input-compat.h"
 
-static int uinput_dev_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
+static int uinput_dev_event(struct input_dev *dev,
+                            unsigned int type, unsigned int code, int value)
 {
         struct uinput_device    *udev = input_get_drvdata(dev);
 
@@ -56,10 +57,11 @@ static int uinput_dev_event(struct input_dev *dev, unsigned int type, unsigned i
 }
 
 /* Atomically allocate an ID for the given request. Returns 0 on success. */
-static int uinput_request_alloc_id(struct uinput_device *udev, struct uinput_request *request)
+static bool uinput_request_alloc_id(struct uinput_device *udev,
+                                    struct uinput_request *request)
 {
-        int id;
-        int err = -1;
+        unsigned int id;
+        bool reserved = false;
 
         spin_lock(&udev->requests_lock);
 
@@ -67,32 +69,35 @@ static int uinput_request_alloc_id(struct uinput_device *udev, struct uinput_req
                 if (!udev->requests[id]) {
                         request->id = id;
                         udev->requests[id] = request;
-                        err = 0;
+                        reserved = true;
                         break;
                 }
         }
 
         spin_unlock(&udev->requests_lock);
-        return err;
+        return reserved;
 }
 
-static struct uinput_request *uinput_request_find(struct uinput_device *udev, int id)
+static struct uinput_request *uinput_request_find(struct uinput_device *udev,
+                                                  unsigned int id)
 {
         /* Find an input request, by ID. Returns NULL if the ID isn't valid. */
-        if (id >= UINPUT_NUM_REQUESTS || id < 0)
+        if (id >= UINPUT_NUM_REQUESTS)
                 return NULL;
 
         return udev->requests[id];
 }
 
-static inline int uinput_request_reserve_slot(struct uinput_device *udev, struct uinput_request *request)
+static int uinput_request_reserve_slot(struct uinput_device *udev,
+                                       struct uinput_request *request)
 {
         /* Allocate slot. If none are available right away, wait. */
         return wait_event_interruptible(udev->requests_waitq,
-                                        !uinput_request_alloc_id(udev, request));
+                                        uinput_request_alloc_id(udev, request));
 }
 
-static void uinput_request_done(struct uinput_device *udev, struct uinput_request *request)
+static void uinput_request_done(struct uinput_device *udev,
+                                struct uinput_request *request)
 {
         /* Mark slot as available */
         udev->requests[request->id] = NULL;
@@ -101,14 +106,11 @@ static void uinput_request_done(struct uinput_device *udev, struct uinput_reques
         complete(&request->done);
 }
 
-static int uinput_request_submit(struct uinput_device *udev, struct uinput_request *request)
+static int uinput_request_send(struct uinput_device *udev,
+                               struct uinput_request *request)
 {
         int retval;
 
-        retval = uinput_request_reserve_slot(udev, request);
-        if (retval)
-                return retval;
-
         retval = mutex_lock_interruptible(&udev->mutex);
         if (retval)
                 return retval;
@@ -118,7 +120,12 @@ static int uinput_request_submit(struct uinput_device *udev, struct uinput_reque
                 goto out;
         }
 
-        /* Tell our userspace app about this new request by queueing an input event */
+        init_completion(&request->done);
+
+        /*
+         * Tell our userspace application about this new request
+         * by queueing an input event.
+         */
         uinput_dev_event(udev->dev, EV_UINPUT, request->code, request->id);
 
  out:
@@ -126,8 +133,27 @@ static int uinput_request_submit(struct uinput_device *udev, struct uinput_reque
         return retval;
 }
 
+static int uinput_request_submit(struct uinput_device *udev,
+                                 struct uinput_request *request)
+{
+        int error;
+
+        error = uinput_request_reserve_slot(udev, request);
+        if (error)
+                return error;
+
+        error = uinput_request_send(udev, request);
+        if (error) {
+                uinput_request_done(udev, request);
+                return error;
+        }
+
+        wait_for_completion(&request->done);
+        return request->retval;
+}
+
 /*
- * Fail all ouitstanding requests so handlers don't wait for the userspace
+ * Fail all outstanding requests so handlers don't wait for the userspace
  * to finish processing them.
  */
 static void uinput_flush_requests(struct uinput_device *udev)
@@ -163,11 +189,12 @@ static int uinput_dev_playback(struct input_dev *dev, int effect_id, int value)
         return uinput_dev_event(dev, EV_FF, effect_id, value);
 }
 
-static int uinput_dev_upload_effect(struct input_dev *dev, struct ff_effect *effect, struct ff_effect *old)
+static int uinput_dev_upload_effect(struct input_dev *dev,
+                                    struct ff_effect *effect,
+                                    struct ff_effect *old)
 {
         struct uinput_device *udev = input_get_drvdata(dev);
         struct uinput_request request;
-        int retval;
 
         /*
          * uinput driver does not currently support periodic effects with
@@ -180,42 +207,25 @@ static int uinput_dev_upload_effect(struct input_dev *dev, struct ff_effect *eff
                         effect->u.periodic.waveform == FF_CUSTOM)
                 return -EINVAL;
 
-        request.id = -1;
-        init_completion(&request.done);
         request.code = UI_FF_UPLOAD;
         request.u.upload.effect = effect;
         request.u.upload.old = old;
 
-        retval = uinput_request_submit(udev, &request);
-        if (!retval) {
-                wait_for_completion(&request.done);
-                retval = request.retval;
-        }
-
-        return retval;
+        return uinput_request_submit(udev, &request);
 }
 
 static int uinput_dev_erase_effect(struct input_dev *dev, int effect_id)
 {
         struct uinput_device *udev = input_get_drvdata(dev);
         struct uinput_request request;
-        int retval;
 
         if (!test_bit(EV_FF, dev->evbit))
                 return -ENOSYS;
 
-        request.id = -1;
-        init_completion(&request.done);
         request.code = UI_FF_ERASE;
         request.u.effect_id = effect_id;
 
-        retval = uinput_request_submit(udev, &request);
-        if (!retval) {
-                wait_for_completion(&request.done);
-                retval = request.retval;
-        }
-
-        return retval;
+        return uinput_request_submit(udev, &request);
 }
 
 static void uinput_destroy_device(struct uinput_device *udev)
@@ -347,7 +357,8 @@ static int uinput_allocate_device(struct uinput_device *udev)
         return 0;
 }
 
-static int uinput_setup_device(struct uinput_device *udev, const char __user *buffer, size_t count)
+static int uinput_setup_device(struct uinput_device *udev,
+                               const char __user *buffer, size_t count)
 {
         struct uinput_user_dev  *user_dev;
         struct input_dev        *dev;
@@ -405,7 +416,7 @@ static int uinput_setup_device(struct uinput_device *udev, const char __user *bu
                         goto exit;
                 if (test_bit(ABS_MT_SLOT, dev->absbit)) {
                         int nslot = input_abs_get_max(dev, ABS_MT_SLOT) + 1;
-                        input_mt_init_slots(dev, nslot);
+                        input_mt_init_slots(dev, nslot, 0);
                 } else if (test_bit(ABS_MT_POSITION_X, dev->absbit)) {
                         input_set_events_per_packet(dev, 60);
                 }
@@ -419,7 +430,8 @@ static int uinput_setup_device(struct uinput_device *udev, const char __user *bu
         return retval;
 }
 
-static inline ssize_t uinput_inject_event(struct uinput_device *udev, const char __user *buffer, size_t count)
+static ssize_t uinput_inject_event(struct uinput_device *udev,
+                                   const char __user *buffer, size_t count)
 {
         struct input_event ev;
 
@@ -434,11 +446,15 @@ static inline ssize_t uinput_inject_event(struct uinput_device *udev, const char
         return input_event_size();
 }
 
-static ssize_t uinput_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
+static ssize_t uinput_write(struct file *file, const char __user *buffer,
+                            size_t count, loff_t *ppos)
 {
         struct uinput_device *udev = file->private_data;
         int retval;
 
+        if (count == 0)
+                return 0;
+
         retval = mutex_lock_interruptible(&udev->mutex);
         if (retval)
                 return retval;
@@ -452,42 +468,74 @@ static ssize_t uinput_write(struct file *file, const char __user *buffer, size_t
         return retval;
 }
 
-static ssize_t uinput_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
+static bool uinput_fetch_next_event(struct uinput_device *udev,
+                                    struct input_event *event)
 {
-        struct uinput_device *udev = file->private_data;
-        int retval = 0;
+        bool have_event;
 
-        if (udev->state != UIST_CREATED)
-                return -ENODEV;
+        spin_lock_irq(&udev->dev->event_lock);
 
-        if (udev->head == udev->tail && (file->f_flags & O_NONBLOCK))
-                return -EAGAIN;
+        have_event = udev->head != udev->tail;
+        if (have_event) {
+                *event = udev->buff[udev->tail];
+                udev->tail = (udev->tail + 1) % UINPUT_BUFFER_SIZE;
+        }
 
-        retval = wait_event_interruptible(udev->waitq,
-                        udev->head != udev->tail || udev->state != UIST_CREATED);
-        if (retval)
-                return retval;
+        spin_unlock_irq(&udev->dev->event_lock);
 
-        retval = mutex_lock_interruptible(&udev->mutex);
-        if (retval)
-                return retval;
+        return have_event;
+}
 
-        if (udev->state != UIST_CREATED) {
-                retval = -ENODEV;
-                goto out;
-        }
+static ssize_t uinput_events_to_user(struct uinput_device *udev,
+                                     char __user *buffer, size_t count)
+{
+        struct input_event event;
+        size_t read = 0;
 
-        while (udev->head != udev->tail && retval + input_event_size() <= count) {
-                if (input_event_to_user(buffer + retval, &udev->buff[udev->tail])) {
-                        retval = -EFAULT;
-                        goto out;
-                }
-                udev->tail = (udev->tail + 1) % UINPUT_BUFFER_SIZE;
-                retval += input_event_size();
+        while (read + input_event_size() <= count &&
+               uinput_fetch_next_event(udev, &event)) {
+
+                if (input_event_to_user(buffer + read, &event))
+                        return -EFAULT;
+
+                read += input_event_size();
         }
 
- out:
-        mutex_unlock(&udev->mutex);
+        return read;
+}
+
+static ssize_t uinput_read(struct file *file, char __user *buffer,
+                           size_t count, loff_t *ppos)
+{
+        struct uinput_device *udev = file->private_data;
+        ssize_t retval;
+
+        if (count != 0 && count < input_event_size())
+                return -EINVAL;
+
+        do {
+                retval = mutex_lock_interruptible(&udev->mutex);
+                if (retval)
+                        return retval;
+
+                if (udev->state != UIST_CREATED)
+                        retval = -ENODEV;
+                else if (udev->head == udev->tail &&
+                         (file->f_flags & O_NONBLOCK))
+                        retval = -EAGAIN;
+                else
+                        retval = uinput_events_to_user(udev, buffer, count);
+
+                mutex_unlock(&udev->mutex);
+
+                if (retval || count == 0)
+                        break;
+
+                if (!(file->f_flags & O_NONBLOCK))
+                        retval = wait_event_interruptible(udev->waitq,
+                                                  udev->head != udev->tail ||
+                                                  udev->state != UIST_CREATED);
+        } while (retval == 0);
 
         return retval;
 }
@@ -516,8 +564,8 @@ static int uinput_release(struct inode *inode, struct file *file)
 
 #ifdef CONFIG_COMPAT
 struct uinput_ff_upload_compat {
-        int                     request_id;
-        int                     retval;
+        __u32                   request_id;
+        __s32                   retval;
         struct ff_effect_compat effect;
         struct ff_effect_compat old;
 };
@@ -703,7 +751,8 @@ static long uinput_ioctl_handler(struct file *file, unsigned int cmd,
                                 break;
 
                         req = uinput_request_find(udev, ff_up.request_id);
-                        if (!req || req->code != UI_FF_UPLOAD || !req->u.upload.effect) {
+                        if (!req || req->code != UI_FF_UPLOAD ||
+                            !req->u.upload.effect) {
                                 retval = -EINVAL;
                                 break;
                         }
@@ -786,7 +835,8 @@ static long uinput_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 }
 
 #ifdef CONFIG_COMPAT
-static long uinput_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+static long uinput_compat_ioctl(struct file *file,
+                                unsigned int cmd, unsigned long arg)
 {
         return uinput_ioctl_handler(file, cmd, arg, compat_ptr(arg));
 }
@@ -831,4 +881,3 @@ MODULE_VERSION("0.3");
 
 module_init(uinput_init);
 module_exit(uinput_exit);
-
diff --git a/drivers/input/mouse/alps.c b/drivers/input/mouse/alps.c
index 4a1347e91bdc..cf5af1f495ec 100644
--- a/drivers/input/mouse/alps.c
+++ b/drivers/input/mouse/alps.c
@@ -1620,7 +1620,7 @@ int alps_init(struct psmouse *psmouse)
         case ALPS_PROTO_V3:
         case ALPS_PROTO_V4:
                 set_bit(INPUT_PROP_SEMI_MT, dev1->propbit);
-                input_mt_init_slots(dev1, 2);
+                input_mt_init_slots(dev1, 2, 0);
                 input_set_abs_params(dev1, ABS_MT_POSITION_X, 0, ALPS_V3_X_MAX, 0, 0);
                 input_set_abs_params(dev1, ABS_MT_POSITION_Y, 0, ALPS_V3_Y_MAX, 0, 0);
 
diff --git a/drivers/input/mouse/bcm5974.c b/drivers/input/mouse/bcm5974.c
index d528c23e194f..3a78f235fa3e 100644
--- a/drivers/input/mouse/bcm5974.c
+++ b/drivers/input/mouse/bcm5974.c
@@ -40,6 +40,7 @@
 #include <linux/usb/input.h>
 #include <linux/hid.h>
 #include <linux/mutex.h>
+#include <linux/input/mt.h>
 
 #define USB_VENDOR_ID_APPLE             0x05ac
 
@@ -183,26 +184,26 @@ struct tp_finger {
         __le16 abs_y;           /* absolute y coodinate */
         __le16 rel_x;           /* relative x coodinate */
         __le16 rel_y;           /* relative y coodinate */
-        __le16 size_major;      /* finger size, major axis? */
-        __le16 size_minor;      /* finger size, minor axis? */
+        __le16 tool_major;      /* tool area, major axis */
+        __le16 tool_minor;      /* tool area, minor axis */
         __le16 orientation;     /* 16384 when point, else 15 bit angle */
-        __le16 force_major;     /* trackpad force, major axis? */
-        __le16 force_minor;     /* trackpad force, minor axis? */
+        __le16 touch_major;     /* touch area, major axis */
+        __le16 touch_minor;     /* touch area, minor axis */
         __le16 unused[3];       /* zeros */
         __le16 multi;           /* one finger: varies, more fingers: constant */
 } __attribute__((packed,aligned(2)));
 
 /* trackpad finger data size, empirically at least ten fingers */
+#define MAX_FINGERS             16
 #define SIZEOF_FINGER           sizeof(struct tp_finger)
-#define SIZEOF_ALL_FINGERS      (16 * SIZEOF_FINGER)
+#define SIZEOF_ALL_FINGERS      (MAX_FINGERS * SIZEOF_FINGER)
 #define MAX_FINGER_ORIENTATION  16384
 
 /* device-specific parameters */
 struct bcm5974_param {
-        int dim;                /* logical dimension */
-        int fuzz;               /* logical noise value */
-        int devmin;             /* device minimum reading */
-        int devmax;             /* device maximum reading */
+        int snratio;            /* signal-to-noise ratio */
+        int min;                /* device minimum reading */
+        int max;                /* device maximum reading */
 };
 
 /* device-specific configuration */
@@ -219,6 +220,7 @@ struct bcm5974_config {
         struct bcm5974_param w; /* finger width limits */
         struct bcm5974_param x; /* horizontal limits */
         struct bcm5974_param y; /* vertical limits */
+        struct bcm5974_param o; /* orientation limits */
 };
 
 /* logical device structure */
@@ -234,23 +236,16 @@ struct bcm5974 {
         struct bt_data *bt_data;        /* button transferred data */
         struct urb *tp_urb;             /* trackpad usb request block */
         u8 *tp_data;                    /* trackpad transferred data */
-        int fingers;                    /* number of fingers on trackpad */
+        const struct tp_finger *index[MAX_FINGERS];     /* finger index data */
+        struct input_mt_pos pos[MAX_FINGERS];           /* position array */
+        int slots[MAX_FINGERS];                         /* slot assignments */
 };
 
-/* logical dimensions */
-#define DIM_PRESSURE    256             /* maximum finger pressure */
-#define DIM_WIDTH       16              /* maximum finger width */
-#define DIM_X           1280            /* maximum trackpad x value */
-#define DIM_Y           800             /* maximum trackpad y value */
-
 /* logical signal quality */
 #define SN_PRESSURE     45              /* pressure signal-to-noise ratio */
-#define SN_WIDTH        100             /* width signal-to-noise ratio */
+#define SN_WIDTH        25              /* width signal-to-noise ratio */
 #define SN_COORD        250             /* coordinate signal-to-noise ratio */
-
-/* pressure thresholds */
-#define PRESSURE_LOW    (2 * DIM_PRESSURE / SN_PRESSURE)
-#define PRESSURE_HIGH   (3 * PRESSURE_LOW)
+#define SN_ORIENT       10              /* orientation signal-to-noise ratio */
 
 /* device constants */
 static const struct bcm5974_config bcm5974_config_table[] = {
@@ -261,10 +256,11 @@ static const struct bcm5974_config bcm5974_config_table[] = {
                 0,
                 0x84, sizeof(struct bt_data),
                 0x81, TYPE1, FINGER_TYPE1, FINGER_TYPE1 + SIZEOF_ALL_FINGERS,
-                { DIM_PRESSURE, DIM_PRESSURE / SN_PRESSURE, 0, 256 },
-                { DIM_WIDTH, DIM_WIDTH / SN_WIDTH, 0, 2048 },
-                { DIM_X, DIM_X / SN_COORD, -4824, 5342 },
-                { DIM_Y, DIM_Y / SN_COORD, -172, 5820 }
+                { SN_PRESSURE, 0, 256 },
+                { SN_WIDTH, 0, 2048 },
+                { SN_COORD, -4824, 5342 },
+                { SN_COORD, -172, 5820 },
+                { SN_ORIENT, -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION }
         },
         {
                 USB_DEVICE_ID_APPLE_WELLSPRING2_ANSI,
@@ -273,10 +269,11 @@ static const struct bcm5974_config bcm5974_config_table[] = {
                 0,
                 0x84, sizeof(struct bt_data),
                 0x81, TYPE1, FINGER_TYPE1, FINGER_TYPE1 + SIZEOF_ALL_FINGERS,
-                { DIM_PRESSURE, DIM_PRESSURE / SN_PRESSURE, 0, 256 },
-                { DIM_WIDTH, DIM_WIDTH / SN_WIDTH, 0, 2048 },
-                { DIM_X, DIM_X / SN_COORD, -4824, 4824 },
-                { DIM_Y, DIM_Y / SN_COORD, -172, 4290 }
+                { SN_PRESSURE, 0, 256 },
+                { SN_WIDTH, 0, 2048 },
+                { SN_COORD, -4824, 4824 },
+                { SN_COORD, -172, 4290 },
+                { SN_ORIENT, -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION }
         },
         {
                 USB_DEVICE_ID_APPLE_WELLSPRING3_ANSI,
@@ -285,10 +282,11 @@ static const struct bcm5974_config bcm5974_config_table[] = {
                 HAS_INTEGRATED_BUTTON,
                 0x84, sizeof(struct bt_data),
                 0x81, TYPE2, FINGER_TYPE2, FINGER_TYPE2 + SIZEOF_ALL_FINGERS,
-                { DIM_PRESSURE, DIM_PRESSURE / SN_PRESSURE, 0, 300 },
-                { DIM_WIDTH, DIM_WIDTH / SN_WIDTH, 0, 2048 },
-                { DIM_X, DIM_X / SN_COORD, -4460, 5166 },
-                { DIM_Y, DIM_Y / SN_COORD, -75, 6700 }
+                { SN_PRESSURE, 0, 300 },
+                { SN_WIDTH, 0, 2048 },
+                { SN_COORD, -4460, 5166 },
+                { SN_COORD, -75, 6700 },
+                { SN_ORIENT, -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION }
         },
         {
                 USB_DEVICE_ID_APPLE_WELLSPRING4_ANSI,
@@ -297,10 +295,11 @@ static const struct bcm5974_config bcm5974_config_table[] = {
                 HAS_INTEGRATED_BUTTON,
                 0x84, sizeof(struct bt_data),
                 0x81, TYPE2, FINGER_TYPE2, FINGER_TYPE2 + SIZEOF_ALL_FINGERS,
-                { DIM_PRESSURE, DIM_PRESSURE / SN_PRESSURE, 0, 300 },
-                { DIM_WIDTH, DIM_WIDTH / SN_WIDTH, 0, 2048 },
-                { DIM_X, DIM_X / SN_COORD, -4620, 5140 },
-                { DIM_Y, DIM_Y / SN_COORD, -150, 6600 }
+                { SN_PRESSURE, 0, 300 },
+                { SN_WIDTH, 0, 2048 },
+                { SN_COORD, -4620, 5140 },
+                { SN_COORD, -150, 6600 },
+                { SN_ORIENT, -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION }
         },
         {
                 USB_DEVICE_ID_APPLE_WELLSPRING4A_ANSI,
@@ -309,10 +308,11 @@ static const struct bcm5974_config bcm5974_config_table[] = {
                 HAS_INTEGRATED_BUTTON,
                 0x84, sizeof(struct bt_data),
                 0x81, TYPE2, FINGER_TYPE2, FINGER_TYPE2 + SIZEOF_ALL_FINGERS,
-                { DIM_PRESSURE, DIM_PRESSURE / SN_PRESSURE, 0, 300 },
-                { DIM_WIDTH, DIM_WIDTH / SN_WIDTH, 0, 2048 },
-                { DIM_X, DIM_X / SN_COORD, -4616, 5112 },
-                { DIM_Y, DIM_Y / SN_COORD, -142, 5234 }
+                { SN_PRESSURE, 0, 300 },
+                { SN_WIDTH, 0, 2048 },
+                { SN_COORD, -4616, 5112 },
+                { SN_COORD, -142, 5234 },
+                { SN_ORIENT, -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION }
         },
         {
                 USB_DEVICE_ID_APPLE_WELLSPRING5_ANSI,
@@ -321,10 +321,11 @@ static const struct bcm5974_config bcm5974_config_table[] = {
                 HAS_INTEGRATED_BUTTON,
                 0x84, sizeof(struct bt_data),
                 0x81, TYPE2, FINGER_TYPE2, FINGER_TYPE2 + SIZEOF_ALL_FINGERS,
-                { DIM_PRESSURE, DIM_PRESSURE / SN_PRESSURE, 0, 300 },
-                { DIM_WIDTH, DIM_WIDTH / SN_WIDTH, 0, 2048 },
-                { DIM_X, DIM_X / SN_COORD, -4415, 5050 },
-                { DIM_Y, DIM_Y / SN_COORD, -55, 6680 }
+                { SN_PRESSURE, 0, 300 },
+                { SN_WIDTH, 0, 2048 },
+                { SN_COORD, -4415, 5050 },
+                { SN_COORD, -55, 6680 },
+                { SN_ORIENT, -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION }
         },
         {
                 USB_DEVICE_ID_APPLE_WELLSPRING6_ANSI,
@@ -333,10 +334,11 @@ static const struct bcm5974_config bcm5974_config_table[] = {
                 HAS_INTEGRATED_BUTTON,
                 0x84, sizeof(struct bt_data),
                 0x81, TYPE2, FINGER_TYPE2, FINGER_TYPE2 + SIZEOF_ALL_FINGERS,
-                { DIM_PRESSURE, DIM_PRESSURE / SN_PRESSURE, 0, 300 },
-                { DIM_WIDTH, DIM_WIDTH / SN_WIDTH, 0, 2048 },
-                { DIM_X, DIM_X / SN_COORD, -4620, 5140 },
-                { DIM_Y, DIM_Y / SN_COORD, -150, 6600 }
+                { SN_PRESSURE, 0, 300 },
+                { SN_WIDTH, 0, 2048 },
+                { SN_COORD, -4620, 5140 },
+                { SN_COORD, -150, 6600 },
+                { SN_ORIENT, -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION }
         },
         {
                 USB_DEVICE_ID_APPLE_WELLSPRING5A_ANSI,
@@ -345,10 +347,11 @@ static const struct bcm5974_config bcm5974_config_table[] = {
                 HAS_INTEGRATED_BUTTON,
                 0x84, sizeof(struct bt_data),
                 0x81, TYPE2, FINGER_TYPE2, FINGER_TYPE2 + SIZEOF_ALL_FINGERS,
-                { DIM_PRESSURE, DIM_PRESSURE / SN_PRESSURE, 0, 300 },
-                { DIM_WIDTH, DIM_WIDTH / SN_WIDTH, 0, 2048 },
-                { DIM_X, DIM_X / SN_COORD, -4750, 5280 },
-                { DIM_Y, DIM_Y / SN_COORD, -150, 6730 }
+                { SN_PRESSURE, 0, 300 },
+                { SN_WIDTH, 0, 2048 },
+                { SN_COORD, -4750, 5280 },
+                { SN_COORD, -150, 6730 },
+                { SN_ORIENT, -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION }
         },
         {
                 USB_DEVICE_ID_APPLE_WELLSPRING6A_ANSI,
@@ -357,10 +360,11 @@ static const struct bcm5974_config bcm5974_config_table[] = {
                 HAS_INTEGRATED_BUTTON,
                 0x84, sizeof(struct bt_data),
                 0x81, TYPE2, FINGER_TYPE2, FINGER_TYPE2 + SIZEOF_ALL_FINGERS,
-                { DIM_PRESSURE, DIM_PRESSURE / SN_PRESSURE, 0, 300 },
-                { DIM_WIDTH, DIM_WIDTH / SN_WIDTH, 0, 2048 },
-                { DIM_X, DIM_X / SN_COORD, -4620, 5140 },
-                { DIM_Y, DIM_Y / SN_COORD, -150, 6600 }
+                { SN_PRESSURE, 0, 300 },
+                { SN_WIDTH, 0, 2048 },
+                { SN_COORD, -4620, 5140 },
+                { SN_COORD, -150, 6600 },
+                { SN_ORIENT, -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION }
         },
         {
                 USB_DEVICE_ID_APPLE_WELLSPRING7_ANSI,
@@ -369,10 +373,11 @@ static const struct bcm5974_config bcm5974_config_table[] = {
                 HAS_INTEGRATED_BUTTON,
                 0x84, sizeof(struct bt_data),
                 0x81, TYPE2, FINGER_TYPE2, FINGER_TYPE2 + SIZEOF_ALL_FINGERS,
-                { DIM_PRESSURE, DIM_PRESSURE / SN_PRESSURE, 0, 300 },
-                { DIM_WIDTH, DIM_WIDTH / SN_WIDTH, 0, 2048 },
-                { DIM_X, DIM_X / SN_COORD, -4750, 5280 },
-                { DIM_Y, DIM_Y / SN_COORD, -150, 6730 }
+                { SN_PRESSURE, 0, 300 },
+                { SN_WIDTH, 0, 2048 },
+                { SN_COORD, -4750, 5280 },
+                { SN_COORD, -150, 6730 },
+                { SN_ORIENT, -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION }
         },
         {}
 };
@@ -396,18 +401,11 @@ static inline int raw2int(__le16 x)
         return (signed short)le16_to_cpu(x);
 }
 
-/* scale device data to logical dimensions (asserts devmin < devmax) */
-static inline int int2scale(const struct bcm5974_param *p, int x)
-{
-        return x * p->dim / (p->devmax - p->devmin);
-}
-
-/* all logical value ranges are [0,dim). */
-static inline int int2bound(const struct bcm5974_param *p, int x)
+static void set_abs(struct input_dev *input, unsigned int code,
+                    const struct bcm5974_param *p)
 {
-        int s = int2scale(p, x);
-
-        return clamp_val(s, 0, p->dim - 1);
+        int fuzz = p->snratio ? (p->max - p->min) / p->snratio : 0;
+        input_set_abs_params(input, code, p->min, p->max, fuzz, 0);
 }
 
 /* setup which logical events to report */
@@ -416,48 +414,30 @@ static void setup_events_to_report(struct input_dev *input_dev,
 {
         __set_bit(EV_ABS, input_dev->evbit);
 
-        input_set_abs_params(input_dev, ABS_PRESSURE,
-                                0, cfg->p.dim, cfg->p.fuzz, 0);
-        input_set_abs_params(input_dev, ABS_TOOL_WIDTH,
-                                0, cfg->w.dim, cfg->w.fuzz, 0);
-        input_set_abs_params(input_dev, ABS_X,
-                                0, cfg->x.dim, cfg->x.fuzz, 0);
-        input_set_abs_params(input_dev, ABS_Y,
-                                0, cfg->y.dim, cfg->y.fuzz, 0);
+        /* for synaptics only */
+        input_set_abs_params(input_dev, ABS_PRESSURE, 0, 256, 5, 0);
+        input_set_abs_params(input_dev, ABS_TOOL_WIDTH, 0, 16, 0, 0);
 
         /* finger touch area */
-        input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR,
-                             cfg->w.devmin, cfg->w.devmax, 0, 0);
-        input_set_abs_params(input_dev, ABS_MT_TOUCH_MINOR,
-                             cfg->w.devmin, cfg->w.devmax, 0, 0);
+        set_abs(input_dev, ABS_MT_TOUCH_MAJOR, &cfg->w);
+        set_abs(input_dev, ABS_MT_TOUCH_MINOR, &cfg->w);
         /* finger approach area */
-        input_set_abs_params(input_dev, ABS_MT_WIDTH_MAJOR,
-                             cfg->w.devmin, cfg->w.devmax, 0, 0);
-        input_set_abs_params(input_dev, ABS_MT_WIDTH_MINOR,
-                             cfg->w.devmin, cfg->w.devmax, 0, 0);
+        set_abs(input_dev, ABS_MT_WIDTH_MAJOR, &cfg->w);
+        set_abs(input_dev, ABS_MT_WIDTH_MINOR, &cfg->w);
         /* finger orientation */
-        input_set_abs_params(input_dev, ABS_MT_ORIENTATION,
-                             -MAX_FINGER_ORIENTATION,
-                             MAX_FINGER_ORIENTATION, 0, 0);
+        set_abs(input_dev, ABS_MT_ORIENTATION, &cfg->o);
         /* finger position */
-        input_set_abs_params(input_dev, ABS_MT_POSITION_X,
-                             cfg->x.devmin, cfg->x.devmax, 0, 0);
-        input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
-                             cfg->y.devmin, cfg->y.devmax, 0, 0);
+        set_abs(input_dev, ABS_MT_POSITION_X, &cfg->x);
+        set_abs(input_dev, ABS_MT_POSITION_Y, &cfg->y);
 
         __set_bit(EV_KEY, input_dev->evbit);
-        __set_bit(BTN_TOUCH, input_dev->keybit);
-        __set_bit(BTN_TOOL_FINGER, input_dev->keybit);
-        __set_bit(BTN_TOOL_DOUBLETAP, input_dev->keybit);
-        __set_bit(BTN_TOOL_TRIPLETAP, input_dev->keybit);
-        __set_bit(BTN_TOOL_QUADTAP, input_dev->keybit);
         __set_bit(BTN_LEFT, input_dev->keybit);
 
-        __set_bit(INPUT_PROP_POINTER, input_dev->propbit);
         if (cfg->caps & HAS_INTEGRATED_BUTTON)
                 __set_bit(INPUT_PROP_BUTTONPAD, input_dev->propbit);
 
-        input_set_events_per_packet(input_dev, 60);
+        input_mt_init_slots(input_dev, MAX_FINGERS,
+                INPUT_MT_POINTER | INPUT_MT_DROP_UNUSED | INPUT_MT_TRACK);
 }
 
 /* report button data as logical button state */
@@ -477,24 +457,44 @@ static int report_bt_state(struct bcm5974 *dev, int size)
         return 0;
 }
 
-static void report_finger_data(struct input_dev *input,
-                               const struct bcm5974_config *cfg,
+static void report_finger_data(struct input_dev *input, int slot,
+                               const struct input_mt_pos *pos,
                                const struct tp_finger *f)
 {
+        input_mt_slot(input, slot);
+        input_mt_report_slot_state(input, MT_TOOL_FINGER, true);
+
         input_report_abs(input, ABS_MT_TOUCH_MAJOR,
-                         raw2int(f->force_major) << 1);
+                         raw2int(f->touch_major) << 1);
         input_report_abs(input, ABS_MT_TOUCH_MINOR,
-                         raw2int(f->force_minor) << 1);
+                         raw2int(f->touch_minor) << 1);
         input_report_abs(input, ABS_MT_WIDTH_MAJOR,
-                         raw2int(f->size_major) << 1);
+                         raw2int(f->tool_major) << 1);
         input_report_abs(input, ABS_MT_WIDTH_MINOR,
-                         raw2int(f->size_minor) << 1);
+                         raw2int(f->tool_minor) << 1);
         input_report_abs(input, ABS_MT_ORIENTATION,
                          MAX_FINGER_ORIENTATION - raw2int(f->orientation));
-        input_report_abs(input, ABS_MT_POSITION_X, raw2int(f->abs_x));
-        input_report_abs(input, ABS_MT_POSITION_Y,
-                         cfg->y.devmin + cfg->y.devmax - raw2int(f->abs_y));
-        input_mt_sync(input);
+        input_report_abs(input, ABS_MT_POSITION_X, pos->x);
+        input_report_abs(input, ABS_MT_POSITION_Y, pos->y);
+}
+
+static void report_synaptics_data(struct input_dev *input,
+                                  const struct bcm5974_config *cfg,
+                                  const struct tp_finger *f, int raw_n)
+{
+        int abs_p = 0, abs_w = 0;
+
+        if (raw_n) {
+                int p = raw2int(f->touch_major);
+                int w = raw2int(f->tool_major);
+                if (p > 0 && raw2int(f->origin)) {
+                        abs_p = clamp_val(256 * p / cfg->p.max, 0, 255);
+                        abs_w = clamp_val(16 * w / cfg->w.max, 0, 15);
+                }
+        }
+
+        input_report_abs(input, ABS_PRESSURE, abs_p);
+        input_report_abs(input, ABS_TOOL_WIDTH, abs_w);
 }
 
 /* report trackpad data as logical trackpad state */
@@ -503,9 +503,7 @@ static int report_tp_state(struct bcm5974 *dev, int size)
         const struct bcm5974_config *c = &dev->cfg;
         const struct tp_finger *f;
         struct input_dev *input = dev->input;
-        int raw_p, raw_w, raw_x, raw_y, raw_n, i;
-        int ptest, origin, ibt = 0, nmin = 0, nmax = 0;
-        int abs_p = 0, abs_w = 0, abs_x = 0, abs_y = 0;
+        int raw_n, i, n = 0;
 
         if (size < c->tp_offset || (size - c->tp_offset) % SIZEOF_FINGER != 0)
                 return -EIO;
@@ -514,76 +512,29 @@ static int report_tp_state(struct bcm5974 *dev, int size)
         f = (const struct tp_finger *)(dev->tp_data + c->tp_offset);
         raw_n = (size - c->tp_offset) / SIZEOF_FINGER;
 
-        /* always track the first finger; when detached, start over */
-        if (raw_n) {
-
-                /* report raw trackpad data */
-                for (i = 0; i < raw_n; i++)
-                        report_finger_data(input, c, &f[i]);
-
-                raw_p = raw2int(f->force_major);
-                raw_w = raw2int(f->size_major);
-                raw_x = raw2int(f->abs_x);
-                raw_y = raw2int(f->abs_y);
-
-                dprintk(9,
-                        "bcm5974: "
-                        "raw: p: %+05d w: %+05d x: %+05d y: %+05d n: %d\n",
-                        raw_p, raw_w, raw_x, raw_y, raw_n);
-
-                ptest = int2bound(&c->p, raw_p);
-                origin = raw2int(f->origin);
-
-                /* while tracking finger still valid, count all fingers */
-                if (ptest > PRESSURE_LOW && origin) {
-                        abs_p = ptest;
-                        abs_w = int2bound(&c->w, raw_w);
-                        abs_x = int2bound(&c->x, raw_x - c->x.devmin);
-                        abs_y = int2bound(&c->y, c->y.devmax - raw_y);
-                        while (raw_n--) {
-                                ptest = int2bound(&c->p,
-                                                  raw2int(f->force_major));
-                                if (ptest > PRESSURE_LOW)
-                                        nmax++;
-                                if (ptest > PRESSURE_HIGH)
-                                        nmin++;
-                                f++;
-                        }
-                }
+        for (i = 0; i < raw_n; i++) {
+                if (raw2int(f[i].touch_major) == 0)
+                        continue;
+                dev->pos[n].x = raw2int(f[i].abs_x);
+                dev->pos[n].y = c->y.min + c->y.max - raw2int(f[i].abs_y);
+                dev->index[n++] = &f[i];
         }
 
-        /* set the integrated button if applicable */
-        if (c->tp_type == TYPE2)
-                ibt = raw2int(dev->tp_data[BUTTON_TYPE2]);
-
-        if (dev->fingers < nmin)
-                dev->fingers = nmin;
-        if (dev->fingers > nmax)
-                dev->fingers = nmax;
-
-        input_report_key(input, BTN_TOUCH, dev->fingers > 0);
-        input_report_key(input, BTN_TOOL_FINGER, dev->fingers == 1);
-        input_report_key(input, BTN_TOOL_DOUBLETAP, dev->fingers == 2);
-        input_report_key(input, BTN_TOOL_TRIPLETAP, dev->fingers == 3);
-        input_report_key(input, BTN_TOOL_QUADTAP, dev->fingers > 3);
-
-        input_report_abs(input, ABS_PRESSURE, abs_p);
-        input_report_abs(input, ABS_TOOL_WIDTH, abs_w);
+        input_mt_assign_slots(input, dev->slots, dev->pos, n);
 
-        if (abs_p) {
-                input_report_abs(input, ABS_X, abs_x);
-                input_report_abs(input, ABS_Y, abs_y);
+        for (i = 0; i < n; i++)
+                report_finger_data(input, dev->slots[i],
+                                   &dev->pos[i], dev->index[i]);
 
-                dprintk(8,
-                        "bcm5974: abs: p: %+05d w: %+05d x: %+05d y: %+05d "
-                        "nmin: %d nmax: %d n: %d ibt: %d\n", abs_p, abs_w,
-                        abs_x, abs_y, nmin, nmax, dev->fingers, ibt);
+        input_mt_sync_frame(input);
 
-        }
+        report_synaptics_data(input, c, f, raw_n);
 
         /* type 2 reports button events via ibt only */
-        if (c->tp_type == TYPE2)
+        if (c->tp_type == TYPE2) {
+                int ibt = raw2int(dev->tp_data[BUTTON_TYPE2]);
                 input_report_key(input, BTN_LEFT, ibt);
+        }
 
         input_sync(input);
 
@@ -742,9 +693,11 @@ static int bcm5974_start_traffic(struct bcm5974 *dev)
                 goto err_out;
         }
 
-        error = usb_submit_urb(dev->bt_urb, GFP_KERNEL);
-        if (error)
-                goto err_reset_mode;
+        if (dev->bt_urb) {
+                error = usb_submit_urb(dev->bt_urb, GFP_KERNEL);
+                if (error)
+                        goto err_reset_mode;
+        }
 
         error = usb_submit_urb(dev->tp_urb, GFP_KERNEL);
         if (error)
@@ -868,19 +821,23 @@ static int bcm5974_probe(struct usb_interface *iface,
         mutex_init(&dev->pm_mutex);
 
         /* setup urbs */
-        dev->bt_urb = usb_alloc_urb(0, GFP_KERNEL);
-        if (!dev->bt_urb)
-                goto err_free_devs;
+        if (cfg->tp_type == TYPE1) {
+                dev->bt_urb = usb_alloc_urb(0, GFP_KERNEL);
+                if (!dev->bt_urb)
+                        goto err_free_devs;
+        }
 
         dev->tp_urb = usb_alloc_urb(0, GFP_KERNEL);
         if (!dev->tp_urb)
                 goto err_free_bt_urb;
 
-        dev->bt_data = usb_alloc_coherent(dev->udev,
+        if (dev->bt_urb) {
+                dev->bt_data = usb_alloc_coherent(dev->udev,
                                           dev->cfg.bt_datalen, GFP_KERNEL,
                                           &dev->bt_urb->transfer_dma);
-        if (!dev->bt_data)
-                goto err_free_urb;
+                if (!dev->bt_data)
+                        goto err_free_urb;
+        }
 
         dev->tp_data = usb_alloc_coherent(dev->udev,
                                           dev->cfg.tp_datalen, GFP_KERNEL,
@@ -888,10 +845,11 @@ static int bcm5974_probe(struct usb_interface *iface,
         if (!dev->tp_data)
                 goto err_free_bt_buffer;
 
-        usb_fill_int_urb(dev->bt_urb, udev,
-                         usb_rcvintpipe(udev, cfg->bt_ep),
-                         dev->bt_data, dev->cfg.bt_datalen,
-                         bcm5974_irq_button, dev, 1);
+        if (dev->bt_urb)
+                usb_fill_int_urb(dev->bt_urb, udev,
+                                 usb_rcvintpipe(udev, cfg->bt_ep),
+                                 dev->bt_data, dev->cfg.bt_datalen,
+                                 bcm5974_irq_button, dev, 1);
 
         usb_fill_int_urb(dev->tp_urb, udev,
                          usb_rcvintpipe(udev, cfg->tp_ep),
@@ -929,8 +887,9 @@ err_free_buffer:
         usb_free_coherent(dev->udev, dev->cfg.tp_datalen,
                 dev->tp_data, dev->tp_urb->transfer_dma);
 err_free_bt_buffer:
-        usb_free_coherent(dev->udev, dev->cfg.bt_datalen,
-                dev->bt_data, dev->bt_urb->transfer_dma);
+        if (dev->bt_urb)
+                usb_free_coherent(dev->udev, dev->cfg.bt_datalen,
+                                  dev->bt_data, dev->bt_urb->transfer_dma);
 err_free_urb:
         usb_free_urb(dev->tp_urb);
 err_free_bt_urb:
@@ -951,8 +910,9 @@ static void bcm5974_disconnect(struct usb_interface *iface)
         input_unregister_device(dev->input);
         usb_free_coherent(dev->udev, dev->cfg.tp_datalen,
                           dev->tp_data, dev->tp_urb->transfer_dma);
-        usb_free_coherent(dev->udev, dev->cfg.bt_datalen,
-                          dev->bt_data, dev->bt_urb->transfer_dma);
+        if (dev->bt_urb)
+                usb_free_coherent(dev->udev, dev->cfg.bt_datalen,
+                                  dev->bt_data, dev->bt_urb->transfer_dma);
         usb_free_urb(dev->tp_urb);
         usb_free_urb(dev->bt_urb);
         kfree(dev);
diff --git a/drivers/input/mouse/elantech.c b/drivers/input/mouse/elantech.c
index 479011004a11..1e8e42fb03a4 100644
--- a/drivers/input/mouse/elantech.c
+++ b/drivers/input/mouse/elantech.c
@@ -1004,7 +1004,7 @@ static int elantech_set_input_params(struct psmouse *psmouse)
                         input_set_abs_params(dev, ABS_TOOL_WIDTH, ETP_WMIN_V2,
                                              ETP_WMAX_V2, 0, 0);
                 }
-                input_mt_init_slots(dev, 2);
+                input_mt_init_slots(dev, 2, 0);
                 input_set_abs_params(dev, ABS_MT_POSITION_X, x_min, x_max, 0, 0);
                 input_set_abs_params(dev, ABS_MT_POSITION_Y, y_min, y_max, 0, 0);
                 break;
@@ -1035,7 +1035,7 @@ static int elantech_set_input_params(struct psmouse *psmouse)
                 input_set_abs_params(dev, ABS_TOOL_WIDTH, ETP_WMIN_V2,
                                      ETP_WMAX_V2, 0, 0);
                 /* Multitouch capable pad, up to 5 fingers. */
-                input_mt_init_slots(dev, ETP_MAX_FINGERS);
+                input_mt_init_slots(dev, ETP_MAX_FINGERS, 0);
                 input_set_abs_params(dev, ABS_MT_POSITION_X, x_min, x_max, 0, 0);
                 input_set_abs_params(dev, ABS_MT_POSITION_Y, y_min, y_max, 0, 0);
                 input_abs_set_res(dev, ABS_MT_POSITION_X, x_res);
diff --git a/drivers/input/mouse/hgpk.c b/drivers/input/mouse/hgpk.c
index 575f880727fe..62be888e83d0 100644
--- a/drivers/input/mouse/hgpk.c
+++ b/drivers/input/mouse/hgpk.c
@@ -334,11 +334,8 @@ static bool hgpk_is_byte_valid(struct psmouse *psmouse, unsigned char *packet)
 
         if (!valid)
                 psmouse_dbg(psmouse,
-                            "bad data, mode %d (%d) %02x %02x %02x %02x %02x %02x\n",
-                            priv->mode, pktcnt,
-                            psmouse->packet[0], psmouse->packet[1],
-                            psmouse->packet[2], psmouse->packet[3],
-                            psmouse->packet[4], psmouse->packet[5]);
+                            "bad data, mode %d (%d) %*ph\n",
+                            priv->mode, pktcnt, 6, psmouse->packet);
 
         return valid;
 }
@@ -1030,7 +1027,7 @@ static enum hgpk_model_t hgpk_get_model(struct psmouse *psmouse)
                 return -EIO;
         }
 
-        psmouse_dbg(psmouse, "ID: %02x %02x %02x\n", param[0], param[1], param[2]);
+        psmouse_dbg(psmouse, "ID: %*ph\n", 3, param);
 
         /* HGPK signature: 0x67, 0x00, 0x<model> */
         if (param[0] != 0x67 || param[1] != 0x00)
diff --git a/drivers/input/mouse/pxa930_trkball.c b/drivers/input/mouse/pxa930_trkball.c
index a9e4bfdf31f4..4fe055f2c536 100644
--- a/drivers/input/mouse/pxa930_trkball.c
+++ b/drivers/input/mouse/pxa930_trkball.c
@@ -20,7 +20,7 @@
 #include <linux/slab.h>
 
 #include <mach/hardware.h>
-#include <mach/pxa930_trkball.h>
+#include <linux/platform_data/mouse-pxa930_trkball.h>
 
 /* Trackball Controller Register Definitions */
 #define TBCR            (0x000C)
diff --git a/drivers/input/mouse/rpcmouse.c b/drivers/input/mouse/rpcmouse.c
index 272deddc8db6..21c60fea5d31 100644
--- a/drivers/input/mouse/rpcmouse.c
+++ b/drivers/input/mouse/rpcmouse.c
@@ -42,7 +42,7 @@ static irqreturn_t rpcmouse_irq(int irq, void *dev_id)
 
         x = (short) iomd_readl(IOMD_MOUSEX);
         y = (short) iomd_readl(IOMD_MOUSEY);
-        b = (short) (__raw_readl(0xe0310000) ^ 0x70);
+        b = (short) (__raw_readl(IOMEM(0xe0310000)) ^ 0x70);
 
         dx = x - rpcmouse_lastx;
         dy = y - rpcmouse_lasty;
diff --git a/drivers/input/mouse/sentelic.c b/drivers/input/mouse/sentelic.c
index 3f5649f19082..e582922bacf7 100644
--- a/drivers/input/mouse/sentelic.c
+++ b/drivers/input/mouse/sentelic.c
@@ -721,6 +721,17 @@ static psmouse_ret_t fsp_process_byte(struct psmouse *psmouse)
 
         switch (psmouse->packet[0] >> FSP_PKT_TYPE_SHIFT) {
         case FSP_PKT_TYPE_ABS:
+
+                if ((packet[0] == 0x48 || packet[0] == 0x49) &&
+                    packet[1] == 0 && packet[2] == 0) {
+                        /*
+                         * Ignore coordinate noise when finger leaving the
+                         * surface, otherwise cursor may jump to upper-left
+                         * corner.
+                         */
+                        packet[3] &= 0xf0;
+                }
+
                 abs_x = GET_ABS_X(packet);
                 abs_y = GET_ABS_Y(packet);
 
@@ -960,7 +971,7 @@ static int fsp_set_input_params(struct psmouse *psmouse)
 
                 input_set_abs_params(dev, ABS_X, 0, abs_x, 0, 0);
                 input_set_abs_params(dev, ABS_Y, 0, abs_y, 0, 0);
-                input_mt_init_slots(dev, 2);
+                input_mt_init_slots(dev, 2, 0);
                 input_set_abs_params(dev, ABS_MT_POSITION_X, 0, abs_x, 0, 0);
                 input_set_abs_params(dev, ABS_MT_POSITION_Y, 0, abs_y, 0, 0);
         }
diff --git a/drivers/input/mouse/synaptics.c b/drivers/input/mouse/synaptics.c
index 14eaecea2b70..12d12ca3fee0 100644
--- a/drivers/input/mouse/synaptics.c
+++ b/drivers/input/mouse/synaptics.c
@@ -53,14 +53,19 @@
 #define ABS_POS_BITS 13
 
 /*
- * Any position values from the hardware above the following limits are
- * treated as "wrapped around negative" values that have been truncated to
- * the 13-bit reporting range of the hardware. These are just reasonable
- * guesses and can be adjusted if hardware is found that operates outside
- * of these parameters.
+ * These values should represent the absolute maximum value that will
+ * be reported for a positive position value. Some Synaptics firmware
+ * uses this value to indicate a finger near the edge of the touchpad
+ * whose precise position cannot be determined.
+ *
+ * At least one touchpad is known to report positions in excess of this
+ * value which are actually negative values truncated to the 13-bit
+ * reporting range. These values have never been observed to be lower
+ * than 8184 (i.e. -8), so we treat all values greater than 8176 as
+ * negative and any other value as positive.
  */
-#define X_MAX_POSITIVE (((1 << ABS_POS_BITS) + XMAX) / 2)
-#define Y_MAX_POSITIVE (((1 << ABS_POS_BITS) + YMAX) / 2)
+#define X_MAX_POSITIVE 8176
+#define Y_MAX_POSITIVE 8176
 
 /*****************************************************************************
  *      Stuff we need even when we do not want native Synaptics support
@@ -604,11 +609,21 @@ static int synaptics_parse_hw_state(const unsigned char buf[],
                 hw->right = (buf[0] & 0x02) ? 1 : 0;
         }
 
-        /* Convert wrap-around values to negative */
+        /*
+         * Convert wrap-around values to negative. (X|Y)_MAX_POSITIVE
+         * is used by some firmware to indicate a finger at the edge of
+         * the touchpad whose precise position cannot be determined, so
+         * convert these values to the maximum axis value.
+         */
         if (hw->x > X_MAX_POSITIVE)
                 hw->x -= 1 << ABS_POS_BITS;
+        else if (hw->x == X_MAX_POSITIVE)
+                hw->x = XMAX;
+
         if (hw->y > Y_MAX_POSITIVE)
                 hw->y -= 1 << ABS_POS_BITS;
+        else if (hw->y == Y_MAX_POSITIVE)
+                hw->y = YMAX;
 
         return 0;
 }
@@ -1232,7 +1247,7 @@ static void set_input_params(struct input_dev *dev, struct synaptics_data *priv)
         input_set_abs_params(dev, ABS_PRESSURE, 0, 255, 0, 0);
 
         if (SYN_CAP_IMAGE_SENSOR(priv->ext_cap_0c)) {
-                input_mt_init_slots(dev, 2);
+                input_mt_init_slots(dev, 2, 0);
                 set_abs_position_params(dev, priv, ABS_MT_POSITION_X,
                                         ABS_MT_POSITION_Y);
                 /* Image sensors can report per-contact pressure */
@@ -1244,7 +1259,7 @@ static void set_input_params(struct input_dev *dev, struct synaptics_data *priv)
         } else if (SYN_CAP_ADV_GESTURE(priv->ext_cap_0c)) {
                 /* Non-image sensors with AGM use semi-mt */
                 __set_bit(INPUT_PROP_SEMI_MT, dev->propbit);
-                input_mt_init_slots(dev, 2);
+                input_mt_init_slots(dev, 2, 0);
                 set_abs_position_params(dev, priv, ABS_MT_POSITION_X,
                                         ABS_MT_POSITION_Y);
         }
diff --git a/drivers/input/mouse/synaptics_i2c.c b/drivers/input/mouse/synaptics_i2c.c
index f14675702c0f..063a174d3a88 100644
--- a/drivers/input/mouse/synaptics_i2c.c
+++ b/drivers/input/mouse/synaptics_i2c.c
@@ -376,12 +376,7 @@ static void synaptics_i2c_reschedule_work(struct synaptics_i2c *touch,
 
         spin_lock_irqsave(&touch->lock, flags);
 
-        /*
-         * If work is already scheduled then subsequent schedules will not
-         * change the scheduled time that's why we have to cancel it first.
-         */
-        __cancel_delayed_work(&touch->dwork);
-        schedule_delayed_work(&touch->dwork, delay);
+        mod_delayed_work(system_wq, &touch->dwork, delay);
 
         spin_unlock_irqrestore(&touch->lock, flags);
 }
diff --git a/drivers/input/mousedev.c b/drivers/input/mousedev.c
index 0110b5a3a167..964e43d81e29 100644
--- a/drivers/input/mousedev.c
+++ b/drivers/input/mousedev.c
@@ -551,17 +551,16 @@ static int mousedev_open(struct inode *inode, struct file *file)
                 return -ENODEV;
 
         error = mutex_lock_interruptible(&mousedev_table_mutex);
-        if (error) {
+        if (error)
                 return error;
-        }
+
         mousedev = mousedev_table[i];
         if (mousedev)
                 get_device(&mousedev->dev);
         mutex_unlock(&mousedev_table_mutex);
 
-        if (!mousedev) {
+        if (!mousedev)
                 return -ENODEV;
-        }
 
         client = kzalloc(sizeof(struct mousedev_client), GFP_KERNEL);
         if (!client) {
@@ -1088,7 +1087,7 @@ static int __init mousedev_init(void)
 #ifdef CONFIG_INPUT_MOUSEDEV_PSAUX
         error = misc_register(&psaux_mouse);
         if (error)
-                pr_warning("could not register psaux device, error: %d\n",
+                pr_warn("could not register psaux device, error: %d\n",
                            error);
         else
                 psaux_registered = 1;
diff --git a/drivers/input/serio/ambakmi.c b/drivers/input/serio/ambakmi.c
index 2ffd110bd5bc..2e77246c2e5a 100644
--- a/drivers/input/serio/ambakmi.c
+++ b/drivers/input/serio/ambakmi.c
@@ -72,7 +72,7 @@ static int amba_kmi_open(struct serio *io)
         unsigned int divisor;
         int ret;
 
-        ret = clk_enable(kmi->clk);
+        ret = clk_prepare_enable(kmi->clk);
         if (ret)
                 goto out;
 
@@ -92,7 +92,7 @@ static int amba_kmi_open(struct serio *io)
         return 0;
 
  clk_disable:
-        clk_disable(kmi->clk);
+        clk_disable_unprepare(kmi->clk);
  out:
         return ret;
 }
@@ -104,7 +104,7 @@ static void amba_kmi_close(struct serio *io)
         writeb(0, KMICR);
 
         free_irq(kmi->irq, kmi);
-        clk_disable(kmi->clk);
+        clk_disable_unprepare(kmi->clk);
 }
 
 static int __devinit amba_kmi_probe(struct amba_device *dev,
diff --git a/drivers/input/serio/ams_delta_serio.c b/drivers/input/serio/ams_delta_serio.c
index f5fbdf94de3b..45887e31242a 100644
--- a/drivers/input/serio/ams_delta_serio.c
+++ b/drivers/input/serio/ams_delta_serio.c
@@ -27,7 +27,7 @@
 #include <linux/module.h>
 
 #include <asm/mach-types.h>
-#include <plat/board-ams-delta.h>
+#include <mach/board-ams-delta.h>
 
 #include <mach/ams-delta-fiq.h>
 
diff --git a/drivers/input/serio/i8042-x86ia64io.h b/drivers/input/serio/i8042-x86ia64io.h
index 5ec774d6c82b..d6cc77a53c7e 100644
--- a/drivers/input/serio/i8042-x86ia64io.h
+++ b/drivers/input/serio/i8042-x86ia64io.h
@@ -177,6 +177,20 @@ static const struct dmi_system_id __initconst i8042_dmi_noloop_table[] = {
                 },
         },
         {
+                /* Gigabyte T1005 - defines wrong chassis type ("Other") */
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "GIGABYTE"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "T1005"),
+                },
+        },
+        {
+                /* Gigabyte T1005M/P - defines wrong chassis type ("Other") */
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "GIGABYTE"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "T1005M/P"),
+                },
+        },
+        {
                 .matches = {
                         DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
                         DMI_MATCH(DMI_PRODUCT_NAME, "HP Pavilion dv9700"),
@@ -321,6 +335,12 @@ static const struct dmi_system_id __initconst i8042_dmi_nomux_table[] = {
         },
         {
                 .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "SATELLITE C850D"),
+                },
+        },
+        {
+                .matches = {
                         DMI_MATCH(DMI_SYS_VENDOR, "ALIENWARE"),
                         DMI_MATCH(DMI_PRODUCT_NAME, "Sentia"),
                 },
diff --git a/drivers/input/sparse-keymap.c b/drivers/input/sparse-keymap.c
index 75fb040a3435..a70aa555bbff 100644
--- a/drivers/input/sparse-keymap.c
+++ b/drivers/input/sparse-keymap.c
@@ -180,11 +180,11 @@ int sparse_keymap_setup(struct input_dev *dev,
         for (e = keymap; e->type != KE_END; e++)
                 map_size++;
 
-        map = kcalloc(map_size, sizeof (struct key_entry), GFP_KERNEL);
+        map = kcalloc(map_size, sizeof(struct key_entry), GFP_KERNEL);
         if (!map)
                 return -ENOMEM;
 
-        memcpy(map, keymap, map_size * sizeof (struct key_entry));
+        memcpy(map, keymap, map_size * sizeof(struct key_entry));
 
         for (i = 0; i < map_size; i++) {
                 entry = &map[i];
diff --git a/drivers/input/tablet/wacom_wac.c b/drivers/input/tablet/wacom_wac.c
index 002041975de9..08b462b6c0d8 100644
--- a/drivers/input/tablet/wacom_wac.c
+++ b/drivers/input/tablet/wacom_wac.c
@@ -606,7 +606,7 @@ static int wacom_intuos_irq(struct wacom_wac *wacom)
                                 input_report_abs(input, ABS_WHEEL, 0);
                         }
 
-                        if (data[2] | (data[3] & 0x01) | data[4]) {
+                        if (data[2] | (data[3] & 0x01) | data[4] | data[5]) {
                                 input_report_key(input, wacom->tool[1], 1);
                                 input_report_abs(input, ABS_MISC, PAD_DEVICE_ID);
                         } else {
@@ -1530,7 +1530,7 @@ int wacom_setup_input_capabilities(struct input_dev *input_dev,
                         __set_bit(BTN_TOOL_TRIPLETAP, input_dev->keybit);
                         __set_bit(BTN_TOOL_QUADTAP, input_dev->keybit);
 
-                        input_mt_init_slots(input_dev, features->touch_max);
+                        input_mt_init_slots(input_dev, features->touch_max, 0);
 
                         input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR,
                                              0, 255, 0, 0);
@@ -1575,7 +1575,7 @@ int wacom_setup_input_capabilities(struct input_dev *input_dev,
 
         case TABLETPC2FG:
                 if (features->device_type == BTN_TOOL_FINGER) {
-                        input_mt_init_slots(input_dev, features->touch_max);
+                        input_mt_init_slots(input_dev, features->touch_max, 0);
                         input_set_abs_params(input_dev, ABS_MT_TOOL_TYPE,
                                         0, MT_TOOL_MAX, 0, 0);
                         input_set_abs_params(input_dev, ABS_MT_POSITION_X,
@@ -1631,7 +1631,7 @@ int wacom_setup_input_capabilities(struct input_dev *input_dev,
 
                         __set_bit(BTN_TOOL_FINGER, input_dev->keybit);
                         __set_bit(BTN_TOOL_DOUBLETAP, input_dev->keybit);
-                        input_mt_init_slots(input_dev, features->touch_max);
+                        input_mt_init_slots(input_dev, features->touch_max, 0);
 
                         if (features->pktlen == WACOM_PKGLEN_BBTOUCH3) {
                                 __set_bit(BTN_TOOL_TRIPLETAP,
@@ -1848,7 +1848,10 @@ static const struct wacom_features wacom_features_0x2A =
         { "Wacom Intuos5 M", WACOM_PKGLEN_INTUOS,  44704, 27940, 2047,
           63, INTUOS5, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
 static const struct wacom_features wacom_features_0xF4 =
-        { "Wacom Cintiq 24HD",    WACOM_PKGLEN_INTUOS,   104480, 65600, 2047,
+        { "Wacom Cintiq 24HD",       WACOM_PKGLEN_INTUOS,   104480, 65600, 2047,
+          63, WACOM_24HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
+static const struct wacom_features wacom_features_0xF8 =
+        { "Wacom Cintiq 24HD touch", WACOM_PKGLEN_INTUOS,   104480, 65600, 2047,
           63, WACOM_24HD, WACOM_INTUOS3_RES, WACOM_INTUOS3_RES };
 static const struct wacom_features wacom_features_0x3F =
         { "Wacom Cintiq 21UX",    WACOM_PKGLEN_INTUOS,    87200, 65600, 1023,
@@ -2091,6 +2094,7 @@ const struct usb_device_id wacom_ids[] = {
         { USB_DEVICE_WACOM(0xEF) },
         { USB_DEVICE_WACOM(0x47) },
         { USB_DEVICE_WACOM(0xF4) },
+        { USB_DEVICE_WACOM(0xF8) },
         { USB_DEVICE_WACOM(0xFA) },
         { USB_DEVICE_LENOVO(0x6004) },
         { }
diff --git a/drivers/input/touchscreen/88pm860x-ts.c b/drivers/input/touchscreen/88pm860x-ts.c
index 05f30b73c3c3..326218dbd6e6 100644
--- a/drivers/input/touchscreen/88pm860x-ts.c
+++ b/drivers/input/touchscreen/88pm860x-ts.c
@@ -10,6 +10,7 @@
  */
 #include <linux/kernel.h>
 #include <linux/module.h>
+#include <linux/of.h>
 #include <linux/platform_device.h>
 #include <linux/i2c.h>
 #include <linux/input.h>
@@ -113,14 +114,69 @@ static void pm860x_touch_close(struct input_dev *dev)
         pm860x_set_bits(touch->i2c, MEAS_EN3, data, 0);
 }
 
+#ifdef CONFIG_OF
+static int __devinit pm860x_touch_dt_init(struct platform_device *pdev,
+                                          struct pm860x_chip *chip,
+                                          int *res_x)
+{
+        struct device_node *np = pdev->dev.parent->of_node;
+        struct i2c_client *i2c = (chip->id == CHIP_PM8607) ? chip->client \
+                                 : chip->companion;
+        int data, n, ret;
+        if (!np)
+                return -ENODEV;
+        np = of_find_node_by_name(np, "touch");
+        if (!np) {
+                dev_err(&pdev->dev, "Can't find touch node\n");
+                return -EINVAL;
+        }
+        /* set GPADC MISC1 register */
+        data = 0;
+        if (!of_property_read_u32(np, "marvell,88pm860x-gpadc-prebias", &n))
+                data |= (n << 1) & PM8607_GPADC_PREBIAS_MASK;
+        if (!of_property_read_u32(np, "marvell,88pm860x-gpadc-slot-cycle", &n))
+                data |= (n << 3) & PM8607_GPADC_SLOT_CYCLE_MASK;
+        if (!of_property_read_u32(np, "marvell,88pm860x-gpadc-off-scale", &n))
+                data |= (n << 5) & PM8607_GPADC_OFF_SCALE_MASK;
+        if (!of_property_read_u32(np, "marvell,88pm860x-gpadc-sw-cal", &n))
+                data |= (n << 7) & PM8607_GPADC_SW_CAL_MASK;
+        if (data) {
+                ret = pm860x_reg_write(i2c, PM8607_GPADC_MISC1, data);
+                if (ret < 0)
+                        return -EINVAL;
+        }
+        /* set tsi prebias time */
+        if (!of_property_read_u32(np, "marvell,88pm860x-tsi-prebias", &data)) {
+                ret = pm860x_reg_write(i2c, PM8607_TSI_PREBIAS, data);
+                if (ret < 0)
+                        return -EINVAL;
+        }
+        /* set prebias & prechg time of pen detect */
+        data = 0;
+        if (!of_property_read_u32(np, "marvell,88pm860x-pen-prebias", &n))
+                data |= n & PM8607_PD_PREBIAS_MASK;
+        if (!of_property_read_u32(np, "marvell,88pm860x-pen-prechg", &n))
+                data |= n & PM8607_PD_PRECHG_MASK;
+        if (data) {
+                ret = pm860x_reg_write(i2c, PM8607_PD_PREBIAS, data);
+                if (ret < 0)
+                        return -EINVAL;
+        }
+        of_property_read_u32(np, "marvell,88pm860x-resistor-X", res_x);
+        return 0;
+}
+#else
+#define pm860x_touch_dt_init(x, y, z)   (-1)
+#endif
+
 static int __devinit pm860x_touch_probe(struct platform_device *pdev)
 {
         struct pm860x_chip *chip = dev_get_drvdata(pdev->dev.parent);
-        struct pm860x_platform_data *pm860x_pdata =             \
-                                pdev->dev.parent->platform_data;
-        struct pm860x_touch_pdata *pdata = NULL;
+        struct pm860x_touch_pdata *pdata = pdev->dev.platform_data;
         struct pm860x_touch *touch;
-        int irq, ret;
+        struct i2c_client *i2c = (chip->id == CHIP_PM8607) ? chip->client \
+                                 : chip->companion;
+        int irq, ret, res_x = 0, data = 0;
 
         irq = platform_get_irq(pdev, 0);
         if (irq < 0) {
@@ -128,16 +184,55 @@ static int __devinit pm860x_touch_probe(struct platform_device *pdev)
                 return -EINVAL;
         }
 
-        if (!pm860x_pdata) {
-                dev_err(&pdev->dev, "platform data is missing\n");
-                return -EINVAL;
-        }
-
-        pdata = pm860x_pdata->touch;
-        if (!pdata) {
-                dev_err(&pdev->dev, "touchscreen data is missing\n");
-                return -EINVAL;
+        if (pm860x_touch_dt_init(pdev, chip, &res_x)) {
+                if (pdata) {
+                        /* set GPADC MISC1 register */
+                        data = 0;
+                        data |= (pdata->gpadc_prebias << 1)
+                                & PM8607_GPADC_PREBIAS_MASK;
+                        data |= (pdata->slot_cycle << 3)
+                                & PM8607_GPADC_SLOT_CYCLE_MASK;
+                        data |= (pdata->off_scale << 5)
+                                & PM8607_GPADC_OFF_SCALE_MASK;
+                        data |= (pdata->sw_cal << 7)
+                                & PM8607_GPADC_SW_CAL_MASK;
+                        if (data) {
+                                ret = pm860x_reg_write(i2c,
+                                        PM8607_GPADC_MISC1, data);
+                                if (ret < 0)
+                                        return -EINVAL;
+                        }
+                        /* set tsi prebias time */
+                        if (pdata->tsi_prebias) {
+                                data = pdata->tsi_prebias;
+                                ret = pm860x_reg_write(i2c,
+                                        PM8607_TSI_PREBIAS, data);
+                                if (ret < 0)
+                                        return -EINVAL;
+                        }
+                        /* set prebias & prechg time of pen detect */
+                        data = 0;
+                        data |= pdata->pen_prebias
+                                & PM8607_PD_PREBIAS_MASK;
+                        data |= (pdata->pen_prechg << 5)
+                                & PM8607_PD_PRECHG_MASK;
+                        if (data) {
+                                ret = pm860x_reg_write(i2c,
+                                        PM8607_PD_PREBIAS, data);
+                                if (ret < 0)
+                                        return -EINVAL;
+                        }
+                        res_x = pdata->res_x;
+                } else {
+                        dev_err(&pdev->dev, "failed to get platform data\n");
+                        return -EINVAL;
+                }
         }
+        /* enable GPADC */
+        ret = pm860x_set_bits(i2c, PM8607_GPADC_MISC1, PM8607_GPADC_EN,
+                              PM8607_GPADC_EN);
+        if (ret)
+                return ret;
 
         touch = kzalloc(sizeof(struct pm860x_touch), GFP_KERNEL);
         if (touch == NULL)
@@ -158,9 +253,9 @@ static int __devinit pm860x_touch_probe(struct platform_device *pdev)
         touch->idev->open = pm860x_touch_open;
         touch->idev->close = pm860x_touch_close;
         touch->chip = chip;
-        touch->i2c = (chip->id == CHIP_PM8607) ? chip->client : chip->companion;
-        touch->irq = irq + chip->irq_base;
-        touch->res_x = pdata->res_x;
+        touch->i2c = i2c;
+        touch->irq = irq;
+        touch->res_x = res_x;
         input_set_drvdata(touch->idev, touch);
 
         ret = request_threaded_irq(touch->irq, NULL, pm860x_touch_handler,
diff --git a/drivers/input/touchscreen/atmel_mxt_ts.c b/drivers/input/touchscreen/atmel_mxt_ts.c
index 4623cc69fc60..e92615d0b1b0 100644
--- a/drivers/input/touchscreen/atmel_mxt_ts.c
+++ b/drivers/input/touchscreen/atmel_mxt_ts.c
@@ -1152,7 +1152,7 @@ static int __devinit mxt_probe(struct i2c_client *client,
 
         /* For multi touch */
         num_mt_slots = data->T9_reportid_max - data->T9_reportid_min + 1;
-        error = input_mt_init_slots(input_dev, num_mt_slots);
+        error = input_mt_init_slots(input_dev, num_mt_slots, 0);
         if (error)
                 goto err_free_object;
         input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR,
diff --git a/drivers/input/touchscreen/cyttsp_core.c b/drivers/input/touchscreen/cyttsp_core.c
index f030d9ec795d..8e60437ac85b 100644
--- a/drivers/input/touchscreen/cyttsp_core.c
+++ b/drivers/input/touchscreen/cyttsp_core.c
@@ -571,7 +571,7 @@ struct cyttsp *cyttsp_probe(const struct cyttsp_bus_ops *bus_ops,
         input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR,
                              0, CY_MAXZ, 0, 0);
 
-        input_mt_init_slots(input_dev, CY_MAX_ID);
+        input_mt_init_slots(input_dev, CY_MAX_ID, 0);
 
         error = request_threaded_irq(ts->irq, NULL, cyttsp_irq,
                                      IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
diff --git a/drivers/input/touchscreen/edt-ft5x06.c b/drivers/input/touchscreen/edt-ft5x06.c
index 9afc777a40a7..099d144ab7c9 100644
--- a/drivers/input/touchscreen/edt-ft5x06.c
+++ b/drivers/input/touchscreen/edt-ft5x06.c
@@ -566,9 +566,12 @@ static ssize_t edt_ft5x06_debugfs_raw_data_read(struct file *file,
         }
 
         read = min_t(size_t, count, tsdata->raw_bufsize - *off);
-        error = copy_to_user(buf, tsdata->raw_buffer + *off, read);
-        if (!error)
-                *off += read;
+        if (copy_to_user(buf, tsdata->raw_buffer + *off, read)) {
+                error = -EFAULT;
+                goto out;
+        }
+
+        *off += read;
 out:
         mutex_unlock(&tsdata->mutex);
         return error ?: read;
@@ -602,6 +605,7 @@ edt_ft5x06_ts_teardown_debugfs(struct edt_ft5x06_ts_data *tsdata)
 {
         if (tsdata->debug_dir)
                 debugfs_remove_recursive(tsdata->debug_dir);
+        kfree(tsdata->raw_buffer);
 }
 
 #else
@@ -778,7 +782,7 @@ static int __devinit edt_ft5x06_ts_probe(struct i2c_client *client,
                              0, tsdata->num_x * 64 - 1, 0, 0);
         input_set_abs_params(input, ABS_MT_POSITION_Y,
                              0, tsdata->num_y * 64 - 1, 0, 0);
-        error = input_mt_init_slots(input, MAX_SUPPORT_POINTS);
+        error = input_mt_init_slots(input, MAX_SUPPORT_POINTS, 0);
         if (error) {
                 dev_err(&client->dev, "Unable to init MT slots.\n");
                 goto err_free_mem;
@@ -843,7 +847,6 @@ static int __devexit edt_ft5x06_ts_remove(struct i2c_client *client)
         if (gpio_is_valid(pdata->reset_pin))
                 gpio_free(pdata->reset_pin);
 
-        kfree(tsdata->raw_buffer);
         kfree(tsdata);
 
         return 0;
diff --git a/drivers/input/touchscreen/egalax_ts.c b/drivers/input/touchscreen/egalax_ts.c
index 70524dd34f42..c1e3460f1195 100644
--- a/drivers/input/touchscreen/egalax_ts.c
+++ b/drivers/input/touchscreen/egalax_ts.c
@@ -204,7 +204,7 @@ static int __devinit egalax_ts_probe(struct i2c_client *client,
                              ABS_MT_POSITION_X, 0, EGALAX_MAX_X, 0, 0);
         input_set_abs_params(input_dev,
                              ABS_MT_POSITION_X, 0, EGALAX_MAX_Y, 0, 0);
-        input_mt_init_slots(input_dev, MAX_SUPPORT_POINTS);
+        input_mt_init_slots(input_dev, MAX_SUPPORT_POINTS, 0);
 
         input_set_drvdata(input_dev, ts);
 
diff --git a/drivers/input/touchscreen/ili210x.c b/drivers/input/touchscreen/ili210x.c
index c0044175a921..4ac69760ec08 100644
--- a/drivers/input/touchscreen/ili210x.c
+++ b/drivers/input/touchscreen/ili210x.c
@@ -252,7 +252,7 @@ static int __devinit ili210x_i2c_probe(struct i2c_client *client,
         input_set_abs_params(input, ABS_Y, 0, ymax, 0, 0);
 
         /* Multi touch */
-        input_mt_init_slots(input, MAX_TOUCHES);
+        input_mt_init_slots(input, MAX_TOUCHES, 0);
         input_set_abs_params(input, ABS_MT_POSITION_X, 0, xmax, 0, 0);
         input_set_abs_params(input, ABS_MT_POSITION_Y, 0, ymax, 0, 0);
 
diff --git a/drivers/input/touchscreen/mms114.c b/drivers/input/touchscreen/mms114.c
index 49c44bbf548d..560cf09d1c5a 100644
--- a/drivers/input/touchscreen/mms114.c
+++ b/drivers/input/touchscreen/mms114.c
@@ -404,7 +404,7 @@ static int __devinit mms114_probe(struct i2c_client *client,
         input_set_abs_params(input_dev, ABS_Y, 0, data->pdata->y_size, 0, 0);
 
         /* For multi touch */
-        input_mt_init_slots(input_dev, MMS114_MAX_TOUCH);
+        input_mt_init_slots(input_dev, MMS114_MAX_TOUCH, 0);
         input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR,
                              0, MMS114_MAX_AREA, 0, 0);
         input_set_abs_params(input_dev, ABS_MT_POSITION_X,
diff --git a/drivers/input/touchscreen/penmount.c b/drivers/input/touchscreen/penmount.c
index 4ccde45b9da2..b49f0b836925 100644
--- a/drivers/input/touchscreen/penmount.c
+++ b/drivers/input/touchscreen/penmount.c
@@ -264,7 +264,7 @@ static int pm_connect(struct serio *serio, struct serio_driver *drv)
         input_set_abs_params(pm->dev, ABS_Y, 0, max_y, 0, 0);
 
         if (pm->maxcontacts > 1) {
-                input_mt_init_slots(pm->dev, pm->maxcontacts);
+                input_mt_init_slots(pm->dev, pm->maxcontacts, 0);
                 input_set_abs_params(pm->dev,
                                      ABS_MT_POSITION_X, 0, max_x, 0, 0);
                 input_set_abs_params(pm->dev,
diff --git a/drivers/input/touchscreen/s3c2410_ts.c b/drivers/input/touchscreen/s3c2410_ts.c
index bf1a06400067..549fa29548f8 100644
--- a/drivers/input/touchscreen/s3c2410_ts.c
+++ b/drivers/input/touchscreen/s3c2410_ts.c
@@ -37,7 +37,7 @@
 
 #include <plat/adc.h>
 #include <plat/regs-adc.h>
-#include <plat/ts.h>
+#include <linux/platform_data/touchscreen-s3c2410.h>
 
 #define TSC_SLEEP  (S3C2410_ADCTSC_PULL_UP_DISABLE | S3C2410_ADCTSC_XY_PST(0))
 
@@ -406,7 +406,7 @@ static int s3c2410ts_resume(struct device *dev)
         return 0;
 }
 
-static struct dev_pm_ops s3c_ts_pmops = {
+static const struct dev_pm_ops s3c_ts_pmops = {
         .suspend        = s3c2410ts_suspend,
         .resume         = s3c2410ts_resume,
 };
diff --git a/drivers/input/touchscreen/usbtouchscreen.c b/drivers/input/touchscreen/usbtouchscreen.c
index e32709e0dd65..721fdb3597ca 100644
--- a/drivers/input/touchscreen/usbtouchscreen.c
+++ b/drivers/input/touchscreen/usbtouchscreen.c
@@ -304,6 +304,45 @@ static int e2i_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
 #define EGALAX_PKT_TYPE_REPT            0x80
 #define EGALAX_PKT_TYPE_DIAG            0x0A
 
+static int egalax_init(struct usbtouch_usb *usbtouch)
+{
+        int ret, i;
+        unsigned char *buf;
+        struct usb_device *udev = interface_to_usbdev(usbtouch->interface);
+
+        /*
+         * An eGalax diagnostic packet kicks the device into using the right
+         * protocol.  We send a "check active" packet.  The response will be
+         * read later and ignored.
+         */
+
+        buf = kmalloc(3, GFP_KERNEL);
+        if (!buf)
+                return -ENOMEM;
+
+        buf[0] = EGALAX_PKT_TYPE_DIAG;
+        buf[1] = 1;     /* length */
+        buf[2] = 'A';   /* command - check active */
+
+        for (i = 0; i < 3; i++) {
+                ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
+                                      0,
+                                      USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+                                      0, 0, buf, 3,
+                                      USB_CTRL_SET_TIMEOUT);
+                if (ret >= 0) {
+                        ret = 0;
+                        break;
+                }
+                if (ret != -EPIPE)
+                        break;
+        }
+
+        kfree(buf);
+
+        return ret;
+}
+
 static int egalax_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
 {
         if ((pkt[0] & EGALAX_PKT_TYPE_MASK) != EGALAX_PKT_TYPE_REPT)
@@ -1056,6 +1095,7 @@ static struct usbtouch_device_info usbtouch_dev_info[] = {
                 .process_pkt    = usbtouch_process_multi,
                 .get_pkt_len    = egalax_get_pkt_len,
                 .read_data      = egalax_read_data,
+                .init           = egalax_init,
         },
 #endif
 
diff --git a/drivers/input/touchscreen/wacom_w8001.c b/drivers/input/touchscreen/wacom_w8001.c
index 8f9ad2f893b8..9a83be6b6584 100644
--- a/drivers/input/touchscreen/wacom_w8001.c
+++ b/drivers/input/touchscreen/wacom_w8001.c
@@ -471,7 +471,7 @@ static int w8001_setup(struct w8001 *w8001)
                 case 5:
                         w8001->pktlen = W8001_PKTLEN_TOUCH2FG;
 
-                        input_mt_init_slots(dev, 2);
+                        input_mt_init_slots(dev, 2, 0);
                         input_set_abs_params(dev, ABS_MT_POSITION_X,
                                                 0, touch.x, 0, 0);
                         input_set_abs_params(dev, ABS_MT_POSITION_Y,
diff --git a/drivers/input/touchscreen/wm831x-ts.c b/drivers/input/touchscreen/wm831x-ts.c
index e83410721e38..52abb98a8ae5 100644
--- a/drivers/input/touchscreen/wm831x-ts.c
+++ b/drivers/input/touchscreen/wm831x-ts.c
@@ -221,7 +221,7 @@ static void wm831x_ts_input_close(struct input_dev *idev)
         synchronize_irq(wm831x_ts->pd_irq);
 
         /* Make sure the IRQ completion work is quiesced */
-        flush_work_sync(&wm831x_ts->pd_data_work);
+        flush_work(&wm831x_ts->pd_data_work);
 
         /* If we ended up with the pen down then make sure we revert back
          * to pen detection state for the next time we start up.