evdev-mt-touchpad.h 15.2 KB
Newer Older
1
/*
Peter Hutterer's avatar
Peter Hutterer committed
2
 * Copyright © 2014-2015 Red Hat, Inc.
3
 *
4 5 6 7 8 9
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
10
 *
11 12 13 14 15 16 17 18 19 20 21
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
22 23 24 25 26 27 28 29 30
 */

#ifndef EVDEV_MT_TOUCHPAD_H
#define EVDEV_MT_TOUCHPAD_H

#include <stdbool.h>

#include "evdev.h"
#include "filter.h"
31
#include "timer.h"
32 33

#define TOUCHPAD_HISTORY_LENGTH 4
34
#define TOUCHPAD_MIN_SAMPLES 4
35

36
/* Convert mm to a distance normalized to DEFAULT_MOUSE_DPI */
37
#define TP_MM_TO_DPI_NORMALIZED(mm) (DEFAULT_MOUSE_DPI/25.4 * mm)
38

39 40 41 42 43
enum touchpad_event {
	TOUCHPAD_EVENT_NONE		= 0,
	TOUCHPAD_EVENT_MOTION		= (1 << 0),
	TOUCHPAD_EVENT_BUTTON_PRESS	= (1 << 1),
	TOUCHPAD_EVENT_BUTTON_RELEASE	= (1 << 2),
44
	TOUCHPAD_EVENT_OTHERAXIS	= (1 << 3),
45 46
};

47 48
enum touch_state {
	TOUCH_NONE = 0,
49
	TOUCH_HOVERING,
50 51 52 53 54
	TOUCH_BEGIN,
	TOUCH_UPDATE,
	TOUCH_END
};

55 56 57
enum touch_palm_state {
	PALM_NONE = 0,
	PALM_EDGE,
58
	PALM_TYPING,
59
	PALM_TRACKPOINT,
60
	PALM_TOOL_PALM,
61
	PALM_PRESSURE,
62
	PALM_TOUCH_SIZE,
63
	PALM_ARBITRATION,
64 65
};

66
enum button_event {
67
	BUTTON_EVENT_IN_BOTTOM_R = 30,
68
	BUTTON_EVENT_IN_BOTTOM_M,
69 70 71 72 73 74 75 76 77
	BUTTON_EVENT_IN_BOTTOM_L,
	BUTTON_EVENT_IN_TOP_R,
	BUTTON_EVENT_IN_TOP_M,
	BUTTON_EVENT_IN_TOP_L,
	BUTTON_EVENT_IN_AREA,
	BUTTON_EVENT_UP,
	BUTTON_EVENT_PRESS,
	BUTTON_EVENT_RELEASE,
	BUTTON_EVENT_TIMEOUT,
78 79 80
};

enum button_state {
81 82 83 84 85 86 87
	BUTTON_STATE_NONE,
	BUTTON_STATE_AREA,
	BUTTON_STATE_BOTTOM,
	BUTTON_STATE_TOP,
	BUTTON_STATE_TOP_NEW,
	BUTTON_STATE_TOP_TO_IGNORE,
	BUTTON_STATE_IGNORE,
88 89
};

90 91 92 93 94 95 96
enum tp_tap_state {
	TAP_STATE_IDLE = 4,
	TAP_STATE_TOUCH,
	TAP_STATE_HOLD,
	TAP_STATE_TAPPED,
	TAP_STATE_TOUCH_2,
	TAP_STATE_TOUCH_2_HOLD,
97
	TAP_STATE_TOUCH_2_RELEASE,
98 99 100
	TAP_STATE_TOUCH_3,
	TAP_STATE_TOUCH_3_HOLD,
	TAP_STATE_DRAGGING_OR_DOUBLETAP,
101
	TAP_STATE_DRAGGING_OR_TAP,
102 103 104
	TAP_STATE_DRAGGING,
	TAP_STATE_DRAGGING_WAIT,
	TAP_STATE_DRAGGING_2,
105 106
	TAP_STATE_MULTITAP,
	TAP_STATE_MULTITAP_DOWN,
107
	TAP_STATE_MULTITAP_PALM,
108 109 110
	TAP_STATE_DEAD, /**< finger count exceeded */
};

