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