2 * Copyright © 2013 Red Hat, Inc.
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.
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
33 #include "libevdev-int.h"
34 #include "libevdev-util.h"
35 #include "event-names.h"
40 LIBEVDEV_EXPORT const enum libevdev_read_flag LIBEVDEV_READ_SYNC = LIBEVDEV_READ_FLAG_SYNC;
41 LIBEVDEV_EXPORT const enum libevdev_read_flag LIBEVDEV_READ_NORMAL = LIBEVDEV_READ_FLAG_NORMAL;
42 LIBEVDEV_EXPORT const enum libevdev_read_flag LIBEVDEV_FORCE_SYNC = LIBEVDEV_READ_FLAG_FORCE_SYNC;
43 LIBEVDEV_EXPORT const enum libevdev_read_flag LIBEVDEV_READ_BLOCKING = LIBEVDEV_READ_FLAG_BLOCKING;
45 static int sync_mt_state(struct libevdev *dev, int create_events);
48 init_event_queue(struct libevdev *dev)
50 /* FIXME: count the number of axes, keys, etc. to get a better idea at how many events per
51 EV_SYN we could possibly get. Then multiply that by the actual buffer size we care about */
53 const int QUEUE_SIZE = 256;
55 return queue_alloc(dev, QUEUE_SIZE);
59 libevdev_dflt_log_func(enum libevdev_log_priority priority,
61 const char *file, int line, const char *func,
62 const char *format, va_list args)
66 case LIBEVDEV_LOG_ERROR: prefix = "libevdev error"; break;
67 case LIBEVDEV_LOG_INFO: prefix = "libevdev info"; break;
68 case LIBEVDEV_LOG_DEBUG:
69 prefix = "libevdev debug";
72 prefix = "libevdev INVALID LOG PRIORITY";
75 /* default logging format:
76 libevev error in libevdev_some_func: blah blah
77 libevev info in libevdev_some_func: blah blah
78 libevev debug in file.c:123:libevdev_some_func: blah blah
81 fprintf(stderr, "%s in ", prefix);
82 if (priority == LIBEVDEV_LOG_DEBUG)
83 fprintf(stderr, "%s:%d:", file, line);
84 fprintf(stderr, "%s: ", func);
85 vfprintf(stderr, format, args);
89 * Global logging settings.
91 struct logdata log_data = {
93 libevdev_dflt_log_func,
98 log_msg(enum libevdev_log_priority priority,
100 const char *file, int line, const char *func,
101 const char *format, ...)
105 if (!log_data.handler)
108 va_start(args, format);
109 log_data.handler(priority, data, file, line, func, format, args);
114 libevdev_reset(struct libevdev *dev)
116 memset(dev, 0, sizeof(*dev));
118 dev->initialized = false;
120 dev->current_slot = -1;
121 dev->grabbed = LIBEVDEV_UNGRAB;
122 dev->sync_state = SYNC_NONE;
125 LIBEVDEV_EXPORT struct libevdev*
128 struct libevdev *dev;
130 dev = malloc(sizeof(*dev));
140 libevdev_new_from_fd(int fd, struct libevdev **dev)
149 rc = libevdev_set_fd(d, fd);
158 libevdev_free(struct libevdev *dev)
172 libevdev_set_log_handler(struct libevdev *dev, libevdev_log_func_t logfunc)
174 /* Can't be backwards compatible to this yet, so don't even try */
175 fprintf(stderr, "libevdev: ABI change. Log function will not be honored.\n");
179 libevdev_set_log_function(libevdev_log_func_t logfunc, void *data)
181 log_data.handler = logfunc;
182 log_data.userdata = data;
186 libevdev_set_log_priority(enum libevdev_log_priority priority)
188 if (priority > LIBEVDEV_LOG_DEBUG)
189 priority = LIBEVDEV_LOG_DEBUG;
190 log_data.priority = priority;
193 LIBEVDEV_EXPORT enum libevdev_log_priority
194 libevdev_get_log_priority(void)
196 return log_data.priority;
200 libevdev_change_fd(struct libevdev *dev, int fd)
202 if (!dev->initialized) {
203 log_bug("device not initialized. call libevdev_set_fd() first\n");
211 libevdev_set_fd(struct libevdev* dev, int fd)
217 if (dev->initialized) {
218 log_bug("device already initialized.\n");
225 rc = ioctl(fd, EVIOCGBIT(0, sizeof(dev->bits)), dev->bits);
229 memset(buf, 0, sizeof(buf));
230 rc = ioctl(fd, EVIOCGNAME(sizeof(buf) - 1), buf);
235 dev->name = strdup(buf);
243 memset(buf, 0, sizeof(buf));
244 rc = ioctl(fd, EVIOCGPHYS(sizeof(buf) - 1), buf);
246 /* uinput has no phys */
250 dev->phys = strdup(buf);
259 memset(buf, 0, sizeof(buf));
260 rc = ioctl(fd, EVIOCGUNIQ(sizeof(buf) - 1), buf);
265 dev->uniq = strdup(buf);
272 rc = ioctl(fd, EVIOCGID, &dev->ids);
276 rc = ioctl(fd, EVIOCGVERSION, &dev->driver_version);
280 /* Built on a kernel with props, running against a kernel without property
281 support. This should not be a fatal case, we'll be missing properties but other
282 than that everything is as expected.
284 rc = ioctl(fd, EVIOCGPROP(sizeof(dev->props)), dev->props);
285 if (rc < 0 && errno != EINVAL)
288 rc = ioctl(fd, EVIOCGBIT(EV_REL, sizeof(dev->rel_bits)), dev->rel_bits);
292 rc = ioctl(fd, EVIOCGBIT(EV_ABS, sizeof(dev->abs_bits)), dev->abs_bits);
296 rc = ioctl(fd, EVIOCGBIT(EV_LED, sizeof(dev->led_bits)), dev->led_bits);
300 rc = ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(dev->key_bits)), dev->key_bits);
304 rc = ioctl(fd, EVIOCGBIT(EV_SW, sizeof(dev->sw_bits)), dev->sw_bits);
308 rc = ioctl(fd, EVIOCGBIT(EV_MSC, sizeof(dev->msc_bits)), dev->msc_bits);
312 rc = ioctl(fd, EVIOCGBIT(EV_FF, sizeof(dev->ff_bits)), dev->ff_bits);
316 rc = ioctl(fd, EVIOCGBIT(EV_SND, sizeof(dev->snd_bits)), dev->snd_bits);
320 rc = ioctl(fd, EVIOCGKEY(sizeof(dev->key_values)), dev->key_values);
324 rc = ioctl(fd, EVIOCGLED(sizeof(dev->led_values)), dev->led_values);
328 rc = ioctl(fd, EVIOCGSW(sizeof(dev->sw_values)), dev->sw_values);
332 /* rep is a special case, always set it to 1 for both values if EV_REP is set */
333 if (bit_is_set(dev->bits, EV_REP)) {
334 for (i = 0; i < REP_CNT; i++)
335 set_bit(dev->rep_bits, i);
336 rc = ioctl(fd, EVIOCGREP, dev->rep_values);
341 for (i = ABS_X; i <= ABS_MAX; i++) {
342 if (bit_is_set(dev->abs_bits, i)) {
343 struct input_absinfo abs_info;
344 rc = ioctl(fd, EVIOCGABS(i), &abs_info);
348 dev->abs_info[i] = abs_info;
349 if (i == ABS_MT_SLOT) {
350 dev->num_slots = abs_info.maximum + 1;
351 dev->current_slot = abs_info.value;
358 sync_mt_state(dev, 0);
360 rc = init_event_queue(dev);
366 /* not copying key state because we won't know when we'll start to
367 * use this fd and key's are likely to change state by then.
368 * Same with the valuators, really, but they may not change.
371 dev->initialized = true;
375 return rc ? -errno : 0;
379 libevdev_get_fd(const struct libevdev* dev)
385 init_event(struct libevdev *dev, struct input_event *ev, int type, int code, int value)
387 ev->time = dev->last_event_time;
394 sync_key_state(struct libevdev *dev)
398 unsigned long keystate[NLONGS(KEY_CNT)] = {0};
400 rc = ioctl(dev->fd, EVIOCGKEY(sizeof(keystate)), keystate);
404 for (i = 0; i < KEY_CNT; i++) {
406 old = bit_is_set(dev->key_values, i);
407 new = bit_is_set(keystate, i);
409 struct input_event *ev = queue_push(dev);
410 init_event(dev, ev, EV_KEY, i, new ? 1 : 0);
414 memcpy(dev->key_values, keystate, rc);
418 return rc ? -errno : 0;
422 sync_sw_state(struct libevdev *dev)
426 unsigned long swstate[NLONGS(SW_CNT)] = {0};
428 rc = ioctl(dev->fd, EVIOCGSW(sizeof(swstate)), swstate);
432 for (i = 0; i < SW_CNT; i++) {
434 old = bit_is_set(dev->sw_values, i);
435 new = bit_is_set(swstate, i);
437 struct input_event *ev = queue_push(dev);
438 init_event(dev, ev, EV_SW, i, new ? 1 : 0);
442 memcpy(dev->sw_values, swstate, rc);
446 return rc ? -errno : 0;
450 sync_led_state(struct libevdev *dev)
454 unsigned long ledstate[NLONGS(LED_CNT)] = {0};
456 rc = ioctl(dev->fd, EVIOCGLED(sizeof(ledstate)), ledstate);
460 for (i = 0; i < LED_CNT; i++) {
462 old = bit_is_set(dev->led_values, i);
463 new = bit_is_set(ledstate, i);
465 struct input_event *ev = queue_push(dev);
466 init_event(dev, ev, EV_LED, i, new ? 1 : 0);
470 memcpy(dev->led_values, ledstate, rc);
474 return rc ? -errno : 0;
477 sync_abs_state(struct libevdev *dev)
482 for (i = ABS_X; i < ABS_CNT; i++) {
483 struct input_absinfo abs_info;
485 if (i >= ABS_MT_MIN && i <= ABS_MT_MAX)
488 if (!bit_is_set(dev->abs_bits, i))
491 rc = ioctl(dev->fd, EVIOCGABS(i), &abs_info);
495 if (dev->abs_info[i].value != abs_info.value) {
496 struct input_event *ev = queue_push(dev);
498 init_event(dev, ev, EV_ABS, i, abs_info.value);
499 dev->abs_info[i].value = abs_info.value;
505 return rc ? -errno : 0;
509 sync_mt_state(struct libevdev *dev, int create_events)
513 int ioctl_success = 0;
517 } mt_state[ABS_MT_CNT];
519 memset(&mt_state, 0, sizeof(mt_state));
521 for (i = ABS_MT_MIN; i <= ABS_MT_MAX; i++) {
523 if (i == ABS_MT_SLOT)
526 if (!libevdev_has_event_code(dev, EV_ABS, i))
529 idx = i - ABS_MT_MIN;
530 mt_state[idx].code = i;
531 rc = ioctl(dev->fd, EVIOCGMTSLOTS(sizeof(struct mt_state)), &mt_state[idx]);
533 /* if the first ioctl fails with -EINVAL, chances are the kernel
534 doesn't support the ioctl. Simply continue */
535 if (errno == -EINVAL && !ioctl_success) {
537 } else /* if the second, ... ioctl fails, really fail */
539 } else if (ioctl_success == 0)
543 for (i = 0; i < dev->num_slots; i++) {
545 struct input_event *ev;
548 ev = queue_push(dev);
549 init_event(dev, ev, EV_ABS, ABS_MT_SLOT, i);
552 for (j = ABS_MT_MIN; j <= ABS_MT_MAX; j++) {
553 int jdx = j - ABS_MT_MIN;
555 if (j == ABS_MT_SLOT)
558 if (!libevdev_has_event_code(dev, EV_ABS, j))
561 if (dev->mt_slot_vals[i][jdx] == mt_state[jdx].val[i])
565 ev = queue_push(dev);
566 init_event(dev, ev, EV_ABS, j, mt_state[jdx].val[i]);
568 dev->mt_slot_vals[i][jdx] = mt_state[jdx].val[i];
574 return rc ? -errno : 0;
578 sync_state(struct libevdev *dev)
582 struct input_event *ev;
584 /* FIXME: if we have events in the queue after the SYN_DROPPED (which was
585 queue[0]) we need to shift this backwards. Except that chances are that the
586 queue may be either full or too full to prepend all the events needed for
589 so we search for the last sync event in the queue and drop everything before
590 including that event and rely on the kernel to tell us the right value for that
591 bitfield during the sync process.
594 for (i = queue_num_elements(dev) - 1; i >= 0; i--) {
595 struct input_event e = {{0,0}, 0, 0, 0};
596 queue_peek(dev, i, &e);
597 if (e.type == EV_SYN)
602 queue_shift_multiple(dev, i + 1, NULL);
604 if (libevdev_has_event_type(dev, EV_KEY))
605 rc = sync_key_state(dev);
606 if (libevdev_has_event_type(dev, EV_LED))
607 rc = sync_led_state(dev);
608 if (libevdev_has_event_type(dev, EV_SW))
609 rc = sync_sw_state(dev);
610 if (rc == 0 && libevdev_has_event_type(dev, EV_ABS))
611 rc = sync_abs_state(dev);
612 if (rc == 0 && libevdev_has_event_code(dev, EV_ABS, ABS_MT_SLOT))
613 rc = sync_mt_state(dev, 1);
615 dev->queue_nsync = queue_num_elements(dev);
617 if (dev->queue_nsync > 0) {
618 ev = queue_push(dev);
619 init_event(dev, ev, EV_SYN, SYN_REPORT, 0);
627 update_key_state(struct libevdev *dev, const struct input_event *e)
629 if (!libevdev_has_event_type(dev, EV_KEY))
632 if (e->code > KEY_MAX)
635 set_bit_state(dev->key_values, e->code, e->value != 0);
641 update_mt_state(struct libevdev *dev, const struct input_event *e)
643 if (e->code == ABS_MT_SLOT) {
645 dev->current_slot = e->value;
646 /* sync abs_info with the current slot values */
647 for (i = ABS_MT_SLOT + 1; i <= ABS_MT_MAX; i++) {
648 if (libevdev_has_event_code(dev, EV_ABS, i))
649 dev->abs_info[i].value = dev->mt_slot_vals[dev->current_slot][i - ABS_MT_MIN];
653 } else if (dev->current_slot == -1)
656 dev->mt_slot_vals[dev->current_slot][e->code - ABS_MT_MIN] = e->value;
662 update_abs_state(struct libevdev *dev, const struct input_event *e)
664 if (!libevdev_has_event_type(dev, EV_ABS))
667 if (e->code > ABS_MAX)
670 if (e->code >= ABS_MT_MIN && e->code <= ABS_MT_MAX)
671 update_mt_state(dev, e);
673 dev->abs_info[e->code].value = e->value;
679 update_led_state(struct libevdev *dev, const struct input_event *e)
681 if (!libevdev_has_event_type(dev, EV_LED))
684 if (e->code > LED_MAX)
687 set_bit_state(dev->led_values, e->code, e->value != 0);
693 update_sw_state(struct libevdev *dev, const struct input_event *e)
695 if (!libevdev_has_event_type(dev, EV_SW))
698 if (e->code > SW_MAX)
701 set_bit_state(dev->sw_values, e->code, e->value != 0);
707 update_state(struct libevdev *dev, const struct input_event *e)
716 rc = update_key_state(dev, e);
719 rc = update_abs_state(dev, e);
722 rc = update_led_state(dev, e);
725 rc = update_sw_state(dev, e);
729 dev->last_event_time = e->time;
735 read_more_events(struct libevdev *dev)
739 struct input_event *next;
741 free_elem = queue_num_free_elements(dev);
745 next = queue_next_element(dev);
746 len = read(dev->fd, next, free_elem * sizeof(struct input_event));
749 } else if (len > 0 && len % sizeof(struct input_event) != 0)
752 int nev = len/sizeof(struct input_event);
753 queue_set_num_elements(dev, queue_num_elements(dev) + nev);
760 libevdev_next_event(struct libevdev *dev, unsigned int flags, struct input_event *ev)
762 int rc = LIBEVDEV_READ_STATUS_SUCCESS;
764 if (!dev->initialized) {
765 log_bug("device not initialized. call libevdev_set_fd() first\n");
767 } else if (dev->fd < 0)
770 if (!(flags & (LIBEVDEV_READ_FLAG_NORMAL|LIBEVDEV_READ_FLAG_SYNC|LIBEVDEV_READ_FLAG_FORCE_SYNC))) {
771 log_bug("invalid flags %#x\n.\n", flags);
775 if (flags & LIBEVDEV_READ_FLAG_SYNC) {
776 if (dev->sync_state == SYNC_NEEDED) {
777 rc = sync_state(dev);
780 dev->sync_state = SYNC_IN_PROGRESS;
783 if (dev->queue_nsync == 0) {
784 dev->sync_state = SYNC_NONE;
788 } else if (dev->sync_state != SYNC_NONE) {
789 struct input_event e;
791 /* call update_state for all events here, otherwise the library has the wrong view
793 while (queue_shift(dev, &e) == 0) {
795 update_state(dev, &e);
798 dev->sync_state = SYNC_NONE;
801 /* FIXME: if the first event after SYNC_IN_PROGRESS is a SYN_DROPPED, log this */
803 /* Always read in some more events. Best case this smoothes over a potential SYN_DROPPED,
804 worst case we don't read fast enough and end up with SYN_DROPPED anyway.
806 Except if the fd is in blocking mode and we still have events from the last read, don't
810 if (!(flags & LIBEVDEV_READ_FLAG_BLOCKING) ||
811 queue_num_elements(dev) == 0) {
812 rc = read_more_events(dev);
813 if (rc < 0 && rc != -EAGAIN)
817 if (flags & LIBEVDEV_READ_FLAG_FORCE_SYNC) {
818 dev->sync_state = SYNC_NEEDED;
819 rc = LIBEVDEV_READ_STATUS_SYNC;
824 if (queue_shift(dev, ev) != 0)
827 update_state(dev, ev);
829 /* if we disabled a code, get the next event instead */
830 } while(!libevdev_has_event_code(dev, ev->type, ev->code));
833 if (ev->type == EV_SYN && ev->code == SYN_DROPPED) {
834 dev->sync_state = SYNC_NEEDED;
835 rc = LIBEVDEV_READ_STATUS_SYNC;
838 if (flags & LIBEVDEV_READ_FLAG_SYNC && dev->queue_nsync > 0) {
840 rc = LIBEVDEV_READ_STATUS_SYNC;
841 if (dev->queue_nsync == 0)
842 dev->sync_state = SYNC_NONE;
850 libevdev_has_event_pending(struct libevdev *dev)
852 struct pollfd fds = { dev->fd, POLLIN, 0 };
855 if (!dev->initialized) {
856 log_bug("device not initialized. call libevdev_set_fd() first\n");
858 } else if (dev->fd < 0)
861 if (queue_num_elements(dev) != 0)
864 rc = poll(&fds, 1, 0);
865 return (rc >= 0) ? rc : -errno;
868 LIBEVDEV_EXPORT const char *
869 libevdev_get_name(const struct libevdev *dev)
871 return dev->name ? dev->name : "";
874 LIBEVDEV_EXPORT const char *
875 libevdev_get_phys(const struct libevdev *dev)
880 LIBEVDEV_EXPORT const char *
881 libevdev_get_uniq(const struct libevdev *dev)
886 #define STRING_SETTER(field) \
887 LIBEVDEV_EXPORT void libevdev_set_##field(struct libevdev *dev, const char *field) \
892 dev->field = strdup(field); \
900 #define PRODUCT_GETTER(name) \
901 LIBEVDEV_EXPORT int libevdev_get_id_##name(const struct libevdev *dev) \
903 return dev->ids.name; \
906 PRODUCT_GETTER(product);
907 PRODUCT_GETTER(vendor);
908 PRODUCT_GETTER(bustype);
909 PRODUCT_GETTER(version);
911 #define PRODUCT_SETTER(field) \
912 LIBEVDEV_EXPORT void libevdev_set_id_##field(struct libevdev *dev, int field) \
914 dev->ids.field = field;\
917 PRODUCT_SETTER(product);
918 PRODUCT_SETTER(vendor);
919 PRODUCT_SETTER(bustype);
920 PRODUCT_SETTER(version);
923 libevdev_get_driver_version(const struct libevdev *dev)
925 return dev->driver_version;
929 libevdev_has_property(const struct libevdev *dev, unsigned int prop)
931 return (prop <= INPUT_PROP_MAX) && bit_is_set(dev->props, prop);
935 libevdev_enable_property(struct libevdev *dev, unsigned int prop)
937 if (prop > INPUT_PROP_MAX)
940 set_bit(dev->props, prop);
945 libevdev_has_event_type(const struct libevdev *dev, unsigned int type)
947 return (type <= EV_MAX) && bit_is_set(dev->bits, type);
951 libevdev_has_event_code(const struct libevdev *dev, unsigned int type, unsigned int code)
953 const unsigned long *mask;
956 if (!libevdev_has_event_type(dev, type))
962 max = type_to_mask_const(dev, type, &mask);
964 if (max == -1 || code > (unsigned int)max)
967 return bit_is_set(mask, code);
971 libevdev_get_event_value(const struct libevdev *dev, unsigned int type, unsigned int code)
975 if (!libevdev_has_event_type(dev, type) || !libevdev_has_event_code(dev, type, code))
979 case EV_ABS: value = dev->abs_info[code].value; break;
980 case EV_KEY: value = bit_is_set(dev->key_values, code); break;
981 case EV_LED: value = bit_is_set(dev->led_values, code); break;
982 case EV_SW: value = bit_is_set(dev->sw_values, code); break;
992 libevdev_set_event_value(struct libevdev *dev, unsigned int type, unsigned int code, int value)
995 struct input_event e;
997 if (!libevdev_has_event_type(dev, type) || !libevdev_has_event_code(dev, type, code))
1005 case EV_ABS: rc = update_abs_state(dev, &e); break;
1006 case EV_KEY: rc = update_key_state(dev, &e); break;
1007 case EV_LED: rc = update_led_state(dev, &e); break;
1008 case EV_SW: rc = update_sw_state(dev, &e); break;
1018 libevdev_fetch_event_value(const struct libevdev *dev, unsigned int type, unsigned int code, int *value)
1020 if (libevdev_has_event_type(dev, type) &&
1021 libevdev_has_event_code(dev, type, code)) {
1022 *value = libevdev_get_event_value(dev, type, code);
1029 libevdev_get_slot_value(const struct libevdev *dev, unsigned int slot, unsigned int code)
1031 if (!libevdev_has_event_type(dev, EV_ABS) || !libevdev_has_event_code(dev, EV_ABS, code))
1034 if (dev->num_slots < 0 || slot >= (unsigned int)dev->num_slots || slot >= MAX_SLOTS)
1037 if (code > ABS_MT_MAX || code < ABS_MT_MIN)
1040 return dev->mt_slot_vals[slot][code - ABS_MT_MIN];
1044 libevdev_set_slot_value(struct libevdev *dev, unsigned int slot, unsigned int code, int value)
1046 if (!libevdev_has_event_type(dev, EV_ABS) || !libevdev_has_event_code(dev, EV_ABS, code))
1049 if (dev->num_slots == -1 || slot >= (unsigned int)dev->num_slots || slot >= MAX_SLOTS)
1052 if (code > ABS_MT_MAX || code < ABS_MT_MIN)
1055 if (code == ABS_MT_SLOT) {
1056 if (value < 0 || value >= libevdev_get_num_slots(dev))
1058 dev->current_slot = value;
1061 dev->mt_slot_vals[slot][code - ABS_MT_MIN] = value;
1068 libevdev_fetch_slot_value(const struct libevdev *dev, unsigned int slot, unsigned int code, int *value)
1070 if (libevdev_has_event_type(dev, EV_ABS) &&
1071 libevdev_has_event_code(dev, EV_ABS, code) &&
1072 dev->num_slots >= 0 &&
1073 slot < (unsigned int)dev->num_slots && slot < MAX_SLOTS) {
1074 *value = libevdev_get_slot_value(dev, slot, code);
1081 libevdev_get_num_slots(const struct libevdev *dev)
1083 return dev->num_slots;
1087 libevdev_get_current_slot(const struct libevdev *dev)
1089 return dev->current_slot;
1092 LIBEVDEV_EXPORT const struct input_absinfo*
1093 libevdev_get_abs_info(const struct libevdev *dev, unsigned int code)
1095 if (!libevdev_has_event_type(dev, EV_ABS) ||
1096 !libevdev_has_event_code(dev, EV_ABS, code))
1099 return &dev->abs_info[code];
1102 #define ABS_GETTER(name) \
1103 LIBEVDEV_EXPORT int libevdev_get_abs_##name(const struct libevdev *dev, unsigned int code) \
1105 const struct input_absinfo *absinfo = libevdev_get_abs_info(dev, code); \
1106 return absinfo ? absinfo->name : 0; \
1109 ABS_GETTER(maximum);
1110 ABS_GETTER(minimum);
1113 ABS_GETTER(resolution);
1115 #define ABS_SETTER(field) \
1116 LIBEVDEV_EXPORT void libevdev_set_abs_##field(struct libevdev *dev, unsigned int code, int val) \
1118 if (!libevdev_has_event_code(dev, EV_ABS, code)) \
1120 dev->abs_info[code].field = val; \
1127 ABS_SETTER(resolution)
1129 LIBEVDEV_EXPORT void
1130 libevdev_set_abs_info(struct libevdev *dev, unsigned int code, const struct input_absinfo *abs)
1132 if (!libevdev_has_event_code(dev, EV_ABS, code))
1135 dev->abs_info[code] = *abs;
1139 libevdev_enable_event_type(struct libevdev *dev, unsigned int type)
1144 if (libevdev_has_event_type(dev, type))
1147 set_bit(dev->bits, type);
1149 if (type == EV_REP) {
1150 int delay = 0, period = 0;
1151 libevdev_enable_event_code(dev, EV_REP, REP_DELAY, &delay);
1152 libevdev_enable_event_code(dev, EV_REP, REP_PERIOD, &period);
1158 libevdev_disable_event_type(struct libevdev *dev, unsigned int type)
1160 if (type > EV_MAX || type == EV_SYN)
1163 clear_bit(dev->bits, type);
1169 libevdev_enable_event_code(struct libevdev *dev, unsigned int type,
1170 unsigned int code, const void *data)
1173 unsigned long *mask = NULL;
1175 if (libevdev_enable_event_type(dev, type))
1192 max = type_to_mask(dev, type, &mask);
1197 set_bit(mask, code);
1199 if (type == EV_ABS) {
1200 const struct input_absinfo *abs = data;
1201 dev->abs_info[code] = *abs;
1202 } else if (type == EV_REP) {
1203 const int *value = data;
1204 dev->rep_values[code] = *value;
1211 libevdev_disable_event_code(struct libevdev *dev, unsigned int type, unsigned int code)
1214 unsigned long *mask = NULL;
1219 max = type_to_mask(dev, type, &mask);
1224 clear_bit(mask, code);
1230 libevdev_kernel_set_abs_value(struct libevdev *dev, unsigned int code, const struct input_absinfo *abs)
1232 return libevdev_kernel_set_abs_info(dev, code, abs);
1236 libevdev_kernel_set_abs_info(struct libevdev *dev, unsigned int code, const struct input_absinfo *abs)
1240 if (!dev->initialized) {
1241 log_bug("device not initialized. call libevdev_set_fd() first\n");
1243 } else if (dev->fd < 0)
1249 rc = ioctl(dev->fd, EVIOCSABS(code), abs);
1253 rc = libevdev_enable_event_code(dev, EV_ABS, code, abs);
1259 libevdev_grab(struct libevdev *dev, enum libevdev_grab_mode grab)
1263 if (!dev->initialized) {
1264 log_bug("device not initialized. call libevdev_set_fd() first\n");
1266 } else if (dev->fd < 0)
1269 if (grab != LIBEVDEV_GRAB && grab != LIBEVDEV_UNGRAB) {
1270 log_bug("invalid grab parameter %#x\n", grab);
1274 if (grab == dev->grabbed)
1277 if (grab == LIBEVDEV_GRAB)
1278 rc = ioctl(dev->fd, EVIOCGRAB, (void *)1);
1279 else if (grab == LIBEVDEV_UNGRAB)
1280 rc = ioctl(dev->fd, EVIOCGRAB, (void *)0);
1283 dev->grabbed = grab;
1285 return rc < 0 ? -errno : 0;
1290 libevdev_is_event_type(const struct input_event *ev, unsigned int type)
1291 ALIAS(libevdev_event_is_type);
1294 libevdev_event_is_type(const struct input_event *ev, unsigned int type)
1296 return type < EV_CNT && ev->type == type;
1301 libevdev_is_event_code(const struct input_event *ev, unsigned int type, unsigned int code)
1302 ALIAS(libevdev_event_is_code);
1305 libevdev_event_is_code(const struct input_event *ev, unsigned int type, unsigned int code)
1309 if (!libevdev_event_is_type(ev, type))
1312 max = libevdev_event_type_get_max(type);
1313 return (max > -1 && code <= (unsigned int)max && ev->code == code);
1317 LIBEVDEV_EXPORT const char*
1318 libevdev_get_event_type_name(unsigned int type)
1319 ALIAS(libevdev_event_type_get_name);
1321 LIBEVDEV_EXPORT const char*
1322 libevdev_event_type_get_name(unsigned int type)
1327 return ev_map[type];
1331 LIBEVDEV_EXPORT const char*
1332 libevdev_get_event_code_name(unsigned int type, unsigned int code)
1333 ALIAS(libevdev_event_code_get_name);
1335 LIBEVDEV_EXPORT const char*
1336 libevdev_event_code_get_name(unsigned int type, unsigned int code)
1338 int max = libevdev_event_type_get_max(type);
1340 if (max == -1 || code > (unsigned int)max)
1343 return event_type_map[type][code];
1347 LIBEVDEV_EXPORT const char*
1348 libevdev_get_input_prop_name(unsigned int prop)
1349 ALIAS(libevdev_property_get_name);
1352 LIBEVDEV_EXPORT const char*
1353 libevdev_get_property_name(unsigned int prop)
1354 ALIAS(libevdev_property_get_name);
1356 LIBEVDEV_EXPORT const char*
1357 libevdev_property_get_name(unsigned int prop)
1359 if (prop > INPUT_PROP_MAX)
1362 return input_prop_map[prop];
1367 libevdev_get_event_type_max(unsigned int type)
1368 ALIAS(libevdev_event_type_get_max);
1371 libevdev_event_type_get_max(unsigned int type)
1376 return ev_max[type];
1380 libevdev_get_repeat(struct libevdev *dev, int *delay, int *period)
1382 if (!libevdev_has_event_type(dev, EV_REP))
1386 *delay = dev->rep_values[REP_DELAY];
1388 *period = dev->rep_values[REP_PERIOD];
1394 libevdev_kernel_set_led_value(struct libevdev *dev, unsigned int code, enum libevdev_led_value value)
1396 return libevdev_kernel_set_led_values(dev, code, value, -1);
1400 libevdev_kernel_set_led_values(struct libevdev *dev, ...)
1402 struct input_event ev[LED_MAX + 1];
1403 enum libevdev_led_value val;
1409 if (!dev->initialized) {
1410 log_bug("device not initialized. call libevdev_set_fd() first\n");
1412 } else if (dev->fd < 0)
1415 memset(ev, 0, sizeof(ev));
1417 va_start(args, dev);
1418 code = va_arg(args, unsigned int);
1419 while (code != -1) {
1420 if (code > LED_MAX) {
1424 val = va_arg(args, enum libevdev_led_value);
1425 if (val != LIBEVDEV_LED_ON && val != LIBEVDEV_LED_OFF) {
1430 if (libevdev_has_event_code(dev, EV_LED, code)) {
1431 struct input_event *e = ev;
1433 while (e->type > 0 && e->code != code)
1440 e->value = (val == LIBEVDEV_LED_ON);
1442 code = va_arg(args, unsigned int);
1446 if (rc == 0 && nleds > 0) {
1447 ev[nleds].type = EV_SYN;
1448 ev[nleds++].code = SYN_REPORT;
1450 rc = write(libevdev_get_fd(dev), ev, nleds * sizeof(ev[0]));
1452 nleds--; /* last is EV_SYN */
1454 update_led_state(dev, &ev[nleds]);
1456 rc = (rc != -1) ? 0 : -errno;
1463 libevdev_set_clock_id(struct libevdev *dev, int clockid)
1465 if (!dev->initialized) {
1466 log_bug("device not initialized. call libevdev_set_fd() first\n");
1468 } else if (dev->fd < 0)
1471 return ioctl(dev->fd, EVIOCSCLOCKID, &clockid) ? -errno : 0;