evdev.h 26.5 KB
Newer Older
1
/*
2
 * Copyright © 2011, 2012 Intel Corporation
3
 * Copyright © 2013 Jonas Ådahl
Peter Hutterer's avatar
Peter Hutterer committed
4
 * Copyright © 2013-2015 Red Hat, Inc.
5
 *
6
7
8
9
10
11
 * 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:
12
 *
13
14
15
16
17
18
19
20
21
22
23
 * 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.
24
25
 */

26
27
28
#ifndef EVDEV_H
#define EVDEV_H

29
30
#include "config.h"

31
#include <stdbool.h>
32
#include <stdarg.h>
33
#include "linux/input.h"
Peter Hutterer's avatar
Peter Hutterer committed
34
#include <libevdev/libevdev.h>
35
36

#include "libinput-private.h"
37
#include "timer.h"
38
#include "filter.h"
39

40
41
/* The fake resolution value for abs devices without resolution */
#define EVDEV_FAKE_RESOLUTION 1
42

43
enum evdev_event_type {
44
	EVDEV_NONE,
45
46
47
	EVDEV_ABSOLUTE_TOUCH_DOWN = (1 << 0),
	EVDEV_ABSOLUTE_MOTION = (1 << 1),
	EVDEV_ABSOLUTE_TOUCH_UP = (1 << 2),
Peter Hutterer's avatar
Peter Hutterer committed
48
	EVDEV_ABSOLUTE_MT = (1 << 3),
49
50
51
52
	EVDEV_WHEEL = (1 << 4),
	EVDEV_KEY = (1 << 5),
	EVDEV_RELATIVE_MOTION = (1 << 6),
	EVDEV_BUTTON = (1 << 7),
53
54
};

55
enum evdev_device_seat_capability {
56
57
	EVDEV_DEVICE_POINTER = (1 << 0),
	EVDEV_DEVICE_KEYBOARD = (1 << 1),
58
59
	EVDEV_DEVICE_TOUCH = (1 << 2),
	EVDEV_DEVICE_TABLET = (1 << 3),
60
	EVDEV_DEVICE_TABLET_PAD = (1 << 4),
61
	EVDEV_DEVICE_GESTURE = (1 << 5),
62
	EVDEV_DEVICE_SWITCH = (1 << 6),
63
64
};

65
66
67
enum evdev_device_tags {
	EVDEV_TAG_EXTERNAL_MOUSE = (1 << 0),
	EVDEV_TAG_INTERNAL_TOUCHPAD = (1 << 1),
68
69
70
	EVDEV_TAG_EXTERNAL_TOUCHPAD = (1 << 2),
	EVDEV_TAG_TRACKPOINT = (1 << 3),
	EVDEV_TAG_KEYBOARD = (1 << 4),
71
	EVDEV_TAG_LID_SWITCH = (1 << 5),
72
73
	EVDEV_TAG_INTERNAL_KEYBOARD = (1 << 6),
	EVDEV_TAG_EXTERNAL_KEYBOARD = (1 << 7),
74
	EVDEV_TAG_TABLET_MODE_SWITCH = (1 << 8),
75
	EVDEV_TAG_TABLET_TOUCHPAD = (1 << 9),
76
77
};

78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
enum evdev_middlebutton_state {
	MIDDLEBUTTON_IDLE,
	MIDDLEBUTTON_LEFT_DOWN,
	MIDDLEBUTTON_RIGHT_DOWN,
	MIDDLEBUTTON_MIDDLE,
	MIDDLEBUTTON_LEFT_UP_PENDING,
	MIDDLEBUTTON_RIGHT_UP_PENDING,
	MIDDLEBUTTON_IGNORE_LR,
	MIDDLEBUTTON_IGNORE_L,
	MIDDLEBUTTON_IGNORE_R,
	MIDDLEBUTTON_PASSTHROUGH,
};

enum evdev_middlebutton_event {
	MIDDLEBUTTON_EVENT_L_DOWN,
	MIDDLEBUTTON_EVENT_R_DOWN,
	MIDDLEBUTTON_EVENT_OTHER,
	MIDDLEBUTTON_EVENT_L_UP,
	MIDDLEBUTTON_EVENT_R_UP,
	MIDDLEBUTTON_EVENT_TIMEOUT,
	MIDDLEBUTTON_EVENT_ALL_UP,
};