111 112 113 114 115 116
enum tp_tap_touch_state {
	TAP_TOUCH_STATE_IDLE = 16,	/**< not in touch */
	TAP_TOUCH_STATE_TOUCH,		/**< touching, may tap */
	TAP_TOUCH_STATE_DEAD,		/**< exceeded motion/timeout */
};

117 118 119 120 121 122 123 124 125 126 127 128 129 130
/* For edge scrolling, so we only care about right and bottom */
enum tp_edge {
	EDGE_NONE = 0,
	EDGE_RIGHT = (1 << 0),
	EDGE_BOTTOM = (1 << 1),
};

enum tp_edge_scroll_touch_state {
	EDGE_SCROLL_TOUCH_STATE_NONE,
	EDGE_SCROLL_TOUCH_STATE_EDGE_NEW,
	EDGE_SCROLL_TOUCH_STATE_EDGE,
	EDGE_SCROLL_TOUCH_STATE_AREA,
};

131 132 133 134 135
enum tp_gesture_state {
	GESTURE_STATE_NONE,
	GESTURE_STATE_UNKNOWN,
	GESTURE_STATE_SCROLL,
	GESTURE_STATE_PINCH,
136
	GESTURE_STATE_SWIPE,
137 138
};

139 140 141 142 143 144
enum tp_thumb_state {
	THUMB_STATE_NO,
	THUMB_STATE_YES,
	THUMB_STATE_MAYBE,
};

145
struct tp_touch {
146
	struct tp_dispatch *tp;
147
	unsigned int index;
148
	enum touch_state state;
149
	bool has_ended;				/* TRACKING_ID == -1 */
150
	bool dirty;
151
	struct device_coords point;
152
	uint64_t time;
153
	int pressure;
154
	bool is_tool_palm; /* MT_TOOL_PALM */
155
	int major, minor;
156

157 158 159
	bool was_down; /* if distance == 0, false for pure hovering
			  touches */

160 161 162 163 164 165 166 167 168
	struct {
		/* A quirk mostly used on Synaptics touchpads. In a
		   transition to/from fake touches > num_slots, the current
		   event data is likely garbage and the subsequent event
		   is likely too. This marker tells us to reset the motion
		   history again -> this effectively swallows any motion */
		bool reset_motion_history;
	} quirks;

169
	struct {
170 171 172 173
		struct tp_history_point {
			uint64_t time;
			struct device_coords point;
		} samples[TOUCHPAD_HISTORY_LENGTH];
174 175 176 177
		unsigned int index;
		unsigned int count;
	} history;

178
	struct device_coords hysteresis_center;
179 180 181 182 183 184 185

	/* A pinned touchpoint is the one that pressed the physical button
	 * on a clickpad. After the release, it won't move until the center
	 * moves more than a threshold away from the original coordinates
	 */
	struct {
		bool is_pinned;
186
		struct device_coords center;
187
	} pinned;
188 189 190 191 192 193

	/* Software-button state and timeout if applicable */
	struct {
		enum button_state state;
		/* We use button_event here so we can use == on events */
		enum button_event curr;
194
		struct libinput_timer timer;
195
	} button;
196 197 198

	struct {
		enum tp_tap_touch_state state;
199
		struct device_coords initial;
200
		bool is_thumb;
201
		bool is_palm;
202
	} tap;
203

204
	struct {
205
		enum tp_edge_scroll_touch_state edge_state;
206 207 208
		uint32_t edge;
		int direction;
		struct libinput_timer timer;
209
		struct device_coords initial;
210 211
	} scroll;

212
	struct {
213
		enum touch_palm_state state;
214
		struct device_coords first; /* first coordinates if is_palm == true */
215
		uint64_t time; /* first timestamp if is_palm == true */
216
	} palm;
217 218 219 220

	struct {
		struct device_coords initial;
	} gesture;
221 222 223 224

	struct {
		enum tp_thumb_state state;
		uint64_t first_touch_time;
225
		struct device_coords initial;
226
	} thumb;
227 228 229 230 231

	struct {
		double last_speed; /* speed in mm/s at last sample */
		unsigned int exceeded_count;
	} speed;
232 233 234 235 236 237
};

