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), &dev->abs_info[i]);
 292                         if (rc < 0)
 293                                 goto out;
 294
 295                         if (i == ABS_MT_SLOT) {
 296                                 dev->num_slots = abs_info.maximum + 1; /* FIXME: non-zero min? */
 297                                 dev->current_slot = abs_info.value;
 298                         }
 299
 300                 }
 301         }
 302
 303         rc = init_event_queue(dev);
 304         if (rc < 0)
 305                 return -rc;
 306
 307         /* not copying key state because we won't know when we'll start to
 308          * use this fd and key's are likely to change state by then.
 309          * Same with the valuators, really, but they may not change.
 310          */
 311
 312         dev->fd = fd;
 313
 314 out:
 315         return rc ? -errno : 0;
 316 }
 317
 318 int
 319 libevdev_get_fd(const struct libevdev* dev)
 320 {
 321         return dev->fd;
 322 }
 323
 324 static inline void
 325 init_event(struct input_event *ev, int type, int code, int value)
 326 {
 327         ev->time.tv_sec = 0; /* FIXME: blah! */
 328         ev->time.tv_usec = 0; /* FIXME: blah! */
 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(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(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(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(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(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         return rc;
 547 }
 548
 549 static int
 550 read_more_events(struct libevdev *dev)
 551 {
 552         int free_elem;
 553         int len;
 554         struct input_event *next;
 555
 556         free_elem = queue_num_free_elements(dev);
 557         if (free_elem <= 0)
 558                 return 0;
 559
 560         next = queue_next_element(dev);
 561         len = read(dev->fd, next, free_elem * sizeof(struct input_event));
 562         if (len < 0) {
 563                 return -errno;
 564         } else if (len > 0 && len % sizeof(struct input_event) != 0)
 565                 return -EINVAL;
 566         else if (len > 0) {
 567                 int nev = len/sizeof(struct input_event);
 568                 queue_set_num_elements(dev, queue_num_elements(dev) + nev);
 569         }
 570
 571         return 0;
 572 }
 573
 574 int libevdev_next_event(struct libevdev *dev, unsigned int flags, struct input_event *ev)
 575 {
 576         int rc = 0;
 577
 578         if (dev->fd < 0)
 579                 return -ENODEV;
 580
 581         if (flags & LIBEVDEV_READ_SYNC) {
 582                 if (!dev->need_sync && dev->queue_nsync == 0)
 583                         return -EAGAIN;
 584                 else if (dev->need_sync) {
 585                         rc = sync_state(dev);
 586                         if (rc != 0)
 587                                 return rc;
 588                 }
 589         } else if (dev->need_sync) {
 590                 /* FIXME: still need to call update_state for all events
 591                  * here, otherwise the library has the wrong view of the
 592                  * device too */
 593                 queue_shift_multiple(dev, dev->queue_nsync, NULL);
 594         }
 595
 596         /* FIXME: check for O_NONBLOCK and if not set, skip if we have an
 597          * event in the queue from the previous read.
 598          */
 599
 600         /* Always read in some more events. Best case this smoothes over a potential SYN_DROPPED,
 601            worst case we don't read fast enough and end up with SYN_DROPPED anyway */
 602         rc = read_more_events(dev);
 603         if (rc < 0 && rc != -EAGAIN)
 604                 goto out;
 605
 606         if (queue_shift(dev, ev) != 0)
 607                 return -EAGAIN;
 608
 609         update_state(dev, ev);
 610
 611         rc = 0;
 612         if (ev->type == EV_SYN && ev->code == SYN_DROPPED) {
 613                 dev->need_sync = 1;
 614                 rc = 1;
 615         }
 616
 617         if (flags & LIBEVDEV_READ_SYNC && dev->queue_nsync > 0) {
 618                 dev->queue_nsync--;
 619                 rc = 1;
 620         }
 621
 622 out:
 623         return rc;
 624 }
 625
 626 const char *
 627 libevdev_get_name(const struct libevdev *dev)
 628 {
 629         return dev->name;
 630 }
 631
 632 const char *
 633 libevdev_get_phys(const struct libevdev *dev)
 634 {
 635         return dev->phys;
 636 }
 637
 638 const char *
 639 libevdev_get_uniq(const struct libevdev *dev)
 640 {
 641         return dev->uniq;
 642 }
 643
 644 int libevdev_get_product_id(const struct libevdev *dev)
 645 {
 646         return dev->ids.product;
 647 }
 648
 649 int libevdev_get_vendor_id(const struct libevdev *dev)
 650 {
 651         return dev->ids.vendor;
 652 }
 653
 654 int libevdev_get_bustype(const struct libevdev *dev)
 655 {
 656         return dev->ids.bustype;
 657 }
 658
 659 int libevdev_get_version(const struct libevdev *dev)
 660 {
 661         return dev->ids.version;
 662 }
 663
 664 int libevdev_get_driver_version(const struct libevdev *dev)
 665 {
 666         return dev->driver_version;
 667 }
 668
 669 int
 670 libevdev_has_property(const struct libevdev *dev, unsigned int prop)
 671 {
 672         return (prop <= INPUT_PROP_MAX) && bit_is_set(dev->props, prop);
 673 }
 674
 675 int
 676 libevdev_has_event_type(const struct libevdev *dev, unsigned int type)
 677 {
 678         return (type <= EV_MAX) && bit_is_set(dev->bits, type);
 679 }
 680
 681 int
 682 libevdev_has_event_code(const struct libevdev *dev, unsigned int type, unsigned int code)
 683 {
 684         const unsigned long *mask;
 685         unsigned int max;
 686
 687         if (!libevdev_has_event_type(dev, type))
 688                 return 0;
 689
 690         if (type == EV_SYN)
 691                 return 1;
 692
 693         max = type_to_mask_const(dev, type, &mask);
 694
 695         if (code > max)
 696                 return 0;
 697
 698         return bit_is_set(mask, code);
 699 }
 700
 701 int
 702 libevdev_get_event_value(const struct libevdev *dev, unsigned int type, unsigned int code)
 703 {
 704         int value;
 705
 706         if (!libevdev_has_event_type(dev, type) || !libevdev_has_event_code(dev, type, code))
 707                 return 0;
 708
 709         switch (type) {
 710                 case EV_ABS: value = dev->abs_info[code].value; break;
 711                 case EV_KEY: value = bit_is_set(dev->key_values, code); break;
 712                 default:
 713                         value = 0;
 714                         break;
 715         }
 716
 717         return value;
 718 }
 719
 720 int
 721 libevdev_fetch_event_value(const struct libevdev *dev, unsigned int type, unsigned int code, int *value)
 722 {
 723         if (libevdev_has_event_type(dev, type) &&
 724             libevdev_has_event_code(dev, type, code)) {
 725                 *value = libevdev_get_event_value(dev, type, code);
 726                 return 1;
 727         } else
 728                 return 0;
 729 }
 730
 731 int
 732 libevdev_get_slot_value(const struct libevdev *dev, unsigned int slot, unsigned int code)
 733 {
 734         if (!libevdev_has_event_type(dev, EV_ABS) || !libevdev_has_event_code(dev, EV_ABS, code))
 735                 return 0;
 736
 737         if (slot >= dev->num_slots || slot >= MAX_SLOTS)
 738                 return 0;
 739
 740         if (code > ABS_MT_MAX || code < ABS_MT_MIN)
 741                 return 0;
 742
 743         return dev->mt_slot_vals[slot][code - ABS_MT_MIN];
 744 }
 745
 746 int
 747 libevdev_fetch_slot_value(const struct libevdev *dev, unsigned int slot, unsigned int code, int *value)
 748 {
 749         if (libevdev_has_event_type(dev, EV_ABS) &&
 750             libevdev_has_event_code(dev, EV_ABS, code) &&
 751             slot < dev->num_slots && slot < MAX_SLOTS) {
 752                 *value = libevdev_get_slot_value(dev, slot, code);
 753                 return 1;
 754         } else
 755                 return 0;
 756 }
 757
 758 int
 759 libevdev_get_num_slots(const struct libevdev *dev)
 760 {
 761         return dev->num_slots;
 762 }
 763
 764 int
 765 libevdev_get_current_slot(const struct libevdev *dev)
 766 {
 767         return dev->current_slot;
 768 }
 769
 770 const struct input_absinfo*
 771 libevdev_get_abs_info(const struct libevdev *dev, unsigned int code)
 772 {
 773         if (!libevdev_has_event_type(dev, EV_ABS) ||
 774             !libevdev_has_event_code(dev, EV_ABS, code))
 775                 return NULL;
 776
 777         return &dev->abs_info[code];
 778 }
 779
 780 int
 781 libevdev_get_abs_min(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->minimum : 0;
 786 }
 787
 788 int
 789 libevdev_get_abs_max(const struct libevdev *dev, unsigned int code)
 790 {
 791         const struct input_absinfo *absinfo = libevdev_get_abs_info(dev, code);
 792
 793         return absinfo ? absinfo->maximum : 0;
 794 }
 795
 796 int
 797 libevdev_get_abs_fuzz(const struct libevdev *dev, unsigned int code)
 798 {
 799         const struct input_absinfo *absinfo = libevdev_get_abs_info(dev, code);
 800
 801         return absinfo ? absinfo->fuzz : 0;
 802 }
 803
 804 int
 805 libevdev_get_abs_flat(const struct libevdev *dev, unsigned int code)
 806 {
 807         const struct input_absinfo *absinfo = libevdev_get_abs_info(dev, code);
 808
 809         return absinfo ? absinfo->flat : 0;
 810 }
 811
 812 int
 813 libevdev_get_abs_resolution(const struct libevdev *dev, unsigned int code)
 814 {
 815         const struct input_absinfo *absinfo = libevdev_get_abs_info(dev, code);
 816
 817         return absinfo ? absinfo->resolution : 0;
 818 }
 819
 820 int
 821 libevdev_enable_event_type(struct libevdev *dev, unsigned int type)
 822 {
 823         if (type > EV_MAX)
 824                 return 1;
 825
 826         set_bit(dev->bits, type);
 827
 828         /* FIXME: pass through to kernel */
 829
 830         return 0;
 831 }
 832
 833 int
 834 libevdev_disable_event_type(struct libevdev *dev, unsigned int type)
 835 {
 836         if (type > EV_MAX)
 837                 return 1;
 838
 839         clear_bit(dev->bits, type);
 840
 841         /* FIXME: pass through to kernel */
 842
 843         return 0;
 844 }
 845
 846 int
 847 libevdev_enable_event_code(struct libevdev *dev, unsigned int type,
 848                            unsigned int code, const void *data)
 849 {
 850         unsigned int max;
 851         unsigned long *mask;
 852
 853         if (libevdev_enable_event_type(dev, type))
 854                 return 1;
 855
 856         max = type_to_mask(dev, type, &mask);
 857
 858         if (code > max)
 859                 return 1;
 860
 861         set_bit(mask, code);
 862
 863         if (type == EV_ABS) {
 864                 const struct input_absinfo *abs = data;
 865                 dev->abs_info[code] = *abs;
 866         }
 867
 868         /* FIXME: pass through to kernel */
 869
 870         return 0;
 871 }
 872
 873 int
 874 libevdev_disable_event_code(struct libevdev *dev, unsigned int type, unsigned int code)
 875 {
 876         unsigned int max;
 877         unsigned long *mask;
 878
 879         if (type > EV_MAX)
 880                 return 1;
 881
 882         max = type_to_mask(dev, type, &mask);
 883
 884         if (code > max)
 885                 return 1;
 886
 887         clear_bit(mask, code);
 888
 889         /* FIXME: pass through to kernel */
 890
 891         return 0;
 892 }
 893
 894 int
 895 libevdev_kernel_set_abs_value(struct libevdev *dev, unsigned int code, const struct input_absinfo *abs)
 896 {
 897         int rc;
 898
 899         if (code > ABS_MAX)
 900                 return -EINVAL;
 901
 902         rc = ioctl(dev->fd, EVIOCSABS(code), *abs);
 903         if (rc < 0)
 904                 rc = -errno;
 905         else
 906                 rc = libevdev_enable_event_code(dev, EV_ABS, code, abs);
 907
 908         return rc;
 909 }
 910
 911 int
 912 libevdev_grab(struct libevdev *dev, int grab)
 913 {
 914         int rc = 0;
 915
 916         if (grab != LIBEVDEV_GRAB && grab != LIBEVDEV_UNGRAB)
 917                 return -EINVAL;
 918
 919         if (grab == dev->grabbed)
 920                 return 0;
 921
 922         if (grab == LIBEVDEV_GRAB)
 923                 rc = ioctl(dev->fd, EVIOCGRAB, (void *)1);
 924         else if (grab == LIBEVDEV_UNGRAB)
 925                 rc = ioctl(dev->fd, EVIOCGRAB, (void *)0);
 926
 927         if (rc == 0)
 928                 dev->grabbed = grab;
 929
 930         return rc < 0 ? -errno : 0;
 931 }