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_NORMAL|LIBEVDEV_READ_SYNC|LIBEVDEV_FORCE_SYNC)))
 534                 return -EINVAL;
 535
 536         if (flags & LIBEVDEV_READ_SYNC) {
 537                 if (!dev->need_sync && dev->queue_nsync == 0)
 538                         return -EAGAIN;
 539                 else if (dev->need_sync) {
 540                         rc = sync_state(dev);
 541                         if (rc != 0)
 542                                 return rc;
 543                 }
 544         } else if (dev->need_sync) {
 545                 /* FIXME: still need to call update_state for all events
 546                  * here, otherwise the library has the wrong view of the
 547                  * device too */
 548                 queue_shift_multiple(dev, dev->queue_nsync, NULL);
 549         }
 550
 551         /* FIXME: check for O_NONBLOCK and if not set, skip if we have an
 552          * event in the queue from the previous read.
 553          */
 554
 555         /* FIXME: if the first event after syncing is a SYN_DROPPED, log this */
 556
 557         /* Always read in some more events. Best case this smoothes over a potential SYN_DROPPED,
 558            worst case we don't read fast enough and end up with SYN_DROPPED anyway */
 559         do {
 560                 rc = read_more_events(dev);
 561                 if (rc < 0 && rc != -EAGAIN)
 562                         goto out;
 563
 564                 if (flags & LIBEVDEV_FORCE_SYNC) {
 565                         dev->need_sync = 1;
 566                         rc = 1;
 567                         goto out;
 568                 }
 569
 570
 571                 if (queue_shift(dev, ev) != 0)
 572                         return -EAGAIN;
 573
 574                 update_state(dev, ev);
 575
 576         /* if we disabled a code, get the next event instead */
 577         } while(!libevdev_has_event_code(dev, ev->type, ev->code));
 578
 579         rc = 0;
 580         if (ev->type == EV_SYN && ev->code == SYN_DROPPED) {
 581                 dev->need_sync = 1;
 582                 rc = 1;
 583         }
 584
 585         if (flags & LIBEVDEV_READ_SYNC && dev->queue_nsync > 0) {
 586                 dev->queue_nsync--;
 587                 rc = 1;
 588         }
 589
 590 out:
 591         return rc;
 592 }
 593
 594 const char *
 595 libevdev_get_name(const struct libevdev *dev)
 596 {
 597         return dev->name ? dev->name : "";
 598 }
 599
 600 const char *
 601 libevdev_get_phys(const struct libevdev *dev)
 602 {
 603         return dev->phys;
 604 }
 605
 606 const char *
 607 libevdev_get_uniq(const struct libevdev *dev)
 608 {
 609         return dev->uniq;
 610 }
 611
 612 int libevdev_get_product_id(const struct libevdev *dev)
 613 {
 614         return dev->ids.product;
 615 }
 616
 617 int libevdev_get_vendor_id(const struct libevdev *dev)
 618 {
 619         return dev->ids.vendor;
 620 }
 621
 622 int libevdev_get_bustype(const struct libevdev *dev)
 623 {
 624         return dev->ids.bustype;
 625 }
 626
 627 int libevdev_get_version(const struct libevdev *dev)
 628 {
 629         return dev->ids.version;
 630 }
 631
 632 int libevdev_get_driver_version(const struct libevdev *dev)
 633 {
 634         return dev->driver_version;
 635 }
 636
 637 int
 638 libevdev_has_property(const struct libevdev *dev, unsigned int prop)
 639 {
 640         return (prop <= INPUT_PROP_MAX) && bit_is_set(dev->props, prop);
 641 }
 642
 643 int
 644 libevdev_has_event_type(const struct libevdev *dev, unsigned int type)
 645 {
 646         return (type <= EV_MAX) && bit_is_set(dev->bits, type);
 647 }
 648
 649 int
 650 libevdev_has_event_code(const struct libevdev *dev, unsigned int type, unsigned int code)
 651 {
 652         const unsigned long *mask;
 653         int max;
 654
 655         if (!libevdev_has_event_type(dev, type))
 656                 return 0;
 657
 658         if (type == EV_SYN)
 659                 return 1;
 660
 661         max = type_to_mask_const(dev, type, &mask);
 662
 663         if (max == -1 || code > max)
 664                 return 0;
 665
 666         return bit_is_set(mask, code);
 667 }
 668
 669 int
 670 libevdev_get_event_value(const struct libevdev *dev, unsigned int type, unsigned int code)
 671 {
 672         int value;
 673
 674         if (!libevdev_has_event_type(dev, type) || !libevdev_has_event_code(dev, type, code))
 675                 return 0;
 676
 677         switch (type) {
 678                 case EV_ABS: value = dev->abs_info[code].value; break;
 679                 case EV_KEY: value = bit_is_set(dev->key_values, code); break;
 680                 default:
 681                         value = 0;
 682                         break;
 683         }
 684
 685         return value;
 686 }
 687
 688 int
 689 libevdev_fetch_event_value(const struct libevdev *dev, unsigned int type, unsigned int code, int *value)
 690 {
 691         if (libevdev_has_event_type(dev, type) &&
 692             libevdev_has_event_code(dev, type, code)) {
 693                 *value = libevdev_get_event_value(dev, type, code);
 694                 return 1;
 695         } else
 696                 return 0;
 697 }
 698
 699 int
 700 libevdev_get_slot_value(const struct libevdev *dev, unsigned int slot, unsigned int code)
 701 {
 702         if (!libevdev_has_event_type(dev, EV_ABS) || !libevdev_has_event_code(dev, EV_ABS, code))
 703                 return 0;
 704
 705         if (slot >= dev->num_slots || slot >= MAX_SLOTS)
 706                 return 0;
 707
 708         if (code > ABS_MT_MAX || code < ABS_MT_MIN)
 709                 return 0;
 710
 711         return dev->mt_slot_vals[slot][code - ABS_MT_MIN];
 712 }
 713
 714 int
 715 libevdev_fetch_slot_value(const struct libevdev *dev, unsigned int slot, unsigned int code, int *value)
 716 {
 717         if (libevdev_has_event_type(dev, EV_ABS) &&
 718             libevdev_has_event_code(dev, EV_ABS, code) &&
 719             slot < dev->num_slots && slot < MAX_SLOTS) {
 720                 *value = libevdev_get_slot_value(dev, slot, code);
 721                 return 1;
 722         } else
 723                 return 0;
 724 }
 725
 726 int
 727 libevdev_get_num_slots(const struct libevdev *dev)
 728 {
 729         return dev->num_slots;
 730 }
 731
 732 int
 733 libevdev_get_current_slot(const struct libevdev *dev)
 734 {
 735         return dev->current_slot;
 736 }
 737
 738 const struct input_absinfo*
 739 libevdev_get_abs_info(const struct libevdev *dev, unsigned int code)
 740 {
 741         if (!libevdev_has_event_type(dev, EV_ABS) ||
 742             !libevdev_has_event_code(dev, EV_ABS, code))
 743                 return NULL;
 744
 745         return &dev->abs_info[code];
 746 }
 747
 748 int
 749 libevdev_get_abs_min(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->minimum : 0;
 754 }
 755
 756 int
 757 libevdev_get_abs_max(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->maximum : 0;
 762 }
 763
 764 int
 765 libevdev_get_abs_fuzz(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->fuzz : 0;
 770 }
 771
 772 int
 773 libevdev_get_abs_flat(const struct libevdev *dev, unsigned int code)
 774 {
 775         const struct input_absinfo *absinfo = libevdev_get_abs_info(dev, code);
 776
 777         return absinfo ? absinfo->flat : 0;
 778 }
 779
 780 int
 781 libevdev_get_abs_resolution(const struct libevdev *dev, unsigned int code)
 782 {
 783         const struct input_absinfo *absinfo = libevdev_get_abs_info(dev, code);
 784
 785         return absinfo ? absinfo->resolution : 0;
 786 }
 787
 788 int
 789 libevdev_enable_event_type(struct libevdev *dev, unsigned int type)
 790 {
 791         if (type > EV_MAX)
 792                 return -1;
 793
 794         set_bit(dev->bits, type);
 795
 796         return 0;
 797 }
 798
 799 int
 800 libevdev_disable_event_type(struct libevdev *dev, unsigned int type)
 801 {
 802         if (type > EV_MAX || type == EV_SYN)
 803                 return -1;
 804
 805         clear_bit(dev->bits, type);
 806
 807         return 0;
 808 }
 809
 810 int
 811 libevdev_enable_event_code(struct libevdev *dev, unsigned int type,
 812                            unsigned int code, const void *data)
 813 {
 814         unsigned int max;
 815         unsigned long *mask;
 816
 817         if (libevdev_enable_event_type(dev, type))
 818                 return -1;
 819
 820         if (type != EV_ABS && data != NULL)
 821                 return -1;
 822
 823         max = type_to_mask(dev, type, &mask);
 824
 825         if (code > max)
 826                 return -1;
 827
 828         set_bit(mask, code);
 829
 830         if (type == EV_ABS) {
 831                 const struct input_absinfo *abs = data;
 832                 dev->abs_info[code] = *abs;
 833         }
 834
 835         return 0;
 836 }
 837
 838 int
 839 libevdev_disable_event_code(struct libevdev *dev, unsigned int type, unsigned int code)
 840 {
 841         unsigned int max;
 842         unsigned long *mask;
 843
 844         if (type > EV_MAX)
 845                 return -1;
 846
 847         max = type_to_mask(dev, type, &mask);
 848
 849         if (code > max)
 850                 return -1;
 851
 852         clear_bit(mask, code);
 853
 854         return 0;
 855 }
 856
 857 int
 858 libevdev_kernel_set_abs_value(struct libevdev *dev, unsigned int code, const struct input_absinfo *abs)
 859 {
 860         int rc;
 861
 862         if (code > ABS_MAX)
 863                 return -EINVAL;
 864
 865         rc = ioctl(dev->fd, EVIOCSABS(code), abs);
 866         if (rc < 0)
 867                 rc = -errno;
 868         else
 869                 rc = libevdev_enable_event_code(dev, EV_ABS, code, abs);
 870
 871         return rc;
 872 }
 873
 874 int
 875 libevdev_grab(struct libevdev *dev, int grab)
 876 {
 877         int rc = 0;
 878
 879         if (grab != LIBEVDEV_GRAB && grab != LIBEVDEV_UNGRAB)
 880                 return -EINVAL;
 881
 882         if (grab == dev->grabbed)
 883                 return 0;
 884
 885         if (grab == LIBEVDEV_GRAB)
 886                 rc = ioctl(dev->fd, EVIOCGRAB, (void *)1);
 887         else if (grab == LIBEVDEV_UNGRAB)
 888                 rc = ioctl(dev->fd, EVIOCGRAB, (void *)0);
 889
 890         if (rc == 0)
 891                 dev->grabbed = grab;
 892
 893         return rc < 0 ? -errno : 0;
 894 }
 895
 896 const char*
 897 libevdev_get_event_type_name(unsigned int type)
 898 {
 899         if (type > EV_MAX)
 900                 return NULL;
 901
 902         return ev_map[type];
 903 }
 904
 905 const char*
 906 libevdev_get_event_code_name(unsigned int type, unsigned int code)
 907 {
 908         if (type > EV_MAX)
 909                 return NULL;
 910
 911         if (code > ev_max[type])
 912                 return NULL;
 913
 914         return event_type_map[type][code];
 915 }
 916
 917 const char*
 918 libevdev_get_input_prop_name(unsigned int prop)
 919 {
 920         if (prop > INPUT_PROP_MAX)
 921                 return NULL;
 922
 923         return input_prop_map[prop];
 924 }
 925
 926 int
 927 libevdev_get_event_type_max(unsigned int type)
 928 {
 929         if (type > EV_MAX)
 930                 return -1;
 931
 932         return ev_max[type];
 933 }
 934
 935 int
 936 libevdev_get_repeat(struct libevdev *dev, int *delay, int *period)
 937 {
 938         if (!libevdev_has_event_type(dev, EV_REP))
 939                 return -1;
 940
 941         if (delay != NULL)
 942                 *delay = dev->rep_values[REP_DELAY];
 943         if (period != NULL)
 944                 *period = dev->rep_values[REP_PERIOD];
 945
 946         return 0;
 947 }