struct tp_dispatch {
	struct evdev_dispatch base;
	struct evdev_device *device;
	unsigned int nfingers_down;		/* number of fingers down */
238
	unsigned int old_nfingers_down;		/* previous no fingers down */
239
	unsigned int slot;			/* current slot */
240
	bool has_mt;
241
	bool semi_mt;
242

243 244 245 246 247
	/* pen/touch arbitration */
	struct {
		bool in_arbitration;
		struct libinput_timer arbitration_timer;
	} arbitration;
Peter Hutterer's avatar
Peter Hutterer committed
248

249
	unsigned int num_slots;			/* number of slots */
250
	unsigned int ntouches;			/* no slots inc. fakes */
251
	struct tp_touch *touches;		/* len == ntouches */
252 253 254 255 256 257
	/* bit 0: BTN_TOUCH
	 * bit 1: BTN_TOOL_FINGER
	 * bit 2: BTN_TOOL_DOUBLETAP
	 * ...
	 */
	unsigned int fake_touches;
258

259 260 261 262 263 264 265 266
	/* if pressure goes above high -> touch down,
	   if pressure then goes below low -> touch up */
	struct {
		bool use_pressure;
		int high;
		int low;
	} pressure;

267 268 269 270 271 272 273 274 275 276 277
	/* If touch size (either axis) goes above high -> touch down,
	   if touch size (either axis) goes below low -> touch up */
	struct  {
		bool use_touch_size;
		int high;
		int low;

		/* convert device units to angle */
		double orientation_to_angle;
	} touch_size;

278
	struct {
279
		bool enabled;
280
		struct device_coords margin;
281 282
		unsigned int other_event_count;
		uint64_t last_motion_time;
283
	} hysteresis;
284 285

	struct {
286 287
		double x_scale_coeff;
		double y_scale_coeff;
288
		double xy_scale_coeff;
289
	} accel;
290

291
	struct {
292
		bool enabled;
293 294 295 296
		bool started;
		unsigned int finger_count;
		unsigned int finger_count_pending;
		struct libinput_timer finger_count_switch_timer;
297
		enum tp_gesture_state state;
298 299 300 301 302 303
		struct tp_touch *touches[2];
		uint64_t initial_time;
		double initial_distance;
		double prev_scale;
		double angle;
		struct device_float_coords center;
304 305
	} gesture;

306
	struct {
307
		bool is_clickpad;		/* true for clickpads */
308
		bool has_topbuttons;
309
		bool use_clickfinger;		/* number of fingers decides button number */
310
		bool click_pending;
311 312
		uint32_t state;
		uint32_t old_state;
313 314 315 316
		struct {
			double x_scale_coeff;
			double y_scale_coeff;
		} motion_dist;			/* for pinned touches */
317
		unsigned int active;		/* currently active button, for release event */
318
		bool active_is_topbutton;	/* is active a top button? */
319

320 321 322
		/* Only used for clickpads. The software button areas are
		 * always 2 horizontal stripes across the touchpad.
		 * The buttons are split according to the edge settings.
323
		 */
324
		struct {
325 326
			int32_t top_edge;	/* in device coordinates */
			int32_t rightbutton_left_edge; /* in device coordinates */
327
			int32_t middlebutton_left_edge; /* in device coordinates */
328
		} bottom_area;
329

330
		struct {
331 332 333
			int32_t bottom_edge;	/* in device coordinates */
			int32_t rightbutton_left_edge; /* in device coordinates */
			int32_t leftbutton_right_edge; /* in device coordinates */
334
		} top_area;
335 336

		struct evdev_device *trackpoint;
337 338 339 340

		enum libinput_config_click_method click_method;
		struct libinput_device_config_click_method config_method;
	} buttons;
341

342
	struct {
343 344
		struct libinput_device_config_scroll_method config_method;
		enum libinput_config_scroll_method method;
345 346
		int32_t right_edge;		/* in device coordinates */
		int32_t bottom_edge;		/* in device coordinates */
347 348
	} scroll;

349
	enum touchpad_event queued;
350 351

	struct {
352
		struct libinput_device_config_tap config;
353
		bool enabled;
354
		bool suspended;
355
		struct libinput_timer timer;
356
		enum tp_tap_state state;
357
		uint32_t buttons_pressed;
358 359
		uint64_t saved_press_time,
			 saved_release_time;
360

361 362 363
		enum libinput_config_tap_button_map map;
		enum libinput_config_tap_button_map want_map;

364
		bool drag_enabled;
365
		bool drag_lock_enabled;
366 367

		unsigned int nfingers_down;	/* number of fingers down for tapping (excl. thumb/palm) */
368
	} tap;
369 370

