path: root/x11-drivers/xf86-input-evdev/files/xf86-input-evdev-xi2.1.patch

diff --git a/configure.ac b/configure.ac
index 887021c..b4b0bad 100644
--- a/configure.ac
+++ b/configure.ac
@@ -47,6 +47,9 @@ XORG_DEFAULT_OPTIONS
 # Obtain compiler/linker options from server and required extensions
 PKG_CHECK_MODULES(XORG, xorg-server xproto inputproto)
 
+# Obtain compiler/linker options for mtdev
+PKG_CHECK_MODULES(MTDEV, mtdev)
+
 # Define a configure option for an alternate input module directory
 AC_ARG_WITH(xorg-module-dir,
             AC_HELP_STRING([--with-xorg-module-dir=DIR],
diff --git a/src/Makefile.am b/src/Makefile.am
index a5c89ac..b8d0dd9 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -30,6 +30,7 @@ AM_CPPFLAGS =-I$(top_srcdir)/include
 
 @DRIVER_NAME@_drv_la_LTLIBRARIES = @DRIVER_NAME@_drv.la
 @DRIVER_NAME@_drv_la_LDFLAGS = -module -avoid-version
+@DRIVER_NAME@_drv_la_LIBADD = $(MTDEV_LIBS)
 @DRIVER_NAME@_drv_ladir = @inputdir@
 
 @DRIVER_NAME@_drv_la_SOURCES = @DRIVER_NAME@.c \
diff --git a/src/draglock.c b/src/draglock.c
index af80cf6..0b430f0 100644
--- a/src/draglock.c
+++ b/src/draglock.c
@@ -44,9 +44,7 @@
 
 #include <evdev-properties.h>
 
-#ifdef HAVE_PROPERTIES
 static Atom prop_dlock     = 0; /* Drag lock buttons. */
-#endif
 
 void EvdevDragLockLockButton(InputInfoPtr pInfo, unsigned int button);
 
@@ -211,7 +209,6 @@ EvdevDragLockFilterEvent(InputInfoPtr pInfo, unsigned int button, int value)
     return FALSE;
 }
 
-#ifdef HAVE_PROPERTIES
 /**
  * Set the drag lock property.
  * If only one value is supplied, then this is used as the meta button.
@@ -319,5 +316,3 @@ EvdevDragLockInitProperty(DeviceIntPtr dev)
 
     XIRegisterPropertyHandler(dev, EvdevDragLockSetProperty, NULL, NULL);
 }
-
-#endif
diff --git a/src/emuMB.c b/src/emuMB.c
index 764b30e..b7a57b8 100644
--- a/src/emuMB.c
+++ b/src/emuMB.c
@@ -43,10 +43,8 @@
 
 #include <evdev-properties.h>
 
-#ifdef HAVE_PROPERTIES
 static Atom prop_mbemu     = 0; /* Middle button emulation on/off property */
 static Atom prop_mbtimeout = 0; /* Middle button timeout property */
-#endif
 /*
  * Lets create a simple finite-state machine for 3 button emulation:
  *
@@ -330,7 +328,6 @@ EvdevMBEmuFinalize(InputInfoPtr pInfo)
 
 }
 
-#ifdef HAVE_PROPERTIES
 static int
 EvdevMBEmuSetProperty(DeviceIntPtr dev, Atom atom, XIPropertyValuePtr val,
                       BOOL checkonly)
@@ -391,4 +388,3 @@ EvdevMBEmuInitProperty(DeviceIntPtr dev)
 
     XIRegisterPropertyHandler(dev, EvdevMBEmuSetProperty, NULL, NULL);
 }
-#endif
diff --git a/src/emuWheel.c b/src/emuWheel.c
index 9a53211..715f8d1 100644
--- a/src/emuWheel.c
+++ b/src/emuWheel.c
@@ -44,13 +44,11 @@
 
 #define WHEEL_NOT_CONFIGURED 0
 
-#ifdef HAVE_PROPERTIES
 static Atom prop_wheel_emu      = 0;
 static Atom prop_wheel_axismap  = 0;
 static Atom prop_wheel_inertia  = 0;
 static Atom prop_wheel_timeout  = 0;
 static Atom prop_wheel_button   = 0;
-#endif
 
 /* Local Funciton Prototypes */
 static BOOL EvdevWheelEmuHandleButtonMap(InputInfoPtr pInfo, WheelAxisPtr pAxis, char *axis_name);
@@ -120,8 +118,9 @@ EvdevWheelEmuFilterMotion(InputInfoPtr pInfo, struct input_event *pEv)
 
 	/* We don't want to intercept real mouse wheel events */
 	if(pEv->type == EV_ABS) {
-	    oldValue = pEvdev->vals[pEvdev->axis_map[pEv->code]];
-	    pEvdev->vals[pEvdev->axis_map[pEv->code]] = value;
+	    int axis = pEvdev->axis_map[pEv->code];
+	    oldValue = valuator_mask_get(pEvdev->vals, axis);
+	    valuator_mask_set(pEvdev->vals, axis, value);
 	    value -= oldValue; /* make value into a differential measurement */
 	}
 
@@ -335,7 +334,6 @@ EvdevWheelEmuPreInit(InputInfoPtr pInfo)
             pInfo->name, pEvdev->emulateWheel.button, inertia, timeout);
 }
 
-#ifdef HAVE_PROPERTIES
 static int
 EvdevWheelEmuSetProperty(DeviceIntPtr dev, Atom atom, XIPropertyValuePtr val,
                          BOOL checkonly)
@@ -485,4 +483,3 @@ EvdevWheelEmuInitProperty(DeviceIntPtr dev)
 
     XIRegisterPropertyHandler(dev, EvdevWheelEmuSetProperty, NULL, NULL);
 }
-#endif
diff --git a/src/evdev.c b/src/evdev.c
index 45873c1..ef72f8f 100644
--- a/src/evdev.c
+++ b/src/evdev.c
@@ -48,23 +48,12 @@
 #include <xorgVersion.h>
 #include <xkbsrv.h>
 
-#ifdef HAVE_PROPERTIES
 #include <X11/Xatom.h>
 #include <evdev-properties.h>
 #include <xserver-properties.h>
-/* 1.6 has properties, but no labels */
-#ifdef AXIS_LABEL_PROP
-#define HAVE_LABELS
-#else
-#undef HAVE_LABELS
-#endif
-
-#endif
 
-#if GET_ABI_MAJOR(ABI_XINPUT_VERSION) >= 12
 /* removed from server, purge when dropping support for server 1.10 */
 #define XI86_SEND_DRAG_EVENTS   0x08
-#endif
 
 #ifndef MAXDEVICES
 #include <inputstr.h> /* for MAX_DEVICES */
@@ -87,6 +76,14 @@
 #define MODEFLAG	8
 #define COMPOSEFLAG	16
 
+#ifndef ABS_MT_SLOT
+#define ABS_MT_SLOT 0x2f
+#endif
+
+#ifndef ABS_MT_TRACKING_ID
+#define ABS_MT_TRACKING_ID 0x39
+#endif
+
 static char *evdevDefaults[] = {
     "XkbRules",     "evdev",
     "XkbModel",     "evdev",
@@ -114,7 +111,6 @@ static BOOL EvdevGrabDevice(InputInfoPtr pInfo, int grab, int ungrab);
 static void EvdevSetCalibration(InputInfoPtr pInfo, int num_calibration, int calibration[4]);
 static int EvdevOpenDevice(InputInfoPtr pInfo);
 
-#ifdef HAVE_PROPERTIES
 static void EvdevInitAxesLabels(EvdevPtr pEvdev, int natoms, Atom *atoms);
 static void EvdevInitButtonLabels(EvdevPtr pEvdev, int natoms, Atom *atoms);
 static void EvdevInitProperty(DeviceIntPtr dev);
@@ -125,7 +121,6 @@ static Atom prop_calibration = 0;
 static Atom prop_swap = 0;
 static Atom prop_axis_label = 0;
 static Atom prop_btn_label = 0;
-#endif
 
 /* All devices the evdev driver has allocated and knows about.
  * MAXDEVICES is safe as null-terminated array, as two devices (VCP and VCK)
@@ -302,22 +297,13 @@ EvdevQueueKbdEvent(InputInfoPtr pInfo, struct input_event *ev, int value)
 
     /* Filter all repeated events from device.
        We'll do softrepeat in the server, but only since 1.6 */
-    if (value == 2
-#if GET_ABI_MAJOR(ABI_XINPUT_VERSION) <= 2
-        && (ev->code == KEY_LEFTCTRL || ev->code == KEY_RIGHTCTRL ||
-            ev->code == KEY_LEFTSHIFT || ev->code == KEY_RIGHTSHIFT ||
-            ev->code == KEY_LEFTALT || ev->code == KEY_RIGHTALT ||
-            ev->code == KEY_LEFTMETA || ev->code == KEY_RIGHTMETA ||
-            ev->code == KEY_CAPSLOCK || ev->code == KEY_NUMLOCK ||
-            ev->code == KEY_SCROLLLOCK) /* XXX windows keys? */
-#endif
-            )
-	return;
+    if (value == 2)
+        return;
 
     if ((pQueue = EvdevNextInQueue(pInfo)))
     {
         pQueue->type = EV_QUEUE_KEY;
-        pQueue->key = code;
+        pQueue->detail.key = code;
         pQueue->val = value;
     }
 }
@@ -327,10 +313,14 @@ EvdevQueueButtonEvent(InputInfoPtr pInfo, int button, int value)
 {
     EventQueuePtr pQueue;
 
+    /* Direct touch devices use server side pointer emulation */
+    if (pInfo->dev->touch && pInfo->dev->touch->mode == XIDirectTouch)
+        return;
+
     if ((pQueue = EvdevNextInQueue(pInfo)))
     {
         pQueue->type = EV_QUEUE_BTN;
-        pQueue->key = button;
+        pQueue->detail.key = button;
         pQueue->val = value;
     }
 }
