sys/dev/misc/evdev/cdev.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/types.h>
  33 #include <sys/module.h>
  34 #include <sys/devfs.h>
  35
  36 #include <sys/param.h>
  37 #include <sys/conf.h>
  38 #include <sys/filio.h>
  39 #include <sys/fcntl.h>
  40 #include <sys/kernel.h>
  41 #include <sys/malloc.h>
  42 #include <sys/poll.h>
  43 #include <sys/proc.h>
  44 #include <sys/systm.h>
  45 #include <sys/time.h>
  46 #include <sys/vnode.h> /* IO_NDELAY in read() */
  47 #include <sys/uio.h>
  48
  49 #include <sys/errno.h>
  50
  51 #include <sys/device.h>
  52 #include <sys/bus.h>
  53
  54 /* Use FreeBSD bitstring locally. */
  55 #include "freebsd-bitstring.h"
  56
  57 #include <dev/misc/evdev/evdev.h>
  58 #include <dev/misc/evdev/evdev_private.h>
  59 #include <dev/misc/evdev/input.h>
  60
  61 #ifdef EVDEV_DEBUG
  62 #define debugf(client, fmt, args...)    kprintf("evdev cdev: "fmt"\n", ##args)
  63 #else
  64 #define debugf(client, fmt, args...)
  65 #endif
  66
  67 #define DEF_RING_REPORTS        8
  68
  69 static d_open_t         evdev_open;
  70 static d_read_t         evdev_read;
  71 static d_write_t        evdev_write;
  72 static d_ioctl_t        evdev_ioctl;
  73 static d_kqfilter_t     evdev_kqfilter;
  74
  75 static int evdev_kqread(struct knote *kn, long hint);
  76 static void evdev_kqdetach(struct knote *kn);
  77 static void evdev_dtor(void *);
  78 static int evdev_ioctl_eviocgbit(struct evdev_dev *, int, int, caddr_t);
  79 static void evdev_client_filter_queue(struct evdev_client *, uint16_t);
  80
  81 static struct dev_ops evdev_cdevsw = {
  82         { "evdev", 0, 0 },
  83         .d_open = evdev_open,
  84         .d_read = evdev_read,
  85         .d_write = evdev_write,
  86         .d_ioctl = evdev_ioctl,
  87         .d_kqfilter = evdev_kqfilter,
  88 };
  89
  90 static struct filterops evdev_cdev_filterops = {
  91         .f_flags = FILTEROP_ISFD,
  92         .f_attach = NULL,
  93         .f_detach = evdev_kqdetach,
  94         .f_event = evdev_kqread,
  95 };
  96
  97 static int
  98 evdev_open(struct dev_open_args *ap)
  99 {
 100         cdev_t dev = ap->a_head.a_dev;
 101         struct evdev_dev *evdev = dev->si_drv1;
 102         struct evdev_client *client;
 103         size_t buffer_size;
 104         int ret;
 105
 106         if (evdev == NULL)
 107                 return (ENODEV);
 108
 109         /* Initialize client structure */
 110         buffer_size = evdev->ev_report_size * DEF_RING_REPORTS;
 111         client = kmalloc(offsetof(struct evdev_client, ec_buffer) +
 112             sizeof(struct input_event) * buffer_size,
 113             M_EVDEV, M_WAITOK | M_ZERO);
 114
 115         /* Initialize ring buffer */
 116         client->ec_buffer_size = buffer_size;
 117         client->ec_buffer_head = 0;
 118         client->ec_buffer_tail = 0;
 119         client->ec_buffer_ready = 0;
 120
 121         client->ec_evdev = evdev;
 122         lockinit(&client->ec_buffer_mtx, "evclient", 0, LK_CANRECURSE);
 123
 124         /* Avoid race with evdev_unregister */
 125         EVDEV_LOCK(evdev);
 126         if (dev->si_drv1 == NULL)
 127                 ret = ENODEV;
 128         else
 129                 ret = evdev_register_client(evdev, client);
 130
 131         if (ret != 0)
 132                 evdev_revoke_client(client);
 133         /*
 134          * Unlock evdev here because non-sleepable lock held
 135          * while calling devfs_set_cdevpriv upsets WITNESS
 136          */
 137         EVDEV_UNLOCK(evdev);
 138
 139         if (!ret)
 140                 ret = devfs_set_cdevpriv(ap->a_fp, client, &evdev_dtor);
 141
 142         if (ret != 0) {
 143                 debugf(client, "cannot register evdev client");
 144         }
 145
 146         return (ret);
 147 }
 148
 149 static void
 150 evdev_dtor(void *data)
 151 {
 152         struct evdev_client *client = (struct evdev_client *)data;
 153
 154         EVDEV_LOCK(client->ec_evdev);
 155         if (!client->ec_revoked)
 156                 evdev_dispose_client(client->ec_evdev, client);
 157         EVDEV_UNLOCK(client->ec_evdev);
 158
 159         funsetown(&client->ec_sigio);
 160         lockuninit(&client->ec_buffer_mtx);
 161         kfree(client, M_EVDEV);
 162 }
 163
 164 static int
 165 evdev_read(struct dev_read_args *ap)
 166 {
 167         struct uio *uio = ap->a_uio;
 168         int ioflag = ap->a_ioflag;
 169         struct evdev_client *client;
 170         struct input_event event;
 171         int ret = 0;
 172         int remaining;
 173
 174         ret = devfs_get_cdevpriv(ap->a_fp, (void **)&client);
 175         if (ret != 0)
 176                 return (ret);
 177
 178         debugf(client, "read %zd bytes by thread %d", uio->uio_resid, 0);
 179
 180         if (client->ec_revoked)
 181                 return (ENODEV);
 182
 183         /* Zero-sized reads are allowed for error checking */
 184         if (uio->uio_resid != 0 && uio->uio_resid < sizeof(struct input_event))
 185                 return (EINVAL);
 186
 187         remaining = uio->uio_resid / sizeof(struct input_event);
 188
 189         EVDEV_CLIENT_LOCKQ(client);
 190
 191         if (EVDEV_CLIENT_EMPTYQ(client)) {
 192                 if (ioflag & IO_NDELAY) {
 193                         ret = EWOULDBLOCK;
 194                 } else {
 195                         if (remaining != 0) {
 196                                 client->ec_blocked = true;
 197                                 ret = lksleep(client, &client->ec_buffer_mtx,
 198                                     PCATCH, "evread", 0);
 199                         }
 200                 }
 201         }
 202
 203         while (ret == 0 && !EVDEV_CLIENT_EMPTYQ(client) && remaining > 0) {
 204                 memcpy(&event, &client->ec_buffer[client->ec_buffer_head],
 205                     sizeof(struct input_event));
 206                 client->ec_buffer_head =
 207                     (client->ec_buffer_head + 1) % client->ec_buffer_size;
 208                 remaining--;
 209
 210                 EVDEV_CLIENT_UNLOCKQ(client);
 211                 ret = uiomove((void *)&event, sizeof(struct input_event), uio);
 212                 EVDEV_CLIENT_LOCKQ(client);
 213         }
 214
 215         EVDEV_CLIENT_UNLOCKQ(client);
 216
 217         return (ret);
 218 }
 219
 220 static int
 221 evdev_write(struct dev_write_args *ap)
 222 {
 223         cdev_t dev = ap->a_head.a_dev;
 224         struct uio *uio = ap->a_uio;
 225         struct evdev_dev *evdev = dev->si_drv1;
 226         struct evdev_client *client;
 227         struct input_event event;
 228         int ret = 0;
 229
 230         ret = devfs_get_cdevpriv(ap->a_fp, (void **)&client);
 231         if (ret != 0)
 232                 return (ret);
 233
 234         debugf(client, "write %zd bytes by thread %d", uio->uio_resid, 0);
 235
 236         if (client->ec_revoked || evdev == NULL)
 237                 return (ENODEV);
 238
 239         if (uio->uio_resid % sizeof(struct input_event) != 0) {
 240                 debugf(client, "write size not multiple of input_event size");
 241                 return (EINVAL);
 242         }
 243
 244         while (uio->uio_resid > 0 && ret == 0) {
 245                 ret = uiomove((void *)&event, sizeof(struct input_event), uio);
 246                 if (ret == 0)
 247                         ret = evdev_inject_event(evdev, event.type, event.code,
 248                             event.value);
 249         }
 250
 251         return (ret);
 252 }
 253
 254 static int
 255 evdev_kqfilter(struct dev_kqfilter_args *ap)
 256 {
 257         struct knote *kn = ap->a_kn;
 258         struct klist *klist;
 259         struct evdev_client *client;
 260         int ret;
 261
 262         ret = devfs_get_cdevpriv(ap->a_fp, (void **)&client);
 263         if (ret != 0)
 264                 return (ret);
 265
 266         if (client->ec_revoked)
 267                 return (ENODEV);
 268
 269         switch(kn->kn_filter) {
 270         case EVFILT_READ:
 271                 kn->kn_fop = &evdev_cdev_filterops;
 272                 break;
 273         default:
 274                 return(EINVAL);
 275         }
 276         kn->kn_hook = (caddr_t)client;
 277
 278         klist = &client->kqinfo.ki_note;
 279         knote_insert(klist, kn);
 280         return (0);
 281 }
 282
 283 static int
 284 evdev_kqread(struct knote *kn, long hint)
 285 {
 286         struct evdev_client *client;
 287         int ret;
 288         int locked = 0;
 289
 290         client = (struct evdev_client *)kn->kn_hook;
 291
 292         /* NOTE on DragonFly v FreeBSD.
 293          * FreeBSD locks the klist when calling f_event, i.e. evdev_kqread().
 294          * That's why the plain assertion EVDEV_CLIENT_LOCKQ_ASSERT(client)
 295          * fails on DragonFly: DragonFly does not ensure the lock associated
 296          * with the klist is locked.
 297          * To mimic FreeBSD's behavior, we will lock ec_buffer_mtx if
 298          * it was not locked, and unlock when leaving.
 299          */
 300         locked = lockowned(&(client)->ec_buffer_mtx);
 301         if (!locked)
 302                 EVDEV_CLIENT_LOCKQ(client);
 303
 304         EVDEV_CLIENT_LOCKQ_ASSERT(client);
 305
 306         if (client->ec_revoked) {
 307                 kn->kn_flags |= EV_EOF;
 308                 ret = 1;
 309         } else {
 310                 kn->kn_data = EVDEV_CLIENT_SIZEQ(client) *
 311                     sizeof(struct input_event);
 312                 ret = !EVDEV_CLIENT_EMPTYQ(client);
 313         }
 314
 315         /* Unlock if ec_buffer_mtx was not locked. */
 316         if (!locked) {
 317                 EVDEV_CLIENT_UNLOCKQ(client);
 318         }
 319
 320         return (ret);
 321 }
 322
 323 static void
 324 evdev_kqdetach(struct knote *kn)
 325 {
 326         struct evdev_client *client;
 327
 328         client = (struct evdev_client *)kn->kn_hook;
 329         knote_remove(&client->kqinfo.ki_note, kn);
 330 }
 331
 332 static int
 333 evdev_ioctl(struct dev_ioctl_args *ap)
 334 {
 335         cdev_t dev = ap->a_head.a_dev;
 336         u_long cmd = ap->a_cmd;
 337         caddr_t data = ap->a_data;
 338         struct evdev_dev *evdev = dev->si_drv1;
 339         struct evdev_client *client;
 340         struct input_keymap_entry *ke;
 341         int ret, len, limit, type_num;
 342         uint32_t code;
 343         size_t nvalues;
 344
 345         ret = devfs_get_cdevpriv(ap->a_fp, (void **)&client);
 346         if (ret != 0)
 347                 return (ret);
 348
 349         if (client->ec_revoked || evdev == NULL)
 350                 return (ENODEV);
 351
 352         /* file I/O ioctl handling */
 353         switch (cmd) {
 354         case FIOSETOWN:
 355                 return (fsetown(*(int *)data, &client->ec_sigio));
 356
 357         case FIOGETOWN:
 358                 *(int *)data = fgetown(&client->ec_sigio);
 359                 return (0);
 360
 361         case FIONBIO:
 362                 return (0);
 363
 364         case FIOASYNC:
 365                 if (*(int *)data)
 366                         client->ec_async = true;
 367                 else
 368                         client->ec_async = false;
 369
 370                 return (0);
 371
 372         case FIONREAD:
 373                 EVDEV_CLIENT_LOCKQ(client);
 374                 *(int *)data =
 375                     EVDEV_CLIENT_SIZEQ(client) * sizeof(struct input_event);
 376                 EVDEV_CLIENT_UNLOCKQ(client);
 377                 return (0);
 378         }
 379
 380         len = IOCPARM_LEN(cmd);
 381         debugf(client, "ioctl called: cmd=0x%08lx, data=%p", cmd, data);
 382
 383         /* evdev fixed-length ioctls handling */
 384         switch (cmd) {
 385         case EVIOCGVERSION:
 386                 *(int *)data = EV_VERSION;
 387                 return (0);
 388
 389         case EVIOCGID:
 390                 debugf(client, "EVIOCGID: bus=%d vendor=0x%04x product=0x%04x",
 391                     evdev->ev_id.bustype, evdev->ev_id.vendor,
 392                     evdev->ev_id.product);
 393                 memcpy(data, &evdev->ev_id, sizeof(struct input_id));
 394                 return (0);
 395
 396         case EVIOCGREP:
 397                 if (!evdev_event_supported(evdev, EV_REP))
 398                         return (ENOTSUP);
 399
 400                 memcpy(data, evdev->ev_rep, sizeof(evdev->ev_rep));
 401                 return (0);
 402
 403         case EVIOCSREP:
 404                 if (!evdev_event_supported(evdev, EV_REP))
 405                         return (ENOTSUP);
 406
 407                 evdev_inject_event(evdev, EV_REP, REP_DELAY, ((int *)data)[0]);
 408                 evdev_inject_event(evdev, EV_REP, REP_PERIOD,
 409                     ((int *)data)[1]);
 410                 return (0);
 411
 412         case EVIOCGKEYCODE:
 413                 /* Fake unsupported ioctl */
 414                 return (0);
 415
 416         case EVIOCGKEYCODE_V2:
 417                 if (evdev->ev_methods == NULL ||
 418                     evdev->ev_methods->ev_get_keycode == NULL)
 419                         return (ENOTSUP);
 420
 421                 ke = (struct input_keymap_entry *)data;
 422                 evdev->ev_methods->ev_get_keycode(evdev, evdev->ev_softc, ke);
 423                 return (0);
 424
 425         case EVIOCSKEYCODE:
 426                 /* Fake unsupported ioctl */
 427                 return (0);
 428
 429         case EVIOCSKEYCODE_V2:
 430                 if (evdev->ev_methods == NULL ||
 431                     evdev->ev_methods->ev_set_keycode == NULL)
 432                         return (ENOTSUP);
 433
 434                 ke = (struct input_keymap_entry *)data;
 435                 evdev->ev_methods->ev_set_keycode(evdev, evdev->ev_softc, ke);
 436                 return (0);
 437
 438         case EVIOCGABS(0) ... EVIOCGABS(ABS_MAX):
 439                 if (evdev->ev_absinfo == NULL)
 440                         return (EINVAL);
 441
 442                 memcpy(data, &evdev->ev_absinfo[cmd - EVIOCGABS(0)],
 443                     sizeof(struct input_absinfo));
 444                 return (0);
 445
 446         case EVIOCSABS(0) ... EVIOCSABS(ABS_MAX):
 447                 if (evdev->ev_absinfo == NULL)
 448                         return (EINVAL);
 449
 450                 code = cmd - EVIOCSABS(0);
 451                 /* mt-slot number can not be changed */
 452                 if (code == ABS_MT_SLOT)
 453                         return (EINVAL);
 454
 455                 EVDEV_LOCK(evdev);
 456                 evdev_set_absinfo(evdev, code, (struct input_absinfo *)data);
 457                 EVDEV_UNLOCK(evdev);
 458                 return (0);
 459
 460         case EVIOCSFF:
 461         case EVIOCRMFF:
 462         case EVIOCGEFFECTS:
 463                 /* Fake unsupported ioctls */
 464                 return (0);
 465
 466         case EVIOCGRAB:
 467                 EVDEV_LOCK(evdev);
 468                 if (*(int *)data)
 469                         ret = evdev_grab_client(evdev, client);
 470                 else
 471                         ret = evdev_release_client(evdev, client);
 472                 EVDEV_UNLOCK(evdev);
 473                 return (ret);
 474
 475         case EVIOCREVOKE:
 476                 if (*(int *)data != 0)
 477                         return (EINVAL);
 478
 479                 EVDEV_LOCK(evdev);
 480                 if (dev->si_drv1 != NULL && !client->ec_revoked) {
 481                         evdev_dispose_client(evdev, client);
 482                         evdev_revoke_client(client);
 483                 }
 484                 EVDEV_UNLOCK(evdev);
 485                 return (0);
 486
 487         case EVIOCSCLOCKID:
 488                 switch (*(int *)data) {
 489                 case CLOCK_REALTIME:
 490                         client->ec_clock_id = EV_CLOCK_REALTIME;
 491                         return (0);
 492                 case CLOCK_MONOTONIC:
 493                         client->ec_clock_id = EV_CLOCK_MONOTONIC;
 494                         return (0);
 495                 default:
 496                         return (EINVAL);
 497                 }
 498         }
 499
 500         /* evdev variable-length ioctls handling */
 501         switch (IOCBASECMD(cmd)) {
 502         case EVIOCGNAME(0):
 503                 strlcpy(data, evdev->ev_name, len);
 504                 return (0);
 505
 506         case EVIOCGPHYS(0):
 507                 if (evdev->ev_shortname[0] == 0)
 508                         return (ENOENT);
 509
 510                 strlcpy(data, evdev->ev_shortname, len);
 511                 return (0);
 512
 513         case EVIOCGUNIQ(0):
 514                 if (evdev->ev_serial[0] == 0)
 515                         return (ENOENT);
 516
 517                 strlcpy(data, evdev->ev_serial, len);
 518                 return (0);
 519
 520         case EVIOCGPROP(0):
 521                 limit = MIN(len, bitstr_size(INPUT_PROP_CNT));
 522                 memcpy(data, evdev->ev_prop_flags, limit);
 523                 return (0);
 524
 525         case EVIOCGMTSLOTS(0):
 526                 if (evdev->ev_mt == NULL)
 527                         return (EINVAL);
 528                 if (len < sizeof(uint32_t))
 529                         return (EINVAL);
 530                 code = *(uint32_t *)data;
 531                 if (!ABS_IS_MT(code))
 532                         return (EINVAL);
 533
 534                 nvalues =
 535                     MIN(len / sizeof(int32_t) - 1, MAXIMAL_MT_SLOT(evdev) + 1);
 536                 for (int i = 0; i < nvalues; i++)
 537                         ((int32_t *)data)[i + 1] =
 538                             evdev_get_mt_value(evdev, i, code);
 539                 return (0);
 540
 541         case EVIOCGKEY(0):
 542                 limit = MIN(len, bitstr_size(KEY_CNT));
 543                 EVDEV_LOCK(evdev);
 544                 evdev_client_filter_queue(client, EV_KEY);
 545                 memcpy(data, evdev->ev_key_states, limit);
 546                 EVDEV_UNLOCK(evdev);
 547                 return (0);
 548
 549         case EVIOCGLED(0):
 550                 limit = MIN(len, bitstr_size(LED_CNT));
 551                 EVDEV_LOCK(evdev);
 552                 evdev_client_filter_queue(client, EV_LED);
 553                 memcpy(data, evdev->ev_led_states, limit);
 554                 EVDEV_UNLOCK(evdev);
 555                 return (0);
 556
 557         case EVIOCGSND(0):
 558                 limit = MIN(len, bitstr_size(SND_CNT));
 559                 EVDEV_LOCK(evdev);
 560                 evdev_client_filter_queue(client, EV_SND);
 561                 memcpy(data, evdev->ev_snd_states, limit);
 562                 EVDEV_UNLOCK(evdev);
 563                 return (0);
 564
 565         case EVIOCGSW(0):
 566                 limit = MIN(len, bitstr_size(SW_CNT));
 567                 EVDEV_LOCK(evdev);
 568                 evdev_client_filter_queue(client, EV_SW);
 569                 memcpy(data, evdev->ev_sw_states, limit);
 570                 EVDEV_UNLOCK(evdev);
 571                 return (0);
 572
 573         case EVIOCGBIT(0, 0) ... EVIOCGBIT(EV_MAX, 0):
 574                 type_num = IOCBASECMD(cmd) - EVIOCGBIT(0, 0);
 575                 debugf(client, "EVIOCGBIT(%d): data=%p, len=%d", type_num,
 576                     data, len);
 577                 return (evdev_ioctl_eviocgbit(evdev, type_num, len, data));
 578         }
 579
 580         return (EINVAL);
 581 }
 582
 583 static int
 584 evdev_ioctl_eviocgbit(struct evdev_dev *evdev, int type, int len, caddr_t data)
 585 {
 586         /*
 587          * We will use freebsd-bitstring.h locally. This ensures bitmap
 588          * is of type (unsigned long *). DragonFly's original bitmap
 589          * is (unsigned char *).
 590          */
 591         unsigned long *bitmap;
 592         int limit;
 593
 594         switch (type) {
 595         case 0:
 596                 bitmap = evdev->ev_type_flags;
 597                 limit = EV_CNT;
 598                 break;
 599         case EV_KEY:
 600                 bitmap = evdev->ev_key_flags;
 601                 limit = KEY_CNT;
 602                 break;
 603         case EV_REL:
 604                 bitmap = evdev->ev_rel_flags;
 605                 limit = REL_CNT;
 606                 break;
 607         case EV_ABS:
 608                 bitmap = evdev->ev_abs_flags;
 609                 limit = ABS_CNT;
 610                 break;
 611         case EV_MSC:
 612                 bitmap = evdev->ev_msc_flags;
 613                 limit = MSC_CNT;
 614                 break;
 615         case EV_LED:
 616                 bitmap = evdev->ev_led_flags;
 617                 limit = LED_CNT;
 618                 break;
 619         case EV_SND:
 620                 bitmap = evdev->ev_snd_flags;
 621                 limit = SND_CNT;
 622                 break;
 623         case EV_SW:
 624                 bitmap = evdev->ev_sw_flags;
 625                 limit = SW_CNT;
 626                 break;
 627         case EV_FF:
 628                 /*
 629                  * We don't support EV_FF now, so let's
 630                  * just fake it returning only zeros.
 631                  */
 632                 bzero(data, len);
 633                 return (0);
 634         default:
 635                 return (ENOTTY);
 636         }
 637
 638         /*
 639          * Clear ioctl data buffer in case it's bigger than
 640          * bitmap size
 641          */
 642         bzero(data, len);
 643
 644         limit = bitstr_size(limit);
 645         len = MIN(limit, len);
 646         memcpy(data, bitmap, len);
 647         return (0);
 648 }
 649
 650 void
 651 evdev_revoke_client(struct evdev_client *client)
 652 {
 653
 654         EVDEV_LOCK_ASSERT(client->ec_evdev);
 655
 656         client->ec_revoked = true;
 657 }
 658
 659 void
 660 evdev_notify_event(struct evdev_client *client)
 661 {
 662
 663         EVDEV_CLIENT_LOCKQ_ASSERT(client);
 664
 665         if (client->ec_blocked) {
 666                 client->ec_blocked = false;
 667                 wakeup(client);
 668         }
 669         if (client->ec_selected) {
 670                 client->ec_selected = false;
 671                 wakeup(&client->kqinfo);
 672         }
 673
 674         KNOTE(&client->kqinfo.ki_note, 0);
 675
 676         if (client->ec_async && client->ec_sigio != NULL)
 677                 pgsigio(client->ec_sigio, SIGIO, 0);
 678 }
 679
 680 int
 681 evdev_cdev_create(struct evdev_dev *evdev)
 682 {
 683         cdev_t dev;
 684         int ret, unit;
 685
 686         /*
 687          * Iterate over devices input/eventX until we find a non-existing
 688          * one and record its number in unit.
 689          */
 690         unit = 0;
 691         while (devfs_find_device_by_name("input/event%d", unit) != NULL) {
 692             unit++;
 693         }
 694
 695         /*
 696          * Put unit as minor. Minor and major will determine st_rdev of
 697          * eventX. Ensuring that all eventX have different major and minor
 698          * will make st_rdev unique. This is needed by libinput, which
 699          * determines eventX from st_rdev.
 700          */
 701         dev = make_dev(&evdev_cdevsw, unit, UID_ROOT, GID_WHEEL, 0600,
 702             "input/event%d", unit);
 703
 704         if (dev != NULL) {
 705                 dev->si_drv1 = evdev;
 706                 evdev->ev_cdev = dev;
 707                 evdev->ev_unit = unit;
 708                 ret = 0;
 709         } else {
 710                 ret = ENODEV;
 711                 goto err;
 712         }
 713
 714         reference_dev(evdev->ev_cdev);
 715
 716 err:
 717         return (ret);
 718 }
 719
 720 int
 721 evdev_cdev_destroy(struct evdev_dev *evdev)
 722 {
 723
 724         if (evdev->ev_cdev) {
 725                 dev_ops_remove_minor(&evdev_cdevsw, evdev->ev_unit);
 726         }
 727
 728         return (0);
 729 }
 730
 731 static void
 732 evdev_client_gettime(struct evdev_client *client, struct timeval *tv)
 733 {
 734
 735         switch (client->ec_clock_id) {
 736         case EV_CLOCK_BOOTTIME:
 737                 /*
 738                  * XXX: FreeBSD does not support true POSIX monotonic clock.
 739                  *      So aliase EV_CLOCK_BOOTTIME to EV_CLOCK_MONOTONIC.
 740                  */
 741         case EV_CLOCK_MONOTONIC:
 742                 microuptime(tv);
 743                 break;
 744
 745         case EV_CLOCK_REALTIME:
 746         default:
 747                 microtime(tv);
 748                 break;
 749         }
 750 }
 751
 752 void
 753 evdev_client_push(struct evdev_client *client, uint16_t type, uint16_t code,
 754     int32_t value)
 755 {
 756         struct timeval time;
 757         size_t count, head, tail, ready;
 758
 759         EVDEV_CLIENT_LOCKQ_ASSERT(client);
 760         head = client->ec_buffer_head;
 761         tail = client->ec_buffer_tail;
 762         ready = client->ec_buffer_ready;
 763         count = client->ec_buffer_size;
 764
 765         /* If queue is full drop its content and place SYN_DROPPED event */
 766         if ((tail + 1) % count == head) {
 767                 debugf(client, "client %p: buffer overflow", client);
 768
 769                 head = (tail + count - 1) % count;
 770                 client->ec_buffer[head] = (struct input_event) {
 771                         .type = EV_SYN,
 772                         .code = SYN_DROPPED,
 773                         .value = 0
 774                 };
 775                 /*
 776                  * XXX: Here is a small race window from now till the end of
 777                  *      report. The queue is empty but client has been already
 778                  *      notified of data readyness. Can be fixed in two ways:
 779                  * 1. Implement bulk insert so queue lock would not be dropped
 780                  *    till the SYN_REPORT event.
 781                  * 2. Insert SYN_REPORT just now and skip remaining events
 782                  */
 783                 client->ec_buffer_head = head;
 784                 client->ec_buffer_ready = head;
 785         }
 786
 787         client->ec_buffer[tail].type = type;
 788         client->ec_buffer[tail].code = code;
 789         client->ec_buffer[tail].value = value;
 790         client->ec_buffer_tail = (tail + 1) % count;
 791
 792         /* Allow users to read events only after report has been completed */
 793         if (type == EV_SYN && code == SYN_REPORT) {
 794                 evdev_client_gettime(client, &time);
 795                 for (; ready != client->ec_buffer_tail;
 796                     ready = (ready + 1) % count)
 797                         client->ec_buffer[ready].time = time;
 798                 client->ec_buffer_ready = client->ec_buffer_tail;
 799         }
 800 }
 801
 802 void
 803 evdev_client_dumpqueue(struct evdev_client *client)
 804 {
 805         struct input_event *event;
 806         size_t i, head, tail, ready, size;
 807
 808         head = client->ec_buffer_head;
 809         tail = client->ec_buffer_tail;
 810         ready = client->ec_buffer_ready;
 811         size = client->ec_buffer_size;
 812
 813         kprintf("evdev client: %p\n", client);
 814         kprintf("event queue: head=%zu ready=%zu tail=%zu size=%zu\n",
 815             head, ready, tail, size);
 816
 817         kprintf("queue contents:\n");
 818
 819         for (i = 0; i < size; i++) {
 820                 event = &client->ec_buffer[i];
 821                 kprintf("%zu: ", i);
 822
 823                 if (i < head || i > tail)
 824                         kprintf("unused\n");
 825                 else
 826                         kprintf("type=%d code=%d value=%d ", event->type,
 827                             event->code, event->value);
 828
 829                 if (i == head)
 830                         kprintf("<- head\n");
 831                 else if (i == tail)
 832                         kprintf("<- tail\n");
 833                 else if (i == ready)
 834                         kprintf("<- ready\n");
 835                 else
 836                         kprintf("\n");
 837         }
 838 }
 839
 840 static void
 841 evdev_client_filter_queue(struct evdev_client *client, uint16_t type)
 842 {
 843         struct input_event *event;
 844         size_t head, tail, count, i;
 845         bool last_was_syn = false;
 846
 847         EVDEV_CLIENT_LOCKQ(client);
 848
 849         i = head = client->ec_buffer_head;
 850         tail = client->ec_buffer_tail;
 851         count = client->ec_buffer_size;
 852         client->ec_buffer_ready = client->ec_buffer_tail;
 853
 854         while (i != client->ec_buffer_tail) {
 855                 event = &client->ec_buffer[i];
 856                 i = (i + 1) % count;
 857
 858                 /* Skip event of given type */
 859                 if (event->type == type)
 860                         continue;
 861
 862                 /* Remove empty SYN_REPORT events */
 863                 if (event->type == EV_SYN && event->code == SYN_REPORT) {
 864                         if (last_was_syn)
 865                                 continue;
 866                         else
 867                                 client->ec_buffer_ready = (tail + 1) % count;
 868                 }
 869
 870                 /* Rewrite entry */
 871                 memcpy(&client->ec_buffer[tail], event,
 872                     sizeof(struct input_event));
 873
 874                 last_was_syn = (event->type == EV_SYN &&
 875                     event->code == SYN_REPORT);
 876
 877                 tail = (tail + 1) % count;
 878         }
 879
 880         client->ec_buffer_head = i;
 881         client->ec_buffer_tail = tail;
 882
 883         EVDEV_CLIENT_UNLOCKQ(client);
 884 }