101
enum evdev_device_model {
102
103
104
105
106
107
108
109
110
111
	EVDEV_MODEL_DEFAULT = 0,
	EVDEV_MODEL_LENOVO_X230 = (1 << 0),
	EVDEV_MODEL_CHROMEBOOK = (1 << 1),
	EVDEV_MODEL_SYSTEM76_BONOBO = (1 << 2),
	EVDEV_MODEL_SYSTEM76_GALAGO = (1 << 3),
	EVDEV_MODEL_SYSTEM76_KUDU = (1 << 4),
	EVDEV_MODEL_CLEVO_W740SU = (1 << 5),
	EVDEV_MODEL_APPLE_TOUCHPAD = (1 << 6),
	EVDEV_MODEL_WACOM_TOUCHPAD = (1 << 7),
	EVDEV_MODEL_ALPS_TOUCHPAD = (1 << 8),
112
	EVDEV_MODEL_SYNAPTICS_SERIAL_TOUCHPAD = (1 << 9),
113
	EVDEV_MODEL_TEST_DEVICE = (1 << 10),
114
	EVDEV_MODEL_BOUNCING_KEYS = (1 << 11),
115
	EVDEV_MODEL_LENOVO_X220_TOUCHPAD_FW81 = (1 << 12),
116
	EVDEV_MODEL_LENOVO_CARBON_X1_6TH = (1 << 13),
117
	EVDEV_MODEL_CYBORG_RAT = (1 << 14),
118
	EVDEV_MODEL_HP_STREAM11_TOUCHPAD = (1 << 16),
119
	EVDEV_MODEL_LENOVO_T450_TOUCHPAD= (1 << 17),
120
	EVDEV_MODEL_TOUCHPAD_VISIBLE_MARKER = (1 << 18),
Peter Hutterer's avatar
Peter Hutterer committed
121
	EVDEV_MODEL_TRACKBALL = (1 << 19),
122
	EVDEV_MODEL_APPLE_MAGICMOUSE = (1 << 20),
123
	EVDEV_MODEL_HP8510_TOUCHPAD = (1 << 21),
124
	EVDEV_MODEL_HP6910_TOUCHPAD = (1 << 22),
125
	EVDEV_MODEL_HP_ZBOOK_STUDIO_G3 = (1 << 23),
126
	EVDEV_MODEL_HP_PAVILION_DM4_TOUCHPAD = (1 << 24),
127
	EVDEV_MODEL_APPLE_TOUCHPAD_ONEBUTTON = (1 << 25),
128
	EVDEV_MODEL_LOGITECH_MARBLE_MOUSE = (1 << 26),
129
	EVDEV_MODEL_TABLET_NO_PROXIMITY_OUT = (1 << 27),
130
	EVDEV_MODEL_TABLET_NO_TILT = (1 << 29),
131
	EVDEV_MODEL_TABLET_MODE_NO_SUSPEND = (1 << 30),
132
	EVDEV_MODEL_LENOVO_SCROLLPOINT = (1 << 31),
133
134
};

135
136
137
enum evdev_button_scroll_state {
	BUTTONSCROLL_IDLE,
	BUTTONSCROLL_BUTTON_DOWN,	/* button is down */
138
139
	BUTTONSCROLL_READY,		/* ready for scroll events */
	BUTTONSCROLL_SCROLLING,		/* have sent scroll events */
140
141
};

142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
enum evdev_debounce_state {
	/**
	 * Initial state, no debounce but monitoring events
	 */
	DEBOUNCE_INIT,
	/**
	 * Bounce detected, future events need debouncing
	 */
	DEBOUNCE_NEEDED,
	/**
	 * Debounce is enabled, but no event is currently being filtered
	 */
	DEBOUNCE_ON,
	/**
	 * Debounce is enabled and we are currently filtering an event
	 */
	DEBOUNCE_ACTIVE,
};

161
struct evdev_device {
162
163
	struct libinput_device base;

164
165
	struct libinput_source *source;

166
	struct evdev_dispatch *dispatch;
Peter Hutterer's avatar
Peter Hutterer committed
167
	struct libevdev *evdev;
168
	struct udev_device *udev_device;
169
	char *output_name;
Peter Hutterer's avatar
Peter Hutterer committed
170
	const char *devname;
171
	bool was_removed;
172
	int fd;
173
174
	enum evdev_device_seat_capability seat_caps;
	enum evdev_device_tags tags;
175
176
	bool is_mt;
	bool is_suspended;
177
	int dpi; /* HW resolution */
178
	double trackpoint_multiplier; /* trackpoint constant multiplier */
179
	bool use_velocity_averaging; /* whether averaging should be applied on velocity calculation */
180
181
182
183
184
	struct ratelimit syn_drop_limit; /* ratelimit for SYN_DROPPED logging */
	struct ratelimit nonpointer_rel_limit; /* ratelimit for REL_* events from non-pointer devices */
	uint32_t model_flags;
	struct mtdev *mtdev;

185
	struct {
186
		const struct input_absinfo *absinfo_x, *absinfo_y;
187
		bool is_fake_resolution;
188
189

