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