@@ -342,11 +332,27 @@ EvdevQueueProximityEvent(InputInfoPtr pInfo, int value)
     if ((pQueue = EvdevNextInQueue(pInfo)))
     {
         pQueue->type = EV_QUEUE_PROXIMITY;
-        pQueue->key = 0;
+        pQueue->detail.key = 0;
         pQueue->val = value;
     }
 }
 
+#ifdef MULTITOUCH
+void
+EvdevQueueTouchEvent(InputInfoPtr pInfo, unsigned int touch, ValuatorMask *mask,
+                     uint16_t evtype)
+{
+    EventQueuePtr pQueue;
+    if ((pQueue = EvdevNextInQueue(pInfo)))
+    {
+        pQueue->type = EV_QUEUE_TOUCH;
+        pQueue->detail.touch = touch;
+        valuator_mask_copy(pQueue->touch_vals, mask);
+        pQueue->val = evtype;
+    }
+}
+#endif
+
 /**
  * Post button event right here, right now.
  * Interface for MB emulation since these need to post immediately.
@@ -368,41 +374,44 @@ EvdevQueueButtonClicks(InputInfoPtr pInfo, int button, int count)
     }
 }
 
-#define ABS_X_VALUE 0x1
-#define ABS_Y_VALUE 0x2
-#define ABS_VALUE   0x4
 /**
  * Take the valuators and process them accordingly.
  */
 static void
-EvdevProcessValuators(InputInfoPtr pInfo, int v[MAX_VALUATORS], int *num_v,
-                      int *first_v)
+EvdevProcessValuators(InputInfoPtr pInfo)
 {
     int tmp;
     EvdevPtr pEvdev = pInfo->private;
-
-    *num_v = *first_v = 0;
+    int *delta = pEvdev->delta;
 
     /* convert to relative motion for touchpads */
     if (pEvdev->abs_queued && (pEvdev->flags & EVDEV_RELATIVE_MODE)) {
         if (pEvdev->in_proximity) {
-            if (pEvdev->old_vals[0] != -1)
-                pEvdev->delta[REL_X] = pEvdev->vals[0] - pEvdev->old_vals[0];
-            if (pEvdev->old_vals[1] != -1)
-                pEvdev->delta[REL_Y] = pEvdev->vals[1] - pEvdev->old_vals[1];
-            if (pEvdev->abs_queued & ABS_X_VALUE)
-                pEvdev->old_vals[0] = pEvdev->vals[0];
-            if (pEvdev->abs_queued & ABS_Y_VALUE)
-                pEvdev->old_vals[1] = pEvdev->vals[1];
+            if (valuator_mask_isset(pEvdev->vals, 0))
+            {
+                if (valuator_mask_isset(pEvdev->old_vals, 0))
+                    delta[REL_X] = valuator_mask_get(pEvdev->vals, 0) -
+                                   valuator_mask_get(pEvdev->old_vals, 0);
+                valuator_mask_set(pEvdev->old_vals, 0,
+                                  valuator_mask_get(pEvdev->vals, 0));
+            }
+            if (valuator_mask_isset(pEvdev->vals, 1))
+            {
+                if (valuator_mask_isset(pEvdev->old_vals, 1))
+                    delta[REL_Y] = valuator_mask_get(pEvdev->vals, 1) -
+                                   valuator_mask_get(pEvdev->old_vals, 1);
+                valuator_mask_set(pEvdev->old_vals, 1,
+                                  valuator_mask_get(pEvdev->vals, 1));
+            }
         } else {
-            pEvdev->old_vals[0] = pEvdev->old_vals[1] = -1;
+            valuator_mask_zero(pEvdev->old_vals);
         }
+        valuator_mask_zero(pEvdev->vals);
         pEvdev->abs_queued = 0;
         pEvdev->rel_queued = 1;
     }
 
     if (pEvdev->rel_queued) {
-        int first = REL_CNT, last = -1;
         int i;
 
         if (pEvdev->swap_axes) {
@@ -419,19 +428,7 @@ EvdevProcessValuators(InputInfoPtr pInfo, int v[MAX_VALUATORS], int *num_v,
         {
             int map = pEvdev->axis_map[i];
             if (pEvdev->delta[i] && map != -1)
-            {
-                v[map] = pEvdev->delta[i];
-                if (map < first)
-                    first = map;
-                if (map > last)
-                    last = map;
-            }
-        }
-
-        if (last >= 0)
-        {
-            *num_v = (last - first + 1);
-            *first_v = first;
+                valuator_mask_set(pEvdev->vals, map, pEvdev->delta[i]);
         }
     }
     /*
@@ -444,43 +441,46 @@ EvdevProcessValuators(InputInfoPtr pInfo, int v[MAX_VALUATORS], int *num_v,
      * just works.
      */
     else if (pEvdev->abs_queued && pEvdev->in_proximity) {
-        memcpy(v, pEvdev->vals, sizeof(int) * pEvdev->num_vals);
+        int unswapped_x = valuator_mask_get(pEvdev->vals, 0);
+        int unswapped_y = valuator_mask_get(pEvdev->vals, 1);
+        int i;
 
-        if (pEvdev->swap_axes) {
-            int tmp = v[0];
-            v[0] = xf86ScaleAxis(v[1],
-                    pEvdev->absinfo[ABS_X].maximum,
-                    pEvdev->absinfo[ABS_X].minimum,
-                    pEvdev->absinfo[ABS_Y].maximum,
-                    pEvdev->absinfo[ABS_Y].minimum);
-            v[1] = xf86ScaleAxis(tmp,
-                    pEvdev->absinfo[ABS_Y].maximum,
-                    pEvdev->absinfo[ABS_Y].minimum,
-                    pEvdev->absinfo[ABS_X].maximum,
-                    pEvdev->absinfo[ABS_X].minimum);
-        }
+        for (i = 0; i <= 1; i++) {
+            int val;
+            int calib_min;
+            int calib_max;
 
-        if (pEvdev->flags & EVDEV_CALIBRATED)
-        {
-            v[0] = xf86ScaleAxis(v[0],
-                    pEvdev->absinfo[ABS_X].maximum,
-                    pEvdev->absinfo[ABS_X].minimum,
-                    pEvdev->calibration.max_x, pEvdev->calibration.min_x);
-            v[1] = xf86ScaleAxis(v[1],
-                    pEvdev->absinfo[ABS_Y].maximum,
-                    pEvdev->absinfo[ABS_Y].minimum,
-                    pEvdev->calibration.max_y, pEvdev->calibration.min_y);
-        }
+            if (!valuator_mask_isset(pEvdev->vals, i))
+                continue;
 
-        if (pEvdev->invert_x)
-            v[0] = (pEvdev->absinfo[ABS_X].maximum - v[0] +
-                    pEvdev->absinfo[ABS_X].minimum);
-        if (pEvdev->invert_y)
-            v[1] = (pEvdev->absinfo[ABS_Y].maximum - v[1] +
-                    pEvdev->absinfo[ABS_Y].minimum);
+            val = valuator_mask_get(pEvdev->vals, i);
+
+            if (i == 0) {
+                calib_min = pEvdev->calibration.min_x;
+                calib_max = pEvdev->calibration.max_x;
+            } else {
+                calib_min = pEvdev->calibration.min_y;
+                calib_max = pEvdev->calibration.max_y;
+            }
+
+            if (pEvdev->swap_axes)
+                val = xf86ScaleAxis((i == 0 ? unswapped_y : unswapped_x),
+                                    pEvdev->absinfo[i].maximum,
+                                    pEvdev->absinfo[i].minimum,
+                                    pEvdev->absinfo[1 - i].maximum,
+                                    pEvdev->absinfo[1 - i].minimum);
 
-        *num_v = pEvdev->num_vals;
-        *first_v = 0;
+            if (pEvdev->flags & EVDEV_CALIBRATED)
+                val = xf86ScaleAxis(val, pEvdev->absinfo[i].maximum,
+                                    pEvdev->absinfo[i].minimum, calib_max,
+                                    calib_min);
+
+            if ((i == 0 && pEvdev->invert_x) || (i == 1 && pEvdev->invert_y))
+                val = (pEvdev->absinfo[i].maximum - val +
+                       pEvdev->absinfo[i].minimum);
+
+            valuator_mask_set(pEvdev->vals, i, val);
+        }
     }
 }
 
@@ -518,11 +518,15 @@ EvdevProcessProximityState(InputInfoPtr pInfo)
     int prox_state = 0;
     int i;
 
+    /* Does this device have any proximity axes? */
+    if (!pEvdev->prox)
+        return 0;
+
     /* no proximity change in the queue */
     if (!pEvdev->prox_queued)
     {
         if (pEvdev->abs_queued && !pEvdev->in_proximity)
-            pEvdev->abs_prox = pEvdev->abs_queued;
+            valuator_mask_copy(pEvdev->prox, pEvdev->vals);
         return 0;
     }
 
@@ -540,10 +544,11 @@ EvdevProcessProximityState(InputInfoPtr pInfo)
     {
         /* We're about to go into/out of proximity but have no abs events
          * within the EV_SYN. Use the last coordinates we have. */
-        if (!pEvdev->abs_queued && pEvdev->abs_prox)
+        if (!pEvdev->abs_queued &&
+            valuator_mask_num_valuators(pEvdev->prox) > 0)
         {
-            pEvdev->abs_queued = pEvdev->abs_prox;
-            pEvdev->abs_prox = 0;
+            valuator_mask_copy(pEvdev->vals, pEvdev->prox);
+            valuator_mask_zero(pEvdev->prox);
         }
     }
 
@@ -590,6 +595,7 @@ EvdevProcessRelativeMotionEvent(InputInfoPtr pInfo, struct input_event *ev)
 {
     int value;
     EvdevPtr pEvdev = pInfo->private;
+    int map;
 
     /* Get the signed value, earlier kernels had this as unsigned */
     value = ev->value;
@@ -622,10 +628,63 @@ EvdevProcessRelativeMotionEvent(InputInfoPtr pInfo, struct input_event *ev)
 
             pEvdev->rel_queued = 1;
             pEvdev->delta[ev->code] += value;
+            map = pEvdev->axis_map[ev->code];
+            valuator_mask_set(pEvdev->vals, map, value);
             break;
     }
 }
 
+#ifdef MULTITOUCH
+static void
+EvdevProcessTouch(InputInfoPtr pInfo)
+{
+    EvdevPtr pEvdev = pInfo->private;
+
+    if (pEvdev->cur_slot < 0 || !pEvdev->mt_vals ||
+        (!pEvdev->open_slot && !pEvdev->close_slot &&
+         valuator_mask_num_valuators(pEvdev->mt_vals) == 0))
+        return;
+
+    if (pEvdev->close_slot) {
+        EvdevQueueTouchEvent(pInfo, pEvdev->cur_slot, pEvdev->mt_vals,
+                             XI_TouchEnd);
+        pEvdev->close_slot = 0;
+    } else {
+        EvdevQueueTouchEvent(pInfo, pEvdev->cur_slot, pEvdev->mt_vals,
+                             pEvdev->open_slot ? XI_TouchBegin :
+                                                 XI_TouchUpdate);
+        pEvdev->open_slot = 0;
+    }
+
+    valuator_mask_zero(pEvdev->mt_vals);
+}
+
+static void
+EvdevProcessTouchEvent(InputInfoPtr pInfo, struct input_event *ev)
+{
+    EvdevPtr pEvdev = pInfo->private;
+    int map;
+
+    if (ev->code == ABS_MT_SLOT) {
+        EvdevProcessTouch(pInfo);
+        pEvdev->cur_slot = ev->value;
+    } else if (ev->code == ABS_MT_TRACKING_ID) {
+        if (ev->value >= 0) {
+            pEvdev->open_slot = 1;
+            valuator_mask_copy(pEvdev->mt_vals, pEvdev->cur_vals);
+        } else
+            pEvdev->close_slot = 1;
+    } else {
+        map = pEvdev->axis_map[ev->code] - pEvdev->num_vals;
+        valuator_mask_set(pEvdev->mt_vals, map, ev->value);
+        valuator_mask_set(pEvdev->cur_vals, map, ev->value);
+    }
+}
+#else
+#define EvdevProcessTouch(pInfo)
+#define EvdevProcessTouchEvent(pInfo, ev)
+#endif /* MULTITOUCH */
+
 /**
  * Take the absolute motion input event and process it accordingly.
  */
@@ -634,6 +693,7 @@ EvdevProcessAbsoluteMotionEvent(InputInfoPtr pInfo, struct input_event *ev)
 {
     int value;
     EvdevPtr pEvdev = pInfo->private;
+    int map;
 
     /* Get the signed value, earlier kernels had this as unsigned */
     value = ev->value;
@@ -648,13 +708,16 @@ EvdevProcessAbsoluteMotionEvent(InputInfoPtr pInfo, struct input_event *ev)
     if (EvdevWheelEmuFilterMotion(pInfo, ev))
         return;
 
-    pEvdev->vals[pEvdev->axis_map[ev->code]] = value;
-    if (ev->code == ABS_X)
-        pEvdev->abs_queued |= ABS_X_VALUE;
-    else if (ev->code == ABS_Y)
-        pEvdev->abs_queued |= ABS_Y_VALUE;
-    else
-        pEvdev->abs_queued |= ABS_VALUE;
+    if (ev->code >= ABS_MT_SLOT) {
+        EvdevProcessTouchEvent(pInfo, ev);
+        pEvdev->abs_queued = 1;
+    }
+    /* Direct touch devices use server side pointer emulation */
+    else if (!pInfo->dev->touch || pInfo->dev->touch->mode != XIDirectTouch) {
+        map = pEvdev->axis_map[ev->code];
+        valuator_mask_set(pEvdev->vals, map, value);
+        pEvdev->abs_queued = 1;
+    }
 }
 
 /**
@@ -712,7 +775,7 @@ EvdevPostRelativeMotionEvents(InputInfoPtr pInfo, int num_v, int first_v,
     EvdevPtr pEvdev = pInfo->private;
 
     if (pEvdev->rel_queued) {
-        xf86PostMotionEventP(pInfo->dev, FALSE, first_v, num_v, v + first_v);
+        xf86PostMotionEventM(pInfo->dev, FALSE, pEvdev->vals);
     }
 }
 
@@ -735,7 +798,7 @@ EvdevPostAbsoluteMotionEvents(InputInfoPtr pInfo, int num_v, int first_v,
      * this scheme still just work.
      */
     if (pEvdev->abs_queued && pEvdev->in_proximity) {
-        xf86PostMotionEventP(pInfo->dev, TRUE, first_v, num_v, v + first_v);
+        xf86PostMotionEventM(pInfo->dev, TRUE, pEvdev->vals);
     }
 }
 
