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                 if (!libevdev_has_event_code(dev, EV_ABS, i))
 356                         continue;
 357
 358                 idx = i - ABS_MT_MIN;
 359                 mt_state[idx].code = i;
 360                 rc = ioctl(dev->fd, EVIOCGMTSLOTS(sizeof(struct mt_state)), &mt_state[idx]);
 361                 if (rc < 0)
 362                         goto out;
 363         }
 364
 365         for (i = 0; i < dev->num_slots; i++) {
 366                 int j;
 367                 struct input_event *ev;
 368
 369                 ev = queue_push(dev);
 370                 init_event(dev, ev, EV_ABS, ABS_MT_SLOT, i);
 371                 for (j = ABS_MT_MIN; j < ABS_MT_MAX; j++) {
 372                         int jdx = j - ABS_MT_MIN;
 373
 374                         if (j == ABS_MT_SLOT)
 375                                 continue;
 376
 377                         if (!libevdev_has_event_code(dev, EV_ABS, j))
 378                                 continue;
 379
 380                         if (dev->mt_slot_vals[i][jdx] == mt_state[jdx].val[i])
 381                                 continue;
 382
 383                         ev = queue_push(dev);
 384                         init_event(dev, ev, EV_ABS, j, mt_state[jdx].val[i]);
 385                         dev->mt_slot_vals[i][jdx] = mt_state[jdx].val[i];
 386                 }
 387         }
 388
 389         rc = 0;
 390 out:
 391         return rc ? -errno : 0;
 392 }
 393
 394 static int
 395 sync_state(struct libevdev *dev)
 396 {
 397         int i;
 398         int rc = 0;
 399         struct input_event *ev;
 400
 401         /* FIXME: if we have events in the queue after the SYN_DROPPED (which was
 402            queue[0]) we need to shift this backwards. Except that chances are that the
 403            queue may be either full or too full to prepend all the events needed for
 404            syncing.
 405
 406            so we search for the last sync event in the queue and drop everything before
 407            including that event and rely on the kernel to tell us the right value for that
 408            bitfield during the sync process.
 409          */
 410
 411         for (i = queue_num_elements(dev) - 1; i >= 0; i--) {
 412                 struct input_event e;
 413                 queue_peek(dev, i, &e);
 414                 if (e.type == EV_SYN)
 415                         break;
 416         }
 417
 418         if (i > 0)
 419                 queue_shift_multiple(dev, i + 1, NULL);
 420
 421         if (libevdev_has_event_type(dev, EV_KEY))
 422                 rc = sync_key_state(dev);
 423         if (rc == 0 && libevdev_has_event_type(dev, EV_ABS))
 424                 rc = sync_abs_state(dev);
 425         if (rc == 0 && libevdev_has_event_code(dev, EV_ABS, ABS_MT_SLOT))
 426                 rc = sync_mt_state(dev);
 427
 428         ev = queue_push(dev);
 429         init_event(dev, ev, EV_SYN, SYN_REPORT, 0);
 430
 431         dev->queue_nsync = queue_num_elements(dev);
 432         dev->need_sync = 0;
 433
 434         return rc;
 435 }
 436
 437 static int
 438 update_key_state(struct libevdev *dev, const struct input_event *e)
 439 {
 440         if (!libevdev_has_event_type(dev, EV_KEY))
 441                 return 1;
 442
 443         if (e->code > KEY_MAX)
 444                 return 1;
 445
 446         if (e->value == 0)
 447                 clear_bit(dev->key_values, e->code);
 448         else
 449                 set_bit(dev->key_values, e->code);
 450
 451         return 0;
 452 }
 453
 454 static int
 455 update_mt_state(struct libevdev *dev, const struct input_event *e)
 456 {
 457         if (e->code == ABS_MT_SLOT) {
 458                 dev->current_slot = e->value;
 459                 return 0;
 460         } else if (dev->current_slot == -1)
 461                 return 1;
 462
 463         dev->mt_slot_vals[dev->current_slot][e->code - ABS_MT_MIN] = e->value;
 464
 465         return 0;
 466 }
 467
 468 static int
 469 update_abs_state(struct libevdev *dev, const struct input_event *e)
 470 {
 471         if (!libevdev_has_event_type(dev, EV_ABS))
 472                 return 1;
 473
 474         if (e->code > ABS_MAX)
 475                 return 1;
 476
 477         if (e->code >= ABS_MT_MIN && e->code <= ABS_MT_MAX)
 478                 return update_mt_state(dev, e);
 479
 480         dev->abs_info[e->code].value = e->value;
 481
 482         return 0;
 483 }
 484
 485 static int
 486 update_state(struct libevdev *dev, const struct input_event *e)
 487 {
 488         int rc = 0;
 489
 490         switch(e->type) {
 491                 case EV_SYN:
 492                 case EV_REL:
 493                         break;
 494                 case EV_KEY:
 495                         rc = update_key_state(dev, e);
 496                         break;
 497                 case EV_ABS:
 498                         rc = update_abs_state(dev, e);
 499                         break;
 500         }
 501
 502         dev->last_event_time = e->time;
 503
 504         return rc;
 505 }
 506
 507 static int
 508 read_more_events(struct libevdev *dev)
 509 {
 510         int free_elem;
 511         int len;
 512         struct input_event *next;
 513
 514         free_elem = queue_num_free_elements(dev);
 515         if (free_elem <= 0)
 516                 return 0;
 517
 518         next = queue_next_element(dev);
 519         len = read(dev->fd, next, free_elem * sizeof(struct input_event));
 520         if (len < 0) {
 521                 return -errno;
 522         } else if (len > 0 && len % sizeof(struct input_event) != 0)
 523                 return -EINVAL;
 524         else if (len > 0) {
 525                 int nev = len/sizeof(struct input_event);
 526                 queue_set_num_elements(dev, queue_num_elements(dev) + nev);
 527         }
 528
 529         return 0;
 530 }
 531
 532 int libevdev_next_event(struct libevdev *dev, unsigned int flags, struct input_event *ev)
 533 {
 534         int rc = 0;
 535
 536         if (dev->fd < 0)
 537                 return -ENODEV;
 538
 539         if (!(flags & (LIBEVDEV_READ_NORMAL|LIBEVDEV_READ_SYNC|LIBEVDEV_FORCE_SYNC)))
 540                 return -EINVAL;
 541
 542         if (flags & LIBEVDEV_READ_SYNC) {
 543                 if (!dev->need_sync && dev->queue_nsync == 0)
 544                         return -EAGAIN;
 545                 else if (dev->need_sync) {
 546                         rc = sync_state(dev);
 547                         if (rc != 0)
 548                                 return rc;
 549                 }
 550         } else if (dev->need_sync) {
 551                 struct input_event e;
 552
 553                 /* call update_state for all events here, otherwise the library has the wrong view
 554                    of the device too */
 555                 while (queue_shift(dev, &e) == 0)
 556                         update_state(dev, &e);
 557         }
 558
 559         /* FIXME: if the first event after syncing is a SYN_DROPPED, log this */
 560
 561         /* Always read in some more events. Best case this smoothes over a potential SYN_DROPPED,
 562            worst case we don't read fast enough and end up with SYN_DROPPED anyway.
 563
 564            Except if the fd is in blocking mode and we still have events from the last read, don't
 565            read in any more.
 566          */
 567         do {
 568                 if (!(flags & LIBEVDEV_READ_BLOCKING) ||
 569                     queue_num_elements(dev) == 0) {
 570                         rc = read_more_events(dev);
 571                         if (rc < 0 && rc != -EAGAIN)
 572                                 goto out;
 573                 }
 574
 575                 if (flags & LIBEVDEV_FORCE_SYNC) {
 576                         dev->need_sync = 1;
 577                         rc = 1;
 578                         goto out;
 579                 }
 580
 581
 582                 if (queue_shift(dev, ev) != 0)
 583                         return -EAGAIN;
 584
 585                 update_state(dev, ev);
 586
 587         /* if we disabled a code, get the next event instead */
 588         } while(!libevdev_has_event_code(dev, ev->type, ev->code));
 589
 590         rc = 0;
 591         if (ev->type == EV_SYN && ev->code == SYN_DROPPED) {
 592                 dev->need_sync = 1;
 593                 rc = 1;
 594         }
 595
 596         if (flags & LIBEVDEV_READ_SYNC && dev->queue_nsync > 0) {
 597                 dev->queue_nsync--;
 598                 rc = 1;
 599         }
 600
 601 out:
 602         return rc;
 603 }
 604
 605 const char *
 606 libevdev_get_name(const struct libevdev *dev)
 607 {
 608         return dev->name ? dev->name : "";
 609 }
 610
 611 const char *
 612 libevdev_get_phys(const struct libevdev *dev)
 613 {
 614         return dev->phys;
 615 }
 616
 617 const char *
 618 libevdev_get_uniq(const struct libevdev *dev)
 619 {
 620         return dev->uniq;
 621 }
 622
 623 int libevdev_get_product_id(const struct libevdev *dev)
 624 {
 625         return dev->ids.product;
 626 }
 627
 628 int libevdev_get_vendor_id(const struct libevdev *dev)
 629 {
 630         return dev->ids.vendor;
 631 }
 632
 633 int libevdev_get_bustype(const struct libevdev *dev)
 634 {
 635         return dev->ids.bustype;
 636 }
 637
 638 int libevdev_get_version(const struct libevdev *dev)
 639 {
 640         return dev->ids.version;
 641 }
 642
 643 int libevdev_get_driver_version(const struct libevdev *dev)
 644 {
 645         return dev->driver_version;
 646 }
 647
 648 int
 649 libevdev_has_property(const struct libevdev *dev, unsigned int prop)
 650 {
 651         return (prop <= INPUT_PROP_MAX) && bit_is_set(dev->props, prop);
 652 }
 653
 654 int
 655 libevdev_has_event_type(const struct libevdev *dev, unsigned int type)
 656 {
 657         return (type <= EV_MAX) && bit_is_set(dev->bits, type);
 658 }
 659
 660 int
 661 libevdev_has_event_code(const struct libevdev *dev, unsigned int type, unsigned int code)
 662 {
 663         const unsigned long *mask;
 664         int max;
 665
 666         if (!libevdev_has_event_type(dev, type))
 667                 return 0;
 668
 669         if (type == EV_SYN)
 670                 return 1;
 671
 672         max = type_to_mask_const(dev, type, &mask);
 673
 674         if (max == -1 || code > max)
 675                 return 0;
 676
 677         return bit_is_set(mask, code);
 678 }
 679
 680 int
 681 libevdev_get_event_value(const struct libevdev *dev, unsigned int type, unsigned int code)
 682 {
 683         int value;
 684
 685         if (!libevdev_has_event_type(dev, type) || !libevdev_has_event_code(dev, type, code))
 686                 return 0;
 687
 688         switch (type) {
 689                 case EV_ABS: value = dev->abs_info[code].value; break;
 690                 case EV_KEY: value = bit_is_set(dev->key_values, code); break;
 691                 default:
 692                         value = 0;
 693                         break;
 694         }
 695
 696         return value;
 697 }
 698
 699 int
 700 libevdev_fetch_event_value(const struct libevdev *dev, unsigned int type, unsigned int code, int *value)
 701 {
 702         if (libevdev_has_event_type(dev, type) &&
 703             libevdev_has_event_code(dev, type, code)) {
 704                 *value = libevdev_get_event_value(dev, type, code);
 705                 return 1;
 706         } else
 707                 return 0;
 708 }
 709
 710 int
 711 libevdev_get_slot_value(const struct libevdev *dev, unsigned int slot, unsigned int code)
 712 {
 713         if (!libevdev_has_event_type(dev, EV_ABS) || !libevdev_has_event_code(dev, EV_ABS, code))
 714                 return 0;
 715
 716         if (slot >= dev->num_slots || slot >= MAX_SLOTS)
 717                 return 0;
 718
 719         if (code > ABS_MT_MAX || code < ABS_MT_MIN)
 720                 return 0;
 721
 722         return dev->mt_slot_vals[slot][code - ABS_MT_MIN];
 723 }
 724
 725 int
 726 libevdev_fetch_slot_value(const struct libevdev *dev, unsigned int slot, unsigned int code, int *value)
 727 {
 728         if (libevdev_has_event_type(dev, EV_ABS) &&
 729             libevdev_has_event_code(dev, EV_ABS, code) &&
 730             slot < dev->num_slots && slot < MAX_SLOTS) {
 731                 *value = libevdev_get_slot_value(dev, slot, code);
 732                 return 1;
 733         } else
 734                 return 0;
 735 }
 736
 737 int
 738 libevdev_get_num_slots(const struct libevdev *dev)
 739 {
 740         return dev->num_slots;
 741 }
 742
 743 int
 744 libevdev_get_current_slot(const struct libevdev *dev)
 745 {
 746         return dev->current_slot;
 747 }
 748
 749 const struct input_absinfo*
 750 libevdev_get_abs_info(const struct libevdev *dev, unsigned int code)
 751 {
 752         if (!libevdev_has_event_type(dev, EV_ABS) ||
 753             !libevdev_has_event_code(dev, EV_ABS, code))
 754                 return NULL;
 755
 756         return &dev->abs_info[code];
 757 }
 758
 759 int
 760 libevdev_get_abs_min(const struct libevdev *dev, unsigned int code)
 761 {
 762         const struct input_absinfo *absinfo = libevdev_get_abs_info(dev, code);
 763
 764         return absinfo ? absinfo->minimum : 0;
 765 }
 766
 767 int
 768 libevdev_get_abs_max(const struct libevdev *dev, unsigned int code)
 769 {
 770         const struct input_absinfo *absinfo = libevdev_get_abs_info(dev, code);
 771
 772         return absinfo ? absinfo->maximum : 0;
 773 }
 774
 775 int
 776 libevdev_get_abs_fuzz(const struct libevdev *dev, unsigned int code)
 777 {
 778         const struct input_absinfo *absinfo = libevdev_get_abs_info(dev, code);
 779
 780         return absinfo ? absinfo->fuzz : 0;
 781 }
 782
 783 int
 784 libevdev_get_abs_flat(const struct libevdev *dev, unsigned int code)
 785 {
 786         const struct input_absinfo *absinfo = libevdev_get_abs_info(dev, code);
 787
 788         return absinfo ? absinfo->flat : 0;
 789 }
 790
 791 int
 792 libevdev_get_abs_resolution(const struct libevdev *dev, unsigned int code)
 793 {
 794         const struct input_absinfo *absinfo = libevdev_get_abs_info(dev, code);
 795
 796         return absinfo ? absinfo->resolution : 0;
 797 }
 798
 799 int
 800 libevdev_enable_event_type(struct libevdev *dev, unsigned int type)
 801 {
 802         if (type > EV_MAX)
 803                 return -1;
 804
 805         set_bit(dev->bits, type);
 806
 807         return 0;
 808 }
 809
 810 int
 811 libevdev_disable_event_type(struct libevdev *dev, unsigned int type)
 812 {
 813         if (type > EV_MAX || type == EV_SYN)
 814                 return -1;
 815
 816         clear_bit(dev->bits, type);
 817
 818         return 0;
 819 }
 820
 821 int
 822 libevdev_enable_event_code(struct libevdev *dev, unsigned int type,
 823                            unsigned int code, const void *data)
 824 {
 825         unsigned int max;
 826         unsigned long *mask;
 827
 828         if (libevdev_enable_event_type(dev, type))
 829                 return -1;
 830
 831         if (type != EV_ABS && data != NULL)
 832                 return -1;
 833
 834         max = type_to_mask(dev, type, &mask);
 835
 836         if (code > max)
 837                 return -1;
 838
 839         set_bit(mask, code);
 840
 841         if (type == EV_ABS) {
 842                 const struct input_absinfo *abs = data;
 843                 dev->abs_info[code] = *abs;
 844         }
 845
 846         return 0;
 847 }
 848
 849 int
 850 libevdev_disable_event_code(struct libevdev *dev, unsigned int type, unsigned int code)
 851 {
 852         unsigned int max;
 853         unsigned long *mask;
 854
 855         if (type > EV_MAX)
 856                 return -1;
 857
 858         max = type_to_mask(dev, type, &mask);
 859
 860         if (code > max)
 861                 return -1;
 862
 863         clear_bit(mask, code);
 864
 865         return 0;
 866 }
 867
 868 int
 869 libevdev_kernel_set_abs_value(struct libevdev *dev, unsigned int code, const struct input_absinfo *abs)
 870 {
 871         int rc;
 872
 873         if (code > ABS_MAX)
 874                 return -EINVAL;
 875
 876         rc = ioctl(dev->fd, EVIOCSABS(code), abs);
 877         if (rc < 0)
 878                 rc = -errno;
 879         else
 880                 rc = libevdev_enable_event_code(dev, EV_ABS, code, abs);
 881
 882         return rc;
 883 }
 884
 885 int
 886 libevdev_grab(struct libevdev *dev, int grab)
 887 {
 888         int rc = 0;
 889
 890         if (grab != LIBEVDEV_GRAB && grab != LIBEVDEV_UNGRAB)
 891                 return -EINVAL;
 892
 893         if (grab == dev->grabbed)
 894                 return 0;
 895
 896         if (grab == LIBEVDEV_GRAB)
 897                 rc = ioctl(dev->fd, EVIOCGRAB, (void *)1);
 898         else if (grab == LIBEVDEV_UNGRAB)
 899                 rc = ioctl(dev->fd, EVIOCGRAB, (void *)0);
 900
 901         if (rc == 0)
 902                 dev->grabbed = grab;
 903
 904         return rc < 0 ? -errno : 0;
 905 }
 906
 907 const char*
 908 libevdev_get_event_type_name(unsigned int type)
 909 {
 910         if (type > EV_MAX)
 911                 return NULL;
 912
 913         return ev_map[type];
 914 }
 915
 916 const char*
 917 libevdev_get_event_code_name(unsigned int type, unsigned int code)
 918 {
 919         if (type > EV_MAX)
 920                 return NULL;
 921
 922         if (code > ev_max[type])
 923                 return NULL;
 924
 925         return event_type_map[type][code];
 926 }
 927
 928 const char*
 929 libevdev_get_input_prop_name(unsigned int prop)
 930 {
 931         if (prop > INPUT_PROP_MAX)
 932                 return NULL;
 933
 934         return input_prop_map[prop];
 935 }
 936
 937 int
 938 libevdev_get_event_type_max(unsigned int type)
 939 {
 940         if (type > EV_MAX)
 941                 return -1;
 942
 943         return ev_max[type];
 944 }
 945
 946 int
 947 libevdev_get_repeat(struct libevdev *dev, int *delay, int *period)
 948 {
 949         if (!libevdev_has_event_type(dev, EV_REP))
 950                 return -1;
 951
 952         if (delay != NULL)
 953                 *delay = dev->rep_values[REP_DELAY];
 954         if (period != NULL)
 955                 *period = dev->rep_values[REP_PERIOD];
 956
 957         return 0;
 958 }