7 files changed, 233 insertions, 203 deletions

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..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 c703d53be3a0..37033ade79d3 100644
--- a/drivers/input/mouse/synaptics.c
+++ b/drivers/input/mouse/synaptics.c
@@ -40,11 +40,27 @@
  * Note that newer firmware allows querying device for maximum useable
  * coordinates.
  */
+#define XMIN 0
+#define XMAX 6143
+#define YMIN 0
+#define YMAX 6143
 #define XMIN_NOMINAL 1472
 #define XMAX_NOMINAL 5472
 #define YMIN_NOMINAL 1408
 #define YMAX_NOMINAL 4448
 
+/* Size in bits of absolute position values reported by the hardware */
+#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.
+ */
+#define X_MAX_POSITIVE (((1 << ABS_POS_BITS) + XMAX) / 2)
+#define Y_MAX_POSITIVE (((1 << ABS_POS_BITS) + YMAX) / 2)
 
 /*****************************************************************************
  *      Stuff we need even when we do not want native Synaptics support
@@ -139,6 +155,35 @@ static int synaptics_model_id(struct psmouse *psmouse)
 }
 
 /*
+ * Read the board id from the touchpad
+ * The board id is encoded in the "QUERY MODES" response
+ */
+static int synaptics_board_id(struct psmouse *psmouse)
+{
+        struct synaptics_data *priv = psmouse->private;
+        unsigned char bid[3];
+
+        if (synaptics_send_cmd(psmouse, SYN_QUE_MODES, bid))
+                return -1;
+        priv->board_id = ((bid[0] & 0xfc) << 6) | bid[1];
+        return 0;
+}
+
+/*
+ * Read the firmware id from the touchpad
+ */
+static int synaptics_firmware_id(struct psmouse *psmouse)
+{
+        struct synaptics_data *priv = psmouse->private;
+        unsigned char fwid[3];
+
+        if (synaptics_send_cmd(psmouse, SYN_QUE_FIRMWARE_ID, fwid))
+                return -1;
+        priv->firmware_id = (fwid[0] << 16) | (fwid[1] << 8) | fwid[2];
+        return 0;
+}
+
+/*
  * Read the capability-bits from the touchpad
  * see also the SYN_CAP_* macros
  */
@@ -261,6 +306,10 @@ static int synaptics_query_hardware(struct psmouse *psmouse)
                 return -1;
         if (synaptics_model_id(psmouse))
                 return -1;
+        if (synaptics_firmware_id(psmouse))
+                return -1;
+        if (synaptics_board_id(psmouse))
+                return -1;
         if (synaptics_capability(psmouse))
                 return -1;
         if (synaptics_resolution(psmouse))
@@ -555,6 +604,12 @@ static int synaptics_parse_hw_state(const unsigned char buf[],
                 hw->right = (buf[0] & 0x02) ? 1 : 0;
         }
 
+        /* Convert wrap-around values to negative */
+        if (hw->x > X_MAX_POSITIVE)
+                hw->x -= 1 << ABS_POS_BITS;
+        if (hw->y > Y_MAX_POSITIVE)
+                hw->y -= 1 << ABS_POS_BITS;
+
         return 0;
 }
 
@@ -1177,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 */
@@ -1189,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);
         }
@@ -1435,11 +1490,12 @@ static int __synaptics_init(struct psmouse *psmouse, bool absolute_mode)
         priv->pkt_type = SYN_MODEL_NEWABS(priv->model_id) ? SYN_NEWABS : SYN_OLDABS;
 
         psmouse_info(psmouse,
-                     "Touchpad model: %ld, fw: %ld.%ld, id: %#lx, caps: %#lx/%#lx/%#lx\n",
+                     "Touchpad model: %ld, fw: %ld.%ld, id: %#lx, caps: %#lx/%#lx/%#lx, board id: %lu, fw id: %lu\n",
                      SYN_ID_MODEL(priv->identity),
                      SYN_ID_MAJOR(priv->identity), SYN_ID_MINOR(priv->identity),
                      priv->model_id,
-                     priv->capabilities, priv->ext_cap, priv->ext_cap_0c);
+                     priv->capabilities, priv->ext_cap, priv->ext_cap_0c,
+                     priv->board_id, priv->firmware_id);
 
         set_input_params(psmouse->dev, priv);
 
diff --git a/drivers/input/mouse/synaptics.h b/drivers/input/mouse/synaptics.h
index fd26ccca13d7..e594af0b264b 100644
--- a/drivers/input/mouse/synaptics.h
+++ b/drivers/input/mouse/synaptics.h
@@ -18,6 +18,7 @@
 #define SYN_QUE_SERIAL_NUMBER_SUFFIX    0x07
 #define SYN_QUE_RESOLUTION              0x08
 #define SYN_QUE_EXT_CAPAB               0x09
+#define SYN_QUE_FIRMWARE_ID             0x0a
 #define SYN_QUE_EXT_CAPAB_0C            0x0c
 #define SYN_QUE_EXT_MAX_COORDS          0x0d
 #define SYN_QUE_EXT_MIN_COORDS          0x0f
@@ -148,6 +149,8 @@ struct synaptics_hw_state {
 struct synaptics_data {
         /* Data read from the touchpad */
         unsigned long int model_id;             /* Model-ID */
+        unsigned long int firmware_id;          /* Firmware-ID */
+        unsigned long int board_id;             /* Board-ID */
         unsigned long int capabilities;         /* Capabilities */
         unsigned long int ext_cap;              /* Extended Capabilities */
         unsigned long int ext_cap_0c;           /* Ext Caps from 0x0c query */
diff --git a/drivers/input/mouse/synaptics_usb.c b/drivers/input/mouse/synaptics_usb.c
index 3c5eaaa5d154..64cf34ea7604 100644
--- a/drivers/input/mouse/synaptics_usb.c
+++ b/drivers/input/mouse/synaptics_usb.c
@@ -364,7 +364,7 @@ static int synusb_probe(struct usb_interface *intf,
                          le16_to_cpu(udev->descriptor.idProduct));
 
         if (synusb->flags & SYNUSB_STICK)
-                strlcat(synusb->name, " (Stick) ", sizeof(synusb->name));
+                strlcat(synusb->name, " (Stick)", sizeof(synusb->name));
 
         usb_make_path(udev, synusb->phys, sizeof(synusb->phys));
         strlcat(synusb->phys, "/input0", sizeof(synusb->phys));