@@ -750,6 +813,9 @@ EvdevPostProximityEvents(InputInfoPtr pInfo, int which, int num_v, int first_v,
         switch (pEvdev->queue[i].type) {
             case EV_QUEUE_KEY:
             case EV_QUEUE_BTN:
+#ifdef MULTITOUCH
+            case EV_QUEUE_TOUCH:
+#endif
                 break;
             case EV_QUEUE_PROXIMITY:
                 if (pEvdev->queue[i].val == which)
@@ -772,23 +838,28 @@ static void EvdevPostQueuedEvents(InputInfoPtr pInfo, int num_v, int first_v,
     for (i = 0; i < pEvdev->num_queue; i++) {
         switch (pEvdev->queue[i].type) {
         case EV_QUEUE_KEY:
-            xf86PostKeyboardEvent(pInfo->dev, pEvdev->queue[i].key,
+            xf86PostKeyboardEvent(pInfo->dev, pEvdev->queue[i].detail.key,
                                   pEvdev->queue[i].val);
             break;
         case EV_QUEUE_BTN:
-#if GET_ABI_MAJOR(ABI_XINPUT_VERSION) >= 11
             if (pEvdev->abs_queued && pEvdev->in_proximity) {
-                xf86PostButtonEventP(pInfo->dev, 1, pEvdev->queue[i].key,
+                xf86PostButtonEventP(pInfo->dev, 1, pEvdev->queue[i].detail.key,
                                      pEvdev->queue[i].val, first_v, num_v,
                                      v + first_v);
 
             } else
-#endif
-                xf86PostButtonEvent(pInfo->dev, 0, pEvdev->queue[i].key,
+                xf86PostButtonEvent(pInfo->dev, 0, pEvdev->queue[i].detail.key,
                                     pEvdev->queue[i].val, 0, 0);
             break;
         case EV_QUEUE_PROXIMITY:
             break;
+#ifdef MULTITOUCH
+        case EV_QUEUE_TOUCH:
+            xf86PostTouchEvent(pInfo->dev, pEvdev->queue[i].detail.touch,
+                               pEvdev->queue[i].val, 0,
+                               pEvdev->queue[i].touch_vals);
+            break;
+#endif
         }
     }
 }
@@ -806,7 +877,8 @@ EvdevProcessSyncEvent(InputInfoPtr pInfo, struct input_event *ev)
 
     EvdevProcessProximityState(pInfo);
 
-    EvdevProcessValuators(pInfo, v, &num_v, &first_v);
+    EvdevProcessValuators(pInfo);
+    EvdevProcessTouch(pInfo);
 
     EvdevPostProximityEvents(pInfo, TRUE, num_v, first_v, v);
     EvdevPostRelativeMotionEvents(pInfo, num_v, first_v, v);
@@ -815,7 +887,8 @@ EvdevProcessSyncEvent(InputInfoPtr pInfo, struct input_event *ev)
     EvdevPostProximityEvents(pInfo, FALSE, num_v, first_v, v);
 
     memset(pEvdev->delta, 0, sizeof(pEvdev->delta));
-    memset(pEvdev->queue, 0, sizeof(pEvdev->queue));
+    if (pEvdev->vals)
+        valuator_mask_zero(pEvdev->vals);
     pEvdev->num_queue = 0;
     pEvdev->abs_queued = 0;
     pEvdev->rel_queued = 0;
@@ -861,7 +934,17 @@ EvdevReadInput(InputInfoPtr pInfo)
 
     while (len == sizeof(ev))
     {
-        len = read(pInfo->fd, &ev, sizeof(ev));
+#ifdef MULTITOUCH
+        EvdevPtr pEvdev = pInfo->private;
+
+        if (pEvdev->mtdev)
+            len = mtdev_get(pEvdev->mtdev, pInfo->fd, ev, NUM_EVENTS) *
+                sizeof(struct input_event);
+        else
+            len = read(pInfo->fd, &ev, sizeof(ev));
+#else
+            len = read(pInfo->fd, &ev, sizeof(ev));
+#endif
         if (len <= 0)
         {
             if (errno == ENODEV) /* May happen after resume */
@@ -900,317 +983,6 @@ EvdevPtrCtrlProc(DeviceIntPtr device, PtrCtrl *ctrl)
     /* Nothing to do, dix handles all settings */
 }
 
-#if GET_ABI_MAJOR(ABI_XINPUT_VERSION) < 5
-static KeySym map[] = {
-    /* 0x00 */  NoSymbol,       NoSymbol,
-    /* 0x01 */  XK_Escape,      NoSymbol,
-    /* 0x02 */  XK_1,           XK_exclam,
-    /* 0x03 */  XK_2,           XK_at,
-    /* 0x04 */  XK_3,           XK_numbersign,
-    /* 0x05 */  XK_4,           XK_dollar,
-    /* 0x06 */  XK_5,           XK_percent,
-    /* 0x07 */  XK_6,           XK_asciicircum,
-    /* 0x08 */  XK_7,           XK_ampersand,
-    /* 0x09 */  XK_8,           XK_asterisk,
-    /* 0x0a */  XK_9,           XK_parenleft,
-    /* 0x0b */  XK_0,           XK_parenright,
-    /* 0x0c */  XK_minus,       XK_underscore,
-    /* 0x0d */  XK_equal,       XK_plus,
-    /* 0x0e */  XK_BackSpace,   NoSymbol,
-    /* 0x0f */  XK_Tab,         XK_ISO_Left_Tab,
-    /* 0x10 */  XK_Q,           NoSymbol,
-    /* 0x11 */  XK_W,           NoSymbol,
-    /* 0x12 */  XK_E,           NoSymbol,
-    /* 0x13 */  XK_R,           NoSymbol,
-    /* 0x14 */  XK_T,           NoSymbol,
-    /* 0x15 */  XK_Y,           NoSymbol,
-    /* 0x16 */  XK_U,           NoSymbol,
-    /* 0x17 */  XK_I,           NoSymbol,
-    /* 0x18 */  XK_O,           NoSymbol,
-    /* 0x19 */  XK_P,           NoSymbol,
-    /* 0x1a */  XK_bracketleft, XK_braceleft,
-    /* 0x1b */  XK_bracketright,XK_braceright,
-    /* 0x1c */  XK_Return,      NoSymbol,
-    /* 0x1d */  XK_Control_L,   NoSymbol,
-    /* 0x1e */  XK_A,           NoSymbol,
-    /* 0x1f */  XK_S,           NoSymbol,
-    /* 0x20 */  XK_D,           NoSymbol,
-    /* 0x21 */  XK_F,           NoSymbol,
-    /* 0x22 */  XK_G,           NoSymbol,
-    /* 0x23 */  XK_H,           NoSymbol,
-    /* 0x24 */  XK_J,           NoSymbol,
-    /* 0x25 */  XK_K,           NoSymbol,
-    /* 0x26 */  XK_L,           NoSymbol,
-    /* 0x27 */  XK_semicolon,   XK_colon,
-    /* 0x28 */  XK_quoteright,  XK_quotedbl,
-    /* 0x29 */  XK_quoteleft,	XK_asciitilde,
-    /* 0x2a */  XK_Shift_L,     NoSymbol,
-    /* 0x2b */  XK_backslash,   XK_bar,
-    /* 0x2c */  XK_Z,           NoSymbol,
-    /* 0x2d */  XK_X,           NoSymbol,
-    /* 0x2e */  XK_C,           NoSymbol,
-    /* 0x2f */  XK_V,           NoSymbol,
-    /* 0x30 */  XK_B,           NoSymbol,
-    /* 0x31 */  XK_N,           NoSymbol,
-    /* 0x32 */  XK_M,           NoSymbol,
-    /* 0x33 */  XK_comma,       XK_less,
-    /* 0x34 */  XK_period,      XK_greater,
-    /* 0x35 */  XK_slash,       XK_question,
-    /* 0x36 */  XK_Shift_R,     NoSymbol,
-    /* 0x37 */  XK_KP_Multiply, NoSymbol,
-    /* 0x38 */  XK_Alt_L,	XK_Meta_L,
-    /* 0x39 */  XK_space,       NoSymbol,
-    /* 0x3a */  XK_Caps_Lock,   NoSymbol,
-    /* 0x3b */  XK_F1,          NoSymbol,
-    /* 0x3c */  XK_F2,          NoSymbol,
-    /* 0x3d */  XK_F3,          NoSymbol,
-    /* 0x3e */  XK_F4,          NoSymbol,
-    /* 0x3f */  XK_F5,          NoSymbol,
-    /* 0x40 */  XK_F6,          NoSymbol,
-    /* 0x41 */  XK_F7,          NoSymbol,
-    /* 0x42 */  XK_F8,          NoSymbol,
-    /* 0x43 */  XK_F9,          NoSymbol,
-    /* 0x44 */  XK_F10,         NoSymbol,
-    /* 0x45 */  XK_Num_Lock,    NoSymbol,
-    /* 0x46 */  XK_Scroll_Lock,	NoSymbol,
-    /* These KP keys should have the KP_7 keysyms in the numlock
-     * modifer... ? */
-    /* 0x47 */  XK_KP_Home,	XK_KP_7,
-    /* 0x48 */  XK_KP_Up,	XK_KP_8,
-    /* 0x49 */  XK_KP_Prior,	XK_KP_9,
-    /* 0x4a */  XK_KP_Subtract, NoSymbol,
-    /* 0x4b */  XK_KP_Left,	XK_KP_4,
-    /* 0x4c */  XK_KP_Begin,	XK_KP_5,
-    /* 0x4d */  XK_KP_Right,	XK_KP_6,
-    /* 0x4e */  XK_KP_Add,      NoSymbol,
-    /* 0x4f */  XK_KP_End,	XK_KP_1,
-    /* 0x50 */  XK_KP_Down,	XK_KP_2,
-    /* 0x51 */  XK_KP_Next,	XK_KP_3,
-    /* 0x52 */  XK_KP_Insert,	XK_KP_0,
-    /* 0x53 */  XK_KP_Delete,	XK_KP_Decimal,
-    /* 0x54 */  NoSymbol,	NoSymbol,
-    /* 0x55 */  XK_F13,		NoSymbol,
-    /* 0x56 */  XK_less,	XK_greater,
-    /* 0x57 */  XK_F11,		NoSymbol,
-    /* 0x58 */  XK_F12,		NoSymbol,
-    /* 0x59 */  XK_F14,		NoSymbol,
-    /* 0x5a */  XK_F15,		NoSymbol,
-    /* 0x5b */  XK_F16,		NoSymbol,
-    /* 0x5c */  XK_F17,		NoSymbol,
-    /* 0x5d */  XK_F18,		NoSymbol,
-    /* 0x5e */  XK_F19,		NoSymbol,
-    /* 0x5f */  XK_F20,		NoSymbol,
-    /* 0x60 */  XK_KP_Enter,	NoSymbol,
-    /* 0x61 */  XK_Control_R,	NoSymbol,
-    /* 0x62 */  XK_KP_Divide,	NoSymbol,
-    /* 0x63 */  XK_Print,	XK_Sys_Req,
-    /* 0x64 */  XK_Alt_R,	XK_Meta_R,
-    /* 0x65 */  NoSymbol,	NoSymbol, /* KEY_LINEFEED */
-    /* 0x66 */  XK_Home,	NoSymbol,
-    /* 0x67 */  XK_Up,		NoSymbol,
-    /* 0x68 */  XK_Prior,	NoSymbol,
-    /* 0x69 */  XK_Left,	NoSymbol,
-    /* 0x6a */  XK_Right,	NoSymbol,
-    /* 0x6b */  XK_End,		NoSymbol,
-    /* 0x6c */  XK_Down,	NoSymbol,
-    /* 0x6d */  XK_Next,	NoSymbol,
-    /* 0x6e */  XK_Insert,	NoSymbol,
-    /* 0x6f */  XK_Delete,	NoSymbol,
-    /* 0x70 */  NoSymbol,	NoSymbol, /* KEY_MACRO */
-    /* 0x71 */  NoSymbol,	NoSymbol,
-    /* 0x72 */  NoSymbol,	NoSymbol,
-    /* 0x73 */  NoSymbol,	NoSymbol,
-    /* 0x74 */  NoSymbol,	NoSymbol,
-    /* 0x75 */  XK_KP_Equal,	NoSymbol,
-    /* 0x76 */  NoSymbol,	NoSymbol,
-    /* 0x77 */  NoSymbol,	NoSymbol,
-    /* 0x78 */  XK_F21,		NoSymbol,
-    /* 0x79 */  XK_F22,		NoSymbol,
-    /* 0x7a */  XK_F23,		NoSymbol,
-    /* 0x7b */  XK_F24,		NoSymbol,
-    /* 0x7c */  XK_KP_Separator, NoSymbol,
-    /* 0x7d */  XK_Meta_L,	NoSymbol,
-    /* 0x7e */  XK_Meta_R,	NoSymbol,
-    /* 0x7f */  XK_Multi_key,	NoSymbol,
-    /* 0x80 */  NoSymbol,	NoSymbol,
-    /* 0x81 */  NoSymbol,	NoSymbol,
-    /* 0x82 */  NoSymbol,	NoSymbol,
-    /* 0x83 */  NoSymbol,	NoSymbol,
-    /* 0x84 */  NoSymbol,	NoSymbol,
-    /* 0x85 */  NoSymbol,	NoSymbol,
-    /* 0x86 */  NoSymbol,	NoSymbol,
-    /* 0x87 */  NoSymbol,	NoSymbol,
-    /* 0x88 */  NoSymbol,	NoSymbol,
-    /* 0x89 */  NoSymbol,	NoSymbol,
-    /* 0x8a */  NoSymbol,	NoSymbol,
-    /* 0x8b */  NoSymbol,	NoSymbol,
-    /* 0x8c */  NoSymbol,	NoSymbol,
-    /* 0x8d */  NoSymbol,	NoSymbol,
-    /* 0x8e */  NoSymbol,	NoSymbol,
-    /* 0x8f */  NoSymbol,	NoSymbol,
-    /* 0x90 */  NoSymbol,	NoSymbol,
-    /* 0x91 */  NoSymbol,	NoSymbol,
-    /* 0x92 */  NoSymbol,	NoSymbol,
-    /* 0x93 */  NoSymbol,	NoSymbol,
-    /* 0x94 */  NoSymbol,	NoSymbol,
-    /* 0x95 */  NoSymbol,	NoSymbol,
-    /* 0x96 */  NoSymbol,	NoSymbol,
-    /* 0x97 */  NoSymbol,	NoSymbol,
-    /* 0x98 */  NoSymbol,	NoSymbol,
-    /* 0x99 */  NoSymbol,	NoSymbol,
-    /* 0x9a */  NoSymbol,	NoSymbol,
-    /* 0x9b */  NoSymbol,	NoSymbol,
-    /* 0x9c */  NoSymbol,	NoSymbol,
-    /* 0x9d */  NoSymbol,	NoSymbol,
-    /* 0x9e */  NoSymbol,	NoSymbol,
-    /* 0x9f */  NoSymbol,	NoSymbol,
-    /* 0xa0 */  NoSymbol,	NoSymbol,
-    /* 0xa1 */  NoSymbol,	NoSymbol,
-    /* 0xa2 */  NoSymbol,	NoSymbol,
-    /* 0xa3 */  NoSymbol,	NoSymbol,
-    /* 0xa4 */  NoSymbol,	NoSymbol,
-    /* 0xa5 */  NoSymbol,	NoSymbol,
-    /* 0xa6 */  NoSymbol,	NoSymbol,
-    /* 0xa7 */  NoSymbol,	NoSymbol,
-    /* 0xa8 */  NoSymbol,	NoSymbol,
-    /* 0xa9 */  NoSymbol,	NoSymbol,
-    /* 0xaa */  NoSymbol,	NoSymbol,
-    /* 0xab */  NoSymbol,	NoSymbol,
-    /* 0xac */  NoSymbol,	NoSymbol,
-    /* 0xad */  NoSymbol,	NoSymbol,
-    /* 0xae */  NoSymbol,	NoSymbol,
-    /* 0xaf */  NoSymbol,	NoSymbol,
-    /* 0xb0 */  NoSymbol,	NoSymbol,
-    /* 0xb1 */  NoSymbol,	NoSymbol,
-    /* 0xb2 */  NoSymbol,	NoSymbol,
-    /* 0xb3 */  NoSymbol,	NoSymbol,
-    /* 0xb4 */  NoSymbol,	NoSymbol,
-    /* 0xb5 */  NoSymbol,	NoSymbol,
-    /* 0xb6 */  NoSymbol,	NoSymbol,
-    /* 0xb7 */  NoSymbol,	NoSymbol,
-    /* 0xb8 */  NoSymbol,	NoSymbol,
-    /* 0xb9 */  NoSymbol,	NoSymbol,
-    /* 0xba */  NoSymbol,	NoSymbol,
-    /* 0xbb */  NoSymbol,	NoSymbol,
-    /* 0xbc */  NoSymbol,	NoSymbol,
-    /* 0xbd */  NoSymbol,	NoSymbol,
-    /* 0xbe */  NoSymbol,	NoSymbol,
-    /* 0xbf */  NoSymbol,	NoSymbol,
-    /* 0xc0 */  NoSymbol,	NoSymbol,
-    /* 0xc1 */  NoSymbol,	NoSymbol,
-    /* 0xc2 */  NoSymbol,	NoSymbol,
-    /* 0xc3 */  NoSymbol,	NoSymbol,
-    /* 0xc4 */  NoSymbol,	NoSymbol,
-    /* 0xc5 */  NoSymbol,	NoSymbol,
-    /* 0xc6 */  NoSymbol,	NoSymbol,
-    /* 0xc7 */  NoSymbol,	NoSymbol,
-    /* 0xc8 */  NoSymbol,	NoSymbol,
-    /* 0xc9 */  NoSymbol,	NoSymbol,
-    /* 0xca */  NoSymbol,	NoSymbol,
-    /* 0xcb */  NoSymbol,	NoSymbol,
-    /* 0xcc */  NoSymbol,	NoSymbol,
-    /* 0xcd */  NoSymbol,	NoSymbol,
-    /* 0xce */  NoSymbol,	NoSymbol,
-    /* 0xcf */  NoSymbol,	NoSymbol,
-    /* 0xd0 */  NoSymbol,	NoSymbol,
-    /* 0xd1 */  NoSymbol,	NoSymbol,
-    /* 0xd2 */  NoSymbol,	NoSymbol,
-    /* 0xd3 */  NoSymbol,	NoSymbol,
-    /* 0xd4 */  NoSymbol,	NoSymbol,
-    /* 0xd5 */  NoSymbol,	NoSymbol,
-    /* 0xd6 */  NoSymbol,	NoSymbol,
-    /* 0xd7 */  NoSymbol,	NoSymbol,
-    /* 0xd8 */  NoSymbol,	NoSymbol,
-    /* 0xd9 */  NoSymbol,	NoSymbol,
-    /* 0xda */  NoSymbol,	NoSymbol,
-    /* 0xdb */  NoSymbol,	NoSymbol,
-    /* 0xdc */  NoSymbol,	NoSymbol,
-    /* 0xdd */  NoSymbol,	NoSymbol,
-    /* 0xde */  NoSymbol,	NoSymbol,
-    /* 0xdf */  NoSymbol,	NoSymbol,
-    /* 0xe0 */  NoSymbol,	NoSymbol,
-    /* 0xe1 */  NoSymbol,	NoSymbol,
-    /* 0xe2 */  NoSymbol,	NoSymbol,
-    /* 0xe3 */  NoSymbol,	NoSymbol,
-    /* 0xe4 */  NoSymbol,	NoSymbol,
-    /* 0xe5 */  NoSymbol,	NoSymbol,
-    /* 0xe6 */  NoSymbol,	NoSymbol,
-    /* 0xe7 */  NoSymbol,	NoSymbol,
-    /* 0xe8 */  NoSymbol,	NoSymbol,
-    /* 0xe9 */  NoSymbol,	NoSymbol,
-    /* 0xea */  NoSymbol,	NoSymbol,
-    /* 0xeb */  NoSymbol,	NoSymbol,
-    /* 0xec */  NoSymbol,	NoSymbol,
-    /* 0xed */  NoSymbol,	NoSymbol,
-    /* 0xee */  NoSymbol,	NoSymbol,
-    /* 0xef */  NoSymbol,	NoSymbol,
-    /* 0xf0 */  NoSymbol,	NoSymbol,
-    /* 0xf1 */  NoSymbol,	NoSymbol,
-    /* 0xf2 */  NoSymbol,	NoSymbol,
-    /* 0xf3 */  NoSymbol,	NoSymbol,
-    /* 0xf4 */  NoSymbol,	NoSymbol,
-    /* 0xf5 */  NoSymbol,	NoSymbol,
-    /* 0xf6 */  NoSymbol,	NoSymbol,
-    /* 0xf7 */  NoSymbol,	NoSymbol,
-};
-
-static struct { KeySym keysym; CARD8 mask; } modifiers[] = {
-    { XK_Shift_L,		ShiftMask },
-    { XK_Shift_R,		ShiftMask },
-    { XK_Control_L,		ControlMask },
-    { XK_Control_R,		ControlMask },
-    { XK_Caps_Lock,		LockMask },
-    { XK_Alt_L,		AltMask },
-    { XK_Alt_R,		AltMask },
-    { XK_Meta_L,		Mod4Mask },
-    { XK_Meta_R,		Mod4Mask },
-    { XK_Num_Lock,		NumLockMask },
-    { XK_Scroll_Lock,	ScrollLockMask },
-    { XK_Mode_switch,	AltLangMask }
-};
-
-/* Server 1.6 and earlier */
-static int
-EvdevInitKeysyms(DeviceIntPtr device)
-{
-    InputInfoPtr pInfo;
-    EvdevPtr pEvdev;
-    KeySymsRec keySyms;
-    CARD8 modMap[MAP_LENGTH];
-    KeySym sym;
-    int i, j;
-
-    pInfo = device->public.devicePrivate;
-    pEvdev = pInfo->private;
-
-     /* Compute the modifier map */
-    memset(modMap, 0, sizeof modMap);
-
-    for (i = 0; i < ArrayLength(map) / GLYPHS_PER_KEY; i++) {
-        sym = map[i * GLYPHS_PER_KEY];
-        for (j = 0; j < ArrayLength(modifiers); j++) {
-            if (modifiers[j].keysym == sym)
-                modMap[i + MIN_KEYCODE] = modifiers[j].mask;
-        }
-    }
-
-    keySyms.map        = map;
-    keySyms.mapWidth   = GLYPHS_PER_KEY;
-    keySyms.minKeyCode = MIN_KEYCODE;
-    keySyms.maxKeyCode = MIN_KEYCODE + ArrayLength(map) / GLYPHS_PER_KEY - 1;
-
-    XkbSetRulesDflts(pEvdev->rmlvo.rules, pEvdev->rmlvo.model,
-            pEvdev->rmlvo.layout, pEvdev->rmlvo.variant,
-            pEvdev->rmlvo.options);
-    if (!XkbInitKeyboardDeviceStruct(device, &pEvdev->xkbnames,
-                &keySyms, modMap, NULL,
-                EvdevKbdCtrl))
-        return 0;
-
-    return 1;
-}
-#endif
-
 static void
 EvdevKbdCtrl(DeviceIntPtr device, KeybdCtrl *ctrl)
 {
@@ -1263,14 +1035,8 @@ EvdevAddKeyClass(DeviceIntPtr device)
     if (!pEvdev->rmlvo.options)
         SetXkbOption(pInfo, "XkbOptions", &pEvdev->rmlvo.options);
 
-#if GET_ABI_MAJOR(ABI_XINPUT_VERSION) >= 5
     if (!InitKeyboardDeviceStruct(device, &pEvdev->rmlvo, NULL, EvdevKbdCtrl))
         return !Success;
-#else
-    if (!EvdevInitKeysyms(device))
-        return !Success;
-
-#endif
 
     return Success;
 }
@@ -1280,53 +1046,114 @@ EvdevAddAbsClass(DeviceIntPtr device)
 {
     InputInfoPtr pInfo;
     EvdevPtr pEvdev;
-    int num_axes, axis, i = 0;
+    int num_axes, num_mt_axes, axis, i = 0;
     Atom *atoms;
 
     pInfo = device->public.devicePrivate;
     pEvdev = pInfo->private;
 
     if (!TestBit(EV_ABS, pEvdev->bitmask))
-            return !Success;
+        goto out;
 
-    num_axes = EvdevCountBits(pEvdev->abs_bitmask, NLONGS(ABS_MAX));
-    if (num_axes < 1)
-        return !Success;
+    num_axes = CountBits((uint8_t *)pEvdev->abs_bitmask, ABS_MT_SLOT);
+    num_mt_axes = CountBits((uint8_t *)pEvdev->abs_bitmask, ABS_CNT) - num_axes;
 
     if (num_axes > MAX_VALUATORS) {
         xf86Msg(X_WARNING, "%s: found %d axes, limiting to %d.\n", device->name, num_axes, MAX_VALUATORS);
         num_axes = MAX_VALUATORS;
     }
 
+#ifdef MULTITOUCH
+    if (TestBit(ABS_MT_SLOT, pEvdev->abs_bitmask))
+        num_mt_axes--;
+    if (TestBit(ABS_MT_TRACKING_ID, pEvdev->abs_bitmask))
+        num_mt_axes--;
+
+    if (num_mt_axes > MAX_VALUATORS) {
+        xf86Msg(X_WARNING, "%s: found %d MT axes, limiting to %d.\n", device->name, num_axes, MAX_VALUATORS);
+        num_mt_axes = MAX_VALUATORS;
+    }
+#endif
+
+    if (num_axes < 1 && num_mt_axes < 1) {
+        xf86Msg(X_WARNING, "%s: no absolute or touch axes found.\n",
+                device->name);
+        goto out;
+    }
+
     pEvdev->num_vals = num_axes;
-    memset(pEvdev->vals, 0, num_axes * sizeof(int));
-    memset(pEvdev->old_vals, -1, num_axes * sizeof(int));
-    atoms = malloc(pEvdev->num_vals * sizeof(Atom));
+    if (num_axes > 0) {
+        pEvdev->vals = valuator_mask_new(num_axes);
+        pEvdev->old_vals = valuator_mask_new(num_axes);
+        if (!pEvdev->vals || !pEvdev->old_vals) {
+            xf86Msg(X_ERROR, "%s: failed to allocate valuator masks.\n",
+                    device->name);
+            goto out;
+        }
+    }
+#ifdef MULTITOUCH
+    pEvdev->num_mt_vals = num_mt_axes;
+    if (num_mt_axes > 0) {
+        pEvdev->mt_vals = valuator_mask_new(num_mt_axes);
+        pEvdev->cur_vals = valuator_mask_new(num_mt_axes);
+        if (!pEvdev->mt_vals || !pEvdev->cur_vals) {
+            xf86Msg(X_ERROR, "%s: failed to allocate MT valuator mask.\n",
+                    device->name);
+            goto out;
+        }
 
+        for (i = 0; i < EVDEV_MAXQUEUE; i++) {
+            pEvdev->queue[i].touch_vals =
+                valuator_mask_new(num_mt_axes);
+            if (!pEvdev->queue[i].touch_vals) {
+                xf86Msg(X_ERROR, "%s: failed to allocate MT valuator masks for "
+                        "evdev event queue.\n", device->name);
+                goto out;
+            }
+        }
+    }
+#endif
+    atoms = malloc((pEvdev->num_vals + num_mt_axes) * sizeof(Atom));
+
+    i = 0;
     for (axis = ABS_X; i < MAX_VALUATORS && axis <= ABS_MAX; axis++) {
         pEvdev->axis_map[axis] = -1;
-        if (!TestBit(axis, pEvdev->abs_bitmask))
+        if (!TestBit(axis, pEvdev->abs_bitmask) || axis == ABS_MT_SLOT ||
+            axis == ABS_MT_TRACKING_ID)
             continue;
         pEvdev->axis_map[axis] = i;
         i++;
     }
 
-    EvdevInitAxesLabels(pEvdev, pEvdev->num_vals, atoms);
+    EvdevInitAxesLabels(pEvdev, pEvdev->num_vals + num_mt_axes, atoms);
 
-    if (!InitValuatorClassDeviceStruct(device, num_axes,
-#if GET_ABI_MAJOR(ABI_XINPUT_VERSION) >= 7
-                                       atoms,
-#endif
-#if GET_ABI_MAJOR(ABI_XINPUT_VERSION) < 3
-                                       GetMotionHistory,
-#endif
+    if (!InitValuatorClassDeviceStruct(device, num_axes, atoms,
                                        GetMotionHistorySize(), Absolute)) {
         xf86Msg(X_ERROR, "%s: failed to initialize valuator class device.\n",
                 device->name);
-        return !Success;
+        goto out;
+    }
+
+#ifdef MULTITOUCH
+    if (num_mt_axes > 0)
+    {
+        int num_touches = 10;
+        int mode = pEvdev->flags & EVDEV_TOUCHPAD ?
+            XIDependentTouch : XIDirectTouch;
+
+        if (pEvdev->mtdev->caps.slot.maximum > 0)
+            num_touches = pEvdev->mtdev->caps.slot.maximum;
+
+        if (!InitTouchClassDeviceStruct(device, num_touches, mode,
+                                        num_mt_axes)) {
+            xf86Msg(X_ERROR, "%s: failed to initialize touch class device.\n",
+                    device->name);
+            goto out;
+        }
     }
+#endif
 
-    for (axis = ABS_X; axis <= ABS_MAX; axis++) {
+    for (axis = ABS_X; axis < ABS_MT_SLOT; axis++) {
         int axnum = pEvdev->axis_map[axis];
         int resolution = 10000;
 
@@ -1340,20 +1167,32 @@ EvdevAddAbsClass(DeviceIntPtr device)
 #endif
 
         xf86InitValuatorAxisStruct(device, axnum,
-#if GET_ABI_MAJOR(ABI_XINPUT_VERSION) >= 7
                                    atoms[axnum],
-#endif
                                    pEvdev->absinfo[axis].minimum,
                                    pEvdev->absinfo[axis].maximum,
-                                   resolution, 0, resolution
-#if GET_ABI_MAJOR(ABI_XINPUT_VERSION) >= 12
-                                   , Absolute
-#endif
-                                   );
+                                   resolution, 0, resolution, Absolute);
         xf86InitValuatorDefaults(device, axnum);
-        pEvdev->old_vals[axnum] = -1;
     }
 
+#ifdef MULTITOUCH
+    for (axis = ABS_MT_TOUCH_MAJOR; axis <= ABS_MAX; axis++) {
+        int axnum = pEvdev->axis_map[axis] - pEvdev->num_vals;
+        int resolution = 10000;
+
+        if (axnum < 0)
+            continue;
+
+        if (pEvdev->absinfo[axis].resolution)
+            resolution = pEvdev->absinfo[axis].resolution * 1000;
+
+        xf86InitTouchValuatorAxisStruct(device, axnum,
+                                        atoms[axnum + pEvdev->num_vals],
+                                        pEvdev->absinfo[axis].minimum,
+                                        pEvdev->absinfo[axis].maximum,
+                                        pEvdev->absinfo[axis].resolution);
+    }
+#endif
+
     free(atoms);
 
     for (i = 0; i < ArrayLength(proximity_bits); i++)
@@ -1364,6 +1203,12 @@ EvdevAddAbsClass(DeviceIntPtr device)
         if (TestBit(proximity_bits[i], pEvdev->key_bitmask))
         {
             InitProximityClassDeviceStruct(device);
+            pEvdev->prox = valuator_mask_new(num_axes);
+            if (!pEvdev->prox) {
+                xf86Msg(X_ERROR, "%s: failed to allocate proximity valuator "
+                        "mask.\n", device->name);
+                goto out;
+            }
             break;
         }
     }
@@ -1371,7 +1216,7 @@ EvdevAddAbsClass(DeviceIntPtr device)
     if (!InitPtrFeedbackClassDeviceStruct(device, EvdevPtrCtrlProc)) {
         xf86Msg(X_ERROR, "%s: failed to initialize pointer feedback class "
                 "device.\n", device->name);
-        return !Success;
+        goto out;
     }
 
     if (pEvdev->flags & EVDEV_TOUCHPAD)
@@ -1393,6 +1238,18 @@ EvdevAddAbsClass(DeviceIntPtr device)
     }
 
     return Success;
+
+out:
+#ifdef MULTITOUCH
+    valuator_mask_free(&pEvdev->mt_vals);
+    valuator_mask_free(&pEvdev->cur_vals);
+    for (i = 0; i < EVDEV_MAXQUEUE; i++)
+        valuator_mask_free(&pEvdev->queue[i].touch_vals);
+#endif
+    valuator_mask_free(&pEvdev->vals);
+    valuator_mask_free(&pEvdev->old_vals);
+    valuator_mask_free(&pEvdev->prox);
+    return !Success;
 }
 
 static int
@@ -1407,11 +1264,11 @@ EvdevAddRelClass(DeviceIntPtr device)
     pEvdev = pInfo->private;
 
     if (!TestBit(EV_REL, pEvdev->bitmask))
-        return !Success;
+        goto out;
 
     num_axes = EvdevCountBits(pEvdev->rel_bitmask, NLONGS(REL_MAX));
     if (num_axes < 1)
-        return !Success;
+        goto out;
 
     /* Wheels are special, we post them as button events. So let's ignore them
      * in the axes list too */
@@ -1423,7 +1280,7 @@ EvdevAddRelClass(DeviceIntPtr device)
         num_axes--;
 
     if (num_axes <= 0)
-        return !Success;
+        goto out;
 
     if (num_axes > MAX_VALUATORS) {
         xf86Msg(X_WARNING, "%s: found %d axes, limiting to %d.\n", device->name, num_axes, MAX_VALUATORS);
@@ -1431,7 +1288,11 @@ EvdevAddRelClass(DeviceIntPtr device)
     }
 
     pEvdev->num_vals = num_axes;
-    memset(pEvdev->vals, 0, num_axes * sizeof(int));
+    if (num_axes > 0) {
+        pEvdev->vals = valuator_mask_new(num_axes);
+        if (!pEvdev->vals)
+            goto out;
+    }
     atoms = malloc(pEvdev->num_vals * sizeof(Atom));
 
     for (axis = REL_X; i < MAX_VALUATORS && axis <= REL_MAX; axis++)
@@ -1448,23 +1309,17 @@ EvdevAddRelClass(DeviceIntPtr device)
 
     EvdevInitAxesLabels(pEvdev, pEvdev->num_vals, atoms);
 
-    if (!InitValuatorClassDeviceStruct(device, num_axes,
-#if GET_ABI_MAJOR(ABI_XINPUT_VERSION) >= 7
-                                       atoms,
-#endif
-#if GET_ABI_MAJOR(ABI_XINPUT_VERSION) < 3
-                                       GetMotionHistory,
-#endif
+    if (!InitValuatorClassDeviceStruct(device, num_axes, atoms,
                                        GetMotionHistorySize(), Relative)) {
         xf86Msg(X_ERROR, "%s: failed to initialize valuator class device.\n",
                 device->name);
-        return !Success;
+        goto out;
     }
 
     if (!InitPtrFeedbackClassDeviceStruct(device, EvdevPtrCtrlProc)) {
         xf86Msg(X_ERROR, "%s: failed to initialize pointer feedback class "
                 "device.\n", device->name);
-        return !Success;
+        goto out;
     }
 
     for (axis = REL_X; axis <= REL_MAX; axis++)
@@ -1473,21 +1328,18 @@ EvdevAddRelClass(DeviceIntPtr device)
 
         if (axnum == -1)
             continue;
-        xf86InitValuatorAxisStruct(device, axnum,
-#if GET_ABI_MAJOR(ABI_XINPUT_VERSION) >= 7
-                atoms[axnum],
-#endif
-                -1, -1, 1, 0, 1
-#if GET_ABI_MAJOR(ABI_XINPUT_VERSION) >= 12
-                                   , Relative
-#endif
-                );
+        xf86InitValuatorAxisStruct(device, axnum, atoms[axnum], -1, -1, 1, 0, 1,
+                                   Relative);
         xf86InitValuatorDefaults(device, axnum);
     }
 
     free(atoms);
 
     return Success;
+
+out:
+    valuator_mask_free(&pEvdev->vals);
+    return !Success;
 }
 
 static int
@@ -1503,10 +1355,7 @@ EvdevAddButtonClass(DeviceIntPtr device)
     labels = malloc(pEvdev->num_buttons * sizeof(Atom));
     EvdevInitButtonLabels(pEvdev, pEvdev->num_buttons, labels);
 
-    if (!InitButtonClassDeviceStruct(device, pEvdev->num_buttons,
-#if GET_ABI_MAJOR(ABI_XINPUT_VERSION) >= 7
-                                     labels,
-#endif
+    if (!InitButtonClassDeviceStruct(device, pEvdev->num_buttons, labels,
                                      pEvdev->btnmap))
         return !Success;
 
@@ -1678,7 +1527,6 @@ EvdevInit(DeviceIntPtr device)
     else if (pEvdev->flags & EVDEV_ABSOLUTE_EVENTS)
         EvdevInitAbsClass(device, pEvdev);
 
-#ifdef HAVE_PROPERTIES
     /* We drop the return value, the only time we ever want the handlers to
      * unregister is when the device dies. In which case we don't have to
      * unregister anyway */
@@ -1687,7 +1535,6 @@ EvdevInit(DeviceIntPtr device)
     EvdevMBEmuInitProperty(device);
     EvdevWheelEmuInitProperty(device);
     EvdevDragLockInitProperty(device);
-#endif
 
     return Success;
 }
@@ -1726,6 +1573,9 @@ EvdevProc(DeviceIntPtr device, int what)
 {
     InputInfoPtr pInfo;
     EvdevPtr pEvdev;
+#ifdef MULTITOUCH
+    int i;
+#endif
 
     pInfo = device->public.devicePrivate;
     pEvdev = pInfo->private;
@@ -1759,6 +1609,17 @@ EvdevProc(DeviceIntPtr device, int what)
             close(pInfo->fd);
             pInfo->fd = -1;
         }
+        valuator_mask_free(&pEvdev->vals);
+        valuator_mask_free(&pEvdev->old_vals);
+        valuator_mask_free(&pEvdev->prox);
+#ifdef MULTITOUCH
+        valuator_mask_free(&pEvdev->mt_vals);
+        valuator_mask_free(&pEvdev->cur_vals);
+        for (i = 0; i < EVDEV_MAXQUEUE; i++)
+            valuator_mask_free(&pEvdev->queue[i].touch_vals);
+        if (pEvdev->mtdev)
+            mtdev_close(pEvdev->mtdev);
+#endif
         EvdevRemoveDevice(pInfo);
         pEvdev->min_maj = 0;
 	break;
@@ -2015,7 +1876,6 @@ EvdevProbe(InputInfoPtr pInfo)
                 if (has_lmr || TestBit(BTN_TOOL_FINGER, pEvdev->key_bitmask)) {
                     xf86Msg(X_PROBED, "%s: Found absolute touchpad.\n", pInfo->name);
                     pEvdev->flags |= EVDEV_TOUCHPAD;
-                    memset(pEvdev->old_vals, -1, sizeof(int) * pEvdev->num_vals);
                 } else {
                     xf86Msg(X_PROBED, "%s: Found absolute touchscreen\n", pInfo->name);
                     pEvdev->flags |= EVDEV_TOUCHSCREEN;
@@ -2135,6 +1995,16 @@ EvdevOpenDevice(InputInfoPtr pInfo)
 
         pEvdev->device = device;
         xf86Msg(X_CONFIG, "%s: Device: \"%s\"\n", pInfo->name, device);
+
+#ifdef MULTITOUCH
+        pEvdev->mtdev = malloc(sizeof(struct mtdev));
+        if (!pEvdev->mtdev)
+        {
+            xf86Msg(X_ERROR, "%s: Couldn't allocate mtdev structure\n",
+                    pInfo->name);
+            return BadAlloc;
+        }
+#endif
     }
 
     if (pInfo->fd < 0)
@@ -2149,6 +2019,17 @@ EvdevOpenDevice(InputInfoPtr pInfo)
         }
     }
 
+#ifdef MULTITOUCH
+    if (mtdev_open(pEvdev->mtdev, pInfo->fd) == 0)
+        pEvdev->cur_slot = pEvdev->mtdev->caps.slot.value;
+    else {
+        free(pEvdev->mtdev);
+        pEvdev->mtdev = NULL;
+        xf86Msg(X_ERROR, "%s: Couldn't open mtdev device\n", pInfo->name);
+        return FALSE;
+    }
+#endif
+
     /* Check major/minor of device node to avoid adding duplicate devices. */
     pEvdev->min_maj = EvdevGetMajorMinor(pInfo);
     if (EvdevIsDuplicate(pInfo))
@@ -2162,52 +2043,8 @@ EvdevOpenDevice(InputInfoPtr pInfo)
     return Success;
 }
 
-#if GET_ABI_MAJOR(ABI_XINPUT_VERSION) < 12
-static int NewEvdevPreInit(InputDriverPtr, InputInfoPtr, int);
-
-static InputInfoPtr
-EvdevPreInit(InputDriverPtr drv, IDevPtr dev, int flags)
-{
-    InputInfoPtr pInfo;
-
-    if (!(pInfo = xf86AllocateInput(drv, 0)))
-	return NULL;
-
-    /* Initialise the InputInfoRec. */
-    pInfo->fd = -1;
-    pInfo->name = dev->identifier;
-    pInfo->flags = 0;
-    pInfo->history_size = 0;
-    pInfo->control_proc = NULL;
-    pInfo->close_proc = NULL;
-    pInfo->conversion_proc = NULL;
-    pInfo->reverse_conversion_proc = NULL;
-    pInfo->dev = NULL;
-    pInfo->private_flags = 0;
-    pInfo->always_core_feedback = NULL;
-    pInfo->conf_idev = dev;
-    pInfo->private = NULL;
-
-    xf86CollectInputOptions(pInfo, (const char**)evdevDefaults, NULL);
-    xf86ProcessCommonOptions(pInfo, pInfo->options);
-
-    if (NewEvdevPreInit(drv, pInfo, flags) == Success)
-    {
-        pInfo->flags |= XI86_CONFIGURED;
-        return pInfo;
-    }
-
-
-    xf86DeleteInput(pInfo, 0);
-    return NULL;
-}
-
-static int
-NewEvdevPreInit(InputDriverPtr drv, InputInfoPtr pInfo, int flags)
-#else
 static int
 EvdevPreInit(InputDriverPtr drv, InputInfoPtr pInfo, int flags)
-#endif
 {
     EvdevPtr pEvdev;
     int rc = BadAlloc;
@@ -2225,6 +2062,10 @@ EvdevPreInit(InputDriverPtr drv, InputInfoPtr pInfo, int flags)
     if (rc != Success)
         goto error;
 
+#ifdef MULTITOUCH
+    pEvdev->cur_slot = -1;
+#endif
+
     /*
      * We initialize pEvdev->in_proximity to 1 so that device that doesn't use
      * proximity will still report events.
@@ -2279,9 +2120,7 @@ _X_EXPORT InputDriverRec EVDEV = {
     EvdevPreInit,
     NULL,
     NULL,
-#if GET_ABI_MAJOR(ABI_XINPUT_VERSION) >= 12
     evdevDefaults
-#endif
 };
 
 static void
@@ -2356,8 +2195,6 @@ EvdevUtilButtonEventToButtonNumber(EvdevPtr pEvdev, int code)
     }
 }
 
-#ifdef HAVE_PROPERTIES
-#ifdef HAVE_LABELS
 /* Aligned with linux/input.h.
    Note that there are holes in the ABS_ range, these are simply replaced with
    MISC here */
@@ -2411,7 +2248,6 @@ static char* abs_labels[] = {
     AXIS_LABEL_PROP_ABS_MISC,           /* undefined */
     AXIS_LABEL_PROP_ABS_MISC,           /* undefined */
     AXIS_LABEL_PROP_ABS_MISC,           /* undefined */
-#if GET_ABI_MAJOR(ABI_XINPUT_VERSION) >= 10
     AXIS_LABEL_PROP_ABS_MT_TOUCH_MAJOR, /* 0x30 */
     AXIS_LABEL_PROP_ABS_MT_TOUCH_MINOR, /* 0x31 */
     AXIS_LABEL_PROP_ABS_MT_WIDTH_MAJOR, /* 0x32 */
@@ -2423,7 +2259,6 @@ static char* abs_labels[] = {
     AXIS_LABEL_PROP_ABS_MT_BLOB_ID,     /* 0x38 */
     AXIS_LABEL_PROP_ABS_MT_TRACKING_ID, /* 0x39 */
     AXIS_LABEL_PROP_ABS_MT_PRESSURE,    /* 0x3a */
-#endif
 };
 
 static char* rel_labels[] = {
@@ -2520,11 +2355,8 @@ static char* btn_labels[][16] = {
     }
 };
 
-#endif /* HAVE_LABELS */
-
 static void EvdevInitAxesLabels(EvdevPtr pEvdev, int natoms, Atom *atoms)
 {
-#ifdef HAVE_LABELS
     Atom atom;
     int axis;
     char **labels;
@@ -2557,12 +2389,10 @@ static void EvdevInitAxesLabels(EvdevPtr pEvdev, int natoms, Atom *atoms)
 
         atoms[pEvdev->axis_map[axis]] = atom;
     }
-#endif
 }
 
 static void EvdevInitButtonLabels(EvdevPtr pEvdev, int natoms, Atom *atoms)
 {
-#ifdef HAVE_LABELS
     Atom atom;
     int button, bmap;
 
@@ -2600,7 +2430,6 @@ static void EvdevInitButtonLabels(EvdevPtr pEvdev, int natoms, Atom *atoms)
         atoms[5] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_HWHEEL_LEFT);
     if (natoms > 6)
         atoms[6] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_HWHEEL_RIGHT);
-#endif
 }
 
 static void
@@ -2659,11 +2488,10 @@ EvdevInitProperty(DeviceIntPtr dev)
 
         XISetDevicePropertyDeletable(dev, prop_swap, FALSE);
 
-#ifdef HAVE_LABELS
         /* Axis labelling */
         if ((pEvdev->num_vals > 0) && (prop_axis_label = XIGetKnownProperty(AXIS_LABEL_PROP)))
         {
-            Atom atoms[pEvdev->num_vals];
+            Atom atoms[pEvdev->num_vals + pEvdev->num_mt_vals];
             EvdevInitAxesLabels(pEvdev, pEvdev->num_vals, atoms);
             XIChangeDeviceProperty(dev, prop_axis_label, XA_ATOM, 32,
                                    PropModeReplace, pEvdev->num_vals, atoms, FALSE);
@@ -2678,7 +2506,6 @@ EvdevInitProperty(DeviceIntPtr dev)
                                    PropModeReplace, pEvdev->num_buttons, atoms, FALSE);
             XISetDevicePropertyDeletable(dev, prop_btn_label, FALSE);
         }
-#endif /* HAVE_LABELS */
     }
 
 }
