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;
123 libevdev_enable_event_type(dev, EV_SYN);
126 LIBEVDEV_EXPORT struct libevdev*
129 struct libevdev *dev;
131 dev = malloc(sizeof(*dev));
141 libevdev_new_from_fd(int fd, struct libevdev **dev)
150 rc = libevdev_set_fd(d, fd);
159 libevdev_free(struct libevdev *dev)
172 libevdev_set_log_function(libevdev_log_func_t logfunc, void *data)
174 log_data.handler = logfunc;
175 log_data.userdata = data;
179 libevdev_set_log_priority(enum libevdev_log_priority priority)
181 if (priority > LIBEVDEV_LOG_DEBUG)
182 priority = LIBEVDEV_LOG_DEBUG;
183 log_data.priority = priority;
186 LIBEVDEV_EXPORT enum libevdev_log_priority
187 libevdev_get_log_priority(void)
189 return log_data.priority;
193 libevdev_change_fd(struct libevdev *dev, int fd)
195 if (!dev->initialized) {
196 log_bug("device not initialized. call libevdev_set_fd() first\n");
204 libevdev_set_fd(struct libevdev* dev, int fd)
210 if (dev->initialized) {
211 log_bug("device already initialized.\n");
218 rc = ioctl(fd, EVIOCGBIT(0, sizeof(dev->bits)), dev->bits);
222 memset(buf, 0, sizeof(buf));
223 rc = ioctl(fd, EVIOCGNAME(sizeof(buf) - 1), buf);
228 dev->name = strdup(buf);
236 memset(buf, 0, sizeof(buf));
237 rc = ioctl(fd, EVIOCGPHYS(sizeof(buf) - 1), buf);
239 /* uinput has no phys */
243 dev->phys = strdup(buf);
252 memset(buf, 0, sizeof(buf));
253 rc = ioctl(fd, EVIOCGUNIQ(sizeof(buf) - 1), buf);
258 dev->uniq = strdup(buf);
265 rc = ioctl(fd, EVIOCGID, &dev->ids);
269 rc = ioctl(fd, EVIOCGVERSION, &dev->driver_version);
273 /* Built on a kernel with props, running against a kernel without property
274 support. This should not be a fatal case, we'll be missing properties but other
275 than that everything is as expected.
277 rc = ioctl(fd, EVIOCGPROP(sizeof(dev->props)), dev->props);
278 if (rc < 0 && errno != EINVAL)
281 rc = ioctl(fd, EVIOCGBIT(EV_REL, sizeof(dev->rel_bits)), dev->rel_bits);
285 rc = ioctl(fd, EVIOCGBIT(EV_ABS, sizeof(dev->abs_bits)), dev->abs_bits);
289 rc = ioctl(fd, EVIOCGBIT(EV_LED, sizeof(dev->led_bits)), dev->led_bits);
293 rc = ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(dev->key_bits)), dev->key_bits);
297 rc = ioctl(fd, EVIOCGBIT(EV_SW, sizeof(dev->sw_bits)), dev->sw_bits);
301 rc = ioctl(fd, EVIOCGBIT(EV_MSC, sizeof(dev->msc_bits)), dev->msc_bits);
305 rc = ioctl(fd, EVIOCGBIT(EV_FF, sizeof(dev->ff_bits)), dev->ff_bits);
309 rc = ioctl(fd, EVIOCGBIT(EV_SND, sizeof(dev->snd_bits)), dev->snd_bits);
313 rc = ioctl(fd, EVIOCGKEY(sizeof(dev->key_values)), dev->key_values);
317 rc = ioctl(fd, EVIOCGLED(sizeof(dev->led_values)), dev->led_values);
321 rc = ioctl(fd, EVIOCGSW(sizeof(dev->sw_values)), dev->sw_values);
325 /* rep is a special case, always set it to 1 for both values if EV_REP is set */
326 if (bit_is_set(dev->bits, EV_REP)) {
327 for (i = 0; i < REP_CNT; i++)
328 set_bit(dev->rep_bits, i);
329 rc = ioctl(fd, EVIOCGREP, dev->rep_values);
334 for (i = ABS_X; i <= ABS_MAX; i++) {
335 if (bit_is_set(dev->abs_bits, i)) {
336 struct input_absinfo abs_info;
337 rc = ioctl(fd, EVIOCGABS(i), &abs_info);
341 dev->abs_info[i] = abs_info;
342 if (i == ABS_MT_SLOT) {
343 dev->num_slots = abs_info.maximum + 1;
344 dev->current_slot = abs_info.value;
351 sync_mt_state(dev, 0);
353 rc = init_event_queue(dev);
359 /* not copying key state because we won't know when we'll start to
360 * use this fd and key's are likely to change state by then.
361 * Same with the valuators, really, but they may not change.
364 dev->initialized = true;
368 return rc ? -errno : 0;
372 libevdev_get_fd(const struct libevdev* dev)
378 init_event(struct libevdev *dev, struct input_event *ev, int type, int code, int value)
380 ev->time = dev->last_event_time;
387 sync_key_state(struct libevdev *dev)
391 unsigned long keystate[NLONGS(KEY_CNT)] = {0};
393 rc = ioctl(dev->fd, EVIOCGKEY(sizeof(keystate)), keystate);
397 for (i = 0; i < KEY_CNT; i++) {
399 old = bit_is_set(dev->key_values, i);
400 new = bit_is_set(keystate, i);
402 struct input_event *ev = queue_push(dev);
403 init_event(dev, ev, EV_KEY, i, new ? 1 : 0);
407 memcpy(dev->key_values, keystate, rc);
411 return rc ? -errno : 0;
415 sync_sw_state(struct libevdev *dev)
419 unsigned long swstate[NLONGS(SW_CNT)] = {0};
421 rc = ioctl(dev->fd, EVIOCGSW(sizeof(swstate)), swstate);
425 for (i = 0; i < SW_CNT; i++) {
427 old = bit_is_set(dev->sw_values, i);
428 new = bit_is_set(swstate, i);
430 struct input_event *ev = queue_push(dev);
431 init_event(dev, ev, EV_SW, i, new ? 1 : 0);
435 memcpy(dev->sw_values, swstate, rc);
439 return rc ? -errno : 0;
443 sync_led_state(struct libevdev *dev)
447 unsigned long ledstate[NLONGS(LED_CNT)] = {0};
449 rc = ioctl(dev->fd, EVIOCGLED(sizeof(ledstate)), ledstate);
453 for (i = 0; i < LED_CNT; i++) {
455 old = bit_is_set(dev->led_values, i);
456 new = bit_is_set(ledstate, i);
458 struct input_event *ev = queue_push(dev);
459 init_event(dev, ev, EV_LED, i, new ? 1 : 0);
463 memcpy(dev->led_values, ledstate, rc);
467 return rc ? -errno : 0;
470 sync_abs_state(struct libevdev *dev)
475 for (i = ABS_X; i < ABS_CNT; i++) {
476 struct input_absinfo abs_info;
478 if (i >= ABS_MT_MIN && i <= ABS_MT_MAX)
481 if (!bit_is_set(dev->abs_bits, i))
484 rc = ioctl(dev->fd, EVIOCGABS(i), &abs_info);
488 if (dev->abs_info[i].value != abs_info.value) {
489 struct input_event *ev = queue_push(dev);
491 init_event(dev, ev, EV_ABS, i, abs_info.value);
492 dev->abs_info[i].value = abs_info.value;
498 return rc ? -errno : 0;
502 sync_mt_state(struct libevdev *dev, int create_events)
506 int ioctl_success = 0;
510 } mt_state[ABS_MT_CNT];
512 memset(&mt_state, 0, sizeof(mt_state));
514 for (i = ABS_MT_MIN; i <= ABS_MT_MAX; i++) {
516 if (i == ABS_MT_SLOT)
519 if (!libevdev_has_event_code(dev, EV_ABS, i))
522 idx = i - ABS_MT_MIN;
523 mt_state[idx].code = i;
524 rc = ioctl(dev->fd, EVIOCGMTSLOTS(sizeof(struct mt_state)), &mt_state[idx]);
526 /* if the first ioctl fails with -EINVAL, chances are the kernel
527 doesn't support the ioctl. Simply continue */
528 if (errno == -EINVAL && !ioctl_success) {
530 } else /* if the second, ... ioctl fails, really fail */
532 } else if (ioctl_success == 0)
536 for (i = 0; i < dev->num_slots; i++) {
538 struct input_event *ev;
541 ev = queue_push(dev);
542 init_event(dev, ev, EV_ABS, ABS_MT_SLOT, i);
545 for (j = ABS_MT_MIN; j <= ABS_MT_MAX; j++) {
546 int jdx = j - ABS_MT_MIN;
548 if (j == ABS_MT_SLOT)
551 if (!libevdev_has_event_code(dev, EV_ABS, j))
554 if (dev->mt_slot_vals[i][jdx] == mt_state[jdx].val[i])
558 ev = queue_push(dev);
559 init_event(dev, ev, EV_ABS, j, mt_state[jdx].val[i]);
561 dev->mt_slot_vals[i][jdx] = mt_state[jdx].val[i];
567 return rc ? -errno : 0;
571 sync_state(struct libevdev *dev)
575 struct input_event *ev;
577 /* FIXME: if we have events in the queue after the SYN_DROPPED (which was
578 queue[0]) we need to shift this backwards. Except that chances are that the
579 queue may be either full or too full to prepend all the events needed for
582 so we search for the last sync event in the queue and drop everything before
583 including that event and rely on the kernel to tell us the right value for that
584 bitfield during the sync process.
587 for (i = queue_num_elements(dev) - 1; i >= 0; i--) {
588 struct input_event e = {{0,0}, 0, 0, 0};
589 queue_peek(dev, i, &e);
590 if (e.type == EV_SYN)
595 queue_shift_multiple(dev, i + 1, NULL);
597 if (libevdev_has_event_type(dev, EV_KEY))
598 rc = sync_key_state(dev);
599 if (libevdev_has_event_type(dev, EV_LED))
600 rc = sync_led_state(dev);
601 if (libevdev_has_event_type(dev, EV_SW))
602 rc = sync_sw_state(dev);
603 if (rc == 0 && libevdev_has_event_type(dev, EV_ABS))
604 rc = sync_abs_state(dev);
605 if (rc == 0 && libevdev_has_event_code(dev, EV_ABS, ABS_MT_SLOT))
606 rc = sync_mt_state(dev, 1);
608 dev->queue_nsync = queue_num_elements(dev);
610 if (dev->queue_nsync > 0) {
611 ev = queue_push(dev);
612 init_event(dev, ev, EV_SYN, SYN_REPORT, 0);
620 update_key_state(struct libevdev *dev, const struct input_event *e)
622 if (!libevdev_has_event_type(dev, EV_KEY))
625 if (e->code > KEY_MAX)
628 set_bit_state(dev->key_values, e->code, e->value != 0);
634 update_mt_state(struct libevdev *dev, const struct input_event *e)
636 if (e->code == ABS_MT_SLOT) {
638 dev->current_slot = e->value;
639 /* sync abs_info with the current slot values */
640 for (i = ABS_MT_SLOT + 1; i <= ABS_MT_MAX; i++) {
641 if (libevdev_has_event_code(dev, EV_ABS, i))
642 dev->abs_info[i].value = dev->mt_slot_vals[dev->current_slot][i - ABS_MT_MIN];
646 } else if (dev->current_slot == -1)
649 dev->mt_slot_vals[dev->current_slot][e->code - ABS_MT_MIN] = e->value;
655 update_abs_state(struct libevdev *dev, const struct input_event *e)
657 if (!libevdev_has_event_type(dev, EV_ABS))
660 if (e->code > ABS_MAX)
663 if (e->code >= ABS_MT_MIN && e->code <= ABS_MT_MAX)
664 update_mt_state(dev, e);
666 dev->abs_info[e->code].value = e->value;
672 update_led_state(struct libevdev *dev, const struct input_event *e)
674 if (!libevdev_has_event_type(dev, EV_LED))
677 if (e->code > LED_MAX)
680 set_bit_state(dev->led_values, e->code, e->value != 0);
686 update_sw_state(struct libevdev *dev, const struct input_event *e)
688 if (!libevdev_has_event_type(dev, EV_SW))
691 if (e->code > SW_MAX)
694 set_bit_state(dev->sw_values, e->code, e->value != 0);
700 update_state(struct libevdev *dev, const struct input_event *e)
709 rc = update_key_state(dev, e);
712 rc = update_abs_state(dev, e);
715 rc = update_led_state(dev, e);
718 rc = update_sw_state(dev, e);
722 dev->last_event_time = e->time;
728 read_more_events(struct libevdev *dev)
732 struct input_event *next;
734 free_elem = queue_num_free_elements(dev);
738 next = queue_next_element(dev);
739 len = read(dev->fd, next, free_elem * sizeof(struct input_event));
742 } else if (len > 0 && len % sizeof(struct input_event) != 0)
745 int nev = len/sizeof(struct input_event);
746 queue_set_num_elements(dev, queue_num_elements(dev) + nev);
753 libevdev_next_event(struct libevdev *dev, unsigned int flags, struct input_event *ev)
755 int rc = LIBEVDEV_READ_STATUS_SUCCESS;
757 if (!dev->initialized) {
758 log_bug("device not initialized. call libevdev_set_fd() first\n");
760 } else if (dev->fd < 0)
763 if (!(flags & (LIBEVDEV_READ_FLAG_NORMAL|LIBEVDEV_READ_FLAG_SYNC|LIBEVDEV_READ_FLAG_FORCE_SYNC))) {
764 log_bug("invalid flags %#x\n.\n", flags);
768 if (flags & LIBEVDEV_READ_FLAG_SYNC) {
769 if (dev->sync_state == SYNC_NEEDED) {
770 rc = sync_state(dev);
773 dev->sync_state = SYNC_IN_PROGRESS;
776 if (dev->queue_nsync == 0) {
777 dev->sync_state = SYNC_NONE;
781 } else if (dev->sync_state != SYNC_NONE) {
782 struct input_event e;
784 /* call update_state for all events here, otherwise the library has the wrong view
786 while (queue_shift(dev, &e) == 0) {
788 update_state(dev, &e);
791 dev->sync_state = SYNC_NONE;
794 /* FIXME: if the first event after SYNC_IN_PROGRESS is a SYN_DROPPED, log this */
796 /* Always read in some more events. Best case this smoothes over a potential SYN_DROPPED,
797 worst case we don't read fast enough and end up with SYN_DROPPED anyway.
799 Except if the fd is in blocking mode and we still have events from the last read, don't
803 if (!(flags & LIBEVDEV_READ_FLAG_BLOCKING) ||
804 queue_num_elements(dev) == 0) {
805 rc = read_more_events(dev);
806 if (rc < 0 && rc != -EAGAIN)
810 if (flags & LIBEVDEV_READ_FLAG_FORCE_SYNC) {
811 dev->sync_state = SYNC_NEEDED;
812 rc = LIBEVDEV_READ_STATUS_SYNC;
817 if (queue_shift(dev, ev) != 0)
820 update_state(dev, ev);
822 /* if we disabled a code, get the next event instead */
823 } while(!libevdev_has_event_code(dev, ev->type, ev->code));
826 if (ev->type == EV_SYN && ev->code == SYN_DROPPED) {
827 dev->sync_state = SYNC_NEEDED;
828 rc = LIBEVDEV_READ_STATUS_SYNC;
831 if (flags & LIBEVDEV_READ_FLAG_SYNC && dev->queue_nsync > 0) {
833 rc = LIBEVDEV_READ_STATUS_SYNC;
834 if (dev->queue_nsync == 0)
835 dev->sync_state = SYNC_NONE;
843 libevdev_has_event_pending(struct libevdev *dev)
845 struct pollfd fds = { dev->fd, POLLIN, 0 };
848 if (!dev->initialized) {
849 log_bug("device not initialized. call libevdev_set_fd() first\n");
851 } else if (dev->fd < 0)
854 if (queue_num_elements(dev) != 0)
857 rc = poll(&fds, 1, 0);
858 return (rc >= 0) ? rc : -errno;
861 LIBEVDEV_EXPORT const char *
862 libevdev_get_name(const struct libevdev *dev)
864 return dev->name ? dev->name : "";
867 LIBEVDEV_EXPORT const char *
868 libevdev_get_phys(const struct libevdev *dev)
873 LIBEVDEV_EXPORT const char *
874 libevdev_get_uniq(const struct libevdev *dev)
879 #define STRING_SETTER(field) \
880 LIBEVDEV_EXPORT void libevdev_set_##field(struct libevdev *dev, const char *field) \
885 dev->field = strdup(field); \
893 #define PRODUCT_GETTER(name) \
894 LIBEVDEV_EXPORT int libevdev_get_id_##name(const struct libevdev *dev) \
896 return dev->ids.name; \
899 PRODUCT_GETTER(product);
900 PRODUCT_GETTER(vendor);
901 PRODUCT_GETTER(bustype);
902 PRODUCT_GETTER(version);
904 #define PRODUCT_SETTER(field) \
905 LIBEVDEV_EXPORT void libevdev_set_id_##field(struct libevdev *dev, int field) \
907 dev->ids.field = field;\
910 PRODUCT_SETTER(product);
911 PRODUCT_SETTER(vendor);
912 PRODUCT_SETTER(bustype);
913 PRODUCT_SETTER(version);
916 libevdev_get_driver_version(const struct libevdev *dev)
918 return dev->driver_version;
922 libevdev_has_property(const struct libevdev *dev, unsigned int prop)
924 return (prop <= INPUT_PROP_MAX) && bit_is_set(dev->props, prop);
928 libevdev_enable_property(struct libevdev *dev, unsigned int prop)
930 if (prop > INPUT_PROP_MAX)
933 set_bit(dev->props, prop);
938 libevdev_has_event_type(const struct libevdev *dev, unsigned int type)
940 return type == EV_SYN ||(type <= EV_MAX && bit_is_set(dev->bits, type));
944 libevdev_has_event_code(const struct libevdev *dev, unsigned int type, unsigned int code)
946 const unsigned long *mask;
949 if (!libevdev_has_event_type(dev, type))
955 max = type_to_mask_const(dev, type, &mask);
957 if (max == -1 || code > (unsigned int)max)
960 return bit_is_set(mask, code);
964 libevdev_get_event_value(const struct libevdev *dev, unsigned int type, unsigned int code)
968 if (!libevdev_has_event_type(dev, type) || !libevdev_has_event_code(dev, type, code))
972 case EV_ABS: value = dev->abs_info[code].value; break;
973 case EV_KEY: value = bit_is_set(dev->key_values, code); break;
974 case EV_LED: value = bit_is_set(dev->led_values, code); break;
975 case EV_SW: value = bit_is_set(dev->sw_values, code); break;
985 libevdev_set_event_value(struct libevdev *dev, unsigned int type, unsigned int code, int value)
988 struct input_event e;
990 if (!libevdev_has_event_type(dev, type) || !libevdev_has_event_code(dev, type, code))
998 case EV_ABS: rc = update_abs_state(dev, &e); break;
999 case EV_KEY: rc = update_key_state(dev, &e); break;
1000 case EV_LED: rc = update_led_state(dev, &e); break;
1001 case EV_SW: rc = update_sw_state(dev, &e); break;
1011 libevdev_fetch_event_value(const struct libevdev *dev, unsigned int type, unsigned int code, int *value)
1013 if (libevdev_has_event_type(dev, type) &&
1014 libevdev_has_event_code(dev, type, code)) {
1015 *value = libevdev_get_event_value(dev, type, code);
1022 libevdev_get_slot_value(const struct libevdev *dev, unsigned int slot, unsigned int code)
1024 if (!libevdev_has_event_type(dev, EV_ABS) || !libevdev_has_event_code(dev, EV_ABS, code))
1027 if (dev->num_slots < 0 || slot >= (unsigned int)dev->num_slots || slot >= MAX_SLOTS)
1030 if (code > ABS_MT_MAX || code < ABS_MT_MIN)
1033 return dev->mt_slot_vals[slot][code - ABS_MT_MIN];
1037 libevdev_set_slot_value(struct libevdev *dev, unsigned int slot, unsigned int code, int value)
1039 if (!libevdev_has_event_type(dev, EV_ABS) || !libevdev_has_event_code(dev, EV_ABS, code))
1042 if (dev->num_slots == -1 || slot >= (unsigned int)dev->num_slots || slot >= MAX_SLOTS)
1045 if (code > ABS_MT_MAX || code < ABS_MT_MIN)
1048 if (code == ABS_MT_SLOT) {
1049 if (value < 0 || value >= libevdev_get_num_slots(dev))
1051 dev->current_slot = value;
1054 dev->mt_slot_vals[slot][code - ABS_MT_MIN] = value;
1061 libevdev_fetch_slot_value(const struct libevdev *dev, unsigned int slot, unsigned int code, int *value)
1063 if (libevdev_has_event_type(dev, EV_ABS) &&
1064 libevdev_has_event_code(dev, EV_ABS, code) &&
1065 dev->num_slots >= 0 &&
1066 slot < (unsigned int)dev->num_slots && slot < MAX_SLOTS) {
1067 *value = libevdev_get_slot_value(dev, slot, code);
1074 libevdev_get_num_slots(const struct libevdev *dev)
1076 return dev->num_slots;
1080 libevdev_get_current_slot(const struct libevdev *dev)
1082 return dev->current_slot;
1085 LIBEVDEV_EXPORT const struct input_absinfo*
1086 libevdev_get_abs_info(const struct libevdev *dev, unsigned int code)
1088 if (!libevdev_has_event_type(dev, EV_ABS) ||
1089 !libevdev_has_event_code(dev, EV_ABS, code))
1092 return &dev->abs_info[code];
1095 #define ABS_GETTER(name) \
1096 LIBEVDEV_EXPORT int libevdev_get_abs_##name(const struct libevdev *dev, unsigned int code) \
1098 const struct input_absinfo *absinfo = libevdev_get_abs_info(dev, code); \
1099 return absinfo ? absinfo->name : 0; \
1102 ABS_GETTER(maximum);
1103 ABS_GETTER(minimum);
1106 ABS_GETTER(resolution);
1108 #define ABS_SETTER(field) \
1109 LIBEVDEV_EXPORT void libevdev_set_abs_##field(struct libevdev *dev, unsigned int code, int val) \
1111 if (!libevdev_has_event_code(dev, EV_ABS, code)) \
1113 dev->abs_info[code].field = val; \
1120 ABS_SETTER(resolution)
1122 LIBEVDEV_EXPORT void
1123 libevdev_set_abs_info(struct libevdev *dev, unsigned int code, const struct input_absinfo *abs)
1125 if (!libevdev_has_event_code(dev, EV_ABS, code))
1128 dev->abs_info[code] = *abs;
1132 libevdev_enable_event_type(struct libevdev *dev, unsigned int type)
1139 if (libevdev_has_event_type(dev, type))
1142 max = libevdev_event_type_get_max(type);
1146 set_bit(dev->bits, type);
1148 if (type == EV_REP) {
1149 int delay = 0, period = 0;
1150 libevdev_enable_event_code(dev, EV_REP, REP_DELAY, &delay);
1151 libevdev_enable_event_code(dev, EV_REP, REP_PERIOD, &period);
1157 libevdev_disable_event_type(struct libevdev *dev, unsigned int type)
1161 if (type > EV_MAX || type == EV_SYN)
1164 max = libevdev_event_type_get_max(type);
1168 clear_bit(dev->bits, type);
1174 libevdev_enable_event_code(struct libevdev *dev, unsigned int type,
1175 unsigned int code, const void *data)
1178 unsigned long *mask = NULL;
1180 if (libevdev_enable_event_type(dev, type))
1197 max = type_to_mask(dev, type, &mask);
1199 if (code > max || (int)max == -1)
1202 set_bit(mask, code);
1204 if (type == EV_ABS) {
1205 const struct input_absinfo *abs = data;
1206 dev->abs_info[code] = *abs;
1207 } else if (type == EV_REP) {
1208 const int *value = data;
1209 dev->rep_values[code] = *value;
1216 libevdev_disable_event_code(struct libevdev *dev, unsigned int type, unsigned int code)
1219 unsigned long *mask = NULL;
1221 if (type > EV_MAX || type == EV_SYN)
1224 max = type_to_mask(dev, type, &mask);
1226 if (code > max || (int)max == -1)
1229 clear_bit(mask, code);
1235 libevdev_kernel_set_abs_info(struct libevdev *dev, unsigned int code, const struct input_absinfo *abs)
1239 if (!dev->initialized) {
1240 log_bug("device not initialized. call libevdev_set_fd() first\n");
1242 } else if (dev->fd < 0)
1248 rc = ioctl(dev->fd, EVIOCSABS(code), abs);
1252 rc = libevdev_enable_event_code(dev, EV_ABS, code, abs);
1258 libevdev_grab(struct libevdev *dev, enum libevdev_grab_mode grab)
1262 if (!dev->initialized) {
1263 log_bug("device not initialized. call libevdev_set_fd() first\n");
1265 } else if (dev->fd < 0)
1268 if (grab != LIBEVDEV_GRAB && grab != LIBEVDEV_UNGRAB) {
1269 log_bug("invalid grab parameter %#x\n", grab);
1273 if (grab == dev->grabbed)
1276 if (grab == LIBEVDEV_GRAB)
1277 rc = ioctl(dev->fd, EVIOCGRAB, (void *)1);
1278 else if (grab == LIBEVDEV_UNGRAB)
1279 rc = ioctl(dev->fd, EVIOCGRAB, (void *)0);
1282 dev->grabbed = grab;
1284 return rc < 0 ? -errno : 0;
1288 libevdev_event_is_type(const struct input_event *ev, unsigned int type)
1290 return type < EV_CNT && ev->type == type;
1294 libevdev_event_is_code(const struct input_event *ev, unsigned int type, unsigned int code)
1298 if (!libevdev_event_is_type(ev, type))
1301 max = libevdev_event_type_get_max(type);
1302 return (max > -1 && code <= (unsigned int)max && ev->code == code);
1305 LIBEVDEV_EXPORT const char*
1306 libevdev_event_type_get_name(unsigned int type)
1311 return ev_map[type];
1314 LIBEVDEV_EXPORT const char*
1315 libevdev_event_code_get_name(unsigned int type, unsigned int code)
1317 int max = libevdev_event_type_get_max(type);
1319 if (max == -1 || code > (unsigned int)max)
1322 return event_type_map[type][code];
1325 LIBEVDEV_EXPORT const char*
1326 libevdev_property_get_name(unsigned int prop)
1328 if (prop > INPUT_PROP_MAX)
1331 return input_prop_map[prop];
1335 libevdev_event_type_get_max(unsigned int type)
1340 return ev_max[type];
1344 libevdev_get_repeat(struct libevdev *dev, int *delay, int *period)
1346 if (!libevdev_has_event_type(dev, EV_REP))
1350 *delay = dev->rep_values[REP_DELAY];
1352 *period = dev->rep_values[REP_PERIOD];
1358 libevdev_kernel_set_led_value(struct libevdev *dev, unsigned int code, enum libevdev_led_value value)
1360 return libevdev_kernel_set_led_values(dev, code, value, -1);
1364 libevdev_kernel_set_led_values(struct libevdev *dev, ...)
1366 struct input_event ev[LED_MAX + 1];
1367 enum libevdev_led_value val;
1373 if (!dev->initialized) {
1374 log_bug("device not initialized. call libevdev_set_fd() first\n");
1376 } else if (dev->fd < 0)
1379 memset(ev, 0, sizeof(ev));
1381 va_start(args, dev);
1382 code = va_arg(args, unsigned int);
1383 while (code != -1) {
1384 if (code > LED_MAX) {
1388 val = va_arg(args, enum libevdev_led_value);
1389 if (val != LIBEVDEV_LED_ON && val != LIBEVDEV_LED_OFF) {
1394 if (libevdev_has_event_code(dev, EV_LED, code)) {
1395 struct input_event *e = ev;
1397 while (e->type > 0 && e->code != code)
1404 e->value = (val == LIBEVDEV_LED_ON);
1406 code = va_arg(args, unsigned int);
1410 if (rc == 0 && nleds > 0) {
1411 ev[nleds].type = EV_SYN;
1412 ev[nleds++].code = SYN_REPORT;
1414 rc = write(libevdev_get_fd(dev), ev, nleds * sizeof(ev[0]));
1416 nleds--; /* last is EV_SYN */
1418 update_led_state(dev, &ev[nleds]);
1420 rc = (rc != -1) ? 0 : -errno;
1427 libevdev_set_clock_id(struct libevdev *dev, int clockid)
1429 if (!dev->initialized) {
1430 log_bug("device not initialized. call libevdev_set_fd() first\n");
1432 } else if (dev->fd < 0)
1435 return ioctl(dev->fd, EVIOCSCLOCKID, &clockid) ? -errno : 0;