libevdev/libevdev.c

   1 /*
   2  * Copyright © 2013 Red Hat, Inc.
   3  *
   4  * Permission to use, copy, modify, distribute, and sell this software and its
   5  * documentation for any purpose is hereby granted without fee, provided that
   6  * the above copyright notice appear in all copies and that both that copyright
   7  * notice and this permission notice appear in supporting documentation, and
   8  * that the name of the copyright holders not be used in advertising or
   9  * publicity pertaining to distribution of the software without specific,
  10  * written prior permission.  The copyright holders make no representations
  11  * about the suitability of this software for any purpose.  It is provided "as
  12  * is" without express or implied warranty.
  13  *
  14  * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  15  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  16  * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  17  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  18  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  19  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  20  * OF THIS SOFTWARE.
  21  */
  22
  23 #include <config.h>
  24 #include <errno.h>
  25 #include <poll.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <unistd.h>
  29 #include <stdarg.h>
  30 #include <linux/uinput.h>
  31
  32 #include "libevdev.h"
  33 #include "libevdev-int.h"
  34 #include "libevdev-util.h"
  35 #include "event-names.h"
  36
  37 #define MAXEVENTS 64
  38
  39 static int sync_mt_state(struct libevdev *dev, int create_events);
  40
  41 static int
  42 init_event_queue(struct libevdev *dev)
  43 {
  44         /* FIXME: count the number of axes, keys, etc. to get a better idea at how many events per
  45            EV_SYN we could possibly get. Then multiply that by the actual buffer size we care about */
  46
  47         const int QUEUE_SIZE = 256;
  48
  49         return queue_alloc(dev, QUEUE_SIZE);
  50 }
  51
  52 static void
  53 _libevdev_log(struct libevdev *dev, const char *format, ...)
  54 {
  55         va_list args;
  56
  57         va_start(args, format);
  58         dev->log(format, args);
  59         va_end(args);
  60 }
  61
  62 static void
  63 libevdev_noop_log_func(const char *format, va_list args)
  64 {
  65 }
  66
  67 struct libevdev*
  68 libevdev_new(void)
  69 {
  70         struct libevdev *dev;
  71
  72         dev = calloc(1, sizeof(*dev));
  73         if (!dev)
  74                 return NULL;
  75         dev->fd = -1;
  76         dev->num_slots = -1;
  77         dev->current_slot = -1;
  78         dev->log = libevdev_noop_log_func;
  79         dev->grabbed = LIBEVDEV_UNGRAB;
  80         dev->sync_state = SYNC_NONE;
  81
  82         return dev;
  83 }
  84
  85 int
  86 libevdev_new_from_fd(int fd, struct libevdev **dev)
  87 {
  88         struct libevdev *d;
  89         int rc;
  90
  91         d = libevdev_new();
  92         if (!d)
  93                 return -ENOSPC;
  94
  95         rc = libevdev_set_fd(d, fd);
  96         if (rc < 0)
  97                 libevdev_free(d);
  98         else
  99                 *dev = d;
 100         return rc;
 101 }
 102
 103 void
 104 libevdev_free(struct libevdev *dev)
 105 {
 106         if (!dev)
 107                 return;
 108
 109         free(dev->name);
 110         free(dev->phys);
 111         free(dev->uniq);
 112         queue_free(dev);
 113         free(dev);
 114 }
 115
 116 void
 117 libevdev_set_log_handler(struct libevdev *dev, libevdev_log_func_t logfunc)
 118 {
 119         if (dev == NULL)
 120                 return;
 121
 122         dev->log = logfunc ? logfunc : libevdev_noop_log_func;
 123 }
 124
 125 int
 126 libevdev_change_fd(struct libevdev *dev, int fd)
 127 {
 128         if (dev->fd == -1)
 129                 return -1;
 130         dev->fd = fd;
 131         return 0;
 132 }
 133
 134 int
 135 libevdev_set_fd(struct libevdev* dev, int fd)
 136 {
 137         int rc;
 138         int i;
 139         char buf[256];
 140
 141         if (dev->fd != -1)
 142                 return -EBADF;
 143
 144         rc = ioctl(fd, EVIOCGBIT(0, sizeof(dev->bits)), dev->bits);
 145         if (rc < 0)
 146                 goto out;
 147
 148         memset(buf, 0, sizeof(buf));
 149         rc = ioctl(fd, EVIOCGNAME(sizeof(buf) - 1), buf);
 150         if (rc < 0)
 151                 goto out;
 152
 153         free(dev->name);
 154         dev->name = strdup(buf);
 155         if (!dev->name) {
 156                 errno = ENOSPC;
 157                 goto out;
 158         }
 159
 160         free(dev->phys);
 161         dev->phys = NULL;
 162         memset(buf, 0, sizeof(buf));
 163         rc = ioctl(fd, EVIOCGPHYS(sizeof(buf) - 1), buf);
 164         if (rc < 0) {
 165                 /* uinput has no phys */
 166                 if (errno != ENOENT)
 167                         goto out;
 168         } else {
 169                 dev->phys = strdup(buf);
 170                 if (!dev->phys) {
 171                         errno = ENOSPC;
 172                         goto out;
 173                 }
 174         }
 175
 176         free(dev->uniq);
 177         dev->uniq = NULL;
 178         memset(buf, 0, sizeof(buf));
 179         rc = ioctl(fd, EVIOCGUNIQ(sizeof(buf) - 1), buf);
 180         if (rc < 0) {
 181                 if (errno != ENOENT)
 182                         goto out;
 183         } else  {
 184                 dev->uniq = strdup(buf);
 185                 if (!dev->uniq) {
 186                         errno = ENOSPC;
 187                         goto out;
 188                 }
 189         }
 190
 191         rc = ioctl(fd, EVIOCGID, &dev->ids);
 192         if (rc < 0)
 193                 goto out;
 194
 195         rc = ioctl(fd, EVIOCGVERSION, &dev->driver_version);
 196         if (rc < 0)
 197                 goto out;
 198
 199         rc = ioctl(fd, EVIOCGPROP(sizeof(dev->props)), dev->props);
 200         if (rc < 0)
 201                 goto out;
 202
 203         rc = ioctl(fd, EVIOCGBIT(EV_REL, sizeof(dev->rel_bits)), dev->rel_bits);
 204         if (rc < 0)
 205                 goto out;
 206
 207         rc = ioctl(fd, EVIOCGBIT(EV_ABS, sizeof(dev->abs_bits)), dev->abs_bits);
 208         if (rc < 0)
 209                 goto out;
 210
 211         rc = ioctl(fd, EVIOCGBIT(EV_LED, sizeof(dev->led_bits)), dev->led_bits);
 212         if (rc < 0)
 213                 goto out;
 214
 215         rc = ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(dev->key_bits)), dev->key_bits);
 216         if (rc < 0)
 217                 goto out;
 218
 219         rc = ioctl(fd, EVIOCGBIT(EV_SW, sizeof(dev->sw_bits)), dev->sw_bits);
 220         if (rc < 0)
 221                 goto out;
 222
 223         rc = ioctl(fd, EVIOCGBIT(EV_MSC, sizeof(dev->msc_bits)), dev->msc_bits);
 224         if (rc < 0)
 225                 goto out;
 226
 227         rc = ioctl(fd, EVIOCGBIT(EV_FF, sizeof(dev->ff_bits)), dev->ff_bits);
 228         if (rc < 0)
 229                 goto out;
 230
 231         rc = ioctl(fd, EVIOCGBIT(EV_SND, sizeof(dev->snd_bits)), dev->snd_bits);
 232         if (rc < 0)
 233                 goto out;
 234
 235         /* rep is a special case, always set it to 1 for both values if EV_REP is set */
 236         if (bit_is_set(dev->bits, EV_REP)) {
 237                 for (i = 0; i < REP_CNT; i++)
 238                         set_bit(dev->rep_bits, i);
 239                 rc = ioctl(fd, EVIOCGREP, dev->rep_values);
 240                 if (rc < 0)
 241                         goto out;
 242         }
 243
 244         for (i = ABS_X; i <= ABS_MAX; i++) {
 245                 if (bit_is_set(dev->abs_bits, i)) {
 246                         struct input_absinfo abs_info;
 247                         rc = ioctl(fd, EVIOCGABS(i), &abs_info);
 248                         if (rc < 0)
 249                                 goto out;
 250
 251                         dev->abs_info[i] = abs_info;
 252                         if (i == ABS_MT_SLOT) {
 253                                 dev->num_slots = abs_info.maximum + 1;
 254                                 dev->current_slot = abs_info.value;
 255                         }
 256
 257                 }
 258         }
 259
 260         dev->fd = fd;
 261         sync_mt_state(dev, 0);
 262
 263         rc = init_event_queue(dev);
 264         if (rc < 0) {
 265                 dev->fd = -1;
 266                 return -rc;
 267         }
 268
 269         /* not copying key state because we won't know when we'll start to
 270          * use this fd and key's are likely to change state by then.
 271          * Same with the valuators, really, but they may not change.
 272          */
 273
 274 out:
 275         return rc ? -errno : 0;
 276 }
 277
 278 int
 279 libevdev_get_fd(const struct libevdev* dev)
 280 {
 281         return dev->fd;
 282 }
 283
 284 static inline void
 285 init_event(struct libevdev *dev, struct input_event *ev, int type, int code, int value)
 286 {
 287         ev->time = dev->last_event_time;
 288         ev->type = type;
 289         ev->code = code;
 290         ev->value = value;
 291 }
 292
 293 static int
 294 sync_key_state(struct libevdev *dev)
 295 {
 296         int rc;
 297         int i;
 298         unsigned long keystate[NLONGS(KEY_MAX)];
 299
 300         rc = ioctl(dev->fd, EVIOCGKEY(sizeof(keystate)), keystate);
 301         if (rc < 0)
 302                 goto out;
 303
 304         for (i = 0; i < KEY_MAX; i++) {
 305                 int old, new;
 306                 old = bit_is_set(dev->key_values, i);
 307                 new = bit_is_set(keystate, i);
 308                 if (old ^ new) {
 309                         struct input_event *ev = queue_push(dev);
 310                         init_event(dev, ev, EV_KEY, i, new ? 1 : 0);
 311                 }
 312                 set_bit_state(dev->key_values, i, new);
 313         }
 314
 315         rc = 0;
 316 out:
 317         return rc ? -errno : 0;
 318 }
 319
 320 static int
 321 sync_abs_state(struct libevdev *dev)
 322 {
 323         int rc;
 324         int i;
 325
 326         for (i = ABS_X; i <= ABS_MAX; i++) {
 327                 struct input_absinfo abs_info;
 328
 329                 if (i >= ABS_MT_MIN && i <= ABS_MT_MAX)
 330                         continue;
 331
 332                 if (!bit_is_set(dev->abs_bits, i))
 333                         continue;
 334
 335                 rc = ioctl(dev->fd, EVIOCGABS(i), &abs_info);
 336                 if (rc < 0)
 337                         goto out;
 338
 339                 if (dev->abs_info[i].value != abs_info.value) {
 340                         struct input_event *ev = queue_push(dev);
 341
 342                         init_event(dev, ev, EV_ABS, i, abs_info.value);
 343                         dev->abs_info[i].value = abs_info.value;
 344                 }
 345         }
 346
 347         rc = 0;
 348 out:
 349         return rc ? -errno : 0;
 350 }
 351
 352 static int
 353 sync_mt_state(struct libevdev *dev, int create_events)
 354 {
 355         int rc;
 356         int i;
 357         struct mt_state {
 358                 int code;
 359                 int val[MAX_SLOTS];
 360         } mt_state[ABS_MT_CNT];
 361
 362         for (i = ABS_MT_MIN; i < ABS_MT_MAX; i++) {
 363                 int idx;
 364                 if (i == ABS_MT_SLOT)
 365                         continue;
 366
 367                 if (!libevdev_has_event_code(dev, EV_ABS, i))
 368                         continue;
 369
 370                 idx = i - ABS_MT_MIN;
 371                 mt_state[idx].code = i;
 372                 rc = ioctl(dev->fd, EVIOCGMTSLOTS(sizeof(struct mt_state)), &mt_state[idx]);
 373                 if (rc < 0)
 374                         goto out;
 375         }
 376
 377         for (i = 0; i < dev->num_slots; i++) {
 378                 int j;
 379                 struct input_event *ev;
 380
 381                 if (create_events) {
 382                         ev = queue_push(dev);
 383                         init_event(dev, ev, EV_ABS, ABS_MT_SLOT, i);
 384                 }
 385
 386                 for (j = ABS_MT_MIN; j < ABS_MT_MAX; j++) {
 387                         int jdx = j - ABS_MT_MIN;
 388
 389                         if (j == ABS_MT_SLOT)
 390                                 continue;
 391
 392                         if (!libevdev_has_event_code(dev, EV_ABS, j))
 393                                 continue;
 394
 395                         if (dev->mt_slot_vals[i][jdx] == mt_state[jdx].val[i])
 396                                 continue;
 397
 398                         if (create_events) {
 399                                 ev = queue_push(dev);
 400                                 init_event(dev, ev, EV_ABS, j, mt_state[jdx].val[i]);
 401                         }
 402                         dev->mt_slot_vals[i][jdx] = mt_state[jdx].val[i];
 403                 }
 404         }
 405
 406         rc = 0;
 407 out:
 408         return rc ? -errno : 0;
 409 }
 410
 411 static int
 412 sync_state(struct libevdev *dev)
 413 {
 414         int i;
 415         int rc = 0;
 416         struct input_event *ev;
 417
 418         /* FIXME: if we have events in the queue after the SYN_DROPPED (which was
 419            queue[0]) we need to shift this backwards. Except that chances are that the
 420            queue may be either full or too full to prepend all the events needed for
 421            SYNC_IN_PROGRESS.
 422
 423            so we search for the last sync event in the queue and drop everything before
 424            including that event and rely on the kernel to tell us the right value for that
 425            bitfield during the sync process.
 426          */
 427
 428         for (i = queue_num_elements(dev) - 1; i >= 0; i--) {
 429                 struct input_event e;
 430                 queue_peek(dev, i, &e);
 431                 if (e.type == EV_SYN)
 432                         break;
 433         }
 434
 435         if (i > 0)
 436                 queue_shift_multiple(dev, i + 1, NULL);
 437
 438         if (libevdev_has_event_type(dev, EV_KEY))
 439                 rc = sync_key_state(dev);
 440         if (rc == 0 && libevdev_has_event_type(dev, EV_ABS))
 441                 rc = sync_abs_state(dev);
 442         if (rc == 0 && libevdev_has_event_code(dev, EV_ABS, ABS_MT_SLOT))
 443                 rc = sync_mt_state(dev, 1);
 444
 445         dev->queue_nsync = queue_num_elements(dev);
 446
 447         if (dev->queue_nsync > 0) {
 448                 ev = queue_push(dev);
 449                 init_event(dev, ev, EV_SYN, SYN_REPORT, 0);
 450                 dev->queue_nsync++;
 451         }
 452
 453         return rc;
 454 }
 455
 456 static int
 457 update_key_state(struct libevdev *dev, const struct input_event *e)
 458 {
 459         if (!libevdev_has_event_type(dev, EV_KEY))
 460                 return 1;
 461
 462         if (e->code > KEY_MAX)
 463                 return 1;
 464
 465         if (e->value == 0)
 466                 clear_bit(dev->key_values, e->code);
 467         else
 468                 set_bit(dev->key_values, e->code);
 469
 470         return 0;
 471 }
 472
 473 static int
 474 update_mt_state(struct libevdev *dev, const struct input_event *e)
 475 {
 476         if (e->code == ABS_MT_SLOT) {
 477                 dev->current_slot = e->value;
 478                 return 0;
 479         } else if (dev->current_slot == -1)
 480                 return 1;
 481
 482         dev->mt_slot_vals[dev->current_slot][e->code - ABS_MT_MIN] = e->value;
 483
 484         return 0;
 485 }
 486
 487 static int
 488 update_abs_state(struct libevdev *dev, const struct input_event *e)
 489 {
 490         if (!libevdev_has_event_type(dev, EV_ABS))
 491                 return 1;
 492
 493         if (e->code > ABS_MAX)
 494                 return 1;
 495
 496         if (e->code >= ABS_MT_MIN && e->code <= ABS_MT_MAX)
 497                 return update_mt_state(dev, e);
 498
 499         dev->abs_info[e->code].value = e->value;
 500
 501         return 0;
 502 }
 503
 504 static int
 505 update_state(struct libevdev *dev, const struct input_event *e)
 506 {
 507         int rc = 0;
 508
 509         switch(e->type) {
 510                 case EV_SYN:
 511                 case EV_REL:
 512                         break;
 513                 case EV_KEY:
 514                         rc = update_key_state(dev, e);
 515                         break;
 516                 case EV_ABS:
 517                         rc = update_abs_state(dev, e);
 518                         break;
 519         }
 520
 521         dev->last_event_time = e->time;
 522
 523         return rc;
 524 }
 525
 526 static int
 527 read_more_events(struct libevdev *dev)
 528 {
 529         int free_elem;
 530         int len;
 531         struct input_event *next;
 532
 533         free_elem = queue_num_free_elements(dev);
 534         if (free_elem <= 0)
 535                 return 0;
 536
 537         next = queue_next_element(dev);
 538         len = read(dev->fd, next, free_elem * sizeof(struct input_event));
 539         if (len < 0) {
 540                 return -errno;
 541         } else if (len > 0 && len % sizeof(struct input_event) != 0)
 542                 return -EINVAL;
 543         else if (len > 0) {
 544                 int nev = len/sizeof(struct input_event);
 545                 queue_set_num_elements(dev, queue_num_elements(dev) + nev);
 546         }
 547
 548         return 0;
 549 }
 550
 551 int libevdev_next_event(struct libevdev *dev, unsigned int flags, struct input_event *ev)
 552 {
 553         int rc = 0;
 554
 555         if (dev->fd < 0)
 556                 return -ENODEV;
 557
 558         if (!(flags & (LIBEVDEV_READ_NORMAL|LIBEVDEV_READ_SYNC|LIBEVDEV_FORCE_SYNC)))
 559                 return -EINVAL;
 560
 561         if (flags & LIBEVDEV_READ_SYNC) {
 562                 if (dev->sync_state == SYNC_NEEDED) {
 563                         rc = sync_state(dev);
 564                         if (rc != 0)
 565                                 return rc;
 566                         dev->sync_state = SYNC_IN_PROGRESS;
 567                 }
 568
 569                 if (dev->queue_nsync == 0) {
 570                         dev->sync_state = SYNC_NONE;
 571                         return -EAGAIN;
 572                 }
 573
 574         } else if (dev->sync_state != SYNC_NONE) {
 575                 struct input_event e;
 576
 577                 /* call update_state for all events here, otherwise the library has the wrong view
 578                    of the device too */
 579                 while (queue_shift(dev, &e) == 0) {
 580                         dev->queue_nsync--;
 581                         update_state(dev, &e);
 582                 }
 583
 584                 dev->sync_state = SYNC_NONE;
 585         }
 586
 587         /* FIXME: if the first event after SYNC_IN_PROGRESS is a SYN_DROPPED, log this */
 588
 589         /* Always read in some more events. Best case this smoothes over a potential SYN_DROPPED,
 590            worst case we don't read fast enough and end up with SYN_DROPPED anyway.
 591
 592            Except if the fd is in blocking mode and we still have events from the last read, don't
 593            read in any more.
 594          */
 595         do {
 596                 if (!(flags & LIBEVDEV_READ_BLOCKING) ||
 597                     queue_num_elements(dev) == 0) {
 598                         rc = read_more_events(dev);
 599                         if (rc < 0 && rc != -EAGAIN)
 600                                 goto out;
 601                 }
 602
 603                 if (flags & LIBEVDEV_FORCE_SYNC) {
 604                         dev->sync_state = SYNC_NEEDED;
 605                         rc = 1;
 606                         goto out;
 607                 }
 608
 609
 610                 if (queue_shift(dev, ev) != 0)
 611                         return -EAGAIN;
 612
 613                 update_state(dev, ev);
 614
 615         /* if we disabled a code, get the next event instead */
 616         } while(!libevdev_has_event_code(dev, ev->type, ev->code));
 617
 618         rc = 0;
 619         if (ev->type == EV_SYN && ev->code == SYN_DROPPED) {
 620                 dev->sync_state = SYNC_NEEDED;
 621                 rc = 1;
 622         }
 623
 624         if (flags & LIBEVDEV_READ_SYNC && dev->queue_nsync > 0) {
 625                 dev->queue_nsync--;
 626                 rc = 1;
 627                 if (dev->queue_nsync == 0)
 628                         dev->sync_state = SYNC_NONE;
 629         }
 630
 631 out:
 632         return rc;
 633 }
 634
 635 int libevdev_has_event_pending(struct libevdev *dev)
 636 {
 637         struct pollfd fds = { dev->fd, POLLIN, 0 };
 638         int rc;
 639
 640         if (dev->fd < 0)
 641                 return -EBADF;
 642
 643         if (queue_num_elements(dev) != 0)
 644                 return 1;
 645
 646         rc = poll(&fds, 1, 0);
 647         return (rc >= 0) ? rc : -errno;
 648 }
 649
 650 const char *
 651 libevdev_get_name(const struct libevdev *dev)
 652 {
 653         return dev->name ? dev->name : "";
 654 }
 655
 656 const char *
 657 libevdev_get_phys(const struct libevdev *dev)
 658 {
 659         return dev->phys;
 660 }
 661
 662 const char *
 663 libevdev_get_uniq(const struct libevdev *dev)
 664 {
 665         return dev->uniq;
 666 }
 667
 668 #define STRING_SETTER(field) \
 669 void libevdev_set_##field(struct libevdev *dev, const char *field) \
 670 { \
 671         if (field == NULL) \
 672                 return; \
 673         free(dev->field); \
 674         dev->field = strdup(field); \
 675 }
 676
 677 STRING_SETTER(name);
 678 STRING_SETTER(phys);
 679 STRING_SETTER(uniq);
 680
 681
 682 #define PRODUCT_GETTER(name, field) \
 683 int libevdev_get_##name(const struct libevdev *dev) \
 684 { \
 685         return dev->ids.field; \
 686 }
 687
 688 PRODUCT_GETTER(product_id, product); /* DEPRECATED */
 689 PRODUCT_GETTER(vendor_id, vendor); /* DEPRECATED */
 690 PRODUCT_GETTER(bustype, bustype); /* DEPRECATED */
 691 PRODUCT_GETTER(version, version); /* DEPRECATED */
 692
 693 PRODUCT_GETTER(id_product, product);
 694 PRODUCT_GETTER(id_vendor, vendor);
 695 PRODUCT_GETTER(id_bustype, bustype);
 696 PRODUCT_GETTER(id_version, version);
 697
 698 #define PRODUCT_SETTER(field) \
 699 void libevdev_set_id_##field(struct libevdev *dev, int field) \
 700 { \
 701         dev->ids.field = field;\
 702 }
 703
 704 PRODUCT_SETTER(product);
 705 PRODUCT_SETTER(vendor);
 706 PRODUCT_SETTER(bustype);
 707 PRODUCT_SETTER(version);
 708
 709 int libevdev_get_driver_version(const struct libevdev *dev)
 710 {
 711         return dev->driver_version;
 712 }
 713
 714 int
 715 libevdev_has_property(const struct libevdev *dev, unsigned int prop)
 716 {
 717         return (prop <= INPUT_PROP_MAX) && bit_is_set(dev->props, prop);
 718 }
 719
 720 int
 721 libevdev_enable_property(struct libevdev *dev, unsigned int prop)
 722 {
 723         if (prop > INPUT_PROP_MAX)
 724                 return -1;
 725
 726         set_bit(dev->props, prop);
 727         return 0;
 728 }
 729
 730 int
 731 libevdev_has_event_type(const struct libevdev *dev, unsigned int type)
 732 {
 733         return (type <= EV_MAX) && bit_is_set(dev->bits, type);
 734 }
 735
 736 int
 737 libevdev_has_event_code(const struct libevdev *dev, unsigned int type, unsigned int code)
 738 {
 739         const unsigned long *mask;
 740         int max;
 741
 742         if (!libevdev_has_event_type(dev, type))
 743                 return 0;
 744
 745         if (type == EV_SYN)
 746                 return 1;
 747
 748         max = type_to_mask_const(dev, type, &mask);
 749
 750         if (max == -1 || code > max)
 751                 return 0;
 752
 753         return bit_is_set(mask, code);
 754 }
 755
 756 int
 757 libevdev_get_event_value(const struct libevdev *dev, unsigned int type, unsigned int code)
 758 {
 759         int value;
 760
 761         if (!libevdev_has_event_type(dev, type) || !libevdev_has_event_code(dev, type, code))
 762                 return 0;
 763
 764         switch (type) {
 765                 case EV_ABS: value = dev->abs_info[code].value; break;
 766                 case EV_KEY: value = bit_is_set(dev->key_values, code); break;
 767                 default:
 768                         value = 0;
 769                         break;
 770         }
 771
 772         return value;
 773 }
 774
 775 int
 776 libevdev_fetch_event_value(const struct libevdev *dev, unsigned int type, unsigned int code, int *value)
 777 {
 778         if (libevdev_has_event_type(dev, type) &&
 779             libevdev_has_event_code(dev, type, code)) {
 780                 *value = libevdev_get_event_value(dev, type, code);
 781                 return 1;
 782         } else
 783                 return 0;
 784 }
 785
 786 int
 787 libevdev_get_slot_value(const struct libevdev *dev, unsigned int slot, unsigned int code)
 788 {
 789         if (!libevdev_has_event_type(dev, EV_ABS) || !libevdev_has_event_code(dev, EV_ABS, code))
 790                 return 0;
 791
 792         if (slot >= dev->num_slots || slot >= MAX_SLOTS)
 793                 return 0;
 794
 795         if (code > ABS_MT_MAX || code < ABS_MT_MIN)
 796                 return 0;
 797
 798         return dev->mt_slot_vals[slot][code - ABS_MT_MIN];
 799 }
 800
 801 int
 802 libevdev_fetch_slot_value(const struct libevdev *dev, unsigned int slot, unsigned int code, int *value)
 803 {
 804         if (libevdev_has_event_type(dev, EV_ABS) &&
 805             libevdev_has_event_code(dev, EV_ABS, code) &&
 806             slot < dev->num_slots && slot < MAX_SLOTS) {
 807                 *value = libevdev_get_slot_value(dev, slot, code);
 808                 return 1;
 809         } else
 810                 return 0;
 811 }
 812
 813 int
 814 libevdev_get_num_slots(const struct libevdev *dev)
 815 {
 816         return dev->num_slots;
 817 }
 818
 819 int
 820 libevdev_get_current_slot(const struct libevdev *dev)
 821 {
 822         return dev->current_slot;
 823 }
 824
 825 const struct input_absinfo*
 826 libevdev_get_abs_info(const struct libevdev *dev, unsigned int code)
 827 {
 828         if (!libevdev_has_event_type(dev, EV_ABS) ||
 829             !libevdev_has_event_code(dev, EV_ABS, code))
 830                 return NULL;
 831
 832         return &dev->abs_info[code];
 833 }
 834
 835 #define ABS_GETTER(name, field) \
 836 int libevdev_get_abs_##name(const struct libevdev *dev, unsigned int code) \
 837 { \
 838         const struct input_absinfo *absinfo = libevdev_get_abs_info(dev, code); \
 839         return absinfo ? absinfo->field : 0; \
 840 }
 841
 842 ABS_GETTER(max, maximum); /* DEPRECATED */
 843 ABS_GETTER(min, minimum); /* DEPRECATED */
 844 ABS_GETTER(maximum, maximum);
 845 ABS_GETTER(minimum, minimum);
 846 ABS_GETTER(fuzz, fuzz)
 847 ABS_GETTER(flat, flat)
 848 ABS_GETTER(resolution, resolution)
 849
 850 #define ABS_SETTER(field) \
 851 void libevdev_set_abs_##field(struct libevdev *dev, unsigned int code, int val) \
 852 { \
 853         if (!libevdev_has_event_code(dev, EV_ABS, code)) \
 854                 return; \
 855         dev->abs_info[code].field = val; \
 856 }
 857
 858 ABS_SETTER(maximum)
 859 ABS_SETTER(minimum)
 860 ABS_SETTER(fuzz)
 861 ABS_SETTER(flat)
 862 ABS_SETTER(resolution)
 863
 864 void libevdev_set_abs_info(struct libevdev *dev, unsigned int code, const struct input_absinfo *abs)
 865 {
 866         if (!libevdev_has_event_code(dev, EV_ABS, code))
 867                 return;
 868
 869         dev->abs_info[code] = *abs;
 870 }
 871
 872 int
 873 libevdev_enable_event_type(struct libevdev *dev, unsigned int type)
 874 {
 875         if (type > EV_MAX)
 876                 return -1;
 877
 878         if (libevdev_has_event_type(dev, type))
 879                 return 0;
 880
 881         set_bit(dev->bits, type);
 882
 883         if (type == EV_REP) {
 884                 int delay = 0, period = 0;
 885                 libevdev_enable_event_code(dev, EV_REP, REP_DELAY, &delay);
 886                 libevdev_enable_event_code(dev, EV_REP, REP_PERIOD, &period);
 887         }
 888         return 0;
 889 }
 890
 891 int
 892 libevdev_disable_event_type(struct libevdev *dev, unsigned int type)
 893 {
 894         if (type > EV_MAX || type == EV_SYN)
 895                 return -1;
 896
 897         clear_bit(dev->bits, type);
 898
 899         return 0;
 900 }
 901
 902 int
 903 libevdev_enable_event_code(struct libevdev *dev, unsigned int type,
 904                            unsigned int code, const void *data)
 905 {
 906         unsigned int max;
 907         unsigned long *mask;
 908
 909         if (libevdev_enable_event_type(dev, type))
 910                 return -1;
 911
 912         switch(type) {
 913                 case EV_SYN:
 914                         return 0;
 915                 case EV_ABS:
 916                 case EV_REP:
 917                         if (data == NULL)
 918                                 return -1;
 919                         break;
 920                 default:
 921                         if (data != NULL)
 922                                 return -1;
 923                         break;
 924         }
 925
 926         max = type_to_mask(dev, type, &mask);
 927
 928         if (code > max)
 929                 return -1;
 930
 931         set_bit(mask, code);
 932
 933         if (type == EV_ABS) {
 934                 const struct input_absinfo *abs = data;
 935                 dev->abs_info[code] = *abs;
 936         } else if (type == EV_REP) {
 937                 const int *value = data;
 938                 dev->rep_values[code] = *value;
 939         }
 940
 941         return 0;
 942 }
 943
 944 int
 945 libevdev_disable_event_code(struct libevdev *dev, unsigned int type, unsigned int code)
 946 {
 947         unsigned int max;
 948         unsigned long *mask;
 949
 950         if (type > EV_MAX)
 951                 return -1;
 952
 953         max = type_to_mask(dev, type, &mask);
 954
 955         if (code > max)
 956                 return -1;
 957
 958         clear_bit(mask, code);
 959
 960         return 0;
 961 }
 962
 963 int
 964 libevdev_kernel_set_abs_value(struct libevdev *dev, unsigned int code, const struct input_absinfo *abs)
 965 {
 966         int rc;
 967
 968         if (code > ABS_MAX)
 969                 return -EINVAL;
 970
 971         rc = ioctl(dev->fd, EVIOCSABS(code), abs);
 972         if (rc < 0)
 973                 rc = -errno;
 974         else
 975                 rc = libevdev_enable_event_code(dev, EV_ABS, code, abs);
 976
 977         return rc;
 978 }
 979
 980 int
 981 libevdev_grab(struct libevdev *dev, int grab)
 982 {
 983         int rc = 0;
 984
 985         if (grab != LIBEVDEV_GRAB && grab != LIBEVDEV_UNGRAB)
 986                 return -EINVAL;
 987
 988         if (grab == dev->grabbed)
 989                 return 0;
 990
 991         if (grab == LIBEVDEV_GRAB)
 992                 rc = ioctl(dev->fd, EVIOCGRAB, (void *)1);
 993         else if (grab == LIBEVDEV_UNGRAB)
 994                 rc = ioctl(dev->fd, EVIOCGRAB, (void *)0);
 995
 996         if (rc == 0)
 997                 dev->grabbed = grab;
 998
 999         return rc < 0 ? -errno : 0;
1000 }
1001
1002 int
1003 libevdev_is_event_type(const struct input_event *ev, unsigned int type)
1004 {
1005         return type < EV_MAX && ev->type == type;
1006 }
1007
1008 int
1009 libevdev_is_event_code(const struct input_event *ev, unsigned int type, unsigned int code)
1010 {
1011         return type < EV_MAX &&
1012                 ev->type == type &&
1013                 (type == EV_SYN || code <= libevdev_get_event_type_max(type)) &&
1014                 ev->code == code;
1015 }
1016
1017 const char*
1018 libevdev_get_event_type_name(unsigned int type)
1019 {
1020         if (type > EV_MAX)
1021                 return NULL;
1022
1023         return ev_map[type];
1024 }
1025
1026 const char*
1027 libevdev_get_event_code_name(unsigned int type, unsigned int code)
1028 {
1029         if (type > EV_MAX)
1030                 return NULL;
1031
1032         if (code > ev_max[type])
1033                 return NULL;
1034
1035         return event_type_map[type][code];
1036 }
1037
1038 /* DEPRECATED */
1039 const char*
1040 libevdev_get_input_prop_name(unsigned int prop)
1041 {
1042         return libevdev_get_property_name(prop);
1043 }
1044
1045 const char*
1046 libevdev_get_property_name(unsigned int prop)
1047 {
1048         if (prop > INPUT_PROP_MAX)
1049                 return NULL;
1050
1051         return input_prop_map[prop];
1052 }
1053
1054 int
1055 libevdev_get_event_type_max(unsigned int type)
1056 {
1057         if (type > EV_MAX)
1058                 return -1;
1059
1060         return ev_max[type];
1061 }
1062
1063 int
1064 libevdev_get_repeat(struct libevdev *dev, int *delay, int *period)
1065 {
1066         if (!libevdev_has_event_type(dev, EV_REP))
1067                 return -1;
1068
1069         if (delay != NULL)
1070                 *delay = dev->rep_values[REP_DELAY];
1071         if (period != NULL)
1072                 *period = dev->rep_values[REP_PERIOD];
1073
1074         return 0;
1075 }