@@ -2723,4 +2550,3 @@ EvdevSetProperty(DeviceIntPtr dev, Atom atom, XIPropertyValuePtr val,
 
     return Success;
 }
-#endif
diff --git a/src/evdev.h b/src/evdev.h
index f640fdd..a590eaf 100644
--- a/src/evdev.h
+++ b/src/evdev.h
@@ -39,6 +39,16 @@
 #include <xf86_OSproc.h>
 #include <xkbstr.h>
 
+#if GET_ABI_MAJOR(ABI_XINPUT_VERSION) * 100 + GET_ABI_MINOR(ABI_XINPUT_VERSION) < 1202
+#error "Need X server input ABI version 12.2 or greater"
+#endif
+
+#define MULTITOUCH /* Will be at least ABI 13.1, but it's not there yet */
+
+#ifdef MULTITOUCH
+#include <mtdev.h>
+#endif
+
 #ifndef EV_CNT /* linux 2.6.23 kernels and earlier lack _CNT defines */
 #define EV_CNT (EV_MAX+1)
 #endif
@@ -72,26 +82,10 @@
 #define EVDEV_UNIGNORE_RELATIVE (1 << 10) /* explicitly unignore rel axes */
 #define EVDEV_RELATIVE_MODE	(1 << 11) /* Force relative events for devices with absolute axes */
 
