2 * Copyright © 2014 Red Hat, Inc.
4 * Permission to use, copy, modify, distribute, and sell this software and
5 * its documentation for any purpose is hereby granted without fee, provided
6 * that the above copyright notice appear in all copies and that both that
7 * copyright notice and this permission notice appear in supporting
8 * documentation, and that the name of the copyright holders not be used in
9 * advertising or publicity pertaining to distribution of the software
10 * without specific, written prior permission. The copyright holders make
11 * no representations about the suitability of this software for any
12 * purpose. It is provided "as is" without express or implied warranty.
14 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
15 * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
16 * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
17 * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
18 * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
19 * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
20 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
29 #include "evdev-mt-touchpad.h"
31 #define DEFAULT_ACCEL_NUMERATOR 1200.0
32 #define DEFAULT_HYSTERESIS_MARGIN_DENOMINATOR 700.0
35 tp_hysteresis(int in, int center, int margin)
37 int diff = in - center;
38 if (abs(diff) <= margin)
42 return center + diff - margin;
44 return center + diff + margin;
47 static inline struct tp_motion *
48 tp_motion_history_offset(struct tp_touch *t, int offset)
51 (t->history.index - offset + TOUCHPAD_HISTORY_LENGTH) %
52 TOUCHPAD_HISTORY_LENGTH;
54 return &t->history.samples[offset_index];
58 tp_filter_motion(struct tp_dispatch *tp,
59 double *dx, double *dy, uint64_t time)
61 struct motion_params motion;
63 motion.dx = *dx * tp->accel.x_scale_coeff;
64 motion.dy = *dy * tp->accel.y_scale_coeff;
66 if (motion.dx != 0.0 || motion.dy != 0.0)
67 filter_dispatch(tp->filter, &motion, tp, time);
74 tp_motion_history_push(struct tp_touch *t)
76 int motion_index = (t->history.index + 1) % TOUCHPAD_HISTORY_LENGTH;
78 if (t->history.count < TOUCHPAD_HISTORY_LENGTH)
81 t->history.samples[motion_index].x = t->x;
82 t->history.samples[motion_index].y = t->y;
83 t->history.index = motion_index;
87 tp_motion_hysteresis(struct tp_dispatch *tp,
93 if (t->history.count == 0) {
94 t->hysteresis.center_x = t->x;
95 t->hysteresis.center_y = t->y;
98 t->hysteresis.center_x,
99 tp->hysteresis.margin_x);
101 t->hysteresis.center_y,
102 tp->hysteresis.margin_y);
103 t->hysteresis.center_x = x;
104 t->hysteresis.center_y = y;
111 tp_motion_history_reset(struct tp_touch *t)
113 t->history.count = 0;
116 static inline struct tp_touch *
117 tp_current_touch(struct tp_dispatch *tp)
119 return &tp->touches[min(tp->slot, tp->ntouches - 1)];
122 static inline struct tp_touch *
123 tp_get_touch(struct tp_dispatch *tp, unsigned int slot)
125 assert(slot < tp->ntouches);
126 return &tp->touches[slot];
130 tp_begin_touch(struct tp_dispatch *tp, struct tp_touch *t)
132 if (t->state != TOUCH_UPDATE) {
133 tp_motion_history_reset(t);
135 t->state = TOUCH_BEGIN;
136 t->pinned.is_pinned = false;
138 assert(tp->nfingers_down >= 1);
139 tp->queued |= TOUCHPAD_EVENT_MOTION;
144 tp_end_touch(struct tp_dispatch *tp, struct tp_touch *t)
146 if (t->state == TOUCH_NONE)
150 t->is_pointer = false;
151 t->palm.is_palm = false;
152 t->state = TOUCH_END;
153 t->pinned.is_pinned = false;
154 assert(tp->nfingers_down >= 1);
156 tp->queued |= TOUCHPAD_EVENT_MOTION;
160 tp_estimate_delta(int x0, int x1, int x2, int x3)
162 return (x0 + x1 - x2 - x3) / 4;
166 tp_get_delta(struct tp_touch *t, double *dx, double *dy)
168 if (t->history.count < 4) {
174 *dx = tp_estimate_delta(tp_motion_history_offset(t, 0)->x,
175 tp_motion_history_offset(t, 1)->x,
176 tp_motion_history_offset(t, 2)->x,
177 tp_motion_history_offset(t, 3)->x);
178 *dy = tp_estimate_delta(tp_motion_history_offset(t, 0)->y,
179 tp_motion_history_offset(t, 1)->y,
180 tp_motion_history_offset(t, 2)->y,
181 tp_motion_history_offset(t, 3)->y);
185 tp_process_absolute(struct tp_dispatch *tp,
186 const struct input_event *e,
189 struct tp_touch *t = tp_current_touch(tp);
192 case ABS_MT_POSITION_X:
196 tp->queued |= TOUCHPAD_EVENT_MOTION;
198 case ABS_MT_POSITION_Y:
202 tp->queued |= TOUCHPAD_EVENT_MOTION;
207 case ABS_MT_TRACKING_ID:
210 tp_begin_touch(tp, t);
217 tp_process_absolute_st(struct tp_dispatch *tp,
218 const struct input_event *e,
221 struct tp_touch *t = tp_current_touch(tp);
228 tp->queued |= TOUCHPAD_EVENT_MOTION;
234 tp->queued |= TOUCHPAD_EVENT_MOTION;
240 tp_process_fake_touch(struct tp_dispatch *tp,
241 const struct input_event *e,
245 unsigned int fake_touches;
246 unsigned int nfake_touches;
250 if (e->code != BTN_TOUCH &&
251 (e->code < BTN_TOOL_DOUBLETAP || e->code > BTN_TOOL_QUADTAP))
254 shift = e->code == BTN_TOUCH ? 0 : (e->code - BTN_TOOL_DOUBLETAP + 1);
257 tp->fake_touches |= 1 << shift;
259 tp->fake_touches &= ~(0x1 << shift);
261 fake_touches = tp->fake_touches;
263 while (fake_touches) {
268 for (i = 0; i < tp->ntouches; i++) {
269 t = tp_get_touch(tp, i);
270 if (i >= nfake_touches) {
271 if (t->state != TOUCH_NONE) {
275 } else if (t->state != TOUCH_UPDATE &&
276 t->state != TOUCH_BEGIN) {
277 t->state = TOUCH_NONE;
278 tp_begin_touch(tp, t);
284 assert(tp->nfingers_down == nfake_touches);
288 tp_process_key(struct tp_dispatch *tp,
289 const struct input_event *e,
296 tp_process_button(tp, e, time);
299 case BTN_TOOL_DOUBLETAP:
300 case BTN_TOOL_TRIPLETAP:
301 case BTN_TOOL_QUADTAP:
303 tp_process_fake_touch(tp, e, time);
309 tp_unpin_finger(struct tp_dispatch *tp, struct tp_touch *t)
311 unsigned int xdist, ydist;
313 if (!t->pinned.is_pinned)
316 xdist = abs(t->x - t->pinned.center_x);
317 ydist = abs(t->y - t->pinned.center_y);
319 if (xdist * xdist + ydist * ydist >=
320 tp->buttons.motion_dist * tp->buttons.motion_dist) {
321 t->pinned.is_pinned = false;
322 tp_set_pointer(tp, t);
327 tp_pin_fingers(struct tp_dispatch *tp)
331 tp_for_each_touch(tp, t) {
332 t->is_pointer = false;
333 t->pinned.is_pinned = true;
334 t->pinned.center_x = t->x;
335 t->pinned.center_y = t->y;
340 tp_touch_active(struct tp_dispatch *tp, struct tp_touch *t)
342 return (t->state == TOUCH_BEGIN || t->state == TOUCH_UPDATE) &&
344 !t->pinned.is_pinned && tp_button_touch_active(tp, t);
348 tp_set_pointer(struct tp_dispatch *tp, struct tp_touch *t)
350 struct tp_touch *tmp = NULL;
352 /* Only set the touch as pointer if we don't have one yet */
353 tp_for_each_touch(tp, tmp) {
358 if (tp_touch_active(tp, t))
359 t->is_pointer = true;
363 tp_palm_detect(struct tp_dispatch *tp, struct tp_touch *t, uint64_t time)
365 const int PALM_TIMEOUT = 200; /* ms */
367 /* If labelled a touch as palm, we unlabel as palm when
368 we move out of the palm edge zone within the timeout.
370 if (t->palm.is_palm) {
371 if (time < t->palm.time + PALM_TIMEOUT &&
372 (t->x > tp->palm.left_edge && t->x < tp->palm.right_edge)) {
373 t->palm.is_palm = false;
374 tp_set_pointer(tp, t);
379 /* palm must start in exclusion zone, it's ok to move into
380 the zone without being a palm */
381 if (t->state != TOUCH_BEGIN ||
382 (t->x > tp->palm.left_edge && t->x < tp->palm.right_edge))
385 /* don't detect palm in software button areas, it's
386 likely that legitimate touches start in the area
387 covered by the exclusion zone */
388 if (tp->buttons.is_clickpad &&
389 tp_button_is_inside_softbutton_area(tp, t))
392 t->palm.is_palm = true;
397 tp_process_state(struct tp_dispatch *tp, uint64_t time)
400 struct tp_touch *first = tp_get_touch(tp, 0);
402 tp_for_each_touch(tp, t) {
403 if (!tp->has_mt && t != first && first->fake) {
407 t->dirty = first->dirty;
408 } else if (!t->dirty) {
412 tp_palm_detect(tp, t, time);
414 tp_motion_hysteresis(tp, t);
415 tp_motion_history_push(t);
417 tp_unpin_finger(tp, t);
420 tp_button_handle_state(tp, time);
423 * We have a physical button down event on a clickpad. To avoid
424 * spurious pointer moves by the clicking finger we pin all fingers.
425 * We unpin fingers when they move more then a certain threshold to
426 * to allow drag and drop.
428 if ((tp->queued & TOUCHPAD_EVENT_BUTTON_PRESS) &&
429 tp->buttons.is_clickpad)
434 tp_post_process_state(struct tp_dispatch *tp, uint64_t time)
438 tp_for_each_touch(tp, t) {
442 if (t->state == TOUCH_END) {
443 t->state = TOUCH_NONE;
445 } else if (t->state == TOUCH_BEGIN)
446 t->state = TOUCH_UPDATE;
451 tp->buttons.old_state = tp->buttons.state;
453 tp->queued = TOUCHPAD_EVENT_NONE;
457 tp_post_twofinger_scroll(struct tp_dispatch *tp, uint64_t time)
461 double dx = 0, dy =0;
464 tp_for_each_touch(tp, t) {
465 if (tp_touch_active(tp, t) && t->dirty) {
467 tp_get_delta(t, &tmpx, &tmpy);
472 /* Stop spurious MOTION events at the end of scrolling */
473 t->is_pointer = false;
482 tp_filter_motion(tp, &dx, &dy, time);
484 /* Require at least five px scrolling to start */
485 if (dy <= -5.0 || dy >= 5.0)
486 tp->scroll.direction |= (1 << LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL);
488 if (dx <= -5.0 || dx >= 5.0)
489 tp->scroll.direction |= (1 << LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL);
492 (tp->scroll.direction & (1 << LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL))) {
493 pointer_notify_axis(&tp->device->base,
495 LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL,
500 (tp->scroll.direction & (1 << LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL))) {
501 pointer_notify_axis(&tp->device->base,
503 LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL,
509 tp_stop_scroll_events(struct tp_dispatch *tp, uint64_t time)
511 /* terminate scrolling with a zero scroll event */
512 if (tp->scroll.direction & (1 << LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL))
513 pointer_notify_axis(&tp->device->base,
515 LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL,
517 if (tp->scroll.direction & (1 << LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL))
518 pointer_notify_axis(&tp->device->base,
520 LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL,
523 tp->scroll.direction = 0;
527 tp_post_scroll_events(struct tp_dispatch *tp, uint64_t time)
530 int nfingers_down = 0;
532 /* Only count active touches for 2 finger scrolling */
533 tp_for_each_touch(tp, t) {
534 if (tp_touch_active(tp, t))
538 if (nfingers_down != 2) {
539 tp_stop_scroll_events(tp, time);
543 tp_post_twofinger_scroll(tp, time);
548 tp_post_events(struct tp_dispatch *tp, uint64_t time)
550 struct tp_touch *t = tp_current_touch(tp);
554 consumed |= tp_tap_handle_state(tp, time);
555 consumed |= tp_post_button_events(tp, time);
558 tp_stop_scroll_events(tp, time);
562 if (tp_post_scroll_events(tp, time) != 0)
565 if (!t->is_pointer) {
566 tp_for_each_touch(tp, t) {
572 if (!t->is_pointer ||
574 t->history.count < TOUCHPAD_MIN_SAMPLES)
577 tp_get_delta(t, &dx, &dy);
578 tp_filter_motion(tp, &dx, &dy, time);
580 if (dx != 0.0 || dy != 0.0)
581 pointer_notify_motion(&tp->device->base, time, dx, dy);
585 tp_process(struct evdev_dispatch *dispatch,
586 struct evdev_device *device,
587 struct input_event *e,
590 struct tp_dispatch *tp =
591 (struct tp_dispatch *)dispatch;
596 tp_process_absolute(tp, e, time);
598 tp_process_absolute_st(tp, e, time);
601 tp_process_key(tp, e, time);
604 tp_process_state(tp, time);
605 tp_post_events(tp, time);
606 tp_post_process_state(tp, time);
612 tp_destroy(struct evdev_dispatch *dispatch)
614 struct tp_dispatch *tp =
615 (struct tp_dispatch*)dispatch;
618 tp_destroy_buttons(tp);
620 filter_destroy(tp->filter);
625 static struct evdev_dispatch_interface tp_interface = {
631 tp_init_touch(struct tp_dispatch *tp,
638 tp_init_slots(struct tp_dispatch *tp,
639 struct evdev_device *device)
642 const struct input_absinfo *absinfo;
644 absinfo = libevdev_get_abs_info(device->evdev, ABS_MT_SLOT);
646 tp->ntouches = absinfo->maximum + 1;
647 tp->slot = absinfo->value;
654 { BTN_TOOL_QUINTTAP, 5 },
655 { BTN_TOOL_QUADTAP, 4 },
656 { BTN_TOOL_TRIPLETAP, 3 },
657 { BTN_TOOL_DOUBLETAP, 2 },
665 ARRAY_FOR_EACH(max_touches, m) {
666 if (libevdev_has_event_code(device->evdev,
669 tp->ntouches = m->ntouches;
674 tp->touches = calloc(tp->ntouches,
675 sizeof(struct tp_touch));
679 for (i = 0; i < tp->ntouches; i++)
680 tp_init_touch(tp, &tp->touches[i]);
686 tp_init_accel(struct tp_dispatch *tp, double diagonal)
688 struct motion_filter *accel;
692 res_x = libevdev_get_abs_resolution(tp->device->evdev,
694 res_y = libevdev_get_abs_resolution(tp->device->evdev,
697 res_x = libevdev_get_abs_resolution(tp->device->evdev,
699 res_y = libevdev_get_abs_resolution(tp->device->evdev,
704 * Not all touchpads report the same amount of units/mm (resolution).
705 * Normalize motion events to a resolution of 15.74 units/mm
706 * (== 400 dpi) as base (unaccelerated) speed. This also evens out any
707 * differences in x and y resolution, so that a circle on the
708 * touchpad does not turn into an elipse on the screen.
710 * We pick 400dpi as thats one of the many default resolutions
711 * for USB mice, so we end up with a similar base speed on the device.
713 if (res_x > 1 && res_y > 1) {
714 tp->accel.x_scale_coeff = (400/25.4) / res_x;
715 tp->accel.y_scale_coeff = (400/25.4) / res_y;
718 * For touchpads where the driver does not provide resolution, fall
719 * back to scaling motion events based on the diagonal size in units.
721 tp->accel.x_scale_coeff = DEFAULT_ACCEL_NUMERATOR / diagonal;
722 tp->accel.y_scale_coeff = DEFAULT_ACCEL_NUMERATOR / diagonal;
725 accel = create_pointer_accelator_filter(
726 pointer_accel_profile_smooth_simple);
736 tp_init_scroll(struct tp_dispatch *tp)
738 tp->scroll.direction = 0;
744 tp_init_palmdetect(struct tp_dispatch *tp,
745 struct evdev_device *device)
749 width = abs(device->abs.absinfo_x->maximum -
750 device->abs.absinfo_x->minimum);
752 /* palm edges are 5% of the width on each side */
753 tp->palm.right_edge = device->abs.absinfo_x->maximum - width * 0.05;
754 tp->palm.left_edge = device->abs.absinfo_x->minimum + width * 0.05;
761 tp_init(struct tp_dispatch *tp,
762 struct evdev_device *device)
767 tp->base.interface = &tp_interface;
770 if (tp_init_slots(tp, device) != 0)
773 width = abs(device->abs.absinfo_x->maximum -
774 device->abs.absinfo_x->minimum);
775 height = abs(device->abs.absinfo_y->maximum -
776 device->abs.absinfo_y->minimum);
777 diagonal = sqrt(width*width + height*height);
779 tp->hysteresis.margin_x =
780 diagonal / DEFAULT_HYSTERESIS_MARGIN_DENOMINATOR;
781 tp->hysteresis.margin_y =
782 diagonal / DEFAULT_HYSTERESIS_MARGIN_DENOMINATOR;
784 if (tp_init_scroll(tp) != 0)
787 if (tp_init_accel(tp, diagonal) != 0)
790 if (tp_init_tap(tp) != 0)
793 if (tp_init_buttons(tp, device) != 0)
796 if (tp_init_palmdetect(tp, device) != 0)
802 struct evdev_dispatch *
803 evdev_mt_touchpad_create(struct evdev_device *device)
805 struct tp_dispatch *tp;
807 tp = zalloc(sizeof *tp);
811 if (tp_init(tp, device) != 0) {
812 tp_destroy(&tp->base);