Initial load of mtdev project

Signed-off-by: Henrik Rydberg <rydberg@euromail.se>

9 files changed, 1255 insertions, 0 deletions

diff --git a/src/caps.c b/src/caps.c
new file mode 100644
index 0000000..1821bd7
--- /dev/null
+++ b/src/caps.c
@@ -0,0 +1,103 @@
+/*****************************************************************************
+ *
+ * mtdev - MT device event converter (MIT license)
+ *
+ * Copyright (C) 2010 Henrik Rydberg <rydberg@euromail.se>
+ * Copyright (C) 2010 Canonical Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ ****************************************************************************/
+
+#include "common.h"
+
+#define SETABS(c, x, map, key, fd)                                      \
+        (c->has_##x = getbit(map, key) && getabs(&c->x, key, fd))
+
+static const int SN_COORD = 250;        /* coordinate signal-to-noise ratio */
+static const int SN_WIDTH = 100;        /* width signal-to-noise ratio */
+static const int SN_ORIENT = 10;        /* orientation signal-to-noise ratio */
+
+static const int bits_per_long = 8 * sizeof(long);
+
+static inline int nlongs(int nbit)
+{
+        return (nbit + bits_per_long - 1) / bits_per_long;
+}
+
+static inline int getbit(const unsigned long *map, int key)
+{
+        return (map[key / bits_per_long] >> (key % bits_per_long)) & 0x01;
+}
+
+static int getabs(struct input_absinfo *abs, int key, int fd)
+{
+        int rc;
+        SYSCALL(rc = ioctl(fd, EVIOCGABS(key), abs));
+        return rc >= 0;
+}
+
+static int has_mt_data(const struct mtdev_caps *cap)
+{
+        return cap->has_abs[MTDEV_POSITION_X] && cap->has_abs[MTDEV_POSITION_Y];
+}
+
+static void default_fuzz(struct mtdev_caps *cap, int bit, int sn)
+{
+        if (cap->has_abs[bit] && cap->abs[bit].fuzz == 0)
+                cap->abs[bit].fuzz =
+                        (cap->abs[bit].maximum - cap->abs[bit].minimum) / sn;
+}
+
+static int read_caps(struct mtdev_caps *cap, int fd)
+{
+        unsigned long absbits[nlongs(ABS_MAX)];
+        int rc, i;
+
+        memset(cap, 0, sizeof(struct mtdev_caps));
+
+        SYSCALL(rc = ioctl(fd, EVIOCGBIT(EV_ABS, sizeof(absbits)), absbits));
+        if (rc < 0)
+                return rc;
+
+        SETABS(cap, slot, absbits, ABS_MT_SLOT, fd);
+        for (i = 0; i < MT_ABS_SIZE; i++)
+                SETABS(cap, abs[i], absbits, mtdev_mt2abs(i), fd);
+
+        cap->has_mtdata = has_mt_data(cap);
+
+        if (cap->has_abs[MTDEV_TRACKING_ID])
+                cap->nullid = cap->abs[MTDEV_TRACKING_ID].minimum - 1;
+
+        default_fuzz(cap, MTDEV_POSITION_X, SN_COORD);
+        default_fuzz(cap, MTDEV_POSITION_Y, SN_COORD);
+        default_fuzz(cap, MTDEV_TOUCH_MAJOR, SN_WIDTH);
+        default_fuzz(cap, MTDEV_TOUCH_MINOR, SN_WIDTH);
+        default_fuzz(cap, MTDEV_WIDTH_MAJOR, SN_WIDTH);
+        default_fuzz(cap, MTDEV_WIDTH_MINOR, SN_WIDTH);
+        default_fuzz(cap, MTDEV_ORIENTATION, SN_ORIENT);
+
+        return 0;
+}
+
+int mtdev_configure(struct mtdev *dev, int fd)
+{
+        return read_caps(&dev->caps, fd);
+}
diff --git a/src/common.h b/src/common.h
new file mode 100644
index 0000000..03bc7bd
--- /dev/null
+++ b/src/common.h
@@ -0,0 +1,87 @@
+/*****************************************************************************
+ *
+ * mtdev - MT device event converter (MIT license)
+ *
+ * Copyright (C) 2010 Henrik Rydberg <rydberg@euromail.se>
+ * Copyright (C) 2010 Canonical Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ ****************************************************************************/
+
+#ifndef COMMON_H
+#define COMMON_H
+
+#include <mtdev-mapping.h>
+#include <malloc.h>
+#include <string.h>
+#include <errno.h>
+
+#define DIM_FINGER 32
+#define DIM2_FINGER (DIM_FINGER * DIM_FINGER)
+
+/* event buffer size (must be a power of two) */
+#define DIM_EVENTS 512
+
+/* all bit masks have this type */
+typedef unsigned int bitmask_t;
+
+#define BITMASK(x) (1U << (x))
+#define BITONES(x) (BITMASK(x) - 1U)
+#define GETBIT(m, x) (((m) >> (x)) & 1U)
+#define SETBIT(m, x) (m |= BITMASK(x))
+#define CLEARBIT(m, x) (m &= ~BITMASK(x))
+#define MODBIT(m, x, b) ((b) ? SETBIT(m, x) : CLEARBIT(m, x))
+
+static inline int maxval(int x, int y) { return x > y ? x : y; }
+static inline int minval(int x, int y) { return x < y ? x : y; }
+
+static inline int clamp15(int x)
+{
+        return x < -32767 ? -32767 : x > 32767 ? 32767 : x;
+}
+
+/* absolute scale is assumed to fit in 15 bits */
+static inline int dist2(int dx, int dy)
+{
+        dx = clamp15(dx);
+        dy = clamp15(dy);
+        return dx * dx + dy * dy;
+}
+
+/* Count number of bits (Sean Eron Andersson's Bit Hacks) */
+static inline int bitcount(unsigned v)
+{
+        v -= ((v>>1) & 0x55555555);
+        v = (v&0x33333333) + ((v>>2) & 0x33333333);
+        return (((v + (v>>4)) & 0xF0F0F0F) * 0x1010101) >> 24;
+}
+
+/* Return index of first bit [0-31], -1 on zero */
+#define firstbit(v) (__builtin_ffs(v) - 1)
+
+/* boost-style foreach bit */
+#define foreach_bit(i, m)                                               \
+        for (i = firstbit(m); i >= 0; i = firstbit((m) & (~0U << i + 1)))
+
+/* robust system ioctl calls */
+#define SYSCALL(call) while (((call) == -1) && (errno == EINTR))
+
+#endif
diff --git a/src/core.c b/src/core.c
new file mode 100644
index 0000000..3df8257
--- /dev/null
+++ b/src/core.c
@@ -0,0 +1,393 @@
+/*****************************************************************************
+ *
+ * mtdev - MT device event converter (MIT license)
+ *
+ * Copyright (C) 2010 Henrik Rydberg <rydberg@euromail.se>
+ * Copyright (C) 2010 Canonical Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ ****************************************************************************/
+
+#include "state.h"
+#include "iobuf.h"
+#include "evbuf.h"
+
+static inline int istouch(const struct mtdev_slot *data,
+                          const struct mtdev_caps *caps)
+{
+        return data->abs[MTDEV_TOUCH_MAJOR] ||
+                !caps->has_abs[MTDEV_TOUCH_MAJOR];
+}
+
+/* Dmitry Torokhov's code from kernel/driver/input/input.c */
+static int defuzz(int value, int old_val, int fuzz)
+{
+        if (fuzz) {
+                if (value > old_val - fuzz / 2 && value < old_val + fuzz / 2)
+                        return old_val;
+
+                if (value > old_val - fuzz && value < old_val + fuzz)
+                        return (old_val * 3 + value) / 4;
+
+                if (value > old_val - fuzz * 2 && value < old_val + fuzz * 2)
+                        return (old_val + value) / 2;
+        }
+
+        return value;
+}
+
+/*
+ * solve - solve contact matching problem
+ * @state: mtdev state
+ * @caps: device capabilities
+ * @sid: array of current tracking ids
+ * @sx: array of current position x
+ * @sy: array of current position y
+ * @sn: number of current contacts
+ * @nid: array of new or matched tracking ids, to be filled
+ * @nx: array of new position x
+ * @ny: array of new position y
+ * @nn: number of new contacts
+ * @touch: which of the new contacts to fill
+ */
+static void solve(struct mtdev_state *state, const struct mtdev_caps *caps,
+                  const int *sid, const int *sx, const int *sy, int sn,
+                  int *nid, const int *nx, const int *ny, int nn,
+                  bitmask_t touch)
+{
+        int A[DIM2_FINGER], *row;
+        int n2s[DIM_FINGER];
+        int id, i, j;
+
+        /* setup distance matrix for contact matching */
+        for (j = 0; j < sn; j++) {
+                row = A + nn * j;
+                for (i = 0; i < nn; i++)
+                        row[i] = dist2(nx[i] - sx[j], ny[i] - sy[j]);
+        }
+
+        match_fingers(n2s, A, nn, sn);
+
+        /* update matched contacts and create new ones */
+        foreach_bit(i, touch) {
+                j = n2s[i];
+                id = j >= 0 ? sid[j] : caps->nullid;
+                while (id == caps->nullid)
+                        id = ++state->lastid;
+                nid[i] = id;
+        }
+}
+
+/*
+ * assign_tracking_id - assign tracking ids to all contacts
+ * @state: mtdev state
+ * @caps: device capabilities
+ * @data: array of all present contacts, to be filled
+ * @prop: array of all set contacts properties
+ * @size: number of contacts in array
+ * @touch: which of the contacts are actual touches
+ */
+static void assign_tracking_id(struct mtdev_state *state,
+                               const struct mtdev_caps *caps,
+                               struct mtdev_slot *data, bitmask_t *prop,
+                               int size, bitmask_t touch)
+{
+        int sid[DIM_FINGER], sx[DIM_FINGER], sy[DIM_FINGER], sn = 0;
+        int nid[DIM_FINGER], nx[DIM_FINGER], ny[DIM_FINGER], i;
+        foreach_bit(i, state->used) {
+                sid[sn] = state->data[i].abs[MTDEV_TRACKING_ID];
+                sx[sn] = state->data[i].abs[MTDEV_POSITION_X];
+                sy[sn] = state->data[i].abs[MTDEV_POSITION_Y];
+                sn++;
+        }
+        for (i = 0; i < size; i++) {
+                nx[i] = data[i].abs[MTDEV_POSITION_X];
+                ny[i] = data[i].abs[MTDEV_POSITION_Y];
+        }
+        solve(state, caps, sid, sx, sy, sn, nid, nx, ny, size, touch);
+        for (i = 0; i < size; i++) {
+                data[i].abs[MTDEV_TRACKING_ID] =
+                        GETBIT(touch, i) ? nid[i] : caps->nullid;
+                prop[i] |= BITMASK(MTDEV_TRACKING_ID);
+        }
+}
+
+/*
+ * process_typeA - consume MT events and update mtdev state
+ * @state: mtdev state
+ * @data: array of all present contacts, to be filled
+ * @prop: array of all set contacts properties, to be filled
+ *
+ * This function is called when a SYN_REPORT is seen, right before
+ * that event is pushed to the queue.
+ *
+ * Returns -1 if the packet is not MT related and should not affect
+ * the current mtdev state.
+ */
+static int process_typeA(struct mtdev_state *state,
+                         struct mtdev_slot *data, bitmask_t *prop)
+{
+        struct input_event ev;
+        int consumed, mtcode;
+        int mtcnt = 0, size = 0;
+        prop[size] = 0;
+        while (!evbuf_empty(&state->inbuf)) {
+                evbuf_get(&state->inbuf, &ev);
+                consumed = 0;
+                switch (ev.type) {
+                case EV_SYN:
+                        switch (ev.code) {
+                        case SYN_MT_REPORT:
+                                if (size < DIM_FINGER &&
+                                    GETBIT(prop[size], MTDEV_POSITION_X) &&
+                                    GETBIT(prop[size], MTDEV_POSITION_Y))
+                                        size++;
+                                if (size < DIM_FINGER)
+                                        prop[size] = 0;
+                                mtcnt++;
+                                consumed = 1;
+                                break;
+                        }
+                        break;
+                case EV_KEY:
+                        switch (ev.code) {
+                        case BTN_TOUCH:
+                                mtcnt++;
+                                break;
+                        }
+                        break;
+                case EV_ABS:
+                        if (size < DIM_FINGER && mtdev_is_absmt(ev.code)) {
+                                mtcode = mtdev_abs2mt(ev.code);
+                                data[size].abs[mtcode] = ev.value;
+                                prop[size] |= BITMASK(mtcode);
+                                mtcnt++;
+                                consumed = 1;
+                        }
+                        break;
+                }
+                if (!consumed)
+                        evbuf_put(&state->outbuf, &ev);
+        }
+        return mtcnt ? size : -1;
+}
+
+/*
+ * process_typeB - propagate events without parsing
+ * @state: mtdev state
+ *
+ * This function is called when a SYN_REPORT is seen, right before
+ * that event is pushed to the queue.
+ */
+static void process_typeB(struct mtdev_state *state)
+{
+        struct input_event ev;
+        while (!evbuf_empty(&state->inbuf)) {
+                evbuf_get(&state->inbuf, &ev);
+                evbuf_put(&state->outbuf, &ev);
+        }
+}
+
+/*
+ * filter_data - apply input filtering on new incoming data
+ * @state: mtdev state
+ * @caps: device capabilities
+ * @data: the incoming data to filter
+ * @prop: the properties to filter
+ * @slot: the slot the data refers to
+ */
+static void filter_data(const struct mtdev_state *state,
+                        const struct mtdev_caps *caps,
+                        struct mtdev_slot *data, bitmask_t prop,
+                        int slot)
+{
+        int i;
+        foreach_bit(i, prop) {
+                int fuzz = caps->abs[i].fuzz;
+                int oldval = state->data[slot].abs[i];
+                data->abs[i] = defuzz(data->abs[i], oldval, fuzz);
+        }
+}
+
+/*
+ * push_slot_changes - propagate state changes
+ * @state: mtdev state
+ * @data: the incoming data to propagate
+ * @prop: the properties to propagate
+ * @slot: the slot the data refers to
+ * @syn: reference to the SYN_REPORT event
+ */
+static void push_slot_changes(struct mtdev_state *state,
+                              const struct mtdev_slot *data, bitmask_t prop,
+                              int slot, const struct input_event *syn)
+{
+        struct input_event ev;
+        int i, count = 0;
+        foreach_bit(i, prop)
+                if (state->data[slot].abs[i] != data->abs[i])
+                        count++;
+        if (!count)
+                return;
+        ev.time = syn->time;
+        ev.type = EV_ABS;
+        ev.code = ABS_MT_SLOT;
+        ev.value = slot;
+        if (state->slot != ev.value) {
+                evbuf_put(&state->outbuf, &ev);
+                state->slot = ev.value;
+        }
+        foreach_bit(i, prop) {
+                ev.code = mtdev_mt2abs(i);
+                ev.value = data->abs[i];
+                if (state->data[slot].abs[i] != ev.value) {
+                        evbuf_put(&state->outbuf, &ev);
+                        state->data[slot].abs[i] = ev.value;
+                }
+        }
+}
+
+/*
+ * apply_typeA_changes - parse and propagate state changes
+ * @state: mtdev state
+ * @caps: device capabilities
+ * @data: array of data to apply
+ * @prop: array of properties to apply
+ * @size: number of contacts in array
+ * @syn: reference to the SYN_REPORT event
+ */
+static void apply_typeA_changes(struct mtdev_state *state,
+                                const struct mtdev_caps *caps,
+                                struct mtdev_slot *data, const bitmask_t *prop,
+                                int size, const struct input_event *syn)
+{
+        bitmask_t unused = ~state->used;
+        bitmask_t used = 0;
+        int i, slot, id;
+        for (i = 0; i < size; i++) {
+                id = data[i].abs[MTDEV_TRACKING_ID];
+                foreach_bit(slot, state->used) {
+                        if (state->data[slot].abs[MTDEV_TRACKING_ID] != id)
+                                continue;
+                        filter_data(state, caps, &data[i], prop[i], slot);
+                        push_slot_changes(state, &data[i], prop[i], slot, syn);
+                        SETBIT(used, slot);
+                        id = caps->nullid;
+                        break;
+                }
+                if (id != caps->nullid) {
+                        slot = firstbit(unused);
+                        push_slot_changes(state, &data[i], prop[i], slot, syn);
+                        SETBIT(used, slot);
+                        CLEARBIT(unused, slot);
+                }
+        }
+
+        /* clear unused slots and update slot usage */
+        foreach_bit(slot, state->used & ~used) {
+                struct mtdev_slot tdata = state->data[slot];
+                bitmask_t tprop = BITMASK(MTDEV_TRACKING_ID);
+                tdata.abs[MTDEV_TRACKING_ID] = caps->nullid;
+                push_slot_changes(state, &tdata, tprop, slot, syn);
+        }
+        state->used = used;
+}
+
+/*
+ * convert_A_to_B - propagate a type A packet as a type B packet
+ * @state: mtdev state
+ * @caps: device capabilities
+ * @syn: reference to the SYN_REPORT event
+ */
+static void convert_A_to_B(struct mtdev_state *state,
+                           const struct mtdev_caps *caps,
+                           const struct input_event *syn)
+{
+        struct mtdev_slot data[DIM_FINGER];
+        bitmask_t prop[DIM_FINGER];
+        int size = process_typeA(state, data, prop);
+        if (size < 0)
+                return;
+        if (!caps->has_abs[MTDEV_TRACKING_ID]) {
+                bitmask_t touch = 0;
+                int i;
+                for (i = 0; i < size; i++)
+                        MODBIT(touch, i, istouch(&data[i], caps));
+                assign_tracking_id(state, caps, data, prop, size, touch);
+        }
+        apply_typeA_changes(state, caps, data, prop, size, syn);
+}
+
+int mtdev_init(struct mtdev *dev)
+{
+        memset(dev, 0, sizeof(struct mtdev));
+        dev->state = calloc(1, sizeof(struct mtdev_state));
+        if (!dev->state)
+                return -ENOMEM;
+        return 0;
+}
+
+int mtdev_open(struct mtdev *dev, int fd)
+{
+        int ret;
+        ret = mtdev_init(dev);
+        if (ret)
+                goto error;
+        ret = mtdev_configure(dev, fd);
+        if (ret)
+                goto mtdev;
+        return 0;
+ mtdev:
+        mtdev_close(dev);
+ error:
+        return ret;
+}
+
+void mtdev_put(struct mtdev *dev, const struct input_event *ev)
+{
+        struct mtdev_state *state = dev->state;
+        if (ev->type == EV_SYN && ev->code == SYN_REPORT) {
+                bitmask_t head = state->outbuf.head;
+                if (dev->state)
+                        convert_A_to_B(state, &dev->caps, ev);
+                else
+                        process_typeB(state);
+                if (state->outbuf.head != head)
+                        evbuf_put(&state->outbuf, ev);
+        } else {
+                evbuf_put(&state->inbuf, ev);
+        }
+}
+
+int mtdev_empty(struct mtdev *dev)
+{
+        return evbuf_empty(&dev->state->outbuf);
+}
+
+void mtdev_get(struct mtdev *dev, struct input_event* ev)
+{
+        evbuf_get(&dev->state->outbuf, ev);
+}
+
+void mtdev_close(struct mtdev *dev)
+{
+        free(dev->state);
+        memset(dev, 0, sizeof(struct mtdev));
+}
diff --git a/src/evbuf.h b/src/evbuf.h
new file mode 100644
index 0000000..ba61cd5
--- /dev/null
+++ b/src/evbuf.h
@@ -0,0 +1,64 @@
+/*****************************************************************************
+ *
+ * mtdev - MT device event converter (MIT license)
+ *
+ * Copyright (C) 2010 Henrik Rydberg <rydberg@euromail.se>
+ * Copyright (C) 2010 Canonical Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ ****************************************************************************/
+
+#ifndef MTDEV_EVBUF_H
+#define MTDEV_EVBUF_H
+
+#include "common.h"
+
+struct mtdev_evbuf {
+        int head;
+        int tail;
+        struct input_event buffer[DIM_EVENTS];
+};
+
+static inline int evbuf_empty(const struct mtdev_evbuf *evbuf)
+{
+        return evbuf->head == evbuf->tail;
+}
+
+static inline int evbuf_full(const struct mtdev_evbuf *evbuf)
+{
+        return ((evbuf->head + 1) & (DIM_EVENTS - 1)) == evbuf->tail;
+}
+
+static inline void evbuf_put(struct mtdev_evbuf *evbuf,
+                             const struct input_event *ev)
+{
+        evbuf->buffer[evbuf->head++] = *ev;
+        evbuf->head &= DIM_EVENTS - 1;
+}
+
+static inline void evbuf_get(struct mtdev_evbuf *evbuf,
+                             struct input_event *ev)
+{
+        *ev = evbuf->buffer[evbuf->tail++];
+        evbuf->tail &= DIM_EVENTS - 1;
+}
+
+#endif
diff --git a/src/iobuf.c b/src/iobuf.c
new file mode 100644
index 0000000..6d238ec
--- /dev/null
+++ b/src/iobuf.c
@@ -0,0 +1,69 @@
+/*****************************************************************************
+ *
+ * mtdev - MT device event converter (MIT license)
+ *
+ * Copyright (C) 2010 Henrik Rydberg <rydberg@euromail.se>
+ * Copyright (C) 2010 Canonical Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ ****************************************************************************/
+
+#include "iobuf.h"
+#include "state.h"
+
+int mtdev_fetch(struct mtdev *dev, struct input_event *ev, int fd)
+{
+        struct mtdev_iobuf *buf = &dev->state->iobuf;
+        int n = buf->head - buf->tail;
+        if (n < EVENT_SIZE) {
+                if (buf->tail && n > 0)
+                        memmove(buf->data, buf->data + buf->tail, n);
+                buf->head = n;
+                buf->tail = 0;
+                SYSCALL(n = read(fd, buf->data + buf->head,
+                                 DIM_BUFFER - buf->head));
+                if (n <= 0)
+                        return n;
+                buf->head += n;
+        }
+        if (buf->head - buf->tail < EVENT_SIZE)
+                return 0;
+        memcpy(ev, buf->data + buf->tail, EVENT_SIZE);
+        buf->tail += EVENT_SIZE;
+        return 1;
+}
+
+int mtdev_pull(struct mtdev *dev, int fd, int max_events)
+{
+        struct mtdev_state *state = dev->state;
+        struct input_event ev;
+        int ret, count = 0;
+        while (max_events-- && !evbuf_full(&state->inbuf)) {
+                ret = mtdev_fetch(dev, &ev, fd);
+                if (ret < 0)
+                        return ret;
+                if (ret == 0)
+                        break;
+                mtdev_put(dev, &ev);
+                count++;
+        }
+        return count;
+}
diff --git a/src/iobuf.h b/src/iobuf.h
new file mode 100644
index 0000000..b54ea48
--- /dev/null
+++ b/src/iobuf.h
@@ -0,0 +1,42 @@
+/*****************************************************************************
+ *
+ * mtdev - MT device event converter (MIT license)
+ *
+ * Copyright (C) 2010 Henrik Rydberg <rydberg@euromail.se>
+ * Copyright (C) 2010 Canonical Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ ****************************************************************************/
+
+#ifndef MTDEV_IOBUF_H
+#define MTDEV_IOBUF_H
+
+#include "common.h"
+
+#define EVENT_SIZE sizeof(struct input_event)
+#define DIM_BUFFER (DIM_EVENTS * EVENT_SIZE)
+
+struct mtdev_iobuf {
+        int head, tail;
+        char data[DIM_BUFFER];
+};
+
+#endif
diff --git a/src/match.c b/src/match.c
new file mode 100644
index 0000000..1b3700c
--- /dev/null
+++ b/src/match.c
@@ -0,0 +1,392 @@
+/*****************************************************************************
+ *
+ * mtdev - MT device event converter (MIT license)
+ *
+ * Copyright (C) 2010 Henrik Rydberg <rydberg@euromail.se>
+ * Copyright (C) 2010 Canonical Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ ****************************************************************************/
+
+#include "match.h"
+#include <string.h>
+#include <stdio.h>
+
+/**
+ * Bitmap implementation of the hungarian algorithm (GPL license)
+ *
+ * Copyright (C) 2008 Henrik Rydberg <rydberg@euromail.se>
+ *
+ * Based on code released by Markus Buehren (2004) (BSD license)
+ *
+ * Copyright (C) 2004, Markus Buehren. All rights reserved.
+ * See CREDITS file for full license terms.
+ *
+ */
+
+typedef unsigned col_t[1];
+typedef unsigned mat_t[DIM_FINGER];
+
+#define GET1(m, x) ((m[0] >> (x)) & 1U)
+#define SET1(m, x) (m[0] |= (1U << (x)))
+#define CLEAR1(m, x) (m[0] &= ~(1U << (x)))
+
+#define GET2(m, row, col) ((m[col] >> (row)) & 1U)
+#define SET2(m, row, col) (m[col] |= (1U << (row)))
+#define CLEAR2(m, row, col) (m[col] &= ~(1U << (row)))
+
+/********************************************************/
+
+static void buildixvector(int *ix, mat_t mstar, int nrows, int ncols)
+{
+        int row, col;
+        for (row = 0; row < nrows; row++) {
+                for (col = 0; col < ncols; col++) {
+                        if (GET2(mstar, row, col)) {
+                                ix[row] = col;
+                                break;
+                        }
+                }
+        }
+}
+
+
+/********************************************************/
+
+static void step2a(int *ix, int *mdist, mat_t mstar, mat_t nmstar,
+                   mat_t mprime, col_t ccol, col_t crow, int nrows, int ncols,
+                   int dmin);
+static void step2b(int *ix, int *mdist, mat_t mstar, mat_t nmstar,
+                   mat_t mprime, col_t ccol, col_t crow, int nrows, int ncols,
+                   int dmin);
+static void step3(int *ix, int *mdist, mat_t mstar, mat_t nmstar,
+                  mat_t mprime, col_t ccol, col_t crow, int nrows, int ncols,
+                  int dmin);
+static void step4(int *ix, int *mdist, mat_t mstar, mat_t nmstar,
+                  mat_t mprime, col_t ccol, col_t crow, int nrows, int ncols,
+                  int dmin, int row, int col);
+static void step5(int *ix, int *mdist, mat_t mstar, mat_t nmstar,
+                  mat_t mprime, col_t ccol, col_t crow, int nrows, int ncols,
+                  int dmin);
+
+static void ixoptimal(int *ix, int *mdist, int nrows, int ncols)
+{
+        int *mdistTemp, *mdistEnd, *columnEnd, value, minValue;
+        int dmin, row, col;
+        col_t ccol, crow;
+        mat_t mstar, mprime, nmstar;
+
+        memset(ccol, 0, sizeof(col_t));
+        memset(crow, 0, sizeof(col_t));
+        memset(mstar, 0, sizeof(mat_t));
+        memset(mprime, 0, sizeof(mat_t));
+        memset(nmstar, 0, sizeof(mat_t));
+
+        /* initialization */
+        for (row = 0; row < nrows; row++)
+                ix[row] = -1;
+
+        mdistEnd = mdist + nrows * ncols;
+
+        /* preliminary steps */
+        if (nrows <= ncols) {
+                dmin = nrows;
+
+                for (row = 0; row < nrows; row++) {
+                        /* find the smallest element in the row */
+                        mdistTemp = mdist + row;
+                        minValue = *mdistTemp;
+                        mdistTemp += nrows;
+                        while (mdistTemp < mdistEnd) {
+                                value = *mdistTemp;
+                                if (value < minValue)
+                                        minValue = value;
+                                mdistTemp += nrows;
+                        }
+
+                        /* subtract the smallest element from each element
+                           of the row */
+                        mdistTemp = mdist + row;
+                        while (mdistTemp < mdistEnd) {
+                                *mdistTemp -= minValue;
+                                mdistTemp += nrows;
+                        }
+                }
+
+                /* Steps 1 and 2a */
+                for (row = 0; row < nrows; row++) {
+                        for (col = 0; col < ncols; col++) {
+                                if (mdist[row + nrows * col] != 0)
+                                        continue;
+                                if (GET1(ccol, col))
+                                        continue;
+                                SET2(mstar, row, col);
+                                SET1(ccol, col);
+                                break;
+                        }
+                }
+        } else {
+                dmin = ncols;
+
+                for (col = 0; col < ncols; col++) {
+                        /* find the smallest element in the column */
+                        mdistTemp = mdist + nrows*col;
+                        columnEnd = mdistTemp + nrows;
+
+                        minValue = *mdistTemp++;
+                        while (mdistTemp < columnEnd) {
+                                value = *mdistTemp++;
+                                if (value < minValue)
+                                        minValue = value;
+                        }
+
+                        /* subtract the smallest element from each element
+                           of the column */
+                        mdistTemp = mdist + nrows*col;
+                        while (mdistTemp < columnEnd)
+                                *mdistTemp++ -= minValue;
+                }
+
+                /* Steps 1 and 2a */
+                for (col = 0; col < ncols; col++) {
+                        for (row = 0; row < nrows; row++) {
+                                if (mdist[row + nrows * col] != 0)
+                                        continue;
+                                if (GET1(crow, row))
+                                        continue;
+                                SET2(mstar, row, col);
+                                SET1(ccol, col);
+                                SET1(crow, row);
+                                break;
+                        }
+                }
+                memset(crow, 0, sizeof(col_t));
+        }
+
+        /* move to step 2b */
+        step2b(ix, mdist, mstar, nmstar,
+               mprime, ccol, crow, nrows, ncols,
+               dmin);
+}
+
+/********************************************************/
+static void step2a(int *ix, int *mdist, mat_t mstar, mat_t nmstar,
+                   mat_t mprime, col_t ccol, col_t crow, int nrows, int ncols,
+                   int dmin)
+{
+        int col, row;
+
+        /* cover every column containing a starred zero */
+        for (col = 0; col < ncols; col++) {
+                for (row = 0; row < nrows; row++) {
+                        if (!GET2(mstar, row, col))
+                                continue;
+                        SET1(ccol, col);
+                        break;
+                }
+        }
+
+        /* move to step 3 */
+        step2b(ix, mdist, mstar, nmstar,
+               mprime, ccol, crow, nrows, ncols,
+               dmin);
+}
+
+/********************************************************/
+static void step2b(int *ix, int *mdist, mat_t mstar, mat_t nmstar,
+                   mat_t mprime, col_t ccol, col_t crow, int nrows, int ncols,
+                   int dmin)
+{
+        int col, ncc;
+
+        /* count covered columns */
+        ncc = 0;
+        for (col = 0; col < ncols; col++)
+                if (GET1(ccol, col))
+                        ncc++;
+
+        if (ncc == dmin) {
+                /* algorithm finished */
+                buildixvector(ix, mstar, nrows, ncols);
+        } else {
+                /* move to step 3 */
+                step3(ix, mdist, mstar, nmstar,
+                      mprime, ccol, crow, nrows, ncols,
+                      dmin);
+        }
+
+}
+
+/********************************************************/
+static void step3(int *ix, int *mdist, mat_t mstar, mat_t nmstar,
+                  mat_t mprime, col_t ccol, col_t crow, int nrows, int ncols,
+                  int dmin)
+{
+        int zerosFound;
+        int row, col, cstar;
+
+        zerosFound = 1;
+        while (zerosFound) {
+                zerosFound = 0;
+                for (col = 0; col < ncols; col++) {
+                        if (GET1(ccol, col))
+                                continue;
+                        for (row = 0; row < nrows; row++) {
+                                if (mdist[row + nrows * col] != 0)
+                                        continue;
+                                if (GET1(crow, row))
+                                        continue;
+
+                                /* prime zero */
+                                SET2(mprime, row, col);
+
+                                /* find starred zero in current row */
+                                for (cstar = 0; cstar < ncols; cstar++)
+                                        if (GET2(mstar, row, cstar))
+                                                break;
+
+                                if (cstar == ncols) { /* no starred zero */
+                                        /* move to step 4 */
+                                        step4(ix, mdist, mstar, nmstar,
+                                              mprime, ccol, crow, nrows, ncols,
+                                              dmin, row, col);
+                                        return;
+                                } else {
+                                        SET1(crow, row);
+                                        CLEAR1(ccol, cstar);
+                                        zerosFound = 1;
+                                        break;
+                                }
+                        }
+                }
+        }
+
+        /* move to step 5 */
+        step5(ix, mdist, mstar, nmstar,
+              mprime, ccol, crow, nrows, ncols,
+              dmin);
+}
+
+/********************************************************/
+static void step4(int *ix, int *mdist, mat_t mstar, mat_t nmstar,
+                  mat_t mprime, col_t ccol, col_t crow, int nrows, int ncols,
+                  int dmin, int row, int col)
+{
+        int n, rstar, cstar, primeRow, primeCol;
+
+        /* generate temporary copy of mstar */
+        memcpy(nmstar, mstar, sizeof(mat_t));
+
+        /* star current zero */
+        SET2(nmstar, row, col);
+
+        /* find starred zero in current column */
+        cstar = col;
+        for (rstar = 0; rstar < nrows; rstar++)
+                if (GET2(mstar, rstar, cstar))
+                        break;
+
+        while (rstar < nrows) {
+                /* unstar the starred zero */
+                CLEAR2(nmstar, rstar, cstar);
+
+                /* find primed zero in current row */
+                primeRow = rstar;
+                for (primeCol = 0; primeCol < ncols; primeCol++)
+                        if (GET2(mprime, primeRow, primeCol))
+                                break;
+
+                /* star the primed zero */
+                SET2(nmstar, primeRow, primeCol);
+
+                /* find starred zero in current column */
+                cstar = primeCol;
+                for (rstar = 0; rstar < nrows; rstar++)
+                        if (GET2(mstar, rstar, cstar))
+                                break;
+        }
+
+        /* use temporary copy as new mstar */
+        /* delete all primes, uncover all rows */
+        memcpy(mstar, nmstar, sizeof(mat_t));
+        memset(mprime, 0, sizeof(mat_t));
+        memset(crow, 0, sizeof(col_t));
+
+        /* move to step 2a */
+        step2a(ix, mdist, mstar, nmstar,
+               mprime, ccol, crow, nrows, ncols,
+               dmin);
+}
+
+/********************************************************/
+static void step5(int *ix, int *mdist, mat_t mstar, mat_t nmstar,
+                  mat_t mprime, col_t ccol, col_t crow, int nrows, int ncols,
+                  int dmin)
+{
+        int h = 0, value;
+        int row, col, found = 0;
+
+        /* find smallest uncovered element h */
+        for (row = 0; row < nrows; row++) {
+                if (GET1(crow, row))
+                        continue;
+                for (col = 0; col < ncols; col++) {
+                        if (GET1(ccol, col))
+                                continue;
+                        value = mdist[row + nrows * col];
+                        if (!found || value < h) {
+                                h = value;
+                                found = 1;
+                        }
+                }
+        }
+
+        /* where to go if nothing uncovered? */
+        if (!found)
+                return;
+
+        /* add h to each covered row */
+        for (row = 0; row < nrows; row++) {
+                if (!GET1(crow, row))
+                        continue;
+                for (col = 0; col < ncols; col++)
+                        mdist[row + nrows * col] += h;
+        }
+
+        /* subtract h from each uncovered column */
+        for (col = 0; col < ncols; col++) {
+                if (GET1(ccol, col))
+                        continue;
+                for (row = 0; row < nrows; row++)
+                        mdist[row + nrows * col] -= h;
+        }
+
+        /* move to step 3 */
+        step3(ix, mdist, mstar, nmstar,
+              mprime, ccol, crow, nrows, ncols,
+              dmin);
+}
+
+void match_fingers(int ix[DIM_FINGER], int A[DIM2_FINGER], int nrow, int ncol)
+{
+        ixoptimal(ix, A, nrow, ncol);
+}
+
diff --git a/src/match.h b/src/match.h
new file mode 100644
index 0000000..e6d7d73
--- /dev/null
+++ b/src/match.h
@@ -0,0 +1,43 @@
+/*****************************************************************************
+ *
+ * mtdev - MT device event converter (MIT license)
+ *
+ * Copyright (C) 2010 Henrik Rydberg <rydberg@euromail.se>
+ * Copyright (C) 2010 Canonical Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ ****************************************************************************/
+
+#ifndef MATCHER_H
+#define MATCHER_H
+
+/**
+ * Special implementation of the hungarian algorithm.
+ * The maximum number of fingers matches a uint32.
+ * Bitmasks are used extensively.
+ */
+
+#include "common.h"
+
+void match_fingers(int index[DIM_FINGER], int A[DIM2_FINGER],
+                   int nrow, int ncol);
+
+#endif
diff --git a/src/state.h b/src/state.h
new file mode 100644
index 0000000..37ac803
--- /dev/null
+++ b/src/state.h
@@ -0,0 +1,62 @@
+/*****************************************************************************
+ *
+ * mtdev - MT device event converter (MIT license)
+ *
+ * Copyright (C) 2010 Henrik Rydberg <rydberg@euromail.se>
+ * Copyright (C) 2010 Canonical Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ ****************************************************************************/
+
+#ifndef MTDEV_STATE_H
+#define MTDEV_STATE_H
+
+#include "iobuf.h"
+#include "evbuf.h"
+
+/*
+ * struct mtdev_slot - represents the state of an input MT slot
+ * @abs: current values of ABS_MT axes for this slot
+ */
+struct mtdev_slot {
+        int abs[MT_ABS_SIZE];
+};
+
+/*
+ * struct mtdev_state - MT slot parsing
+ * @inbuf: input event buffer
+ * @outbuf: output event buffer
+ * @data: array of scratch slot data
+ * @used: bitmask of currently used slots
+ * @slot: slot currently being modified
+ * @lastid: last used tracking id
+ */
+struct mtdev_state {
+        struct mtdev_iobuf iobuf;
+        struct mtdev_evbuf inbuf;
+        struct mtdev_evbuf outbuf;
+        struct mtdev_slot data[DIM_FINGER];
+        bitmask_t used;
+        bitmask_t slot;
+        bitmask_t lastid;
+};
+
+#endif