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