		int apply_calibration;
190
		struct matrix calibration;
191
		struct matrix default_calibration; /* from LIBINPUT_CALIBRATION_MATRIX */
192
		struct matrix usermatrix; /* as supplied by the caller */
193
194

		struct device_coords dimensions;
195
196
197
198
199

		struct {
			struct device_coords min, max;
			struct ratelimit range_warn_limit;
		} warning_range;
200
201
	} abs;

202
	struct {
203
		struct libinput_timer timer;
204
205
206
		struct libinput_device_config_scroll_method config;
		/* Currently enabled method, button */
		enum libinput_config_scroll_method method;
207
		uint32_t button;
208
209
		uint64_t button_down_time;

210
211
		/* set during device init, used at runtime to delay changes
		 * until all buttons are up */
212
		enum libinput_config_scroll_method want_method;
213
214
		uint32_t want_button;
		/* Checks if buttons are down and commits the setting */
215
		void (*change_scroll_method)(struct evdev_device *device);
216
		enum evdev_button_scroll_state button_scroll_state;
217
		double threshold;
218
		double direction_lock_threshold;
219
		uint32_t direction;
220
		struct normalized_coords buildup;
221
222

		struct libinput_device_config_natural_scroll config_natural;
223
224
		/* set during device init if we want natural scrolling,
		 * used at runtime to enable/disable the feature */
225
		bool natural_scrolling_enabled;
226
227

		/* angle per REL_WHEEL click in degrees */
228
		struct wheel_angle wheel_click_angle;
229
230

		struct wheel_tilt_flags is_tilt;
231
232
	} scroll;

233
	struct {
234
		struct libinput_device_config_accel config;
235
236
		struct motion_filter *filter;
	} pointer;
237

238
239
240
	/* Key counter used for multiplexing button events internally in
	 * libinput. */
	uint8_t key_count[KEY_CNT];
241
242

	struct {
243
		struct libinput_device_config_left_handed config;
244
		/* left-handed currently enabled */
245
		bool enabled;
246
247
		/* set during device init if we want left_handed config,
		 * used at runtime to delay the effect until buttons are up */
248
		bool want_enabled;
249
		/* Checks if buttons are down and commits the setting */
250
251
		void (*change_to_enabled)(struct evdev_device *device);
	} left_handed;
252

253
254
255
256
257
258
259
260
261
262
263
	struct {
		struct libinput_device_config_middle_emulation config;
		/* middle-button emulation enabled */
		bool enabled;
		bool enabled_default;
		bool want_enabled;
		enum evdev_middlebutton_state state;
		struct libinput_timer timer;
		uint32_t button_mask;
		uint64_t first_event_time;
	} middlebutton;
264
265
};

266
267
268
static inline struct evdev_device *
evdev_device(struct libinput_device *device)
{
269
	return container_of(device, struct evdev_device, base);
270
271
}

272
273
#define EVDEV_UNHANDLED_DEVICE ((struct evdev_device *) 1)

274
275
276
277
278
struct evdev_dispatch;

struct evdev_dispatch_interface {
	/* Process an evdev input event. */
	void (*process)(struct evdev_dispatch *dispatch,
279
			struct evdev_device *device,
280
			struct input_event *event,
281
			uint64_t time);
282

283
284
285
286
	/* Device is being suspended */
	void (*suspend)(struct evdev_dispatch *dispatch,
			struct evdev_device *device);

287
288
289
	/* Device is being removed (may be NULL) */
	void (*remove)(struct evdev_dispatch *dispatch);

290
291
	/* Destroy an event dispatch handler and free all its resources. */
	void (*destroy)(struct evdev_dispatch *dispatch);
292
293
294
295
296
297
298
299

	/* A new device was added */
	void (*device_added)(struct evdev_device *device,
			     struct evdev_device *added_device);

	/* A device was removed */
	void (*device_removed)(struct evdev_device *device,
			       struct evdev_device *removed_device);
300

301
302
303
304
305
306
307
308
	/* A device was suspended */
	void (*device_suspended)(struct evdev_device *device,
				 struct evdev_device *suspended_device);

