sys/dev/evdev/evdev.c

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