-#if GET_ABI_MAJOR(ABI_XINPUT_VERSION) >= 3
-#define HAVE_PROPERTIES 1
-#endif
-
 #ifndef MAX_VALUATORS
 #define MAX_VALUATORS 36
 #endif
 
-
-#if GET_ABI_MAJOR(ABI_XINPUT_VERSION) < 5
-typedef struct {
-    char *rules;
-    char *model;
-    char *layout;
-    char *variant;
-    char *options;
-} XkbRMLVOSet;
-#endif
-
-
 #define LONG_BITS (sizeof(long) * 8)
 
 /* Number of longs needed to hold the given number of bits */
@@ -110,9 +104,20 @@ typedef struct {
         EV_QUEUE_KEY,	/* xf86PostKeyboardEvent() */
         EV_QUEUE_BTN,	/* xf86PostButtonEvent() */
         EV_QUEUE_PROXIMITY, /* xf86PostProximityEvent() */
+#ifdef MULTITOUCH
+        EV_QUEUE_TOUCH,	/*xf86PostTouchEvent() */
+#endif
     } type;
-    int key;		/* May be either a key code or button number. */
-    int val;		/* State of the key/button; pressed or released. */
+    union {
+        int key;	/* May be either a key code or button number. */
+#ifdef MULTITOUCH
+        unsigned int touch; /* Touch ID */
+#endif
+    } detail;
+    int val;	/* State of the key/button/touch; pressed or released. */
+#ifdef MULTITOUCH
+    ValuatorMask *touch_vals; /* current state of valuators for touch */
+#endif
 } EventQueueRec, *EventQueuePtr;
 
 typedef struct {
@@ -121,8 +126,18 @@ typedef struct {
 
     int num_vals;           /* number of valuators */
     int axis_map[max(ABS_CNT, REL_CNT)]; /* Map evdev <axis> to index */
-    int vals[MAX_VALUATORS];
-    int old_vals[MAX_VALUATORS]; /* Translate absolute inputs to relative */
+    ValuatorMask *vals;     /* new values coming in */
+    ValuatorMask *old_vals; /* old values for calculating relative motion */
+    ValuatorMask *prox;     /* last values set while not in proximity */
+#ifdef MULTITOUCH
+    int num_mt_vals;
+    ValuatorMask *mt_vals;  /* multitouch values coming in */
+    ValuatorMask *cur_vals; /* current values of MT axes in evdev state */
+    int cur_slot;
+    BOOL close_slot;
+    BOOL open_slot;
+    struct mtdev *mtdev;
+#endif
 
     int flags;
     int in_proximity;           /* device in proximity */
@@ -134,12 +149,8 @@ typedef struct {
 
     int delta[REL_CNT];
     unsigned int abs_queued, rel_queued, prox_queued;
-    unsigned int abs_prox;  /* valuators posted while out of prox? */
 
     /* XKB stuff has to be per-device rather than per-driver */
-#if GET_ABI_MAJOR(ABI_XINPUT_VERSION) < 5
-    XkbComponentNamesRec    xkbnames;
-#endif
     XkbRMLVOSet rmlvo;
 
     /* Middle mouse button emulation */
@@ -202,6 +213,10 @@ typedef struct {
 void EvdevQueueKbdEvent(InputInfoPtr pInfo, struct input_event *ev, int value);
 void EvdevQueueButtonEvent(InputInfoPtr pInfo, int button, int value);
 void EvdevQueueProximityEvent(InputInfoPtr pInfo, int value);
+#ifdef MULTITOUCH
+void EvdevQueueTouchEvent(InputInfoPtr pInfo, unsigned int touch,
+                          ValuatorMask *mask, uint16_t type);
+#endif
 void EvdevPostButtonEvent(InputInfoPtr pInfo, int button, int value);
 void EvdevQueueButtonClicks(InputInfoPtr pInfo, int button, int count);
 void EvdevPostRelativeMotionEvents(InputInfoPtr pInfo, int num_v, int first_v,
@@ -228,9 +243,7 @@ BOOL EvdevWheelEmuFilterMotion(InputInfoPtr pInfo, struct input_event *pEv);
 void EvdevDragLockPreInit(InputInfoPtr pInfo);
 BOOL EvdevDragLockFilterEvent(InputInfoPtr pInfo, unsigned int button, int value);
 
-#ifdef HAVE_PROPERTIES
 void EvdevMBEmuInitProperty(DeviceIntPtr);
 void EvdevWheelEmuInitProperty(DeviceIntPtr);
 void EvdevDragLockInitProperty(DeviceIntPtr);
 #endif
-#endif