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