	struct {
371 372
		int32_t right_edge;		/* in device coordinates */
		int32_t left_edge;		/* in device coordinates */
373
		int32_t upper_edge;		/* in device coordinates */
374 375 376 377

		bool trackpoint_active;
		struct libinput_event_listener trackpoint_listener;
		struct libinput_timer trackpoint_timer;
378
		uint64_t trackpoint_last_event_time;
379
		uint32_t trackpoint_event_count;
380
		bool monitor_trackpoint;
381 382

		bool use_mt_tool;
383 384 385

		bool use_pressure;
		int pressure_threshold;
386 387 388

		bool use_size;
		int size_threshold;
389
	} palm;
390 391 392 393

	struct {
		struct libinput_device_config_send_events config;
		enum libinput_config_send_events_mode current_mode;
394
	} sendevents;
395

396
	struct {
397 398 399
		struct libinput_device_config_dwt config;
		bool dwt_enabled;

400 401 402 403 404 405 406 407 408 409
		/* We have to allow for more than one device node to be the
		 * internal dwt keyboard (Razer Blade). But they're the same
		 * physical device, so we don't care about per-keyboard
		 * key/modifier masks.
		 */
		struct paired_keyboard {
			struct evdev_device *device;
			struct libinput_event_listener listener;
		} paired_keyboard[3];

410
		unsigned long key_mask[NLONGS(KEY_CNT)];
411
		unsigned long mod_mask[NLONGS(KEY_CNT)];
412 413
		bool keyboard_active;
		struct libinput_timer keyboard_timer;
414
		uint64_t keyboard_last_press_time;
415
	} dwt;
416 417 418 419

	struct {
		bool detect_thumbs;
		int threshold;
420 421
		int upper_thumb_line;
		int lower_thumb_line;
422
	} thumb;
423 424 425 426 427 428 429 430 431 432 433

	struct {
		/* A quirk used on the T450 series Synaptics hardware.
		 * Slowly moving the finger causes multiple events with only
		 * ABS_MT_PRESSURE but no x/y information. When the x/y
		 * event comes, it will be a jump of ~20 units. We use the
		 * below to count non-motion events to discard that first
		 * event with the jump.
		 */
		unsigned int nonmotion_event_count;
	} quirks;
434 435

	struct {
436
		struct libinput_event_listener listener;
437 438
		struct evdev_device *lid_switch;
	} lid_switch;
439 440 441 442 443

	struct {
		struct libinput_event_listener listener;
		struct evdev_device *tablet_mode_switch;
	} tablet_mode_switch;
444 445
};

446 447 448 449 450
static inline struct tp_dispatch*
tp_dispatch(struct evdev_dispatch *dispatch)
{
	evdev_verify_dispatch_type(dispatch, DISPATCH_TOUCHPAD);

451
	return container_of(dispatch, struct tp_dispatch, base);
452 453
}

454 455 456
#define tp_for_each_touch(_tp, _t) \
	for (unsigned int _i = 0; _i < (_tp)->ntouches && (_t = &(_tp)->touches[_i]); _i++)

457
static inline struct libinput*
458
tp_libinput_context(const struct tp_dispatch *tp)
459
{
460
	return evdev_libinput_context(tp->device);
461 462
}

463
static inline struct normalized_coords
464 465
tp_normalize_delta(const struct tp_dispatch *tp,
		   struct device_float_coords delta)
466
{
467 468
	struct normalized_coords normalized;

469 470
	normalized.x = delta.x * tp->accel.x_scale_coeff;
	normalized.y = delta.y * tp->accel.y_scale_coeff;
471 472

	return normalized;
473 474
}

475 476 477 478 479 480 481 482 483 484 485 486
static inline struct phys_coords
tp_phys_delta(const struct tp_dispatch *tp,
	      struct device_float_coords delta)
{
	struct phys_coords mm;

	mm.x = delta.x / tp->device->abs.absinfo_x->resolution;
	mm.y = delta.y / tp->device->abs.absinfo_y->resolution;

	return mm;
}

487
/**
488 489
 * Takes a set of device coordinates, returns that set of coordinates in the
 * x-axis' resolution.
490 491
 */
static inline struct device_float_coords
492 493
tp_scale_to_xaxis(const struct tp_dispatch *tp,
		  struct device_float_coords delta)
