Merge branch 'for-next' of git://github.com/rydberg/linux into next

Merge Henrik's updates to multitouch code. Even though Jiri already
pulled them in I need to do it too since my changes to evdev using
dynamic major would clash with them.

18 files changed, 671 insertions, 350 deletions

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/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 768e46b05ef0..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:
@@ -1425,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);
@@ -1760,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,
@@ -1787,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;
 }
 
@@ -1825,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;
 
@@ -1837,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/misc/uinput.c b/drivers/input/misc/uinput.c
index 86328e9c9848..a0a4bbaef02c 100644
--- a/drivers/input/misc/uinput.c
+++ b/drivers/input/misc/uinput.c
@@ -416,7 +416,7 @@ static int uinput_setup_device(struct uinput_device *udev,
                         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);
                 }
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/sentelic.c b/drivers/input/mouse/sentelic.c
index 3f5649f19082..b47155d8bc8c 100644
--- a/drivers/input/mouse/sentelic.c
+++ b/drivers/input/mouse/sentelic.c
@@ -960,7 +960,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..37033ade79d3 100644
--- a/drivers/input/mouse/synaptics.c
+++ b/drivers/input/mouse/synaptics.c
@@ -1232,7 +1232,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 +1244,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/tablet/wacom_wac.c b/drivers/input/tablet/wacom_wac.c
index 532d067a9e07..2a81ce375f75 100644
--- a/drivers/input/tablet/wacom_wac.c
+++ b/drivers/input/tablet/wacom_wac.c
@@ -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,
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..7b786e757ba2 100644
--- a/drivers/input/touchscreen/edt-ft5x06.c
+++ b/drivers/input/touchscreen/edt-ft5x06.c
@@ -778,7 +778,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;
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/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,