	/* A device was resumed */
	void (*device_resumed)(struct evdev_device *device,
			       struct evdev_device *resumed_device);

309
310
311
312
	/* Called immediately after the LIBINPUT_EVENT_DEVICE_ADDED event
	 * was sent */
	void (*post_added)(struct evdev_device *device,
			   struct evdev_dispatch *dispatch);
Peter Hutterer's avatar
Peter Hutterer committed
313

314
315
	/* For touch arbitration, called on the device that should
	 * enable/disable touch capabilities */
Peter Hutterer's avatar
Peter Hutterer committed
316
317
	void (*toggle_touch)(struct evdev_dispatch *dispatch,
			     struct evdev_device *device,
318
319
			     bool enable,
			     uint64_t now);
320
321
322
323
324

	/* Return the state of the given switch */
	enum libinput_switch_state
		(*get_switch_state)(struct evdev_dispatch *dispatch,
				    enum libinput_switch which);
325
326
};

327
328
329
330
331
332
333
enum evdev_dispatch_type {
	DISPATCH_FALLBACK,
	DISPATCH_TOUCHPAD,
	DISPATCH_TABLET,
	DISPATCH_TABLET_PAD,
};

334
struct evdev_dispatch {
335
	enum evdev_dispatch_type dispatch_type;
336
	struct evdev_dispatch_interface *interface;
337
338
339
340
341
342
343

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

344
345
346
347
348
349
350
351
static inline void
evdev_verify_dispatch_type(struct evdev_dispatch *dispatch,
			   enum evdev_dispatch_type type)
{
	if (dispatch->dispatch_type != type)
		abort();
}

352
353
struct evdev_device *
evdev_device_create(struct libinput_seat *seat,
354
		    struct udev_device *device);
355

356
357
void
evdev_transform_absolute(struct evdev_device *device,
358
359
360
361
			 struct device_coords *point);

void
evdev_transform_relative(struct evdev_device *device,
362
363
			 struct device_coords *point);

364
365
void
evdev_init_calibration(struct evdev_device *device,
366
		        struct libinput_device_config_calibration *calibration);
367

368
369
370
void
evdev_read_calibration_prop(struct evdev_device *device);

371
372
373
int
evdev_read_fuzz_prop(struct evdev_device *device, unsigned int code);

374
375
376
enum switch_reliability
evdev_read_switch_reliability_prop(struct evdev_device *device);

377
378
379
380
void
evdev_init_sendevents(struct evdev_device *device,
		      struct evdev_dispatch *dispatch);

381
void
382
evdev_device_init_pointer_acceleration(struct evdev_device *device,
383
				       struct motion_filter *filter);
384

385
struct evdev_dispatch *
386
evdev_touchpad_create(struct evdev_device *device);
387

388
389
390
struct evdev_dispatch *
evdev_mt_touchpad_create(struct evdev_device *device);

391
392
393
struct evdev_dispatch *
evdev_tablet_create(struct evdev_device *device);

394
395
396
struct evdev_dispatch *
evdev_tablet_pad_create(struct evdev_device *device);

397
398
399
struct evdev_dispatch *
evdev_lid_switch_dispatch_create(struct evdev_device *device);

400
401
402
403
404
405
406
407
408
struct evdev_dispatch *
fallback_dispatch_create(struct libinput_device *libinput_device);

bool
evdev_is_fake_mt_device(struct evdev_device *device);

int
evdev_need_mtdev(struct evdev_device *device);

409
void
410
evdev_device_led_update(struct evdev_device *device, enum libinput_led leds);
411

412
413
int
evdev_device_get_keys(struct evdev_device *device, char *keys, size_t size);
414

415
416
417
const char *
evdev_device_get_output(struct evdev_device *device);

418
419
420
const char *
evdev_device_get_sysname(struct evdev_device *device);

421
422
423
424
425
426
427
428
429
const char *
evdev_device_get_name(struct evdev_device *device);

unsigned int
evdev_device_get_id_product(struct evdev_device *device);

unsigned int
evdev_device_get_id_vendor(struct evdev_device *device);

430
431
432
struct udev_device *
evdev_device_get_udev_device(struct evdev_device *device);

433
void
434
435
evdev_device_set_default_calibration(struct evdev_device *device,
				     const float calibration[6]);
436
void
437
438
evdev_device_calibrate(struct evdev_device *device,
		       const float calibration[6]);
439

440
bool
441
442
443
evdev_device_has_capability(struct evdev_device *device,
			    enum libinput_device_capability capability);

444
int
445
evdev_device_get_size(const struct evdev_device *device,
446
447
448
		      double *w,
		      double *h);

449
450
451
int
evdev_device_has_button(struct evdev_device *device, uint32_t code);

452
453
454
int
evdev_device_has_key(struct evdev_device *device, uint32_t code);

455
456
457
int
evdev_device_get_touch_count(struct evdev_device *device);

458
459
460
461
int
evdev_device_has_switch(struct evdev_device *device,
			enum libinput_switch sw);

462
463
464
465
466
467
468
469
470
int
evdev_device_tablet_pad_get_num_buttons(struct evdev_device *device);

int
evdev_device_tablet_pad_get_num_rings(struct evdev_device *device);

int
evdev_device_tablet_pad_get_num_strips(struct evdev_device *device);

471
472
473
474
475
476
477
int
evdev_device_tablet_pad_get_num_mode_groups(struct evdev_device *device);

struct libinput_tablet_pad_mode_group *
evdev_device_tablet_pad_get_mode_group(struct evdev_device *device,
				       unsigned int index);

478
479
480
481
enum libinput_switch_state
evdev_device_switch_get_state(struct evdev_device *device,
			      enum libinput_switch sw);

482
double
483
evdev_device_transform_x(struct evdev_device *device,
484
			 double x,
485
486
			 uint32_t width);

487
double
488
evdev_device_transform_y(struct evdev_device *device,
489
			 double y,
490
			 uint32_t height);
491
void
492
evdev_device_suspend(struct evdev_device *device);
493

494
495
496
int
evdev_device_resume(struct evdev_device *device);

497
498
499
500
501
502
void
evdev_notify_suspended_device(struct evdev_device *device);

void
evdev_notify_resumed_device(struct evdev_device *device);

503
504
void
evdev_pointer_notify_button(struct evdev_device *device,
505
			    uint64_t time,
506
			    unsigned int button,
507
			    enum libinput_button_state state);
508
509
void
evdev_pointer_notify_physical_button(struct evdev_device *device,
510
				     uint64_t time,
511
512
				     int button,
				     enum libinput_button_state state);
513

514
515
516
void
evdev_init_natural_scroll(struct evdev_device *device);

517
518
519
520
521
522
523
524
525
void
evdev_init_button_scroll(struct evdev_device *device,
			 void (*change_scroll_method)(struct evdev_device *));

int
evdev_update_key_down_count(struct evdev_device *device,
			    int code,
			    int pressed);

526
527
528
529
530
531
532
void
evdev_notify_axis(struct evdev_device *device,
		  uint64_t time,
		  uint32_t axes,
		  enum libinput_pointer_axis_source source,
		  const struct normalized_coords *delta_in,
		  const struct discrete_coords *discrete_in);
533
534
535
void
evdev_post_scroll(struct evdev_device *device,
		  uint64_t time,
536
		  enum libinput_pointer_axis_source source,
537
		  const struct normalized_coords *delta);
538
539

void
540
541
542
evdev_stop_scroll(struct evdev_device *device,
		  uint64_t time,
		  enum libinput_pointer_axis_source source);
543

544
void
545
evdev_device_remove(struct evdev_device *device);
546

547
void
548
evdev_device_destroy(struct evdev_device *device);
549

550
551
552
553
554
555
556
557
558
559
560
bool
evdev_middlebutton_filter_button(struct evdev_device *device,
				 uint64_t time,
				 int button,
				 enum libinput_button_state state);

void
evdev_init_middlebutton(struct evdev_device *device,
			bool enabled,
			bool want_config);

561
562
563
564
565
566
567
568
569
enum libinput_config_middle_emulation_state
evdev_middlebutton_get(struct libinput_device *device);

int
evdev_middlebutton_is_available(struct libinput_device *device);

enum libinput_config_middle_emulation_state
evdev_middlebutton_get_default(struct libinput_device *device);

570
571
572
573
574
575
576
static inline double
evdev_convert_to_mm(const struct input_absinfo *absinfo, double v)
{
	double value = v - absinfo->minimum;
	return value/absinfo->resolution;
}

577
578
579
580
581
582
583
584
585
586
587
static inline struct phys_coords
evdev_convert_xy_to_mm(const struct evdev_device *device, int x, int y)
{
	struct phys_coords mm;

	mm.x = evdev_convert_to_mm(device->abs.absinfo_x, x);
	mm.y = evdev_convert_to_mm(device->abs.absinfo_y, y);

	return mm;
}

588
void
589
590
591
evdev_init_left_handed(struct evdev_device *device,
		       void (*change_to_left_handed)(struct evdev_device *));

592
593
594
bool
evdev_tablet_has_left_handed(struct evdev_device *device);

595
596
597
598
static inline uint32_t
evdev_to_left_handed(struct evdev_device *device,
		     uint32_t button)
{
599
	if (device->left_handed.enabled) {
600
601
602
603
604
605
606
607
		if (button == BTN_LEFT)
			return BTN_RIGHT;
		else if (button == BTN_RIGHT)
			return BTN_LEFT;
	}
	return button;
}

608
609
/**
 * Apply a hysteresis filtering to the coordinate in, based on the current
Peter Hutterer's avatar
Peter Hutterer committed
610
 * hysteresis center and the margin. If 'in' is within 'margin' of center,
611
 * return the center (and thus filter the motion). If 'in' is outside,
612
613
614
 * return a point on the edge of the new margin (which is an ellipse, usually
 * a circle). So for a point x in the space outside c + margin we return r:
 * ,---.       ,---.
615
 * | c |  x →  | r x
616
 * `---'       `---'
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
 *
 * The effect of this is that initial small motions are filtered. Once we
 * move into one direction we lag the real coordinates by 'margin' but any
 * movement that continues into that direction will always be just outside
 * margin - we get responsive movement. Once we move back into the other
 * direction, the first movements are filtered again.
 *
 * Returning the edge rather than the point avoids cursor jumps, as the
 * first reachable coordinate is the point next to the center (center + 1).
 * Otherwise, the center has a dead zone of size margin around it and the
 * first reachable point is the margin edge.
 *
 * @param in The input coordinate
 * @param center Current center of the hysteresis
 * @param margin Hysteresis width (on each side)
 *
 * @return The new center of the hysteresis
 */
635
636
637
638
static inline struct device_coords
evdev_hysteresis(const struct device_coords *in,
		 const struct device_coords *center,
		 const struct device_coords *margin)
639
{
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
	int dx = in->x - center->x;
	int dy = in->y - center->y;
	int dx2 = dx * dx;
	int dy2 = dy * dy;
	int a = margin->x;
	int b = margin->y;
	double normalized_finger_distance, finger_distance, margin_distance;
	double lag_x, lag_y;
	struct device_coords result;

	if (!a || !b)
		return *in;

	/*
	 * Basic equation for an ellipse of radii a,b:
	 *   x²/a² + y²/b² = 1
	 * But we start by making a scaled ellipse passing through the
	 * relative finger location (dx,dy). So the scale of this ellipse is
	 * the ratio of finger_distance to margin_distance:
	 *   dx²/a² + dy²/b² = normalized_finger_distance²
	 */
	normalized_finger_distance = sqrt((double)dx2 / (a * a) +
					  (double)dy2 / (b * b));

	/* Which means anything less than 1 is within the elliptical margin */
	if (normalized_finger_distance < 1.0)
		return *center;

	finger_distance = sqrt(dx2 + dy2);
	margin_distance = finger_distance / normalized_finger_distance;

	/*
	 * Now calculate the x,y coordinates on the edge of the margin ellipse
	 * where it intersects the finger vector. Shortcut: We achieve this by
	 * finding the point with the same gradient as dy/dx.
	 */
	if (dx) {
		double gradient = (double)dy / dx;
		lag_x = margin_distance / sqrt(gradient * gradient + 1);
		lag_y = sqrt((margin_distance + lag_x) *
			     (margin_distance - lag_x));
	} else {  /* Infinite gradient */
		lag_x = 0.0;
		lag_y = margin_distance;
	}

	/*
	 * 'result' is the centre of an ellipse (radii a,b) which has been
	 * dragged by the finger moving inside it to 'in'. The finger is now
	 * touching the margin ellipse at some point: (±lag_x,±lag_y)
	 */
	result.x = (dx >= 0) ? in->x - lag_x : in->x + lag_x;
	result.y = (dy >= 0) ? in->y - lag_y : in->y + lag_y;
	return result;
694
695
}

696
697
698
699
700
701
static inline struct libinput *
evdev_libinput_context(const struct evdev_device *device)
{
	return device->base.seat->libinput;
}

702
LIBINPUT_ATTRIBUTE_PRINTF(3, 0)
703
704
705
706
707
708
static inline void
evdev_log_msg_va(struct evdev_device *device,
		 enum libinput_log_priority priority,
		 const char *format,
		 va_list args)
{
709
710
	char buf[1024];

711
	/* Anything info and above is user-visible, use the device name */
712
713
714
715
716
717
718
719
720
	snprintf(buf,
		 sizeof(buf),
		 "%-7s - %s%s%s",
		 evdev_device_get_sysname(device),
		 (priority > LIBINPUT_LOG_PRIORITY_DEBUG) ?  device->devname : "",
		 (priority > LIBINPUT_LOG_PRIORITY_DEBUG) ?  ": " : "",
		 format);

	log_msg_va(evdev_libinput_context(device), priority, buf, args);
721
722
}

723
LIBINPUT_ATTRIBUTE_PRINTF(3, 4)
724
725
726
727
728
729
730
731
732
733
734
735
736
737
static inline void
evdev_log_msg(struct evdev_device *device,
	      enum libinput_log_priority priority,
	      const char *format,
	      ...)
{
	va_list args;

	va_start(args, format);
	evdev_log_msg_va(device, priority, format, args);
	va_end(args);

}

738
LIBINPUT_ATTRIBUTE_PRINTF(4, 5)
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
static inline void
evdev_log_msg_ratelimit(struct evdev_device *device,
			struct ratelimit *ratelimit,
			enum libinput_log_priority priority,
			const char *format,
			...)
{
	va_list args;
	enum ratelimit_state state;

	state = ratelimit_test(ratelimit);
	if (state == RATELIMIT_EXCEEDED)
		return;

	va_start(args, format);
	evdev_log_msg_va(device, priority, format, args);
	va_end(args);

	if (state == RATELIMIT_THRESHOLD)
		evdev_log_msg(device,
			      priority,
			      "WARNING: log rate limit exceeded (%d msgs per %dms). Discarding future messages.\n",
			      ratelimit->burst,
			      us2ms(ratelimit->interval));
}

#define evdev_log_debug(d_, ...) evdev_log_msg((d_), LIBINPUT_LOG_PRIORITY_DEBUG, __VA_ARGS__)
#define evdev_log_info(d_, ...) evdev_log_msg((d_), LIBINPUT_LOG_PRIORITY_INFO, __VA_ARGS__)
#define evdev_log_error(d_, ...) evdev_log_msg((d_), LIBINPUT_LOG_PRIORITY_ERROR, __VA_ARGS__)
#define evdev_log_bug_kernel(d_, ...) evdev_log_msg((d_), LIBINPUT_LOG_PRIORITY_ERROR, "kernel bug: " __VA_ARGS__)
#define evdev_log_bug_libinput(d_, ...) evdev_log_msg((d_), LIBINPUT_LOG_PRIORITY_ERROR, "libinput bug: " __VA_ARGS__)
#define evdev_log_bug_client(d_, ...) evdev_log_msg((d_), LIBINPUT_LOG_PRIORITY_ERROR, "client bug: " __VA_ARGS__)

#define evdev_log_debug_ratelimit(d_, r_, ...) \
	evdev_log_msg_ratelimit((d_), (r_), LIBINPUT_LOG_PRIORITY_DEBUG, __VA_ARGS__)
#define evdev_log_info_ratelimit(d_, r_, ...) \
	evdev_log_msg_ratelimit((d_), (r_), LIBINPUT_LOG_PRIORITY_INFO, __VA_ARGS__)
#define evdev_log_error_ratelimit(d_, r_, ...) \
	evdev_log_msg_ratelimit((d_), (r_), LIBINPUT_LOG_PRIORITY_ERROR, __VA_ARGS__)
#define evdev_log_bug_kernel_ratelimit(d_, r_, ...) \
	evdev_log_msg_ratelimit((d_), (r_), LIBINPUT_LOG_PRIORITY_ERROR, "kernel bug: " __VA_ARGS__)
#define evdev_log_bug_libinput_ratelimit(d_, r_, ...) \
	evdev_log_msg_ratelimit((d_), (r_), LIBINPUT_LOG_PRIORITY_ERROR, "libinput bug: " __VA_ARGS__)
#define evdev_log_bug_client_ratelimit(d_, r_, ...) \
	evdev_log_msg_ratelimit((d_), (r_), LIBINPUT_LOG_PRIORITY_ERROR, "client bug: " __VA_ARGS__)

785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
/**
 * Convert the pair of delta coordinates in device space to mm.
 */
static inline struct phys_coords
evdev_device_unit_delta_to_mm(const struct evdev_device* device,
			      const struct device_coords *units)
{
	struct phys_coords mm = { 0,  0 };
	const struct input_absinfo *absx, *absy;

	if (device->abs.absinfo_x == NULL ||
	    device->abs.absinfo_y == NULL) {
		log_bug_libinput(evdev_libinput_context(device),
				 "%s: is not an abs device\n",
				 device->devname);
		return mm;
	}

	absx = device->abs.absinfo_x;
	absy = device->abs.absinfo_y;

	mm.x = 1.0 * units->x/absx->resolution;
	mm.y = 1.0 * units->y/absy->resolution;

	return mm;
}

812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
/**
 * Convert the pair of coordinates in device space to mm. This takes the
 * axis min into account, i.e. a unit of min is equivalent to 0 mm.
 */
static inline struct phys_coords
evdev_device_units_to_mm(const struct evdev_device* device,
			 const struct device_coords *units)
{
	struct phys_coords mm = { 0,  0 };
	const struct input_absinfo *absx, *absy;

	if (device->abs.absinfo_x == NULL ||
	    device->abs.absinfo_y == NULL) {
		log_bug_libinput(evdev_libinput_context(device),
				 "%s: is not an abs device\n",
				 device->devname);
		return mm;
	}

	absx = device->abs.absinfo_x;
	absy = device->abs.absinfo_y;

	mm.x = (units->x - absx->minimum)/absx->resolution;
	mm.y = (units->y - absy->minimum)/absy->resolution;

	return mm;
}

/**
 * Convert the pair of coordinates in mm to device units. This takes the
 * axis min into account, i.e. 0 mm  is equivalent to the min.
 */
static inline struct device_coords
evdev_device_mm_to_units(const struct evdev_device *device,
			 const struct phys_coords *mm)
{
	struct device_coords units = { 0,  0 };
	const struct input_absinfo *absx, *absy;

	if (device->abs.absinfo_x == NULL ||
	    device->abs.absinfo_y == NULL) {
		log_bug_libinput(evdev_libinput_context(device),
				 "%s: is not an abs device\n",
				 device->devname);
		return units;
	}

	absx = device->abs.absinfo_x;
	absy = device->abs.absinfo_y;

	units.x = mm->x * absx->resolution + absx->minimum;
	units.y = mm->y * absy->resolution + absy->minimum;

	return units;
}
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915

static inline void
evdev_device_init_abs_range_warnings(struct evdev_device *device)
{
	const struct input_absinfo *x, *y;
	int width, height;

	x = device->abs.absinfo_x;
	y = device->abs.absinfo_y;
	width = device->abs.dimensions.x;
	height = device->abs.dimensions.y;

	device->abs.warning_range.min.x = x->minimum - 0.05 * width;
	device->abs.warning_range.min.y = y->minimum - 0.05 * height;
	device->abs.warning_range.max.x = x->maximum + 0.05 * width;
	device->abs.warning_range.max.y = y->maximum + 0.05 * height;

	/* One warning every 5 min is enough */
	ratelimit_init(&device->abs.warning_range.range_warn_limit,
		       s2us(3000),
		       1);
}

static inline void
evdev_device_check_abs_axis_range(struct evdev_device *device,
				  unsigned int code,
				  int value)
{
	int min, max;

	switch(code) {
	case ABS_X:
	case ABS_MT_POSITION_X:
		min = device->abs.warning_range.min.x;
		max = device->abs.warning_range.max.x;
		break;
	case ABS_Y:
	case ABS_MT_POSITION_Y:
		min = device->abs.warning_range.min.y;
		max = device->abs.warning_range.max.y;
		break;
	default:
		return;
	}

	if (value < min || value > max) {
		log_info_ratelimit(evdev_libinput_context(device),
				   &device->abs.warning_range.range_warn_limit,
				   "Axis %#x value %d is outside expected range [%d, %d]\n"
916
				   "See %sabsolute_coordinate_ranges.html for details\n",
917
918
919
920
921
				   code, value, min, max,
				   HTTP_DOC_LINK);
	}
}

922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
struct evdev_paired_keyboard {
	struct list link;
	struct evdev_device *device;
	struct libinput_event_listener listener;
};

static inline void
evdev_paired_keyboard_destroy(struct evdev_paired_keyboard *kbd)
{
	kbd->device = NULL;
	libinput_device_remove_event_listener(&kbd->listener);
	list_remove(&kbd->link);
	free(kbd);
}

937
#endif /* EVDEV_H */