494 495 496
{
	struct device_float_coords raw;

497 498
	raw.x = delta.x;
	raw.y = delta.y * tp->accel.xy_scale_coeff;
499 500 501 502

	return raw;
}

503
struct device_coords
504
tp_get_delta(struct tp_touch *t);
505

506
struct normalized_coords
507
tp_filter_motion(struct tp_dispatch *tp,
508
		 const struct device_float_coords *unaccelerated,
509
		 uint64_t time);
Peter Hutterer's avatar
Peter Hutterer committed
510

511 512
struct normalized_coords
tp_filter_motion_unaccelerated(struct tp_dispatch *tp,
513
			       const struct device_float_coords *unaccelerated,
514
			       uint64_t time);
515

516
bool
517
tp_touch_active(const struct tp_dispatch *tp, const struct tp_touch *t);
518

519
int
520
tp_tap_handle_state(struct tp_dispatch *tp, uint64_t time);
521

522 523 524
void
tp_tap_post_process_state(struct tp_dispatch *tp);

525
void
526 527
tp_init_tap(struct tp_dispatch *tp);

528
void
529
tp_remove_tap(struct tp_dispatch *tp);
530

531
void
532 533
tp_init_buttons(struct tp_dispatch *tp, struct evdev_device *device);

534
void
535 536 537
tp_init_top_softbuttons(struct tp_dispatch *tp,
			struct evdev_device *device,
			double topbutton_size_mult);
538

539
void
540
tp_remove_buttons(struct tp_dispatch *tp);
541

542
void
543 544
tp_process_button(struct tp_dispatch *tp,
		  const struct input_event *e,
545
		  uint64_t time);
546

547 548 549 550
void
tp_release_all_buttons(struct tp_dispatch *tp,
		       uint64_t time);

551
int
552
tp_post_button_events(struct tp_dispatch *tp, uint64_t time);
553

554
void
555
tp_button_handle_state(struct tp_dispatch *tp, uint64_t time);
556

557
bool
558 559
tp_button_touch_active(const struct tp_dispatch *tp,
		       const struct tp_touch *t);
560

561
bool
562 563
tp_button_is_inside_softbutton_area(const struct tp_dispatch *tp,
				    const struct tp_touch *t);
564

565 566 567 568
void
tp_release_all_taps(struct tp_dispatch *tp,
		    uint64_t time);

569 570 571 572 573 574
void
tp_tap_suspend(struct tp_dispatch *tp, uint64_t time);

void
tp_tap_resume(struct tp_dispatch *tp, uint64_t time);

575
bool
576
tp_tap_dragging(const struct tp_dispatch *tp);
577

578
void
579 580 581
tp_edge_scroll_init(struct tp_dispatch *tp, struct evdev_device *device);

void
582
tp_remove_edge_scroll(struct tp_dispatch *tp);
583 584 585 586 587 588 589 590 591 592 593

void
tp_edge_scroll_handle_state(struct tp_dispatch *tp, uint64_t time);

int
tp_edge_scroll_post_events(struct tp_dispatch *tp, uint64_t time);

void
tp_edge_scroll_stop_events(struct tp_dispatch *tp, uint64_t time);

int
594 595
tp_edge_scroll_touch_active(const struct tp_dispatch *tp,
			    const struct tp_touch *t);
596

597
uint32_t
598
tp_touch_get_edge(const struct tp_dispatch *tp, const struct tp_touch *t);
599

600
void
601 602 603 604 605 606
tp_init_gesture(struct tp_dispatch *tp);

void
tp_remove_gesture(struct tp_dispatch *tp);

void
607 608 609 610
tp_gesture_stop(struct tp_dispatch *tp, uint64_t time);

void
tp_gesture_cancel(struct tp_dispatch *tp, uint64_t time);
611 612 613 614 615 616 617 618 619 620

void
tp_gesture_handle_state(struct tp_dispatch *tp, uint64_t time);

void
tp_gesture_post_events(struct tp_dispatch *tp, uint64_t time);

void
tp_gesture_stop_twofinger_scroll(struct tp_dispatch *tp, uint64_t time);

621
bool
622
tp_palm_tap_is_palm(const struct tp_dispatch *tp, const struct tp_touch *t);
623

624 625 626
void
tp_clickpad_middlebutton_apply_config(struct evdev_device *device);

627
#endif