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