1 /*-
2 * Copyright (c) 2014 Jakub Wojciech Klama <[email protected]>
3 * Copyright (c) 2015-2016 Vladimir Kondratyev <[email protected]>
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$
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/kdb.h>
36 #include <sys/kernel.h>
37 #include <sys/malloc.h>
38 #include <sys/module.h>
39 #include <sys/proc.h>
40 #include <sys/sysctl.h>
41 #include <sys/systm.h>
42
43 #include <dev/evdev/evdev.h>
44 #include <dev/evdev/evdev_private.h>
45 #include <dev/evdev/input.h>
46
47 #ifdef EVDEV_DEBUG
48 #define debugf(evdev, fmt, args...) printf("evdev: " fmt "\n", ##args)
49 #else
50 #define debugf(evdev, fmt, args...)
51 #endif
52
53 #ifdef FEATURE
54 FEATURE(evdev, "Input event devices support");
55 #ifdef EVDEV_SUPPORT
56 FEATURE(evdev_support, "Evdev support in hybrid drivers");
57 #endif
58 #endif
59
60 enum evdev_sparse_result
61 {
62 EV_SKIP_EVENT, /* Event value not changed */
63 EV_REPORT_EVENT, /* Event value changed */
64 EV_REPORT_MT_SLOT, /* Event value and MT slot number changed */
65 };
66
67 MALLOC_DEFINE(M_EVDEV, "evdev", "evdev memory");
68
69 int evdev_rcpt_mask = EVDEV_RCPT_SYSMOUSE | EVDEV_RCPT_KBDMUX;
70 int evdev_sysmouse_t_axis = 0;
71
72 SYSCTL_NODE(_kern, OID_AUTO, evdev, CTLFLAG_RW, 0, "Evdev args");
73 #ifdef EVDEV_SUPPORT
74 SYSCTL_INT(_kern_evdev, OID_AUTO, rcpt_mask, CTLFLAG_RW, &evdev_rcpt_mask, 0,
75 "Who is receiving events: bit0 - sysmouse, bit1 - kbdmux, "
76 "bit2 - mouse hardware, bit3 - keyboard hardware");
77 SYSCTL_INT(_kern_evdev, OID_AUTO, sysmouse_t_axis, CTLFLAG_RW,
78 &evdev_sysmouse_t_axis, 0, "Extract T-axis from 0-none, 1-ums, 2-psm");
79 #endif
80 SYSCTL_NODE(_kern_evdev, OID_AUTO, input, CTLFLAG_RD, 0,
81 "Evdev input devices");
82
83 static void evdev_start_repeat(struct evdev_dev *, uint16_t);
84 static void evdev_stop_repeat(struct evdev_dev *);
85 static int evdev_check_event(struct evdev_dev *, uint16_t, uint16_t, int32_t);
86
87 static inline void
bit_change(bitstr_t * bitstr,int bit,int value)88 bit_change(bitstr_t *bitstr, int bit, int value)
89 {
90 if (value)
91 bit_set(bitstr, bit);
92 else
93 bit_clear(bitstr, bit);
94 }
95
96 struct evdev_dev *
evdev_alloc(void)97 evdev_alloc(void)
98 {
99
100 return malloc(sizeof(struct evdev_dev), M_EVDEV, M_WAITOK | M_ZERO);
101 }
102
103 void
evdev_free(struct evdev_dev * evdev)104 evdev_free(struct evdev_dev *evdev)
105 {
106
107 if (evdev != NULL && evdev->ev_cdev != NULL &&
108 evdev->ev_cdev->si_drv1 != NULL)
109 evdev_unregister(evdev);
110
111 free(evdev, M_EVDEV);
112 }
113
114 static struct input_absinfo *
evdev_alloc_absinfo(void)115 evdev_alloc_absinfo(void)
116 {
117
118 return (malloc(sizeof(struct input_absinfo) * ABS_CNT, M_EVDEV,
119 M_WAITOK | M_ZERO));
120 }
121
122 static void
evdev_free_absinfo(struct input_absinfo * absinfo)123 evdev_free_absinfo(struct input_absinfo *absinfo)
124 {
125
126 free(absinfo, M_EVDEV);
127 }
128
129 int
evdev_set_report_size(struct evdev_dev * evdev,size_t report_size)130 evdev_set_report_size(struct evdev_dev *evdev, size_t report_size)
131 {
132 if (report_size > KEY_CNT + REL_CNT + ABS_CNT + MAX_MT_SLOTS * MT_CNT +
133 MSC_CNT + LED_CNT + SND_CNT + SW_CNT + FF_CNT)
134 return (EINVAL);
135
136 evdev->ev_report_size = report_size;
137 return (0);
138 }
139
140 static size_t
evdev_estimate_report_size(struct evdev_dev * evdev)141 evdev_estimate_report_size(struct evdev_dev *evdev)
142 {
143 size_t size = 0;
144 int res;
145
146 /*
147 * Keyboards generate one event per report but other devices with
148 * buttons like mouses can report events simultaneously
149 */
150 bit_ffs_at(evdev->ev_key_flags, KEY_OK, KEY_CNT - KEY_OK, &res);
151 if (res == -1)
152 bit_ffs(evdev->ev_key_flags, BTN_MISC, &res);
153 size += (res != -1);
154 bit_count(evdev->ev_key_flags, BTN_MISC, KEY_OK - BTN_MISC, &res);
155 size += res;
156
157 /* All relative axes can be reported simultaneously */
158 bit_count(evdev->ev_rel_flags, 0, REL_CNT, &res);
159 size += res;
160
161 /*
162 * All absolute axes can be reported simultaneously.
163 * Multitouch axes can be reported ABS_MT_SLOT times
164 */
165 if (evdev->ev_absinfo != NULL) {
166 bit_count(evdev->ev_abs_flags, 0, ABS_CNT, &res);
167 size += res;
168 bit_count(evdev->ev_abs_flags, ABS_MT_FIRST, MT_CNT, &res);
169 if (res > 0) {
170 res++; /* ABS_MT_SLOT or SYN_MT_REPORT */
171 if (bit_test(evdev->ev_abs_flags, ABS_MT_SLOT))
172 /* MT type B */
173 size += res * MAXIMAL_MT_SLOT(evdev);
174 else
175 /* MT type A */
176 size += res * (MAX_MT_REPORTS - 1);
177 }
178 }
179
180 /* All misc events can be reported simultaneously */
181 bit_count(evdev->ev_msc_flags, 0, MSC_CNT, &res);
182 size += res;
183
184 /* All leds can be reported simultaneously */
185 bit_count(evdev->ev_led_flags, 0, LED_CNT, &res);
186 size += res;
187
188 /* Assume other events are generated once per report */
189 bit_ffs(evdev->ev_snd_flags, SND_CNT, &res);
190 size += (res != -1);
191
192 bit_ffs(evdev->ev_sw_flags, SW_CNT, &res);
193 size += (res != -1);
194
195 /* XXX: FF part is not implemented yet */
196
197 size++; /* SYN_REPORT */
198 return (size);
199 }
200
201 static void
evdev_sysctl_create(struct evdev_dev * evdev)202 evdev_sysctl_create(struct evdev_dev *evdev)
203 {
204 struct sysctl_oid *ev_sysctl_tree;
205 char ev_unit_str[8];
206
207 snprintf(ev_unit_str, sizeof(ev_unit_str), "%d", evdev->ev_unit);
208 sysctl_ctx_init(&evdev->ev_sysctl_ctx);
209
210 ev_sysctl_tree = SYSCTL_ADD_NODE_WITH_LABEL(&evdev->ev_sysctl_ctx,
211 SYSCTL_STATIC_CHILDREN(_kern_evdev_input), OID_AUTO,
212 ev_unit_str, CTLFLAG_RD, NULL, "", "device index");
213
214 SYSCTL_ADD_STRING(&evdev->ev_sysctl_ctx,
215 SYSCTL_CHILDREN(ev_sysctl_tree), OID_AUTO, "name", CTLFLAG_RD,
216 evdev->ev_name, 0,
217 "Input device name");
218
219 SYSCTL_ADD_STRUCT(&evdev->ev_sysctl_ctx,
220 SYSCTL_CHILDREN(ev_sysctl_tree), OID_AUTO, "id", CTLFLAG_RD,
221 &evdev->ev_id, input_id,
222 "Input device identification");
223
224 /* ioctl returns ENOENT if phys is not set. sysctl returns "" here */
225 SYSCTL_ADD_STRING(&evdev->ev_sysctl_ctx,
226 SYSCTL_CHILDREN(ev_sysctl_tree), OID_AUTO, "phys", CTLFLAG_RD,
227 evdev->ev_shortname, 0,
228 "Input device short name");
229
230 /* ioctl returns ENOENT if uniq is not set. sysctl returns "" here */
231 SYSCTL_ADD_STRING(&evdev->ev_sysctl_ctx,
232 SYSCTL_CHILDREN(ev_sysctl_tree), OID_AUTO, "uniq", CTLFLAG_RD,
233 evdev->ev_serial, 0,
234 "Input device unique number");
235
236 SYSCTL_ADD_OPAQUE(&evdev->ev_sysctl_ctx,
237 SYSCTL_CHILDREN(ev_sysctl_tree), OID_AUTO, "props", CTLFLAG_RD,
238 evdev->ev_prop_flags, sizeof(evdev->ev_prop_flags), "",
239 "Input device properties");
240
241 SYSCTL_ADD_OPAQUE(&evdev->ev_sysctl_ctx,
242 SYSCTL_CHILDREN(ev_sysctl_tree), OID_AUTO, "type_bits", CTLFLAG_RD,
243 evdev->ev_type_flags, sizeof(evdev->ev_type_flags), "",
244 "Input device supported events types");
245
246 SYSCTL_ADD_OPAQUE(&evdev->ev_sysctl_ctx,
247 SYSCTL_CHILDREN(ev_sysctl_tree), OID_AUTO, "key_bits", CTLFLAG_RD,
248 evdev->ev_key_flags, sizeof(evdev->ev_key_flags),
249 "", "Input device supported keys");
250
251 SYSCTL_ADD_OPAQUE(&evdev->ev_sysctl_ctx,
252 SYSCTL_CHILDREN(ev_sysctl_tree), OID_AUTO, "rel_bits", CTLFLAG_RD,
253 evdev->ev_rel_flags, sizeof(evdev->ev_rel_flags), "",
254 "Input device supported relative events");
255
256 SYSCTL_ADD_OPAQUE(&evdev->ev_sysctl_ctx,
257 SYSCTL_CHILDREN(ev_sysctl_tree), OID_AUTO, "abs_bits", CTLFLAG_RD,
258 evdev->ev_abs_flags, sizeof(evdev->ev_abs_flags), "",
259 "Input device supported absolute events");
260
261 SYSCTL_ADD_OPAQUE(&evdev->ev_sysctl_ctx,
262 SYSCTL_CHILDREN(ev_sysctl_tree), OID_AUTO, "msc_bits", CTLFLAG_RD,
263 evdev->ev_msc_flags, sizeof(evdev->ev_msc_flags), "",
264 "Input device supported miscellaneous events");
265
266 SYSCTL_ADD_OPAQUE(&evdev->ev_sysctl_ctx,
267 SYSCTL_CHILDREN(ev_sysctl_tree), OID_AUTO, "led_bits", CTLFLAG_RD,
268 evdev->ev_led_flags, sizeof(evdev->ev_led_flags), "",
269 "Input device supported LED events");
270
271 SYSCTL_ADD_OPAQUE(&evdev->ev_sysctl_ctx,
272 SYSCTL_CHILDREN(ev_sysctl_tree), OID_AUTO, "snd_bits", CTLFLAG_RD,
273 evdev->ev_snd_flags, sizeof(evdev->ev_snd_flags), "",
274 "Input device supported sound events");
275
276 SYSCTL_ADD_OPAQUE(&evdev->ev_sysctl_ctx,
277 SYSCTL_CHILDREN(ev_sysctl_tree), OID_AUTO, "sw_bits", CTLFLAG_RD,
278 evdev->ev_sw_flags, sizeof(evdev->ev_sw_flags), "",
279 "Input device supported switch events");
280 }
281
282 static int
evdev_register_common(struct evdev_dev * evdev)283 evdev_register_common(struct evdev_dev *evdev)
284 {
285 int ret;
286
287 debugf(evdev, "%s: registered evdev provider: %s <%s>\n",
288 evdev->ev_shortname, evdev->ev_name, evdev->ev_serial);
289
290 /* Initialize internal structures */
291 LIST_INIT(&evdev->ev_clients);
292
293 if (evdev_event_supported(evdev, EV_REP) &&
294 bit_test(evdev->ev_flags, EVDEV_FLAG_SOFTREPEAT)) {
295 /* Initialize callout */
296 callout_init_mtx(&evdev->ev_rep_callout, &evdev->ev_mtx, 0);
297
298 if (evdev->ev_rep[REP_DELAY] == 0 &&
299 evdev->ev_rep[REP_PERIOD] == 0) {
300 /* Supply default values */
301 evdev->ev_rep[REP_DELAY] = 250;
302 evdev->ev_rep[REP_PERIOD] = 33;
303 }
304 }
305
306 /* Initialize multitouch protocol type B states */
307 if (bit_test(evdev->ev_abs_flags, ABS_MT_SLOT) &&
308 evdev->ev_absinfo != NULL && MAXIMAL_MT_SLOT(evdev) > 0)
309 evdev_mt_init(evdev);
310
311 /* Estimate maximum report size */
312 if (evdev->ev_report_size == 0) {
313 ret = evdev_set_report_size(evdev,
314 evdev_estimate_report_size(evdev));
315 if (ret != 0)
316 goto bail_out;
317 }
318
319 /* Create char device node */
320 ret = evdev_cdev_create(evdev);
321 if (ret != 0)
322 goto bail_out;
323
324 /* Create sysctls (for device enumeration without /dev/input access rights) */
325 evdev_sysctl_create(evdev);
326
327 bail_out:
328 return (ret);
329 }
330
331 int
evdev_register(struct evdev_dev * evdev)332 evdev_register(struct evdev_dev *evdev)
333 {
334 int ret;
335
336 evdev->ev_lock_type = EV_LOCK_INTERNAL;
337 evdev->ev_lock = &evdev->ev_mtx;
338 mtx_init(&evdev->ev_mtx, "evmtx", NULL, MTX_DEF);
339
340 ret = evdev_register_common(evdev);
341 if (ret != 0)
342 mtx_destroy(&evdev->ev_mtx);
343
344 return (ret);
345 }
346
347 int
evdev_register_mtx(struct evdev_dev * evdev,struct mtx * mtx)348 evdev_register_mtx(struct evdev_dev *evdev, struct mtx *mtx)
349 {
350
351 evdev->ev_lock_type = EV_LOCK_MTX;
352 evdev->ev_lock = mtx;
353 return (evdev_register_common(evdev));
354 }
355
356 int
evdev_unregister(struct evdev_dev * evdev)357 evdev_unregister(struct evdev_dev *evdev)
358 {
359 struct evdev_client *client;
360 int ret;
361 debugf(evdev, "%s: unregistered evdev provider: %s\n",
362 evdev->ev_shortname, evdev->ev_name);
363
364 sysctl_ctx_free(&evdev->ev_sysctl_ctx);
365
366 EVDEV_LOCK(evdev);
367 evdev->ev_cdev->si_drv1 = NULL;
368 /* Wake up sleepers */
369 LIST_FOREACH(client, &evdev->ev_clients, ec_link) {
370 evdev_revoke_client(client);
371 evdev_dispose_client(evdev, client);
372 EVDEV_CLIENT_LOCKQ(client);
373 evdev_notify_event(client);
374 EVDEV_CLIENT_UNLOCKQ(client);
375 }
376 EVDEV_UNLOCK(evdev);
377
378 /* destroy_dev can sleep so release lock */
379 ret = evdev_cdev_destroy(evdev);
380 evdev->ev_cdev = NULL;
381 if (ret == 0 && evdev->ev_lock_type == EV_LOCK_INTERNAL)
382 mtx_destroy(&evdev->ev_mtx);
383
384 evdev_free_absinfo(evdev->ev_absinfo);
385 evdev_mt_free(evdev);
386
387 return (ret);
388 }
389
390 inline void
evdev_set_name(struct evdev_dev * evdev,const char * name)391 evdev_set_name(struct evdev_dev *evdev, const char *name)
392 {
393
394 snprintf(evdev->ev_name, NAMELEN, "%s", name);
395 }
396
397 inline void
evdev_set_id(struct evdev_dev * evdev,uint16_t bustype,uint16_t vendor,uint16_t product,uint16_t version)398 evdev_set_id(struct evdev_dev *evdev, uint16_t bustype, uint16_t vendor,
399 uint16_t product, uint16_t version)
400 {
401
402 evdev->ev_id = (struct input_id) {
403 .bustype = bustype,
404 .vendor = vendor,
405 .product = product,
406 .version = version
407 };
408 }
409
410 inline void
evdev_set_phys(struct evdev_dev * evdev,const char * name)411 evdev_set_phys(struct evdev_dev *evdev, const char *name)
412 {
413
414 snprintf(evdev->ev_shortname, NAMELEN, "%s", name);
415 }
416
417 inline void
evdev_set_serial(struct evdev_dev * evdev,const char * serial)418 evdev_set_serial(struct evdev_dev *evdev, const char *serial)
419 {
420
421 snprintf(evdev->ev_serial, NAMELEN, "%s", serial);
422 }
423
424 inline void
evdev_set_methods(struct evdev_dev * evdev,void * softc,const struct evdev_methods * methods)425 evdev_set_methods(struct evdev_dev *evdev, void *softc,
426 const struct evdev_methods *methods)
427 {
428
429 evdev->ev_methods = methods;
430 evdev->ev_softc = softc;
431 }
432
433 inline void *
evdev_get_softc(struct evdev_dev * evdev)434 evdev_get_softc(struct evdev_dev *evdev)
435 {
436
437 return (evdev->ev_softc);
438 }
439
440 inline void
evdev_support_prop(struct evdev_dev * evdev,uint16_t prop)441 evdev_support_prop(struct evdev_dev *evdev, uint16_t prop)
442 {
443
444 KASSERT(prop < INPUT_PROP_CNT, ("invalid evdev input property"));
445 bit_set(evdev->ev_prop_flags, prop);
446 }
447
448 inline void
evdev_support_event(struct evdev_dev * evdev,uint16_t type)449 evdev_support_event(struct evdev_dev *evdev, uint16_t type)
450 {
451
452 KASSERT(type < EV_CNT, ("invalid evdev event property"));
453 bit_set(evdev->ev_type_flags, type);
454 }
455
456 inline void
evdev_support_key(struct evdev_dev * evdev,uint16_t code)457 evdev_support_key(struct evdev_dev *evdev, uint16_t code)
458 {
459
460 KASSERT(code < KEY_CNT, ("invalid evdev key property"));
461 bit_set(evdev->ev_key_flags, code);
462 }
463
464 inline void
evdev_support_rel(struct evdev_dev * evdev,uint16_t code)465 evdev_support_rel(struct evdev_dev *evdev, uint16_t code)
466 {
467
468 KASSERT(code < REL_CNT, ("invalid evdev rel property"));
469 bit_set(evdev->ev_rel_flags, code);
470 }
471
472 inline void
evdev_support_abs(struct evdev_dev * evdev,uint16_t code,int32_t value,int32_t minimum,int32_t maximum,int32_t fuzz,int32_t flat,int32_t resolution)473 evdev_support_abs(struct evdev_dev *evdev, uint16_t code, int32_t value,
474 int32_t minimum, int32_t maximum, int32_t fuzz, int32_t flat,
475 int32_t resolution)
476 {
477 struct input_absinfo absinfo;
478
479 KASSERT(code < ABS_CNT, ("invalid evdev abs property"));
480
481 absinfo = (struct input_absinfo) {
482 .value = value,
483 .minimum = minimum,
484 .maximum = maximum,
485 .fuzz = fuzz,
486 .flat = flat,
487 .resolution = resolution,
488 };
489 evdev_set_abs_bit(evdev, code);
490 evdev_set_absinfo(evdev, code, &absinfo);
491 }
492
493 inline void
evdev_set_abs_bit(struct evdev_dev * evdev,uint16_t code)494 evdev_set_abs_bit(struct evdev_dev *evdev, uint16_t code)
495 {
496
497 KASSERT(code < ABS_CNT, ("invalid evdev abs property"));
498 if (evdev->ev_absinfo == NULL)
499 evdev->ev_absinfo = evdev_alloc_absinfo();
500 bit_set(evdev->ev_abs_flags, code);
501 }
502
503 inline void
evdev_support_msc(struct evdev_dev * evdev,uint16_t code)504 evdev_support_msc(struct evdev_dev *evdev, uint16_t code)
505 {
506
507 KASSERT(code < MSC_CNT, ("invalid evdev msc property"));
508 bit_set(evdev->ev_msc_flags, code);
509 }
510
511
512 inline void
evdev_support_led(struct evdev_dev * evdev,uint16_t code)513 evdev_support_led(struct evdev_dev *evdev, uint16_t code)
514 {
515
516 KASSERT(code < LED_CNT, ("invalid evdev led property"));
517 bit_set(evdev->ev_led_flags, code);
518 }
519
520 inline void
evdev_support_snd(struct evdev_dev * evdev,uint16_t code)521 evdev_support_snd(struct evdev_dev *evdev, uint16_t code)
522 {
523
524 KASSERT(code < SND_CNT, ("invalid evdev snd property"));
525 bit_set(evdev->ev_snd_flags, code);
526 }
527
528 inline void
evdev_support_sw(struct evdev_dev * evdev,uint16_t code)529 evdev_support_sw(struct evdev_dev *evdev, uint16_t code)
530 {
531
532 KASSERT(code < SW_CNT, ("invalid evdev sw property"));
533 bit_set(evdev->ev_sw_flags, code);
534 }
535
536 bool
evdev_event_supported(struct evdev_dev * evdev,uint16_t type)537 evdev_event_supported(struct evdev_dev *evdev, uint16_t type)
538 {
539
540 KASSERT(type < EV_CNT, ("invalid evdev event property"));
541 return (bit_test(evdev->ev_type_flags, type));
542 }
543
544 inline void
evdev_set_absinfo(struct evdev_dev * evdev,uint16_t axis,struct input_absinfo * absinfo)545 evdev_set_absinfo(struct evdev_dev *evdev, uint16_t axis,
546 struct input_absinfo *absinfo)
547 {
548
549 KASSERT(axis < ABS_CNT, ("invalid evdev abs property"));
550
551 if (axis == ABS_MT_SLOT &&
552 (absinfo->maximum < 1 || absinfo->maximum >= MAX_MT_SLOTS))
553 return;
554
555 if (evdev->ev_absinfo == NULL)
556 evdev->ev_absinfo = evdev_alloc_absinfo();
557
558 if (axis == ABS_MT_SLOT)
559 evdev->ev_absinfo[ABS_MT_SLOT].maximum = absinfo->maximum;
560 else
561 memcpy(&evdev->ev_absinfo[axis], absinfo,
562 sizeof(struct input_absinfo));
563 }
564
565 inline void
evdev_set_repeat_params(struct evdev_dev * evdev,uint16_t property,int value)566 evdev_set_repeat_params(struct evdev_dev *evdev, uint16_t property, int value)
567 {
568
569 KASSERT(property < REP_CNT, ("invalid evdev repeat property"));
570 evdev->ev_rep[property] = value;
571 }
572
573 inline void
evdev_set_flag(struct evdev_dev * evdev,uint16_t flag)574 evdev_set_flag(struct evdev_dev *evdev, uint16_t flag)
575 {
576
577 KASSERT(flag < EVDEV_FLAG_CNT, ("invalid evdev flag property"));
578 bit_set(evdev->ev_flags, flag);
579 }
580
581 static int
evdev_check_event(struct evdev_dev * evdev,uint16_t type,uint16_t code,int32_t value)582 evdev_check_event(struct evdev_dev *evdev, uint16_t type, uint16_t code,
583 int32_t value)
584 {
585
586 if (type >= EV_CNT)
587 return (EINVAL);
588
589 /* Allow SYN events implicitly */
590 if (type != EV_SYN && !evdev_event_supported(evdev, type))
591 return (EINVAL);
592
593 switch (type) {
594 case EV_SYN:
595 if (code >= SYN_CNT)
596 return (EINVAL);
597 break;
598
599 case EV_KEY:
600 if (code >= KEY_CNT)
601 return (EINVAL);
602 if (!bit_test(evdev->ev_key_flags, code))
603 return (EINVAL);
604 break;
605
606 case EV_REL:
607 if (code >= REL_CNT)
608 return (EINVAL);
609 if (!bit_test(evdev->ev_rel_flags, code))
610 return (EINVAL);
611 break;
612
613 case EV_ABS:
614 if (code >= ABS_CNT)
615 return (EINVAL);
616 if (!bit_test(evdev->ev_abs_flags, code))
617 return (EINVAL);
618 if (code == ABS_MT_SLOT &&
619 (value < 0 || value > MAXIMAL_MT_SLOT(evdev)))
620 return (EINVAL);
621 if (ABS_IS_MT(code) && evdev->ev_mt == NULL &&
622 bit_test(evdev->ev_abs_flags, ABS_MT_SLOT))
623 return (EINVAL);
624 break;
625
626 case EV_MSC:
627 if (code >= MSC_CNT)
628 return (EINVAL);
629 if (!bit_test(evdev->ev_msc_flags, code))
630 return (EINVAL);
631 break;
632
633 case EV_LED:
634 if (code >= LED_CNT)
635 return (EINVAL);
636 if (!bit_test(evdev->ev_led_flags, code))
637 return (EINVAL);
638 break;
639
640 case EV_SND:
641 if (code >= SND_CNT)
642 return (EINVAL);
643 if (!bit_test(evdev->ev_snd_flags, code))
644 return (EINVAL);
645 break;
646
647 case EV_SW:
648 if (code >= SW_CNT)
649 return (EINVAL);
650 if (!bit_test(evdev->ev_sw_flags, code))
651 return (EINVAL);
652 break;
653
654 case EV_REP:
655 if (code >= REP_CNT)
656 return (EINVAL);
657 break;
658
659 default:
660 return (EINVAL);
661 }
662
663 return (0);
664 }
665
666 static void
evdev_modify_event(struct evdev_dev * evdev,uint16_t type,uint16_t code,int32_t * value)667 evdev_modify_event(struct evdev_dev *evdev, uint16_t type, uint16_t code,
668 int32_t *value)
669 {
670
671 EVDEV_LOCK_ASSERT(evdev);
672
673 switch (type) {
674 case EV_KEY:
675 if (!evdev_event_supported(evdev, EV_REP))
676 break;
677
678 if (!bit_test(evdev->ev_flags, EVDEV_FLAG_SOFTREPEAT)) {
679 /* Detect driver key repeats. */
680 if (bit_test(evdev->ev_key_states, code) &&
681 *value == KEY_EVENT_DOWN)
682 *value = KEY_EVENT_REPEAT;
683 } else {
684 /* Start/stop callout for evdev repeats */
685 if (bit_test(evdev->ev_key_states, code) == !*value &&
686 !LIST_EMPTY(&evdev->ev_clients)) {
687 if (*value == KEY_EVENT_DOWN)
688 evdev_start_repeat(evdev, code);
689 else
690 evdev_stop_repeat(evdev);
691 }
692 }
693 break;
694
695 case EV_ABS:
696 /* TBD: implement fuzz */
697 break;
698 }
699 }
700
701 static enum evdev_sparse_result
evdev_sparse_event(struct evdev_dev * evdev,uint16_t type,uint16_t code,int32_t value)702 evdev_sparse_event(struct evdev_dev *evdev, uint16_t type, uint16_t code,
703 int32_t value)
704 {
705 int32_t last_mt_slot;
706
707 EVDEV_LOCK_ASSERT(evdev);
708
709 /*
710 * For certain event types, update device state bits
711 * and convert level reporting to edge reporting
712 */
713 switch (type) {
714 case EV_KEY:
715 switch (value) {
716 case KEY_EVENT_UP:
717 case KEY_EVENT_DOWN:
718 if (bit_test(evdev->ev_key_states, code) == value)
719 return (EV_SKIP_EVENT);
720 bit_change(evdev->ev_key_states, code, value);
721 break;
722
723 case KEY_EVENT_REPEAT:
724 if (bit_test(evdev->ev_key_states, code) == 0 ||
725 !evdev_event_supported(evdev, EV_REP))
726 return (EV_SKIP_EVENT);
727 break;
728
729 default:
730 return (EV_SKIP_EVENT);
731 }
732 break;
733
734 case EV_LED:
735 if (bit_test(evdev->ev_led_states, code) == value)
736 return (EV_SKIP_EVENT);
737 bit_change(evdev->ev_led_states, code, value);
738 break;
739
740 case EV_SND:
741 bit_change(evdev->ev_snd_states, code, value);
742 break;
743
744 case EV_SW:
745 if (bit_test(evdev->ev_sw_states, code) == value)
746 return (EV_SKIP_EVENT);
747 bit_change(evdev->ev_sw_states, code, value);
748 break;
749
750 case EV_REP:
751 if (evdev->ev_rep[code] == value)
752 return (EV_SKIP_EVENT);
753 evdev_set_repeat_params(evdev, code, value);
754 break;
755
756 case EV_REL:
757 if (value == 0)
758 return (EV_SKIP_EVENT);
759 break;
760
761 /* For EV_ABS, save last value in absinfo and ev_mt_states */
762 case EV_ABS:
763 switch (code) {
764 case ABS_MT_SLOT:
765 /* Postpone ABS_MT_SLOT till next event */
766 evdev_set_last_mt_slot(evdev, value);
767 return (EV_SKIP_EVENT);
768
769 case ABS_MT_FIRST ... ABS_MT_LAST:
770 /* Pass MT protocol type A events as is */
771 if (!bit_test(evdev->ev_abs_flags, ABS_MT_SLOT))
772 break;
773 /* Don`t repeat MT protocol type B events */
774 last_mt_slot = evdev_get_last_mt_slot(evdev);
775 if (evdev_get_mt_value(evdev, last_mt_slot, code)
776 == value)
777 return (EV_SKIP_EVENT);
778 evdev_set_mt_value(evdev, last_mt_slot, code, value);
779 if (last_mt_slot != CURRENT_MT_SLOT(evdev)) {
780 CURRENT_MT_SLOT(evdev) = last_mt_slot;
781 evdev->ev_report_opened = true;
782 return (EV_REPORT_MT_SLOT);
783 }
784 break;
785
786 default:
787 if (evdev->ev_absinfo[code].value == value)
788 return (EV_SKIP_EVENT);
789 evdev->ev_absinfo[code].value = value;
790 }
791 break;
792
793 case EV_SYN:
794 if (code == SYN_REPORT) {
795 /* Count empty reports as well as non empty */
796 evdev->ev_report_count++;
797 /* Skip empty reports */
798 if (!evdev->ev_report_opened)
799 return (EV_SKIP_EVENT);
800 evdev->ev_report_opened = false;
801 return (EV_REPORT_EVENT);
802 }
803 break;
804 }
805
806 evdev->ev_report_opened = true;
807 return (EV_REPORT_EVENT);
808 }
809
810 static void
evdev_propagate_event(struct evdev_dev * evdev,uint16_t type,uint16_t code,int32_t value)811 evdev_propagate_event(struct evdev_dev *evdev, uint16_t type, uint16_t code,
812 int32_t value)
813 {
814 struct evdev_client *client;
815
816 debugf(evdev, "%s pushed event %d/%d/%d",
817 evdev->ev_shortname, type, code, value);
818
819 EVDEV_LOCK_ASSERT(evdev);
820
821 /* Propagate event through all clients */
822 LIST_FOREACH(client, &evdev->ev_clients, ec_link) {
823 if (evdev->ev_grabber != NULL && evdev->ev_grabber != client)
824 continue;
825
826 EVDEV_CLIENT_LOCKQ(client);
827 evdev_client_push(client, type, code, value);
828 if (type == EV_SYN && code == SYN_REPORT)
829 evdev_notify_event(client);
830 EVDEV_CLIENT_UNLOCKQ(client);
831 }
832
833 evdev->ev_event_count++;
834 }
835
836 void
evdev_send_event(struct evdev_dev * evdev,uint16_t type,uint16_t code,int32_t value)837 evdev_send_event(struct evdev_dev *evdev, uint16_t type, uint16_t code,
838 int32_t value)
839 {
840 enum evdev_sparse_result sparse;
841
842 EVDEV_LOCK_ASSERT(evdev);
843
844 sparse = evdev_sparse_event(evdev, type, code, value);
845 switch (sparse) {
846 case EV_REPORT_MT_SLOT:
847 /* report postponed ABS_MT_SLOT */
848 evdev_propagate_event(evdev, EV_ABS, ABS_MT_SLOT,
849 CURRENT_MT_SLOT(evdev));
850 /* FALLTHROUGH */
851 case EV_REPORT_EVENT:
852 evdev_propagate_event(evdev, type, code, value);
853 /* FALLTHROUGH */
854 case EV_SKIP_EVENT:
855 break;
856 }
857 }
858
859 void
evdev_restore_after_kdb(struct evdev_dev * evdev)860 evdev_restore_after_kdb(struct evdev_dev *evdev)
861 {
862 int code;
863
864 EVDEV_LOCK_ASSERT(evdev);
865
866 /* Report postponed leds */
867 for (code = 0; code < LED_CNT; code++)
868 if (bit_test(evdev->ev_kdb_led_states, code))
869 evdev_send_event(evdev, EV_LED, code,
870 !bit_test(evdev->ev_led_states, code));
871 bit_nclear(evdev->ev_kdb_led_states, 0, LED_MAX);
872
873 /* Release stuck keys (CTRL + ALT + ESC) */
874 evdev_stop_repeat(evdev);
875 for (code = 0; code < KEY_CNT; code++) {
876 if (bit_test(evdev->ev_key_states, code)) {
877 evdev_send_event(evdev, EV_KEY, code, KEY_EVENT_UP);
878 evdev_send_event(evdev, EV_SYN, SYN_REPORT, 1);
879 }
880 }
881 }
882
883 int
evdev_push_event(struct evdev_dev * evdev,uint16_t type,uint16_t code,int32_t value)884 evdev_push_event(struct evdev_dev *evdev, uint16_t type, uint16_t code,
885 int32_t value)
886 {
887
888 if (evdev_check_event(evdev, type, code, value) != 0)
889 return (EINVAL);
890
891 /*
892 * Discard all but LEDs kdb events as unrelated to userspace.
893 * Aggregate LED updates and postpone reporting until kdb deactivation.
894 */
895 if (kdb_active || SCHEDULER_STOPPED()) {
896 evdev->ev_kdb_active = true;
897 if (type == EV_LED)
898 bit_set(evdev->ev_kdb_led_states,
899 bit_test(evdev->ev_led_states, code) != value);
900 return (0);
901 }
902
903 EVDEV_ENTER(evdev);
904
905 /* Fix evdev state corrupted with discarding of kdb events */
906 if (evdev->ev_kdb_active) {
907 evdev->ev_kdb_active = false;
908 evdev_restore_after_kdb(evdev);
909 }
910
911 evdev_modify_event(evdev, type, code, &value);
912 if (type == EV_SYN && code == SYN_REPORT &&
913 bit_test(evdev->ev_flags, EVDEV_FLAG_MT_AUTOREL))
914 evdev_send_mt_autorel(evdev);
915 if (type == EV_SYN && code == SYN_REPORT && evdev->ev_report_opened &&
916 bit_test(evdev->ev_flags, EVDEV_FLAG_MT_STCOMPAT))
917 evdev_send_mt_compat(evdev);
918 evdev_send_event(evdev, type, code, value);
919
920 EVDEV_EXIT(evdev);
921
922 return (0);
923 }
924
925 int
evdev_inject_event(struct evdev_dev * evdev,uint16_t type,uint16_t code,int32_t value)926 evdev_inject_event(struct evdev_dev *evdev, uint16_t type, uint16_t code,
927 int32_t value)
928 {
929 int ret = 0;
930
931 switch (type) {
932 case EV_REP:
933 /* evdev repeats should not be processed by hardware driver */
934 if (bit_test(evdev->ev_flags, EVDEV_FLAG_SOFTREPEAT))
935 goto push;
936 /* FALLTHROUGH */
937 case EV_LED:
938 case EV_MSC:
939 case EV_SND:
940 case EV_FF:
941 if (evdev->ev_methods != NULL &&
942 evdev->ev_methods->ev_event != NULL)
943 evdev->ev_methods->ev_event(evdev, type, code, value);
944 /*
945 * Leds and driver repeats should be reported in ev_event
946 * method body to interoperate with kbdmux states and rates
947 * propagation so both ways (ioctl and evdev) of changing it
948 * will produce only one evdev event report to client.
949 */
950 if (type == EV_LED || type == EV_REP)
951 break;
952 /* FALLTHROUGH */
953 case EV_SYN:
954 case EV_KEY:
955 case EV_REL:
956 case EV_ABS:
957 case EV_SW:
958 push:
959 if (evdev->ev_lock_type != EV_LOCK_INTERNAL)
960 EVDEV_LOCK(evdev);
961 ret = evdev_push_event(evdev, type, code, value);
962 if (evdev->ev_lock_type != EV_LOCK_INTERNAL)
963 EVDEV_UNLOCK(evdev);
964 break;
965
966 default:
967 ret = EINVAL;
968 }
969
970 return (ret);
971 }
972
973 int
evdev_register_client(struct evdev_dev * evdev,struct evdev_client * client)974 evdev_register_client(struct evdev_dev *evdev, struct evdev_client *client)
975 {
976 int ret = 0;
977
978 debugf(evdev, "adding new client for device %s", evdev->ev_shortname);
979
980 EVDEV_LOCK_ASSERT(evdev);
981
982 if (LIST_EMPTY(&evdev->ev_clients) && evdev->ev_methods != NULL &&
983 evdev->ev_methods->ev_open != NULL) {
984 debugf(evdev, "calling ev_open() on device %s",
985 evdev->ev_shortname);
986 ret = evdev->ev_methods->ev_open(evdev);
987 }
988 if (ret == 0)
989 LIST_INSERT_HEAD(&evdev->ev_clients, client, ec_link);
990 return (ret);
991 }
992
993 void
evdev_dispose_client(struct evdev_dev * evdev,struct evdev_client * client)994 evdev_dispose_client(struct evdev_dev *evdev, struct evdev_client *client)
995 {
996 debugf(evdev, "removing client for device %s", evdev->ev_shortname);
997
998 EVDEV_LOCK_ASSERT(evdev);
999
1000 LIST_REMOVE(client, ec_link);
1001 if (LIST_EMPTY(&evdev->ev_clients)) {
1002 if (evdev->ev_methods != NULL &&
1003 evdev->ev_methods->ev_close != NULL)
1004 (void)evdev->ev_methods->ev_close(evdev);
1005 if (evdev_event_supported(evdev, EV_REP) &&
1006 bit_test(evdev->ev_flags, EVDEV_FLAG_SOFTREPEAT))
1007 evdev_stop_repeat(evdev);
1008 }
1009 evdev_release_client(evdev, client);
1010 }
1011
1012 int
evdev_grab_client(struct evdev_dev * evdev,struct evdev_client * client)1013 evdev_grab_client(struct evdev_dev *evdev, struct evdev_client *client)
1014 {
1015
1016 EVDEV_LOCK_ASSERT(evdev);
1017
1018 if (evdev->ev_grabber != NULL)
1019 return (EBUSY);
1020
1021 evdev->ev_grabber = client;
1022
1023 return (0);
1024 }
1025
1026 int
evdev_release_client(struct evdev_dev * evdev,struct evdev_client * client)1027 evdev_release_client(struct evdev_dev *evdev, struct evdev_client *client)
1028 {
1029
1030 EVDEV_LOCK_ASSERT(evdev);
1031
1032 if (evdev->ev_grabber != client)
1033 return (EINVAL);
1034
1035 evdev->ev_grabber = NULL;
1036
1037 return (0);
1038 }
1039
1040 static void
evdev_repeat_callout(void * arg)1041 evdev_repeat_callout(void *arg)
1042 {
1043 struct evdev_dev *evdev = (struct evdev_dev *)arg;
1044
1045 evdev_send_event(evdev, EV_KEY, evdev->ev_rep_key, KEY_EVENT_REPEAT);
1046 evdev_send_event(evdev, EV_SYN, SYN_REPORT, 1);
1047
1048 if (evdev->ev_rep[REP_PERIOD])
1049 callout_reset(&evdev->ev_rep_callout,
1050 evdev->ev_rep[REP_PERIOD] * hz / 1000,
1051 evdev_repeat_callout, evdev);
1052 else
1053 evdev->ev_rep_key = KEY_RESERVED;
1054 }
1055
1056 static void
evdev_start_repeat(struct evdev_dev * evdev,uint16_t key)1057 evdev_start_repeat(struct evdev_dev *evdev, uint16_t key)
1058 {
1059
1060 EVDEV_LOCK_ASSERT(evdev);
1061
1062 if (evdev->ev_rep[REP_DELAY]) {
1063 evdev->ev_rep_key = key;
1064 callout_reset(&evdev->ev_rep_callout,
1065 evdev->ev_rep[REP_DELAY] * hz / 1000,
1066 evdev_repeat_callout, evdev);
1067 }
1068 }
1069
1070 static void
evdev_stop_repeat(struct evdev_dev * evdev)1071 evdev_stop_repeat(struct evdev_dev *evdev)
1072 {
1073
1074 EVDEV_LOCK_ASSERT(evdev);
1075
1076 if (evdev->ev_rep_key != KEY_RESERVED) {
1077 callout_stop(&evdev->ev_rep_callout);
1078 evdev->ev_rep_key = KEY_RESERVED;
1079 }
1080 }
1081
1082 MODULE_VERSION(evdev, 1);
1083