evdev.c revision 324768 
1/*-
2 * Copyright (c) 2014 Jakub Wojciech Klama <jceel@FreeBSD.org>
3 * Copyright (c) 2015-2016 Vladimir Kondratyev <wulf@FreeBSD.org>
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 *    notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 *    notice, this list of conditions and the following disclaimer in the
13 *    documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25 * SUCH DAMAGE.
26 *
27 * $FreeBSD: stable/11/sys/dev/evdev/evdev.c 324768 2017-10-19 20:16:40Z wulf $
28 */
29
30#include "opt_evdev.h"
31
32#include <sys/param.h>
33#include <sys/bitstring.h>
34#include <sys/conf.h>
35#include <sys/kernel.h>
36#include <sys/malloc.h>
37#include <sys/module.h>
38#include <sys/sysctl.h>
39#include <sys/systm.h>
40
41#include <dev/evdev/evdev.h>
42#include <dev/evdev/evdev_private.h>
43#include <dev/evdev/input.h>
44
45#ifdef EVDEV_DEBUG
46#define	debugf(evdev, fmt, args...)	printf("evdev: " fmt "\n", ##args)
47#else
48#define	debugf(evdev, fmt, args...)
49#endif
50
51#ifdef FEATURE
52FEATURE(evdev, "Input event devices support");
53#endif
54
55enum evdev_sparse_result
56{
57	EV_SKIP_EVENT,		/* Event value not changed */
58	EV_REPORT_EVENT,	/* Event value changed */
59	EV_REPORT_MT_SLOT,	/* Event value and MT slot number changed */
60};
61
62MALLOC_DEFINE(M_EVDEV, "evdev", "evdev memory");
63
64int evdev_rcpt_mask = EVDEV_RCPT_SYSMOUSE | EVDEV_RCPT_KBDMUX;
65int evdev_sysmouse_t_axis = 0;
66
67SYSCTL_NODE(_kern, OID_AUTO, evdev, CTLFLAG_RW, 0, "Evdev args");
68SYSCTL_INT(_kern_evdev, OID_AUTO, rcpt_mask, CTLFLAG_RW, &evdev_rcpt_mask, 0,
69    "Who is receiving events: bit0 - sysmouse, bit1 - kbdmux, "
70    "bit2 - mouse hardware, bit3 - keyboard hardware");
71SYSCTL_INT(_kern_evdev, OID_AUTO, sysmouse_t_axis, CTLFLAG_RW,
72    &evdev_sysmouse_t_axis, 0, "Extract T-axis from 0-none, 1-ums, 2-psm");
73
74static void evdev_start_repeat(struct evdev_dev *, uint16_t);
75static void evdev_stop_repeat(struct evdev_dev *);
76static int evdev_check_event(struct evdev_dev *, uint16_t, uint16_t, int32_t);
77
78static inline void
79bit_change(bitstr_t *bitstr, int bit, int value)
80{
81	if (value)
82		bit_set(bitstr, bit);
83	else
84		bit_clear(bitstr, bit);
85}
86
87struct evdev_dev *
88evdev_alloc(void)
89{
90
91	return malloc(sizeof(struct evdev_dev), M_EVDEV, M_WAITOK | M_ZERO);
92}
93
94void
95evdev_free(struct evdev_dev *evdev)
96{
97
98	if (evdev != NULL && evdev->ev_cdev != NULL &&
99	    evdev->ev_cdev->si_drv1 != NULL)
100		evdev_unregister(evdev);
101
102	free(evdev, M_EVDEV);
103}
104
105static struct input_absinfo *
106evdev_alloc_absinfo(void)
107{
108
109	return (malloc(sizeof(struct input_absinfo) * ABS_CNT, M_EVDEV,
110	    M_WAITOK | M_ZERO));
111}
112
113static void
114evdev_free_absinfo(struct input_absinfo *absinfo)
115{
116
117	free(absinfo, M_EVDEV);
118}
119
120int
121evdev_set_report_size(struct evdev_dev *evdev, size_t report_size)
122{
123	if (report_size > KEY_CNT + REL_CNT + ABS_CNT + MAX_MT_SLOTS * MT_CNT +
124	    MSC_CNT + LED_CNT + SND_CNT + SW_CNT + FF_CNT)
125		return (EINVAL);
126
127	evdev->ev_report_size = report_size;
128	return (0);
129}
130
131static size_t
132evdev_estimate_report_size(struct evdev_dev *evdev)
133{
134	size_t size = 0;
135	int res;
136
137	/*
138	 * Keyboards generate one event per report but other devices with
139	 * buttons like mouses can report events simultaneously
140	 */
141	bit_ffs_at(evdev->ev_key_flags, KEY_OK, KEY_CNT - KEY_OK, &res);
142	if (res == -1)
143		bit_ffs(evdev->ev_key_flags, BTN_MISC, &res);
144	size += (res != -1);
145	bit_count(evdev->ev_key_flags, BTN_MISC, KEY_OK - BTN_MISC, &res);
146	size += res;
147
148	/* All relative axes can be reported simultaneously */
149	bit_count(evdev->ev_rel_flags, 0, REL_CNT, &res);
150	size += res;
151
152	/*
153	 * All absolute axes can be reported simultaneously.
154	 * Multitouch axes can be reported ABS_MT_SLOT times
155	 */
156	if (evdev->ev_absinfo != NULL) {
157		bit_count(evdev->ev_abs_flags, 0, ABS_CNT, &res);
158		size += res;
159		bit_count(evdev->ev_abs_flags, ABS_MT_FIRST, MT_CNT, &res);
160		if (res > 0) {
161			res++;	/* ABS_MT_SLOT or SYN_MT_REPORT */
162			if (bit_test(evdev->ev_abs_flags, ABS_MT_SLOT))
163				/* MT type B */
164				size += res * MAXIMAL_MT_SLOT(evdev);
165			else
166				/* MT type A */
167				size += res * (MAX_MT_REPORTS - 1);
168		}
169	}
170
171	/* All misc events can be reported simultaneously */
172	bit_count(evdev->ev_msc_flags, 0, MSC_CNT, &res);
173	size += res;
174
175	/* All leds can be reported simultaneously */
176	bit_count(evdev->ev_led_flags, 0, LED_CNT, &res);
177	size += res;
178
179	/* Assume other events are generated once per report */
180	bit_ffs(evdev->ev_snd_flags, SND_CNT, &res);
181	size += (res != -1);
182
183	bit_ffs(evdev->ev_sw_flags, SW_CNT, &res);
184	size += (res != -1);
185
186	/* XXX: FF part is not implemented yet */
187
188	size++;		/* SYN_REPORT */
189	return (size);
190}
191
192static int
193evdev_register_common(struct evdev_dev *evdev)
194{
195	int ret;
196
197	debugf(evdev, "%s: registered evdev provider: %s <%s>\n",
198	    evdev->ev_shortname, evdev->ev_name, evdev->ev_serial);
199
200	/* Initialize internal structures */
201	LIST_INIT(&evdev->ev_clients);
202
203	if (evdev_event_supported(evdev, EV_REP) &&
204	    bit_test(evdev->ev_flags, EVDEV_FLAG_SOFTREPEAT)) {
205		/* Initialize callout */
206		callout_init_mtx(&evdev->ev_rep_callout, &evdev->ev_mtx, 0);
207
208		if (evdev->ev_rep[REP_DELAY] == 0 &&
209		    evdev->ev_rep[REP_PERIOD] == 0) {
210			/* Supply default values */
211			evdev->ev_rep[REP_DELAY] = 250;
212			evdev->ev_rep[REP_PERIOD] = 33;
213		}
214	}
215
216	/* Initialize multitouch protocol type B states */
217	if (bit_test(evdev->ev_abs_flags, ABS_MT_SLOT) &&
218	    evdev->ev_absinfo != NULL && MAXIMAL_MT_SLOT(evdev) > 0)
219		evdev_mt_init(evdev);
220
221	/* Estimate maximum report size */
222	if (evdev->ev_report_size == 0) {
223		ret = evdev_set_report_size(evdev,
224		    evdev_estimate_report_size(evdev));
225		if (ret != 0)
226			goto bail_out;
227	}
228
229	/* Create char device node */
230	ret = evdev_cdev_create(evdev);
231bail_out:
232	return (ret);
233}
234
235int
236evdev_register(struct evdev_dev *evdev)
237{
238	int ret;
239
240	evdev->ev_lock_type = EV_LOCK_INTERNAL;
241	evdev->ev_lock = &evdev->ev_mtx;
242	mtx_init(&evdev->ev_mtx, "evmtx", NULL, MTX_DEF);
243
244	ret = evdev_register_common(evdev);
245	if (ret != 0)
246		mtx_destroy(&evdev->ev_mtx);
247
248	return (ret);
249}
250
251int
252evdev_register_mtx(struct evdev_dev *evdev, struct mtx *mtx)
253{
254
255	evdev->ev_lock_type = EV_LOCK_MTX;
256	evdev->ev_lock = mtx;
257	return (evdev_register_common(evdev));
258}
259
260int
261evdev_unregister(struct evdev_dev *evdev)
262{
263	struct evdev_client *client;
264	int ret;
265	debugf(evdev, "%s: unregistered evdev provider: %s\n",
266	    evdev->ev_shortname, evdev->ev_name);
267
268	EVDEV_LOCK(evdev);
269	evdev->ev_cdev->si_drv1 = NULL;
270	/* Wake up sleepers */
271	LIST_FOREACH(client, &evdev->ev_clients, ec_link) {
272		evdev_revoke_client(client);
273		evdev_dispose_client(evdev, client);
274		EVDEV_CLIENT_LOCKQ(client);
275		evdev_notify_event(client);
276		EVDEV_CLIENT_UNLOCKQ(client);
277	}
278	EVDEV_UNLOCK(evdev);
279
280	/* destroy_dev can sleep so release lock */
281	ret = evdev_cdev_destroy(evdev);
282	evdev->ev_cdev = NULL;
283	if (ret == 0 && evdev->ev_lock_type == EV_LOCK_INTERNAL)
284		mtx_destroy(&evdev->ev_mtx);
285
286	evdev_free_absinfo(evdev->ev_absinfo);
287	evdev_mt_free(evdev);
288
289	return (ret);
290}
291
292inline void
293evdev_set_name(struct evdev_dev *evdev, const char *name)
294{
295
296	snprintf(evdev->ev_name, NAMELEN, "%s", name);
297}
298
299inline void
300evdev_set_id(struct evdev_dev *evdev, uint16_t bustype, uint16_t vendor,
301    uint16_t product, uint16_t version)
302{
303
304	evdev->ev_id = (struct input_id) {
305		.bustype = bustype,
306		.vendor = vendor,
307		.product = product,
308		.version = version
309	};
310}
311
312inline void
313evdev_set_phys(struct evdev_dev *evdev, const char *name)
314{
315
316	snprintf(evdev->ev_shortname, NAMELEN, "%s", name);
317}
318
319inline void
320evdev_set_serial(struct evdev_dev *evdev, const char *serial)
321{
322
323	snprintf(evdev->ev_serial, NAMELEN, "%s", serial);
324}
325
326inline void
327evdev_set_methods(struct evdev_dev *evdev, void *softc,
328    const struct evdev_methods *methods)
329{
330
331	evdev->ev_methods = methods;
332	evdev->ev_softc = softc;
333}
334
335inline void
336evdev_support_prop(struct evdev_dev *evdev, uint16_t prop)
337{
338
339	KASSERT(prop < INPUT_PROP_CNT, ("invalid evdev input property"));
340	bit_set(evdev->ev_prop_flags, prop);
341}
342
343inline void
344evdev_support_event(struct evdev_dev *evdev, uint16_t type)
345{
346
347	KASSERT(type < EV_CNT, ("invalid evdev event property"));
348	bit_set(evdev->ev_type_flags, type);
349}
350
351inline void
352evdev_support_key(struct evdev_dev *evdev, uint16_t code)
353{
354
355	KASSERT(code < KEY_CNT, ("invalid evdev key property"));
356	bit_set(evdev->ev_key_flags, code);
357}
358
359inline void
360evdev_support_rel(struct evdev_dev *evdev, uint16_t code)
361{
362
363	KASSERT(code < REL_CNT, ("invalid evdev rel property"));
364	bit_set(evdev->ev_rel_flags, code);
365}
366
367inline void
368evdev_support_abs(struct evdev_dev *evdev, uint16_t code, int32_t value,
369    int32_t minimum, int32_t maximum, int32_t fuzz, int32_t flat,
370    int32_t resolution)
371{
372	struct input_absinfo absinfo;
373
374	KASSERT(code < ABS_CNT, ("invalid evdev abs property"));
375
376	absinfo = (struct input_absinfo) {
377		.value = value,
378		.minimum = minimum,
379		.maximum = maximum,
380		.fuzz = fuzz,
381		.flat = flat,
382		.resolution = resolution,
383	};
384	evdev_set_abs_bit(evdev, code);
385	evdev_set_absinfo(evdev, code, &absinfo);
386}
387
388inline void
389evdev_set_abs_bit(struct evdev_dev *evdev, uint16_t code)
390{
391
392	KASSERT(code < ABS_CNT, ("invalid evdev abs property"));
393	if (evdev->ev_absinfo == NULL)
394		evdev->ev_absinfo = evdev_alloc_absinfo();
395	bit_set(evdev->ev_abs_flags, code);
396}
397
398inline void
399evdev_support_msc(struct evdev_dev *evdev, uint16_t code)
400{
401
402	KASSERT(code < MSC_CNT, ("invalid evdev msc property"));
403	bit_set(evdev->ev_msc_flags, code);
404}
405
406
407inline void
408evdev_support_led(struct evdev_dev *evdev, uint16_t code)
409{
410
411	KASSERT(code < LED_CNT, ("invalid evdev led property"));
412	bit_set(evdev->ev_led_flags, code);
413}
414
415inline void
416evdev_support_snd(struct evdev_dev *evdev, uint16_t code)
417{
418
419	KASSERT(code < SND_CNT, ("invalid evdev snd property"));
420	bit_set(evdev->ev_snd_flags, code);
421}
422
423inline void
424evdev_support_sw(struct evdev_dev *evdev, uint16_t code)
425{
426
427	KASSERT(code < SW_CNT, ("invalid evdev sw property"));
428	bit_set(evdev->ev_sw_flags, code);
429}
430
431bool
432evdev_event_supported(struct evdev_dev *evdev, uint16_t type)
433{
434
435	KASSERT(type < EV_CNT, ("invalid evdev event property"));
436	return (bit_test(evdev->ev_type_flags, type));
437}
438
439inline void
440evdev_set_absinfo(struct evdev_dev *evdev, uint16_t axis,
441    struct input_absinfo *absinfo)
442{
443
444	KASSERT(axis < ABS_CNT, ("invalid evdev abs property"));
445
446	if (axis == ABS_MT_SLOT &&
447	    (absinfo->maximum < 1 || absinfo->maximum >= MAX_MT_SLOTS))
448		return;
449
450	if (evdev->ev_absinfo == NULL)
451		evdev->ev_absinfo = evdev_alloc_absinfo();
452
453	if (axis == ABS_MT_SLOT)
454		evdev->ev_absinfo[ABS_MT_SLOT].maximum = absinfo->maximum;
455	else
456		memcpy(&evdev->ev_absinfo[axis], absinfo,
457		    sizeof(struct input_absinfo));
458}
459
460inline void
461evdev_set_repeat_params(struct evdev_dev *evdev, uint16_t property, int value)
462{
463
464	KASSERT(property < REP_CNT, ("invalid evdev repeat property"));
465	evdev->ev_rep[property] = value;
466}
467
468inline void
469evdev_set_flag(struct evdev_dev *evdev, uint16_t flag)
470{
471
472	KASSERT(flag < EVDEV_FLAG_CNT, ("invalid evdev flag property"));
473	bit_set(evdev->ev_flags, flag);
474}
475
476static int
477evdev_check_event(struct evdev_dev *evdev, uint16_t type, uint16_t code,
478    int32_t value)
479{
480
481	if (type >= EV_CNT)
482		return (EINVAL);
483
484	/* Allow SYN events implicitly */
485	if (type != EV_SYN && !evdev_event_supported(evdev, type))
486		return (EINVAL);
487
488	switch (type) {
489	case EV_SYN:
490		if (code >= SYN_CNT)
491			return (EINVAL);
492		break;
493
494	case EV_KEY:
495		if (code >= KEY_CNT)
496			return (EINVAL);
497		if (!bit_test(evdev->ev_key_flags, code))
498			return (EINVAL);
499		break;
500
501	case EV_REL:
502		if (code >= REL_CNT)
503			return (EINVAL);
504		if (!bit_test(evdev->ev_rel_flags, code))
505			return (EINVAL);
506		break;
507
508	case EV_ABS:
509		if (code >= ABS_CNT)
510			return (EINVAL);
511		if (!bit_test(evdev->ev_abs_flags, code))
512			return (EINVAL);
513		if (code == ABS_MT_SLOT &&
514		    (value < 0 || value > MAXIMAL_MT_SLOT(evdev)))
515			return (EINVAL);
516		if (ABS_IS_MT(code) && evdev->ev_mt == NULL &&
517		    bit_test(evdev->ev_abs_flags, ABS_MT_SLOT))
518			return (EINVAL);
519		break;
520
521	case EV_MSC:
522		if (code >= MSC_CNT)
523			return (EINVAL);
524		if (!bit_test(evdev->ev_msc_flags, code))
525			return (EINVAL);
526		break;
527
528	case EV_LED:
529		if (code >= LED_CNT)
530			return (EINVAL);
531		if (!bit_test(evdev->ev_led_flags, code))
532			return (EINVAL);
533		break;
534
535	case EV_SND:
536		if (code >= SND_CNT)
537			return (EINVAL);
538		if (!bit_test(evdev->ev_snd_flags, code))
539			return (EINVAL);
540		break;
541
542	case EV_SW:
543		if (code >= SW_CNT)
544			return (EINVAL);
545		if (!bit_test(evdev->ev_sw_flags, code))
546			return (EINVAL);
547		break;
548
549	case EV_REP:
550		if (code >= REP_CNT)
551			return (EINVAL);
552		break;
553
554	default:
555		return (EINVAL);
556	}
557
558	return (0);
559}
560
561static void
562evdev_modify_event(struct evdev_dev *evdev, uint16_t type, uint16_t code,
563    int32_t *value)
564{
565
566	EVDEV_LOCK_ASSERT(evdev);
567
568	switch (type) {
569	case EV_KEY:
570		if (!evdev_event_supported(evdev, EV_REP))
571			break;
572
573		if (!bit_test(evdev->ev_flags, EVDEV_FLAG_SOFTREPEAT)) {
574			/* Detect driver key repeats. */
575			if (bit_test(evdev->ev_key_states, code) &&
576			    *value == KEY_EVENT_DOWN)
577				*value = KEY_EVENT_REPEAT;
578		} else {
579			/* Start/stop callout for evdev repeats */
580			if (bit_test(evdev->ev_key_states, code) == !*value) {
581				if (*value == KEY_EVENT_DOWN)
582					evdev_start_repeat(evdev, code);
583				else
584					evdev_stop_repeat(evdev);
585			}
586		}
587		break;
588
589	case EV_ABS:
590		/* TBD: implement fuzz */
591		break;
592	}
593}
594
595static enum evdev_sparse_result
596evdev_sparse_event(struct evdev_dev *evdev, uint16_t type, uint16_t code,
597    int32_t value)
598{
599	int32_t last_mt_slot;
600
601	EVDEV_LOCK_ASSERT(evdev);
602
603	/*
604	 * For certain event types, update device state bits
605	 * and convert level reporting to edge reporting
606	 */
607	switch (type) {
608	case EV_KEY:
609		switch (value) {
610		case KEY_EVENT_UP:
611		case KEY_EVENT_DOWN:
612			if (bit_test(evdev->ev_key_states, code) == value)
613				return (EV_SKIP_EVENT);
614			bit_change(evdev->ev_key_states, code, value);
615			break;
616
617		case KEY_EVENT_REPEAT:
618			if (bit_test(evdev->ev_key_states, code) == 0 ||
619			    !evdev_event_supported(evdev, EV_REP))
620				return (EV_SKIP_EVENT);
621			break;
622
623		default:
624			 return (EV_SKIP_EVENT);
625		}
626		break;
627
628	case EV_LED:
629		if (bit_test(evdev->ev_led_states, code) == value)
630			return (EV_SKIP_EVENT);
631		bit_change(evdev->ev_led_states, code, value);
632		break;
633
634	case EV_SND:
635		if (bit_test(evdev->ev_snd_states, code) == value)
636			return (EV_SKIP_EVENT);
637		bit_change(evdev->ev_snd_states, code, value);
638		break;
639
640	case EV_SW:
641		if (bit_test(evdev->ev_sw_states, code) == value)
642			return (EV_SKIP_EVENT);
643		bit_change(evdev->ev_sw_states, code, value);
644		break;
645
646	case EV_REP:
647		if (evdev->ev_rep[code] == value)
648			return (EV_SKIP_EVENT);
649		evdev_set_repeat_params(evdev, code, value);
650		break;
651
652	case EV_REL:
653		if (value == 0)
654			return (EV_SKIP_EVENT);
655		break;
656
657	/* For EV_ABS, save last value in absinfo and ev_mt_states */
658	case EV_ABS:
659		switch (code) {
660		case ABS_MT_SLOT:
661			/* Postpone ABS_MT_SLOT till next event */
662			evdev_set_last_mt_slot(evdev, value);
663			return (EV_SKIP_EVENT);
664
665		case ABS_MT_FIRST ... ABS_MT_LAST:
666			/* Pass MT protocol type A events as is */
667			if (!bit_test(evdev->ev_abs_flags, ABS_MT_SLOT))
668				break;
669			/* Don`t repeat MT protocol type B events */
670			last_mt_slot = evdev_get_last_mt_slot(evdev);
671			if (evdev_get_mt_value(evdev, last_mt_slot, code)
672			     == value)
673				return (EV_SKIP_EVENT);
674			evdev_set_mt_value(evdev, last_mt_slot, code, value);
675			if (last_mt_slot != CURRENT_MT_SLOT(evdev)) {
676				CURRENT_MT_SLOT(evdev) = last_mt_slot;
677				evdev->ev_report_opened = true;
678				return (EV_REPORT_MT_SLOT);
679			}
680			break;
681
682		default:
683			if (evdev->ev_absinfo[code].value == value)
684				return (EV_SKIP_EVENT);
685			evdev->ev_absinfo[code].value = value;
686		}
687		break;
688
689	case EV_SYN:
690		if (code == SYN_REPORT) {
691			/* Count empty reports as well as non empty */
692			evdev->ev_report_count++;
693			/* Skip empty reports */
694			if (!evdev->ev_report_opened)
695				return (EV_SKIP_EVENT);
696			evdev->ev_report_opened = false;
697			return (EV_REPORT_EVENT);
698		}
699		break;
700	}
701
702	evdev->ev_report_opened = true;
703	return (EV_REPORT_EVENT);
704}
705
706static void
707evdev_propagate_event(struct evdev_dev *evdev, uint16_t type, uint16_t code,
708    int32_t value)
709{
710	struct evdev_client *client;
711
712	debugf(evdev, "%s pushed event %d/%d/%d",
713	    evdev->ev_shortname, type, code, value);
714
715	EVDEV_LOCK_ASSERT(evdev);
716
717	/* Propagate event through all clients */
718	LIST_FOREACH(client, &evdev->ev_clients, ec_link) {
719		if (evdev->ev_grabber != NULL && evdev->ev_grabber != client)
720			continue;
721
722		EVDEV_CLIENT_LOCKQ(client);
723		evdev_client_push(client, type, code, value);
724		if (type == EV_SYN && code == SYN_REPORT)
725			evdev_notify_event(client);
726		EVDEV_CLIENT_UNLOCKQ(client);
727	}
728
729	evdev->ev_event_count++;
730}
731
732void
733evdev_send_event(struct evdev_dev *evdev, uint16_t type, uint16_t code,
734    int32_t value)
735{
736	enum evdev_sparse_result sparse;
737
738	EVDEV_LOCK_ASSERT(evdev);
739
740	sparse =  evdev_sparse_event(evdev, type, code, value);
741	switch (sparse) {
742	case EV_REPORT_MT_SLOT:
743		/* report postponed ABS_MT_SLOT */
744		evdev_propagate_event(evdev, EV_ABS, ABS_MT_SLOT,
745		    CURRENT_MT_SLOT(evdev));
746		/* FALLTHROUGH */
747	case EV_REPORT_EVENT:
748		evdev_propagate_event(evdev, type, code, value);
749		/* FALLTHROUGH */
750	case EV_SKIP_EVENT:
751		break;
752	}
753}
754
755int
756evdev_push_event(struct evdev_dev *evdev, uint16_t type, uint16_t code,
757    int32_t value)
758{
759
760	if (evdev_check_event(evdev, type, code, value) != 0)
761		return (EINVAL);
762
763	EVDEV_ENTER(evdev);
764
765	evdev_modify_event(evdev, type, code, &value);
766	if (type == EV_SYN && code == SYN_REPORT &&
767	     bit_test(evdev->ev_flags, EVDEV_FLAG_MT_AUTOREL))
768		evdev_send_mt_autorel(evdev);
769	if (type == EV_SYN && code == SYN_REPORT && evdev->ev_report_opened &&
770	    bit_test(evdev->ev_flags, EVDEV_FLAG_MT_STCOMPAT))
771		evdev_send_mt_compat(evdev);
772	evdev_send_event(evdev, type, code, value);
773
774	EVDEV_EXIT(evdev);
775
776	return (0);
777}
778
779int
780evdev_inject_event(struct evdev_dev *evdev, uint16_t type, uint16_t code,
781    int32_t value)
782{
783	int ret = 0;
784
785	switch (type) {
786	case EV_REP:
787		/* evdev repeats should not be processed by hardware driver */
788		if (bit_test(evdev->ev_flags, EVDEV_FLAG_SOFTREPEAT))
789			goto push;
790		/* FALLTHROUGH */
791	case EV_LED:
792	case EV_MSC:
793	case EV_SND:
794	case EV_FF:
795		if (evdev->ev_methods != NULL &&
796		    evdev->ev_methods->ev_event != NULL)
797			evdev->ev_methods->ev_event(evdev, evdev->ev_softc,
798			    type, code, value);
799		/*
800		 * Leds and driver repeats should be reported in ev_event
801		 * method body to interoperate with kbdmux states and rates
802		 * propagation so both ways (ioctl and evdev) of changing it
803		 * will produce only one evdev event report to client.
804		 */
805		if (type == EV_LED || type == EV_REP)
806			break;
807		/* FALLTHROUGH */
808	case EV_SYN:
809	case EV_KEY:
810	case EV_REL:
811	case EV_ABS:
812	case EV_SW:
813push:
814		ret = evdev_push_event(evdev, type,  code, value);
815		break;
816
817	default:
818		ret = EINVAL;
819	}
820
821	return (ret);
822}
823
824int
825evdev_register_client(struct evdev_dev *evdev, struct evdev_client *client)
826{
827	int ret = 0;
828
829	debugf(evdev, "adding new client for device %s", evdev->ev_shortname);
830
831	EVDEV_LOCK_ASSERT(evdev);
832
833	if (LIST_EMPTY(&evdev->ev_clients) && evdev->ev_methods != NULL &&
834	    evdev->ev_methods->ev_open != NULL) {
835		debugf(evdev, "calling ev_open() on device %s",
836		    evdev->ev_shortname);
837		ret = evdev->ev_methods->ev_open(evdev, evdev->ev_softc);
838	}
839	if (ret == 0)
840		LIST_INSERT_HEAD(&evdev->ev_clients, client, ec_link);
841	return (ret);
842}
843
844void
845evdev_dispose_client(struct evdev_dev *evdev, struct evdev_client *client)
846{
847	debugf(evdev, "removing client for device %s", evdev->ev_shortname);
848
849	EVDEV_LOCK_ASSERT(evdev);
850
851	LIST_REMOVE(client, ec_link);
852	if (LIST_EMPTY(&evdev->ev_clients)) {
853		if (evdev->ev_methods != NULL &&
854		    evdev->ev_methods->ev_close != NULL)
855			evdev->ev_methods->ev_close(evdev, evdev->ev_softc);
856		if (evdev_event_supported(evdev, EV_REP) &&
857		    bit_test(evdev->ev_flags, EVDEV_FLAG_SOFTREPEAT))
858			evdev_stop_repeat(evdev);
859	}
860	evdev_release_client(evdev, client);
861}
862
863int
864evdev_grab_client(struct evdev_dev *evdev, struct evdev_client *client)
865{
866
867	EVDEV_LOCK_ASSERT(evdev);
868
869	if (evdev->ev_grabber != NULL)
870		return (EBUSY);
871
872	evdev->ev_grabber = client;
873
874	return (0);
875}
876
877int
878evdev_release_client(struct evdev_dev *evdev, struct evdev_client *client)
879{
880
881	EVDEV_LOCK_ASSERT(evdev);
882
883	if (evdev->ev_grabber != client)
884		return (EINVAL);
885
886	evdev->ev_grabber = NULL;
887
888	return (0);
889}
890
891static void
892evdev_repeat_callout(void *arg)
893{
894	struct evdev_dev *evdev = (struct evdev_dev *)arg;
895
896	evdev_send_event(evdev, EV_KEY, evdev->ev_rep_key, KEY_EVENT_REPEAT);
897	evdev_send_event(evdev, EV_SYN, SYN_REPORT, 1);
898
899	if (evdev->ev_rep[REP_PERIOD])
900		callout_reset(&evdev->ev_rep_callout,
901		    evdev->ev_rep[REP_PERIOD] * hz / 1000,
902		    evdev_repeat_callout, evdev);
903	else
904		evdev->ev_rep_key = KEY_RESERVED;
905}
906
907static void
908evdev_start_repeat(struct evdev_dev *evdev, uint16_t key)
909{
910
911	EVDEV_LOCK_ASSERT(evdev);
912
913	if (evdev->ev_rep[REP_DELAY]) {
914		evdev->ev_rep_key = key;
915		callout_reset(&evdev->ev_rep_callout,
916		    evdev->ev_rep[REP_DELAY] * hz / 1000,
917		    evdev_repeat_callout, evdev);
918	}
919}
920
921static void
922evdev_stop_repeat(struct evdev_dev *evdev)
923{
924
925	EVDEV_LOCK_ASSERT(evdev);
926
927	if (evdev->ev_rep_key != KEY_RESERVED) {
928		callout_stop(&evdev->ev_rep_callout);
929		evdev->ev_rep_key = KEY_RESERVED;
930	}
931}
932
933MODULE_VERSION(evdev, 1);
934