drivers/input/input-mt.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Input Multitouch Library
   4  *
   5  * Copyright (c) 2008-2010 Henrik Rydberg
   6  */
   7
   8 #include <linux/input/mt.h>
   9 #include <linux/export.h>
  10 #include <linux/slab.h>
  11 #include "input-core-private.h"
  12
  13 #define TRKID_SGN       ((TRKID_MAX + 1) >> 1)
  14
  15 static void copy_abs(struct input_dev *dev, unsigned int dst, unsigned int src)
  16 {
  17         if (dev->absinfo && test_bit(src, dev->absbit)) {
  18                 dev->absinfo[dst] = dev->absinfo[src];
  19                 dev->absinfo[dst].fuzz = 0;
  20                 __set_bit(dst, dev->absbit);
  21         }
  22 }
  23
  24 /**
  25  * input_mt_init_slots() - initialize MT input slots
  26  * @dev: input device supporting MT events and finger tracking
  27  * @num_slots: number of slots used by the device
  28  * @flags: mt tasks to handle in core
  29  *
  30  * This function allocates all necessary memory for MT slot handling
  31  * in the input device, prepares the ABS_MT_SLOT and
  32  * ABS_MT_TRACKING_ID events for use and sets up appropriate buffers.
  33  * Depending on the flags set, it also performs pointer emulation and
  34  * frame synchronization.
  35  *
  36  * May be called repeatedly. Returns -EINVAL if attempting to
  37  * reinitialize with a different number of slots.
  38  */
  39 int input_mt_init_slots(struct input_dev *dev, unsigned int num_slots,
  40                         unsigned int flags)
  41 {
  42         struct input_mt *mt = dev->mt;
  43         int i;
  44
  45         if (!num_slots)
  46                 return 0;
  47         if (mt)
  48                 return mt->num_slots != num_slots ? -EINVAL : 0;
  49         /* Arbitrary limit for avoiding too large memory allocation. */
  50         if (num_slots > 1024)
  51                 return -EINVAL;
  52
  53         mt = kzalloc(struct_size(mt, slots, num_slots), GFP_KERNEL);
  54         if (!mt)
  55                 goto err_mem;
  56
  57         mt->num_slots = num_slots;
  58         mt->flags = flags;
  59         input_set_abs_params(dev, ABS_MT_SLOT, 0, num_slots - 1, 0, 0);
  60         input_set_abs_params(dev, ABS_MT_TRACKING_ID, 0, TRKID_MAX, 0, 0);
  61
  62         if (flags & (INPUT_MT_POINTER | INPUT_MT_DIRECT)) {
  63                 __set_bit(EV_KEY, dev->evbit);
  64                 __set_bit(BTN_TOUCH, dev->keybit);
  65
  66                 copy_abs(dev, ABS_X, ABS_MT_POSITION_X);
  67                 copy_abs(dev, ABS_Y, ABS_MT_POSITION_Y);
  68                 copy_abs(dev, ABS_PRESSURE, ABS_MT_PRESSURE);
  69         }
  70         if (flags & INPUT_MT_POINTER) {
  71                 __set_bit(BTN_TOOL_FINGER, dev->keybit);
  72                 __set_bit(BTN_TOOL_DOUBLETAP, dev->keybit);
  73                 if (num_slots >= 3)
  74                         __set_bit(BTN_TOOL_TRIPLETAP, dev->keybit);
  75                 if (num_slots >= 4)
  76                         __set_bit(BTN_TOOL_QUADTAP, dev->keybit);
  77                 if (num_slots >= 5)
  78                         __set_bit(BTN_TOOL_QUINTTAP, dev->keybit);
  79                 __set_bit(INPUT_PROP_POINTER, dev->propbit);
  80         }
  81         if (flags & INPUT_MT_DIRECT)
  82                 __set_bit(INPUT_PROP_DIRECT, dev->propbit);
  83         if (flags & INPUT_MT_SEMI_MT)
  84                 __set_bit(INPUT_PROP_SEMI_MT, dev->propbit);
  85         if (flags & INPUT_MT_TRACK) {
  86                 unsigned int n2 = num_slots * num_slots;
  87                 mt->red = kcalloc(n2, sizeof(*mt->red), GFP_KERNEL);
  88                 if (!mt->red)
  89                         goto err_mem;
  90         }
  91
  92         /* Mark slots as 'inactive' */
  93         for (i = 0; i < num_slots; i++)
  94                 input_mt_set_value(&mt->slots[i], ABS_MT_TRACKING_ID, -1);
  95
  96         /* Mark slots as 'unused' */
  97         mt->frame = 1;
  98
  99         dev->mt = mt;
 100         return 0;
 101 err_mem:
 102         kfree(mt);
 103         return -ENOMEM;
 104 }
 105 EXPORT_SYMBOL(input_mt_init_slots);
 106
 107 /**
 108  * input_mt_destroy_slots() - frees the MT slots of the input device
 109  * @dev: input device with allocated MT slots
 110  *
 111  * This function is only needed in error path as the input core will
 112  * automatically free the MT slots when the device is destroyed.
 113  */
 114 void input_mt_destroy_slots(struct input_dev *dev)
 115 {
 116         if (dev->mt) {
 117                 kfree(dev->mt->red);
 118                 kfree(dev->mt);
 119         }
 120         dev->mt = NULL;
 121 }
 122 EXPORT_SYMBOL(input_mt_destroy_slots);
 123
 124 /**
 125  * input_mt_report_slot_state() - report contact state
 126  * @dev: input device with allocated MT slots
 127  * @tool_type: the tool type to use in this slot
 128  * @active: true if contact is active, false otherwise
 129  *
 130  * Reports a contact via ABS_MT_TRACKING_ID, and optionally
 131  * ABS_MT_TOOL_TYPE. If active is true and the slot is currently
 132  * inactive, or if the tool type is changed, a new tracking id is
 133  * assigned to the slot. The tool type is only reported if the
 134  * corresponding absbit field is set.
 135  *
 136  * Returns true if contact is active.
 137  */
 138 bool input_mt_report_slot_state(struct input_dev *dev,
 139                                 unsigned int tool_type, bool active)
 140 {
 141         struct input_mt *mt = dev->mt;
 142         struct input_mt_slot *slot;
 143         int id;
 144
 145         if (!mt)
 146                 return false;
 147
 148         slot = &mt->slots[mt->slot];
 149         slot->frame = mt->frame;
 150
 151         if (!active) {
 152                 input_event(dev, EV_ABS, ABS_MT_TRACKING_ID, -1);
 153                 return false;
 154         }
 155
 156         id = input_mt_get_value(slot, ABS_MT_TRACKING_ID);
 157         if (id < 0)
 158                 id = input_mt_new_trkid(mt);
 159
 160         input_event(dev, EV_ABS, ABS_MT_TRACKING_ID, id);
 161         input_event(dev, EV_ABS, ABS_MT_TOOL_TYPE, tool_type);
 162
 163         return true;
 164 }
 165 EXPORT_SYMBOL(input_mt_report_slot_state);
 166
 167 /**
 168  * input_mt_report_finger_count() - report contact count
 169  * @dev: input device with allocated MT slots
 170  * @count: the number of contacts
 171  *
 172  * Reports the contact count via BTN_TOOL_FINGER, BTN_TOOL_DOUBLETAP,
 173  * BTN_TOOL_TRIPLETAP and BTN_TOOL_QUADTAP.
 174  *
 175  * The input core ensures only the KEY events already setup for
 176  * this device will produce output.
 177  */
 178 void input_mt_report_finger_count(struct input_dev *dev, int count)
 179 {
 180         input_event(dev, EV_KEY, BTN_TOOL_FINGER, count == 1);
 181         input_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, count == 2);
 182         input_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, count == 3);
 183         input_event(dev, EV_KEY, BTN_TOOL_QUADTAP, count == 4);
 184         input_event(dev, EV_KEY, BTN_TOOL_QUINTTAP, count == 5);
 185 }
 186 EXPORT_SYMBOL(input_mt_report_finger_count);
 187
 188 /**
 189  * input_mt_report_pointer_emulation() - common pointer emulation
 190  * @dev: input device with allocated MT slots
 191  * @use_count: report number of active contacts as finger count
 192  *
 193  * Performs legacy pointer emulation via BTN_TOUCH, ABS_X, ABS_Y and
 194  * ABS_PRESSURE. Touchpad finger count is emulated if use_count is true.
 195  *
 196  * The input core ensures only the KEY and ABS axes already setup for
 197  * this device will produce output.
 198  */
 199 void input_mt_report_pointer_emulation(struct input_dev *dev, bool use_count)
 200 {
 201         struct input_mt *mt = dev->mt;
 202         struct input_mt_slot *oldest;
 203         int oldid, count, i;
 204
 205         if (!mt)
 206                 return;
 207
 208         oldest = NULL;
 209         oldid = mt->trkid;
 210         count = 0;
 211
 212         for (i = 0; i < mt->num_slots; ++i) {
 213                 struct input_mt_slot *ps = &mt->slots[i];
 214                 int id = input_mt_get_value(ps, ABS_MT_TRACKING_ID);
 215
 216                 if (id < 0)
 217                         continue;
 218                 if ((id - oldid) & TRKID_SGN) {
 219                         oldest = ps;
 220                         oldid = id;
 221                 }
 222                 count++;
 223         }
 224
 225         input_event(dev, EV_KEY, BTN_TOUCH, count > 0);
 226
 227         if (use_count) {
 228                 if (count == 0 &&
 229                     !test_bit(ABS_MT_DISTANCE, dev->absbit) &&
 230                     test_bit(ABS_DISTANCE, dev->absbit) &&
 231                     input_abs_get_val(dev, ABS_DISTANCE) != 0) {
 232                         /*
 233                          * Force reporting BTN_TOOL_FINGER for devices that
 234                          * only report general hover (and not per-contact
 235                          * distance) when contact is in proximity but not
 236                          * on the surface.
 237                          */
 238                         count = 1;
 239                 }
 240
 241                 input_mt_report_finger_count(dev, count);
 242         }
 243
 244         if (oldest) {
 245                 int x = input_mt_get_value(oldest, ABS_MT_POSITION_X);
 246                 int y = input_mt_get_value(oldest, ABS_MT_POSITION_Y);
 247
 248                 input_event(dev, EV_ABS, ABS_X, x);
 249                 input_event(dev, EV_ABS, ABS_Y, y);
 250
 251                 if (test_bit(ABS_MT_PRESSURE, dev->absbit)) {
 252                         int p = input_mt_get_value(oldest, ABS_MT_PRESSURE);
 253                         input_event(dev, EV_ABS, ABS_PRESSURE, p);
 254                 }
 255         } else {
 256                 if (test_bit(ABS_MT_PRESSURE, dev->absbit))
 257                         input_event(dev, EV_ABS, ABS_PRESSURE, 0);
 258         }
 259 }
 260 EXPORT_SYMBOL(input_mt_report_pointer_emulation);
 261
 262 static void __input_mt_drop_unused(struct input_dev *dev, struct input_mt *mt)
 263 {
 264         int i;
 265
 266         lockdep_assert_held(&dev->event_lock);
 267
 268         for (i = 0; i < mt->num_slots; i++) {
 269                 if (input_mt_is_active(&mt->slots[i]) &&
 270                     !input_mt_is_used(mt, &mt->slots[i])) {
 271                         input_handle_event(dev, EV_ABS, ABS_MT_SLOT, i);
 272                         input_handle_event(dev, EV_ABS, ABS_MT_TRACKING_ID, -1);
 273                 }
 274         }
 275 }
 276
 277 /**
 278  * input_mt_drop_unused() - Inactivate slots not seen in this frame
 279  * @dev: input device with allocated MT slots
 280  *
 281  * Lift all slots not seen since the last call to this function.
 282  */
 283 void input_mt_drop_unused(struct input_dev *dev)
 284 {
 285         struct input_mt *mt = dev->mt;
 286
 287         if (mt) {
 288                 unsigned long flags;
 289
 290                 spin_lock_irqsave(&dev->event_lock, flags);
 291
 292                 __input_mt_drop_unused(dev, mt);
 293                 mt->frame++;
 294
 295                 spin_unlock_irqrestore(&dev->event_lock, flags);
 296         }
 297 }
 298 EXPORT_SYMBOL(input_mt_drop_unused);
 299
 300 /**
 301  * input_mt_release_slots() - Deactivate all slots
 302  * @dev: input device with allocated MT slots
 303  *
 304  * Lift all active slots.
 305  */
 306 void input_mt_release_slots(struct input_dev *dev)
 307 {
 308         struct input_mt *mt = dev->mt;
 309
 310         lockdep_assert_held(&dev->event_lock);
 311
 312         if (mt) {
 313                 /* This will effectively mark all slots unused. */
 314                 mt->frame++;
 315
 316                 __input_mt_drop_unused(dev, mt);
 317
 318                 if (test_bit(ABS_PRESSURE, dev->absbit))
 319                         input_handle_event(dev, EV_ABS, ABS_PRESSURE, 0);
 320
 321                 mt->frame++;
 322         }
 323 }
 324
 325 /**
 326  * input_mt_sync_frame() - synchronize mt frame
 327  * @dev: input device with allocated MT slots
 328  *
 329  * Close the frame and prepare the internal state for a new one.
 330  * Depending on the flags, marks unused slots as inactive and performs
 331  * pointer emulation.
 332  */
 333 void input_mt_sync_frame(struct input_dev *dev)
 334 {
 335         struct input_mt *mt = dev->mt;
 336         bool use_count = false;
 337
 338         if (!mt)
 339                 return;
 340
 341         if (mt->flags & INPUT_MT_DROP_UNUSED) {
 342                 unsigned long flags;
 343
 344                 spin_lock_irqsave(&dev->event_lock, flags);
 345                 __input_mt_drop_unused(dev, mt);
 346                 spin_unlock_irqrestore(&dev->event_lock, flags);
 347         }
 348
 349         if ((mt->flags & INPUT_MT_POINTER) && !(mt->flags & INPUT_MT_SEMI_MT))
 350                 use_count = true;
 351
 352         input_mt_report_pointer_emulation(dev, use_count);
 353
 354         mt->frame++;
 355 }
 356 EXPORT_SYMBOL(input_mt_sync_frame);
 357
 358 static int adjust_dual(int *begin, int step, int *end, int eq, int mu)
 359 {
 360         int f, *p, s, c;
 361
 362         if (begin == end)
 363                 return 0;
 364
 365         f = *begin;
 366         p = begin + step;
 367         s = p == end ? f + 1 : *p;
 368
 369         for (; p != end; p += step) {
 370                 if (*p < f) {
 371                         s = f;
 372                         f = *p;
 373                 } else if (*p < s) {
 374                         s = *p;
 375                 }
 376         }
 377
 378         c = (f + s + 1) / 2;
 379         if (c == 0 || (c > mu && (!eq || mu > 0)))
 380                 return 0;
 381         /* Improve convergence for positive matrices by penalizing overcovers */
 382         if (s < 0 && mu <= 0)
 383                 c *= 2;
 384
 385         for (p = begin; p != end; p += step)
 386                 *p -= c;
 387
 388         return (c < s && s <= 0) || (f >= 0 && f < c);
 389 }
 390
 391 static void find_reduced_matrix(int *w, int nr, int nc, int nrc, int mu)
 392 {
 393         int i, k, sum;
 394
 395         for (k = 0; k < nrc; k++) {
 396                 for (i = 0; i < nr; i++)
 397                         adjust_dual(w + i, nr, w + i + nrc, nr <= nc, mu);
 398                 sum = 0;
 399                 for (i = 0; i < nrc; i += nr)
 400                         sum += adjust_dual(w + i, 1, w + i + nr, nc <= nr, mu);
 401                 if (!sum)
 402                         break;
 403         }
 404 }
 405
 406 static int input_mt_set_matrix(struct input_mt *mt,
 407                                const struct input_mt_pos *pos, int num_pos,
 408                                int mu)
 409 {
 410         const struct input_mt_pos *p;
 411         struct input_mt_slot *s;
 412         int *w = mt->red;
 413         int x, y;
 414
 415         for (s = mt->slots; s != mt->slots + mt->num_slots; s++) {
 416                 if (!input_mt_is_active(s))
 417                         continue;
 418                 x = input_mt_get_value(s, ABS_MT_POSITION_X);
 419                 y = input_mt_get_value(s, ABS_MT_POSITION_Y);
 420                 for (p = pos; p != pos + num_pos; p++) {
 421                         int dx = x - p->x, dy = y - p->y;
 422                         *w++ = dx * dx + dy * dy - mu;
 423                 }
 424         }
 425
 426         return w - mt->red;
 427 }
 428
 429 static void input_mt_set_slots(struct input_mt *mt,
 430                                int *slots, int num_pos)
 431 {
 432         struct input_mt_slot *s;
 433         int *w = mt->red, j;
 434
 435         for (j = 0; j != num_pos; j++)
 436                 slots[j] = -1;
 437
 438         for (s = mt->slots; s != mt->slots + mt->num_slots; s++) {
 439                 if (!input_mt_is_active(s))
 440                         continue;
 441
 442                 for (j = 0; j != num_pos; j++) {
 443                         if (w[j] < 0) {
 444                                 slots[j] = s - mt->slots;
 445                                 break;
 446                         }
 447                 }
 448
 449                 w += num_pos;
 450         }
 451
 452         for (s = mt->slots; s != mt->slots + mt->num_slots; s++) {
 453                 if (input_mt_is_active(s))
 454                         continue;
 455
 456                 for (j = 0; j != num_pos; j++) {
 457                         if (slots[j] < 0) {
 458                                 slots[j] = s - mt->slots;
 459                                 break;
 460                         }
 461                 }
 462         }
 463 }
 464
 465 /**
 466  * input_mt_assign_slots() - perform a best-match assignment
 467  * @dev: input device with allocated MT slots
 468  * @slots: the slot assignment to be filled
 469  * @pos: the position array to match
 470  * @num_pos: number of positions
 471  * @dmax: maximum ABS_MT_POSITION displacement (zero for infinite)
 472  *
 473  * Performs a best match against the current contacts and returns
 474  * the slot assignment list. New contacts are assigned to unused
 475  * slots.
 476  *
 477  * The assignments are balanced so that all coordinate displacements are
 478  * below the euclidian distance dmax. If no such assignment can be found,
 479  * some contacts are assigned to unused slots.
 480  *
 481  * Returns zero on success, or negative error in case of failure.
 482  */
 483 int input_mt_assign_slots(struct input_dev *dev, int *slots,
 484                           const struct input_mt_pos *pos, int num_pos,
 485                           int dmax)
 486 {
 487         struct input_mt *mt = dev->mt;
 488         int mu = 2 * dmax * dmax;
 489         int nrc;
 490
 491         if (!mt || !mt->red)
 492                 return -ENXIO;
 493         if (num_pos > mt->num_slots)
 494                 return -EINVAL;
 495         if (num_pos < 1)
 496                 return 0;
 497
 498         nrc = input_mt_set_matrix(mt, pos, num_pos, mu);
 499         find_reduced_matrix(mt->red, num_pos, nrc / num_pos, nrc, mu);
 500         input_mt_set_slots(mt, slots, num_pos);
 501
 502         return 0;
 503 }
 504 EXPORT_SYMBOL(input_mt_assign_slots);
 505
 506 /**
 507  * input_mt_get_slot_by_key() - return slot matching key
 508  * @dev: input device with allocated MT slots
 509  * @key: the key of the sought slot
 510  *
 511  * Returns the slot of the given key, if it exists, otherwise
 512  * set the key on the first unused slot and return.
 513  *
 514  * If no available slot can be found, -1 is returned.
 515  * Note that for this function to work properly, input_mt_sync_frame() has
 516  * to be called at each frame.
 517  */
 518 int input_mt_get_slot_by_key(struct input_dev *dev, int key)
 519 {
 520         struct input_mt *mt = dev->mt;
 521         struct input_mt_slot *s;
 522
 523         if (!mt)
 524                 return -1;
 525
 526         for (s = mt->slots; s != mt->slots + mt->num_slots; s++)
 527                 if (input_mt_is_active(s) && s->key == key)
 528                         return s - mt->slots;
 529
 530         for (s = mt->slots; s != mt->slots + mt->num_slots; s++)
 531                 if (!input_mt_is_active(s) && !input_mt_is_used(mt, s)) {
 532                         s->key = key;
 533                         return s - mt->slots;
 534                 }
 535
 536         return -1;
 537 }
 538 EXPORT_SYMBOL(input_mt_get_slot_by_key);