sys/dev/evdev/evdev_mt.c

   1 /*-
   2  * Copyright (c) 2016, 2020 Vladimir Kondratyev <wulf@FreeBSD.org>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  * $FreeBSD$
  27  */
  28 /*-
  29  * Copyright (c) 2015, 2016 Ulf Brosziewski
  30  *
  31  * Permission to use, copy, modify, and distribute this software for any
  32  * purpose with or without fee is hereby granted, provided that the above
  33  * copyright notice and this permission notice appear in all copies.
  34  *
  35  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  36  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  37  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  38  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  39  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  40  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  41  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  42  */
  43
  44 #include <sys/param.h>
  45 #include <sys/lock.h>
  46 #include <sys/malloc.h>
  47 #include <sys/mutex.h>
  48 #include <sys/systm.h>
  49
  50 #include <dev/evdev/evdev.h>
  51 #include <dev/evdev/evdev_private.h>
  52 #include <dev/evdev/input.h>
  53
  54 #ifdef DEBUG
  55 #define debugf(fmt, args...)    printf("evdev: " fmt "\n", ##args)
  56 #else
  57 #define debugf(fmt, args...)
  58 #endif
  59
  60 typedef u_int   slotset_t;
  61
  62 _Static_assert(MAX_MT_SLOTS < sizeof(slotset_t) * 8, "MAX_MT_SLOTS too big");
  63
  64 #define FOREACHBIT(v, i) \
  65         for ((i) = ffs(v) - 1; (i) != -1; (i) = ffs((v) & (~1 << (i))) - 1)
  66
  67 struct {
  68         uint16_t        mt;
  69         uint16_t        st;
  70         int32_t         max;
  71 } static evdev_mtstmap[] = {
  72         { ABS_MT_POSITION_X,    ABS_X,          0 },
  73         { ABS_MT_POSITION_Y,    ABS_Y,          0 },
  74         { ABS_MT_PRESSURE,      ABS_PRESSURE,   255 },
  75         { ABS_MT_TOUCH_MAJOR,   ABS_TOOL_WIDTH, 15 },
  76 };
  77
  78 struct evdev_mt {
  79         int                     last_reported_slot;
  80         uint16_t                tracking_id;
  81         int32_t                 tracking_ids[MAX_MT_SLOTS];
  82         bool                    type_a;
  83         u_int                   mtst_events;
  84         /* the set of slots with active touches */
  85         slotset_t               touches;
  86         /* the set of slots with unsynchronized state */
  87         slotset_t               frame;
  88         /* the set of slots to match with active touches */
  89         slotset_t               match_frame;
  90         int                     match_slot;
  91         union evdev_mt_slot     *match_slots;
  92         int                     *matrix;
  93         union evdev_mt_slot     slots[];
  94 };
  95
  96 static void     evdev_mt_support_st_compat(struct evdev_dev *);
  97 static void     evdev_mt_send_st_compat(struct evdev_dev *);
  98 static void     evdev_mt_send_autorel(struct evdev_dev *);
  99 static void     evdev_mt_replay_events(struct evdev_dev *);
 100
 101 static inline int
 102 ffc_slot(struct evdev_dev *evdev, slotset_t slots)
 103 {
 104         return (ffs(~slots & ((2U << MAXIMAL_MT_SLOT(evdev)) - 1)) - 1);
 105 }
 106
 107 void
 108 evdev_mt_init(struct evdev_dev *evdev)
 109 {
 110         struct evdev_mt *mt;
 111         size_t size = offsetof(struct evdev_mt, slots);
 112         int slot, slots;
 113         bool type_a;
 114
 115         type_a = !bit_test(evdev->ev_abs_flags, ABS_MT_SLOT);
 116         if (type_a) {
 117                 /* Add events produced by MT type A to type B converter */
 118                 evdev_support_abs(evdev,
 119                     ABS_MT_SLOT, 0, MAX_MT_SLOTS - 1, 0, 0, 0);
 120                 evdev_support_abs(evdev,
 121                     ABS_MT_TRACKING_ID, -1, MAX_MT_SLOTS - 1, 0, 0, 0);
 122         }
 123
 124         slots = MAXIMAL_MT_SLOT(evdev) + 1;
 125         size += sizeof(mt->slots[0]) * slots;
 126         if (bit_test(evdev->ev_flags, EVDEV_FLAG_MT_TRACK)) {
 127                 size += sizeof(mt->match_slots[0]) * slots;
 128                 size += sizeof(mt->matrix[0]) * (slots + 6) * slots;
 129         }
 130
 131         mt = malloc(size, M_EVDEV, M_WAITOK | M_ZERO);
 132         evdev->ev_mt = mt;
 133         mt->type_a = type_a;
 134
 135         if (bit_test(evdev->ev_flags, EVDEV_FLAG_MT_TRACK)) {
 136                 mt->match_slots = mt->slots + slots;
 137                 mt->matrix = (int *)(mt->match_slots + slots);
 138         }
 139
 140         /* Initialize multitouch protocol type B states */
 141         for (slot = 0; slot < slots; slot++)
 142                 mt->slots[slot].id = -1;
 143
 144         if (!bit_test(evdev->ev_flags, EVDEV_FLAG_MT_KEEPID))
 145                 evdev_support_abs(evdev,
 146                     ABS_MT_TRACKING_ID, -1, UINT16_MAX, 0, 0, 0);
 147         if (bit_test(evdev->ev_flags, EVDEV_FLAG_MT_STCOMPAT))
 148                 evdev_mt_support_st_compat(evdev);
 149 }
 150
 151 void
 152 evdev_mt_free(struct evdev_dev *evdev)
 153 {
 154         free(evdev->ev_mt, M_EVDEV);
 155 }
 156
 157 void
 158 evdev_mt_sync_frame(struct evdev_dev *evdev)
 159 {
 160         if (bit_test(evdev->ev_flags, EVDEV_FLAG_MT_TRACK))
 161                 evdev_mt_replay_events(evdev);
 162         if (bit_test(evdev->ev_flags, EVDEV_FLAG_MT_AUTOREL))
 163                 evdev_mt_send_autorel(evdev);
 164         if (evdev->ev_report_opened &&
 165             bit_test(evdev->ev_flags, EVDEV_FLAG_MT_STCOMPAT))
 166                 evdev_mt_send_st_compat(evdev);
 167         evdev->ev_mt->frame = 0;
 168 }
 169
 170 static void
 171 evdev_mt_send_slot(struct evdev_dev *evdev, int slot,
 172     union evdev_mt_slot *state)
 173 {
 174         int i;
 175         bool type_a = !bit_test(evdev->ev_abs_flags, ABS_MT_SLOT);
 176
 177         EVDEV_LOCK_ASSERT(evdev);
 178         MPASS(type_a || (slot >= 0 && slot <= MAXIMAL_MT_SLOT(evdev)));
 179         MPASS(!type_a || state != NULL);
 180
 181         if (!type_a) {
 182                 evdev_send_event(evdev, EV_ABS, ABS_MT_SLOT, slot);
 183                 if (state == NULL) {
 184                         evdev_send_event(evdev, EV_ABS, ABS_MT_TRACKING_ID, -1);
 185                         return;
 186                 }
 187         }
 188         bit_foreach_at(evdev->ev_abs_flags, ABS_MT_FIRST, ABS_MT_LAST + 1, i)
 189                 evdev_send_event(evdev, EV_ABS, i,
 190                     state->val[ABS_MT_INDEX(i)]);
 191         if (type_a)
 192                 evdev_send_event(evdev, EV_SYN, SYN_MT_REPORT, 1);
 193 }
 194
 195 int
 196 evdev_mt_push_slot(struct evdev_dev *evdev, int slot,
 197     union evdev_mt_slot *state)
 198 {
 199         struct evdev_mt *mt = evdev->ev_mt;
 200         bool type_a = !bit_test(evdev->ev_abs_flags, ABS_MT_SLOT);
 201
 202         if ((type_a || (mt != NULL && mt->type_a)) && state == NULL)
 203                 return (EINVAL);
 204         if (!type_a && (slot < 0 || slot > MAXIMAL_MT_SLOT(evdev)))
 205                 return (EINVAL);
 206
 207         EVDEV_ENTER(evdev);
 208         if (bit_test(evdev->ev_flags, EVDEV_FLAG_MT_TRACK) && mt->type_a) {
 209                 mt->match_slots[mt->match_slot] = *state;
 210                 evdev_mt_record_event(evdev, EV_SYN, SYN_MT_REPORT, 1);
 211         } else if (bit_test(evdev->ev_flags, EVDEV_FLAG_MT_TRACK)) {
 212                 evdev_mt_record_event(evdev, EV_ABS, ABS_MT_SLOT, slot);
 213                 if (state != NULL)
 214                         mt->match_slots[mt->match_slot] = *state;
 215                 else
 216                         evdev_mt_record_event(evdev, EV_ABS,
 217                             ABS_MT_TRACKING_ID, -1);
 218         } else
 219                 evdev_mt_send_slot(evdev, slot, state);
 220         EVDEV_EXIT(evdev);
 221
 222         return (0);
 223 }
 224
 225 /*
 226  * Find a minimum-weight matching for an m-by-n matrix.
 227  *
 228  * m must be greater than or equal to n. The size of the buffer must be
 229  * at least 3m + 3n.
 230  *
 231  * On return, the first m elements of the buffer contain the row-to-
 232  * column mappings, i.e., buffer[i] is the column index for row i, or -1
 233  * if there is no assignment for that row (which may happen if n < m).
 234  *
 235  * Wrong results because of overflows will not occur with input values
 236  * in the range of 0 to INT_MAX / 2 inclusive.
 237  *
 238  * The function applies the Dinic-Kronrod algorithm. It is not modern or
 239  * popular, but it seems to be a good choice for small matrices at least.
 240  * The original form of the algorithm is modified as follows: There is no
 241  * initial search for row minima, the initial assignments are in a
 242  * "virtual" column with the index -1 and zero values. This permits inputs
 243  * with n < m, and it simplifies the reassignments.
 244  */
 245 static void
 246 evdev_mt_matching(int *matrix, int m, int n, int *buffer)
 247 {
 248         int i, j, k, d, e, row, col, delta;
 249         int *p;
 250         int *r2c = buffer;      /* row-to-column assignments */
 251         int *red = r2c + m;     /* reduced values of the assignments */
 252         int *mc = red + m;      /* row-wise minimal elements of cs */
 253         int *cs = mc + m;       /* the column set */
 254         int *c2r = cs + n;      /* column-to-row assignments in cs */
 255         int *cd = c2r + n;      /* column deltas (reduction) */
 256
 257         for (p = r2c; p < red; *p++ = -1) {}
 258         for (; p < mc; *p++ = 0) {}
 259         for (col = 0; col < n; col++) {
 260                 delta = INT_MAX;
 261                 for (i = 0, p = matrix + col; i < m; i++, p += n) {
 262                         d = *p - red[i];
 263                         if (d < delta || (d == delta && r2c[i] < 0)) {
 264                                 delta = d;
 265                                 row = i;
 266                         }
 267                 }
 268                 cd[col] = delta;
 269                 if (r2c[row] < 0) {
 270                         r2c[row] = col;
 271                         continue;
 272                 }
 273                 for (p = mc; p < cs; *p++ = col) {}
 274                 for (k = 0; (j = r2c[row]) >= 0;) {
 275                         cs[k++] = j;
 276                         c2r[j] = row;
 277                         mc[row] -= n;
 278                         delta = INT_MAX;
 279                         for (i = 0, p = matrix; i < m; i++, p += n)
 280                                 if (mc[i] >= 0) {
 281                                         d = p[mc[i]] - cd[mc[i]];
 282                                         e = p[j] - cd[j];
 283                                         if (e < d) {
 284                                                 d = e;
 285                                                 mc[i] = j;
 286                                         }
 287                                         d -= red[i];
 288                                         if (d < delta || (d == delta
 289                                             && r2c[i] < 0)) {
 290                                                 delta = d;
 291                                                 row = i;
 292                                         }
 293                                 }
 294                         cd[col] += delta;
 295                         for (i = 0; i < k; i++) {
 296                                 cd[cs[i]] += delta;
 297                                 red[c2r[cs[i]]] -= delta;
 298                         }
 299                 }
 300                 for (j = mc[row]; (r2c[row] = j) != col;) {
 301                         row = c2r[j];
 302                         j = mc[row] + n;
 303                 }
 304         }
 305 }
 306
 307 /*
 308  * Assign tracking IDs to the points in the pt array.  The tracking ID
 309  * assignment pairs the points with points of the previous frame in
 310  * such a way that the sum of the squared distances is minimal.  Using
 311  * squares instead of simple distances favours assignments with more uniform
 312  * distances, and it is faster.
 313  * Set tracking id to -1 for unassigned (new) points.
 314  */
 315 void
 316 evdev_mt_match_frame(struct evdev_dev *evdev, union evdev_mt_slot *pt,
 317     int size)
 318 {
 319         struct evdev_mt *mt = evdev->ev_mt;
 320         int i, j, m, n, dx, dy, slot, num_touches;
 321         int *p, *r2c, *c2r;
 322
 323         EVDEV_LOCK_ASSERT(evdev);
 324         MPASS(mt->matrix != NULL);
 325         MPASS(size >= 0 && size <= MAXIMAL_MT_SLOT(evdev) + 1);
 326
 327         if (size == 0)
 328                 return;
 329
 330         p = mt->matrix;
 331         num_touches = bitcount(mt->touches);
 332         if (num_touches >= size) {
 333                 FOREACHBIT(mt->touches, slot)
 334                         for (i = 0; i < size; i++) {
 335                                 dx = pt[i].x - mt->slots[slot].x;
 336                                 dy = pt[i].y - mt->slots[slot].y;
 337                                 *p++ = dx * dx + dy * dy;
 338                         }
 339                 m = num_touches;
 340                 n = size;
 341         } else {
 342                 for (i = 0; i < size; i++)
 343                         FOREACHBIT(mt->touches, slot) {
 344                                 dx = pt[i].x - mt->slots[slot].x;
 345                                 dy = pt[i].y - mt->slots[slot].y;
 346                                 *p++ = dx * dx + dy * dy;
 347                         }
 348                 m = size;
 349                 n = num_touches;
 350         }
 351         evdev_mt_matching(mt->matrix, m, n, p);
 352
 353         r2c = p;
 354         c2r = p + m;
 355         for (i = 0; i < m; i++)
 356                 if ((j = r2c[i]) >= 0)
 357                         c2r[j] = i;
 358
 359         p = (n == size ? c2r : r2c);
 360         for (i = 0; i < size; i++)
 361                 if (*p++ < 0)
 362                         pt[i].id = -1;
 363
 364         p = (n == size ? r2c : c2r);
 365         FOREACHBIT(mt->touches, slot)
 366                 if ((i = *p++) >= 0)
 367                         pt[i].id = mt->tracking_ids[slot];
 368 }
 369
 370 static void
 371 evdev_mt_send_frame(struct evdev_dev *evdev, union evdev_mt_slot *pt, int size)
 372 {
 373         struct evdev_mt *mt = evdev->ev_mt;
 374         union evdev_mt_slot *slot;
 375
 376         EVDEV_LOCK_ASSERT(evdev);
 377         MPASS(size >= 0 && size <= MAXIMAL_MT_SLOT(evdev) + 1);
 378
 379         /*
 380          * While MT-matching assign tracking IDs of new contacts to be equal
 381          * to a slot number to make things simpler.
 382          */
 383         for (slot = pt; slot < pt + size; slot++) {
 384                 if (slot->id < 0)
 385                         slot->id = ffc_slot(evdev, mt->touches | mt->frame);
 386                 if (slot->id >= 0)
 387                         evdev_mt_send_slot(evdev, slot->id, slot);
 388         }
 389 }
 390
 391 int
 392 evdev_mt_push_frame(struct evdev_dev *evdev, union evdev_mt_slot *pt, int size)
 393 {
 394         if (size < 0 || size > MAXIMAL_MT_SLOT(evdev) + 1)
 395                 return (EINVAL);
 396
 397         EVDEV_ENTER(evdev);
 398         evdev_mt_send_frame(evdev, pt, size);
 399         EVDEV_EXIT(evdev);
 400
 401         return (0);
 402 }
 403
 404 bool
 405 evdev_mt_record_event(struct evdev_dev *evdev, uint16_t type, uint16_t code,
 406     int32_t value)
 407 {
 408         struct evdev_mt *mt = evdev->ev_mt;
 409
 410         EVDEV_LOCK_ASSERT(evdev);
 411
 412         switch (type) {
 413         case EV_SYN:
 414                 if (code == SYN_MT_REPORT) {
 415                         /* MT protocol type A support */
 416                         KASSERT(mt->type_a, ("Not a MT type A protocol"));
 417                         mt->match_frame |= 1U << mt->match_slot;
 418                         mt->match_slot++;
 419                         return (true);
 420                 }
 421                 break;
 422         case EV_ABS:
 423                 if (code == ABS_MT_SLOT) {
 424                         /* MT protocol type B support */
 425                         KASSERT(!mt->type_a, ("Not a MT type B protocol"));
 426                         KASSERT(value >= 0, ("Negative slot number"));
 427                         mt->match_slot = value;
 428                         mt->match_frame |= 1U << mt->match_slot;
 429                         return (true);
 430                 } else if (code == ABS_MT_TRACKING_ID) {
 431                         KASSERT(!mt->type_a, ("Not a MT type B protocol"));
 432                         if (value == -1)
 433                                 mt->match_frame &= ~(1U << mt->match_slot);
 434                         return (true);
 435                 } else if (ABS_IS_MT(code)) {
 436                         KASSERT(mt->match_slot >= 0, ("Negative slot"));
 437                         KASSERT(mt->match_slot <= MAXIMAL_MT_SLOT(evdev),
 438                             ("Slot number too big"));
 439                         mt->match_slots[mt->match_slot].
 440                             val[ABS_MT_INDEX(code)] = value;
 441                         return (true);
 442                 }
 443                 break;
 444         default:
 445                 break;
 446         }
 447
 448         return (false);
 449 }
 450
 451 static void
 452 evdev_mt_replay_events(struct evdev_dev *evdev)
 453 {
 454         struct evdev_mt *mt = evdev->ev_mt;
 455         int slot, size = 0;
 456
 457         EVDEV_LOCK_ASSERT(evdev);
 458
 459         FOREACHBIT(mt->match_frame, slot) {
 460                 if (slot != size)
 461                         mt->match_slots[size] = mt->match_slots[slot];
 462                 size++;
 463         }
 464         evdev_mt_match_frame(evdev, mt->match_slots, size);
 465         evdev_mt_send_frame(evdev, mt->match_slots, size);
 466         mt->match_slot = 0;
 467         mt->match_frame = 0;
 468 }
 469
 470 union evdev_mt_slot *
 471 evdev_mt_get_match_slots(struct evdev_dev *evdev)
 472 {
 473         return (evdev->ev_mt->match_slots);
 474 }
 475
 476 int
 477 evdev_mt_get_last_slot(struct evdev_dev *evdev)
 478 {
 479         return (evdev->ev_mt->last_reported_slot);
 480 }
 481
 482 void
 483 evdev_mt_set_last_slot(struct evdev_dev *evdev, int slot)
 484 {
 485         struct evdev_mt *mt = evdev->ev_mt;
 486
 487         MPASS(slot >= 0 && slot <= MAXIMAL_MT_SLOT(evdev));
 488
 489         mt->frame |= 1U << slot;
 490         mt->last_reported_slot = slot;
 491 }
 492
 493 int32_t
 494 evdev_mt_get_value(struct evdev_dev *evdev, int slot, int16_t code)
 495 {
 496         struct evdev_mt *mt = evdev->ev_mt;
 497
 498         MPASS(slot >= 0 && slot <= MAXIMAL_MT_SLOT(evdev));
 499
 500         return (mt->slots[slot].val[ABS_MT_INDEX(code)]);
 501 }
 502
 503 void
 504 evdev_mt_set_value(struct evdev_dev *evdev, int slot, int16_t code,
 505     int32_t value)
 506 {
 507         struct evdev_mt *mt = evdev->ev_mt;
 508
 509         MPASS(slot >= 0 && slot <= MAXIMAL_MT_SLOT(evdev));
 510
 511         if (code == ABS_MT_TRACKING_ID) {
 512                 if (value != -1)
 513                         mt->touches |= 1U << slot;
 514                 else
 515                         mt->touches &= ~(1U << slot);
 516         }
 517         mt->slots[slot].val[ABS_MT_INDEX(code)] = value;
 518 }
 519
 520 int
 521 evdev_mt_id_to_slot(struct evdev_dev *evdev, int32_t tracking_id)
 522 {
 523         struct evdev_mt *mt = evdev->ev_mt;
 524         int slot;
 525
 526         KASSERT(!mt->type_a, ("Not a MT type B protocol"));
 527
 528         /*
 529          * Ignore tracking_id if slot assignment is performed by evdev.
 530          * Events are written sequentially to temporary matching buffer.
 531          */
 532         if (bit_test(evdev->ev_flags, EVDEV_FLAG_MT_TRACK))
 533                 return (ffc_slot(evdev, mt->match_frame));
 534
 535         FOREACHBIT(mt->touches, slot)
 536                 if (mt->tracking_ids[slot] == tracking_id)
 537                         return (slot);
 538         /*
 539          * Do not allow allocation of new slot in a place of just
 540          * released one within the same report.
 541          */
 542         return (ffc_slot(evdev, mt->touches | mt->frame));
 543 }
 544
 545 int32_t
 546 evdev_mt_reassign_id(struct evdev_dev *evdev, int slot, int32_t id)
 547 {
 548         struct evdev_mt *mt = evdev->ev_mt;
 549         int32_t nid;
 550
 551         if (id == -1 || bit_test(evdev->ev_flags, EVDEV_FLAG_MT_KEEPID)) {
 552                 mt->tracking_ids[slot] = id;
 553                 return (id);
 554         }
 555
 556         nid = evdev_mt_get_value(evdev, slot, ABS_MT_TRACKING_ID);
 557         if (nid != -1) {
 558                 KASSERT(id == mt->tracking_ids[slot],
 559                     ("MT-slot tracking id has changed"));
 560                 return (nid);
 561         }
 562
 563         mt->tracking_ids[slot] = id;
 564 again:
 565         nid = mt->tracking_id++;
 566         FOREACHBIT(mt->touches, slot)
 567                 if (evdev_mt_get_value(evdev, slot, ABS_MT_TRACKING_ID) == nid)
 568                         goto again;
 569
 570         return (nid);
 571 }
 572
 573 static inline int32_t
 574 evdev_mt_normalize(int32_t value, int32_t mtmin, int32_t mtmax, int32_t stmax)
 575 {
 576         if (stmax != 0 && mtmax != mtmin) {
 577                 value = (value - mtmin) * stmax / (mtmax - mtmin);
 578                 value = MAX(MIN(value, stmax), 0);
 579         }
 580         return (value);
 581 }
 582
 583 static void
 584 evdev_mt_support_st_compat(struct evdev_dev *evdev)
 585 {
 586         struct input_absinfo *ai;
 587         int i;
 588
 589         if (evdev->ev_absinfo == NULL)
 590                 return;
 591
 592         evdev_support_event(evdev, EV_KEY);
 593         evdev_support_key(evdev, BTN_TOUCH);
 594
 595         /* Touchscreens should not advertise tap tool capabilities */
 596         if (!bit_test(evdev->ev_prop_flags, INPUT_PROP_DIRECT))
 597                 evdev_support_nfingers(evdev, MAXIMAL_MT_SLOT(evdev) + 1);
 598
 599         /* Echo 0-th MT-slot as ST-slot */
 600         for (i = 0; i < nitems(evdev_mtstmap); i++) {
 601                 if (!bit_test(evdev->ev_abs_flags, evdev_mtstmap[i].mt) ||
 602                      bit_test(evdev->ev_abs_flags, evdev_mtstmap[i].st))
 603                         continue;
 604                 ai = evdev->ev_absinfo + evdev_mtstmap[i].mt;
 605                 evdev->ev_mt->mtst_events |= 1U << i;
 606                 if (evdev_mtstmap[i].max != 0)
 607                         evdev_support_abs(evdev, evdev_mtstmap[i].st,
 608                             0,
 609                             evdev_mtstmap[i].max,
 610                             0,
 611                             evdev_mt_normalize(
 612                               ai->flat, 0, ai->maximum, evdev_mtstmap[i].max),
 613                             0);
 614                 else
 615                         evdev_support_abs(evdev, evdev_mtstmap[i].st,
 616                             ai->minimum,
 617                             ai->maximum,
 618                             0,
 619                             ai->flat,
 620                             ai->resolution);
 621         }
 622 }
 623
 624 static void
 625 evdev_mt_send_st_compat(struct evdev_dev *evdev)
 626 {
 627         struct evdev_mt *mt = evdev->ev_mt;
 628         int nfingers, i, st_slot;
 629
 630         EVDEV_LOCK_ASSERT(evdev);
 631
 632         nfingers = bitcount(mt->touches);
 633         evdev_send_event(evdev, EV_KEY, BTN_TOUCH, nfingers > 0);
 634
 635         /* Send first active MT-slot state as single touch report */
 636         st_slot = ffs(mt->touches) - 1;
 637         if (st_slot != -1)
 638                 FOREACHBIT(mt->mtst_events, i)
 639                         evdev_send_event(evdev, EV_ABS, evdev_mtstmap[i].st,
 640                             evdev_mt_normalize(evdev_mt_get_value(evdev,
 641                               st_slot, evdev_mtstmap[i].mt),
 642                               evdev->ev_absinfo[evdev_mtstmap[i].mt].minimum,
 643                               evdev->ev_absinfo[evdev_mtstmap[i].mt].maximum,
 644                               evdev_mtstmap[i].max));
 645
 646         /* Touchscreens should not report tool taps */
 647         if (!bit_test(evdev->ev_prop_flags, INPUT_PROP_DIRECT))
 648                 evdev_send_nfingers(evdev, nfingers);
 649
 650         if (nfingers == 0)
 651                 evdev_send_event(evdev, EV_ABS, ABS_PRESSURE, 0);
 652 }
 653
 654 static void
 655 evdev_mt_send_autorel(struct evdev_dev *evdev)
 656 {
 657         struct evdev_mt *mt = evdev->ev_mt;
 658         int slot;
 659
 660         EVDEV_LOCK_ASSERT(evdev);
 661         KASSERT(mt->match_frame == 0, ("Unmatched events exist"));
 662
 663         FOREACHBIT(mt->touches & ~mt->frame, slot)
 664                 evdev_mt_send_slot(evdev, slot, NULL);
 665 }
 666
 667 void
 668 evdev_mt_push_autorel(struct evdev_dev *evdev)
 669 {
 670         EVDEV_ENTER(evdev);
 671         evdev_mt_send_autorel(evdev);
 672         EVDEV_EXIT(evdev);
 673 }