source: rtems-libbsd/freebsd/sys/dev/evdev/evdev.c @ 18cf428

55-freebsd-126-freebsd-12
Last change on this file since 18cf428 was 18cf428, checked in by Kevin Kirspel <kevin-kirspel@…>, on May 17, 2017 at 12:40:31 PM

Modify FREEBSD EVDEV driver for use in RTEMS

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