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