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
30 #include <linux/uinput.h>
33 #include "libevdev-int.h"
34 #include "libevdev-util.h"
35 #include "event-names.h"
39 static int sync_mt_state(struct libevdev *dev, int create_events);
42 init_event_queue(struct libevdev *dev)
44 /* FIXME: count the number of axes, keys, etc. to get a better idea at how many events per
45 EV_SYN we could possibly get. Then multiply that by the actual buffer size we care about */
47 const int QUEUE_SIZE = 256;
49 return queue_alloc(dev, QUEUE_SIZE);
53 _libevdev_log(struct libevdev *dev, const char *format, ...)
57 va_start(args, format);
58 dev->log(format, args);
63 libevdev_noop_log_func(const char *format, va_list args)
72 dev = calloc(1, sizeof(*dev));
77 dev->current_slot = -1;
78 dev->log = libevdev_noop_log_func;
79 dev->grabbed = LIBEVDEV_UNGRAB;
80 dev->sync_state = SYNC_NONE;
86 libevdev_new_from_fd(int fd, struct libevdev **dev)
95 rc = libevdev_set_fd(d, fd);
104 libevdev_free(struct libevdev *dev)
117 libevdev_set_log_handler(struct libevdev *dev, libevdev_log_func_t logfunc)
122 dev->log = logfunc ? logfunc : libevdev_noop_log_func;
126 libevdev_change_fd(struct libevdev *dev, int fd)
135 libevdev_set_fd(struct libevdev* dev, int fd)
144 rc = ioctl(fd, EVIOCGBIT(0, sizeof(dev->bits)), dev->bits);
148 memset(buf, 0, sizeof(buf));
149 rc = ioctl(fd, EVIOCGNAME(sizeof(buf) - 1), buf);
154 dev->name = strdup(buf);
162 memset(buf, 0, sizeof(buf));
163 rc = ioctl(fd, EVIOCGPHYS(sizeof(buf) - 1), buf);
165 /* uinput has no phys */
169 dev->phys = strdup(buf);
178 memset(buf, 0, sizeof(buf));
179 rc = ioctl(fd, EVIOCGUNIQ(sizeof(buf) - 1), buf);
184 dev->uniq = strdup(buf);
191 rc = ioctl(fd, EVIOCGID, &dev->ids);
195 rc = ioctl(fd, EVIOCGVERSION, &dev->driver_version);
199 rc = ioctl(fd, EVIOCGPROP(sizeof(dev->props)), dev->props);
203 rc = ioctl(fd, EVIOCGBIT(EV_REL, sizeof(dev->rel_bits)), dev->rel_bits);
207 rc = ioctl(fd, EVIOCGBIT(EV_ABS, sizeof(dev->abs_bits)), dev->abs_bits);
211 rc = ioctl(fd, EVIOCGBIT(EV_LED, sizeof(dev->led_bits)), dev->led_bits);
215 rc = ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(dev->key_bits)), dev->key_bits);
219 rc = ioctl(fd, EVIOCGBIT(EV_SW, sizeof(dev->sw_bits)), dev->sw_bits);
223 rc = ioctl(fd, EVIOCGBIT(EV_MSC, sizeof(dev->msc_bits)), dev->msc_bits);
227 rc = ioctl(fd, EVIOCGBIT(EV_FF, sizeof(dev->ff_bits)), dev->ff_bits);
231 rc = ioctl(fd, EVIOCGBIT(EV_SND, sizeof(dev->snd_bits)), dev->snd_bits);
235 rc = ioctl(fd, EVIOCGKEY(sizeof(dev->key_values)), dev->key_values);
239 rc = ioctl(fd, EVIOCGLED(sizeof(dev->led_values)), dev->led_values);
243 /* rep is a special case, always set it to 1 for both values if EV_REP is set */
244 if (bit_is_set(dev->bits, EV_REP)) {
245 for (i = 0; i < REP_CNT; i++)
246 set_bit(dev->rep_bits, i);
247 rc = ioctl(fd, EVIOCGREP, dev->rep_values);
252 for (i = ABS_X; i <= ABS_MAX; i++) {
253 if (bit_is_set(dev->abs_bits, i)) {
254 struct input_absinfo abs_info;
255 rc = ioctl(fd, EVIOCGABS(i), &abs_info);
259 dev->abs_info[i] = abs_info;
260 if (i == ABS_MT_SLOT) {
261 dev->num_slots = abs_info.maximum + 1;
262 dev->current_slot = abs_info.value;
269 sync_mt_state(dev, 0);
271 rc = init_event_queue(dev);
277 /* not copying key state because we won't know when we'll start to
278 * use this fd and key's are likely to change state by then.
279 * Same with the valuators, really, but they may not change.
283 return rc ? -errno : 0;
287 libevdev_get_fd(const struct libevdev* dev)
293 init_event(struct libevdev *dev, struct input_event *ev, int type, int code, int value)
295 ev->time = dev->last_event_time;
302 sync_key_state(struct libevdev *dev)
306 unsigned long keystate[NLONGS(KEY_MAX)];
308 rc = ioctl(dev->fd, EVIOCGKEY(sizeof(keystate)), keystate);
312 for (i = 0; i < KEY_MAX; i++) {
314 old = bit_is_set(dev->key_values, i);
315 new = bit_is_set(keystate, i);
317 struct input_event *ev = queue_push(dev);
318 init_event(dev, ev, EV_KEY, i, new ? 1 : 0);
320 set_bit_state(dev->key_values, i, new);
325 return rc ? -errno : 0;
329 sync_led_state(struct libevdev *dev)
333 unsigned long ledstate[NLONGS(LED_MAX)];
335 rc = ioctl(dev->fd, EVIOCGLED(sizeof(ledstate)), ledstate);
339 for (i = 0; i < LED_MAX; i++) {
341 old = bit_is_set(dev->led_values, i);
342 new = bit_is_set(ledstate, i);
344 struct input_event *ev = queue_push(dev);
345 init_event(dev, ev, EV_LED, i, new ? 1 : 0);
347 set_bit_state(dev->led_values, i, new);
352 return rc ? -errno : 0;
355 sync_abs_state(struct libevdev *dev)
360 for (i = ABS_X; i <= ABS_MAX; i++) {
361 struct input_absinfo abs_info;
363 if (i >= ABS_MT_MIN && i <= ABS_MT_MAX)
366 if (!bit_is_set(dev->abs_bits, i))
369 rc = ioctl(dev->fd, EVIOCGABS(i), &abs_info);
373 if (dev->abs_info[i].value != abs_info.value) {
374 struct input_event *ev = queue_push(dev);
376 init_event(dev, ev, EV_ABS, i, abs_info.value);
377 dev->abs_info[i].value = abs_info.value;
383 return rc ? -errno : 0;
387 sync_mt_state(struct libevdev *dev, int create_events)
394 } mt_state[ABS_MT_CNT];
396 for (i = ABS_MT_MIN; i < ABS_MT_MAX; i++) {
398 if (i == ABS_MT_SLOT)
401 if (!libevdev_has_event_code(dev, EV_ABS, i))
404 idx = i - ABS_MT_MIN;
405 mt_state[idx].code = i;
406 rc = ioctl(dev->fd, EVIOCGMTSLOTS(sizeof(struct mt_state)), &mt_state[idx]);
411 for (i = 0; i < dev->num_slots; i++) {
413 struct input_event *ev;
416 ev = queue_push(dev);
417 init_event(dev, ev, EV_ABS, ABS_MT_SLOT, i);
420 for (j = ABS_MT_MIN; j < ABS_MT_MAX; j++) {
421 int jdx = j - ABS_MT_MIN;
423 if (j == ABS_MT_SLOT)
426 if (!libevdev_has_event_code(dev, EV_ABS, j))
429 if (dev->mt_slot_vals[i][jdx] == mt_state[jdx].val[i])
433 ev = queue_push(dev);
434 init_event(dev, ev, EV_ABS, j, mt_state[jdx].val[i]);
436 dev->mt_slot_vals[i][jdx] = mt_state[jdx].val[i];
442 return rc ? -errno : 0;
446 sync_state(struct libevdev *dev)
450 struct input_event *ev;
452 /* FIXME: if we have events in the queue after the SYN_DROPPED (which was
453 queue[0]) we need to shift this backwards. Except that chances are that the
454 queue may be either full or too full to prepend all the events needed for
457 so we search for the last sync event in the queue and drop everything before
458 including that event and rely on the kernel to tell us the right value for that
459 bitfield during the sync process.
462 for (i = queue_num_elements(dev) - 1; i >= 0; i--) {
463 struct input_event e;
464 queue_peek(dev, i, &e);
465 if (e.type == EV_SYN)
470 queue_shift_multiple(dev, i + 1, NULL);
472 if (libevdev_has_event_type(dev, EV_KEY))
473 rc = sync_key_state(dev);
474 if (libevdev_has_event_type(dev, EV_LED))
475 rc = sync_led_state(dev);
476 if (rc == 0 && libevdev_has_event_type(dev, EV_ABS))
477 rc = sync_abs_state(dev);
478 if (rc == 0 && libevdev_has_event_code(dev, EV_ABS, ABS_MT_SLOT))
479 rc = sync_mt_state(dev, 1);
481 dev->queue_nsync = queue_num_elements(dev);
483 if (dev->queue_nsync > 0) {
484 ev = queue_push(dev);
485 init_event(dev, ev, EV_SYN, SYN_REPORT, 0);
493 update_key_state(struct libevdev *dev, const struct input_event *e)
495 if (!libevdev_has_event_type(dev, EV_KEY))
498 if (e->code > KEY_MAX)
501 set_bit_state(dev->key_values, e->code, e->value != 0);
507 update_mt_state(struct libevdev *dev, const struct input_event *e)
509 if (e->code == ABS_MT_SLOT) {
511 dev->current_slot = e->value;
512 /* sync abs_info with the current slot values */
513 for (i = ABS_MT_SLOT + 1; i <= ABS_MT_MAX; i++) {
514 if (libevdev_has_event_code(dev, EV_ABS, i))
515 dev->abs_info[i].value = dev->mt_slot_vals[dev->current_slot][i - ABS_MT_MIN];
519 } else if (dev->current_slot == -1)
522 dev->mt_slot_vals[dev->current_slot][e->code - ABS_MT_MIN] = e->value;
528 update_abs_state(struct libevdev *dev, const struct input_event *e)
530 if (!libevdev_has_event_type(dev, EV_ABS))
533 if (e->code > ABS_MAX)
536 if (e->code >= ABS_MT_MIN && e->code <= ABS_MT_MAX)
537 update_mt_state(dev, e);
539 dev->abs_info[e->code].value = e->value;
545 update_led_state(struct libevdev *dev, const struct input_event *e)
547 if (!libevdev_has_event_type(dev, EV_LED))
550 if (e->code > LED_MAX)
553 set_bit_state(dev->led_values, e->code, e->value != 0);
559 update_state(struct libevdev *dev, const struct input_event *e)
568 rc = update_key_state(dev, e);
571 rc = update_abs_state(dev, e);
574 rc = update_led_state(dev, e);
578 dev->last_event_time = e->time;
584 read_more_events(struct libevdev *dev)
588 struct input_event *next;
590 free_elem = queue_num_free_elements(dev);
594 next = queue_next_element(dev);
595 len = read(dev->fd, next, free_elem * sizeof(struct input_event));
598 } else if (len > 0 && len % sizeof(struct input_event) != 0)
601 int nev = len/sizeof(struct input_event);
602 queue_set_num_elements(dev, queue_num_elements(dev) + nev);
608 int libevdev_next_event(struct libevdev *dev, unsigned int flags, struct input_event *ev)
615 if (!(flags & (LIBEVDEV_READ_NORMAL|LIBEVDEV_READ_SYNC|LIBEVDEV_FORCE_SYNC)))
618 if (flags & LIBEVDEV_READ_SYNC) {
619 if (dev->sync_state == SYNC_NEEDED) {
620 rc = sync_state(dev);
623 dev->sync_state = SYNC_IN_PROGRESS;
626 if (dev->queue_nsync == 0) {
627 dev->sync_state = SYNC_NONE;
631 } else if (dev->sync_state != SYNC_NONE) {
632 struct input_event e;
634 /* call update_state for all events here, otherwise the library has the wrong view
636 while (queue_shift(dev, &e) == 0) {
638 update_state(dev, &e);
641 dev->sync_state = SYNC_NONE;
644 /* FIXME: if the first event after SYNC_IN_PROGRESS is a SYN_DROPPED, log this */
646 /* Always read in some more events. Best case this smoothes over a potential SYN_DROPPED,
647 worst case we don't read fast enough and end up with SYN_DROPPED anyway.
649 Except if the fd is in blocking mode and we still have events from the last read, don't
653 if (!(flags & LIBEVDEV_READ_BLOCKING) ||
654 queue_num_elements(dev) == 0) {
655 rc = read_more_events(dev);
656 if (rc < 0 && rc != -EAGAIN)
660 if (flags & LIBEVDEV_FORCE_SYNC) {
661 dev->sync_state = SYNC_NEEDED;
667 if (queue_shift(dev, ev) != 0)
670 update_state(dev, ev);
672 /* if we disabled a code, get the next event instead */
673 } while(!libevdev_has_event_code(dev, ev->type, ev->code));
676 if (ev->type == EV_SYN && ev->code == SYN_DROPPED) {
677 dev->sync_state = SYNC_NEEDED;
681 if (flags & LIBEVDEV_READ_SYNC && dev->queue_nsync > 0) {
684 if (dev->queue_nsync == 0)
685 dev->sync_state = SYNC_NONE;
692 int libevdev_has_event_pending(struct libevdev *dev)
694 struct pollfd fds = { dev->fd, POLLIN, 0 };
700 if (queue_num_elements(dev) != 0)
703 rc = poll(&fds, 1, 0);
704 return (rc >= 0) ? rc : -errno;
708 libevdev_get_name(const struct libevdev *dev)
710 return dev->name ? dev->name : "";
714 libevdev_get_phys(const struct libevdev *dev)
720 libevdev_get_uniq(const struct libevdev *dev)
725 #define STRING_SETTER(field) \
726 void libevdev_set_##field(struct libevdev *dev, const char *field) \
731 dev->field = strdup(field); \
739 #define PRODUCT_GETTER(name, field) \
740 int libevdev_get_##name(const struct libevdev *dev) \
742 return dev->ids.field; \
745 PRODUCT_GETTER(product_id, product); /* DEPRECATED */
746 PRODUCT_GETTER(vendor_id, vendor); /* DEPRECATED */
747 PRODUCT_GETTER(bustype, bustype); /* DEPRECATED */
748 PRODUCT_GETTER(version, version); /* DEPRECATED */
750 PRODUCT_GETTER(id_product, product);
751 PRODUCT_GETTER(id_vendor, vendor);
752 PRODUCT_GETTER(id_bustype, bustype);
753 PRODUCT_GETTER(id_version, version);
755 #define PRODUCT_SETTER(field) \
756 void libevdev_set_id_##field(struct libevdev *dev, int field) \
758 dev->ids.field = field;\
761 PRODUCT_SETTER(product);
762 PRODUCT_SETTER(vendor);
763 PRODUCT_SETTER(bustype);
764 PRODUCT_SETTER(version);
766 int libevdev_get_driver_version(const struct libevdev *dev)
768 return dev->driver_version;
772 libevdev_has_property(const struct libevdev *dev, unsigned int prop)
774 return (prop <= INPUT_PROP_MAX) && bit_is_set(dev->props, prop);
778 libevdev_enable_property(struct libevdev *dev, unsigned int prop)
780 if (prop > INPUT_PROP_MAX)
783 set_bit(dev->props, prop);
788 libevdev_has_event_type(const struct libevdev *dev, unsigned int type)
790 return (type <= EV_MAX) && bit_is_set(dev->bits, type);
794 libevdev_has_event_code(const struct libevdev *dev, unsigned int type, unsigned int code)
796 const unsigned long *mask;
799 if (!libevdev_has_event_type(dev, type))
805 max = type_to_mask_const(dev, type, &mask);
807 if (max == -1 || code > max)
810 return bit_is_set(mask, code);
814 libevdev_get_event_value(const struct libevdev *dev, unsigned int type, unsigned int code)
818 if (!libevdev_has_event_type(dev, type) || !libevdev_has_event_code(dev, type, code))
822 case EV_ABS: value = dev->abs_info[code].value; break;
823 case EV_KEY: value = bit_is_set(dev->key_values, code); break;
824 case EV_LED: value = bit_is_set(dev->led_values, code); break;
833 int libevdev_set_event_value(struct libevdev *dev, unsigned int type, unsigned int code, int value)
836 struct input_event e;
838 if (!libevdev_has_event_type(dev, type) || !libevdev_has_event_code(dev, type, code))
846 case EV_ABS: rc = update_abs_state(dev, &e); break;
847 case EV_KEY: rc = update_key_state(dev, &e); break;
848 case EV_LED: rc = update_led_state(dev, &e); break;
858 libevdev_fetch_event_value(const struct libevdev *dev, unsigned int type, unsigned int code, int *value)
860 if (libevdev_has_event_type(dev, type) &&
861 libevdev_has_event_code(dev, type, code)) {
862 *value = libevdev_get_event_value(dev, type, code);
869 libevdev_get_slot_value(const struct libevdev *dev, unsigned int slot, unsigned int code)
871 if (!libevdev_has_event_type(dev, EV_ABS) || !libevdev_has_event_code(dev, EV_ABS, code))
874 if (slot >= dev->num_slots || slot >= MAX_SLOTS)
877 if (code > ABS_MT_MAX || code < ABS_MT_MIN)
880 return dev->mt_slot_vals[slot][code - ABS_MT_MIN];
884 libevdev_set_slot_value(struct libevdev *dev, unsigned int slot, unsigned int code, int value)
886 if (!libevdev_has_event_type(dev, EV_ABS) || !libevdev_has_event_code(dev, EV_ABS, code))
889 if (slot >= dev->num_slots || slot >= MAX_SLOTS)
892 if (code > ABS_MT_MAX || code < ABS_MT_MIN)
895 if (code == ABS_MT_SLOT) {
896 if (value < 0 || value >= libevdev_get_num_slots(dev))
898 dev->current_slot = value;
901 dev->mt_slot_vals[slot][code - ABS_MT_MIN] = value;
908 libevdev_fetch_slot_value(const struct libevdev *dev, unsigned int slot, unsigned int code, int *value)
910 if (libevdev_has_event_type(dev, EV_ABS) &&
911 libevdev_has_event_code(dev, EV_ABS, code) &&
912 slot < dev->num_slots && slot < MAX_SLOTS) {
913 *value = libevdev_get_slot_value(dev, slot, code);
920 libevdev_get_num_slots(const struct libevdev *dev)
922 return dev->num_slots;
926 libevdev_get_current_slot(const struct libevdev *dev)
928 return dev->current_slot;
931 const struct input_absinfo*
932 libevdev_get_abs_info(const struct libevdev *dev, unsigned int code)
934 if (!libevdev_has_event_type(dev, EV_ABS) ||
935 !libevdev_has_event_code(dev, EV_ABS, code))
938 return &dev->abs_info[code];
941 #define ABS_GETTER(name, field) \
942 int libevdev_get_abs_##name(const struct libevdev *dev, unsigned int code) \
944 const struct input_absinfo *absinfo = libevdev_get_abs_info(dev, code); \
945 return absinfo ? absinfo->field : 0; \
948 ABS_GETTER(max, maximum); /* DEPRECATED */
949 ABS_GETTER(min, minimum); /* DEPRECATED */
950 ABS_GETTER(maximum, maximum);
951 ABS_GETTER(minimum, minimum);
952 ABS_GETTER(fuzz, fuzz)
953 ABS_GETTER(flat, flat)
954 ABS_GETTER(resolution, resolution)
956 #define ABS_SETTER(field) \
957 void libevdev_set_abs_##field(struct libevdev *dev, unsigned int code, int val) \
959 if (!libevdev_has_event_code(dev, EV_ABS, code)) \
961 dev->abs_info[code].field = val; \
968 ABS_SETTER(resolution)
970 void libevdev_set_abs_info(struct libevdev *dev, unsigned int code, const struct input_absinfo *abs)
972 if (!libevdev_has_event_code(dev, EV_ABS, code))
975 dev->abs_info[code] = *abs;
979 libevdev_enable_event_type(struct libevdev *dev, unsigned int type)
984 if (libevdev_has_event_type(dev, type))
987 set_bit(dev->bits, type);
989 if (type == EV_REP) {
990 int delay = 0, period = 0;
991 libevdev_enable_event_code(dev, EV_REP, REP_DELAY, &delay);
992 libevdev_enable_event_code(dev, EV_REP, REP_PERIOD, &period);
998 libevdev_disable_event_type(struct libevdev *dev, unsigned int type)
1000 if (type > EV_MAX || type == EV_SYN)
1003 clear_bit(dev->bits, type);
1009 libevdev_enable_event_code(struct libevdev *dev, unsigned int type,
1010 unsigned int code, const void *data)
1013 unsigned long *mask;
1015 if (libevdev_enable_event_type(dev, type))
1032 max = type_to_mask(dev, type, &mask);
1037 set_bit(mask, code);
1039 if (type == EV_ABS) {
1040 const struct input_absinfo *abs = data;
1041 dev->abs_info[code] = *abs;
1042 } else if (type == EV_REP) {
1043 const int *value = data;
1044 dev->rep_values[code] = *value;
1051 libevdev_disable_event_code(struct libevdev *dev, unsigned int type, unsigned int code)
1054 unsigned long *mask;
1059 max = type_to_mask(dev, type, &mask);
1064 clear_bit(mask, code);
1071 libevdev_kernel_set_abs_value(struct libevdev *dev, unsigned int code, const struct input_absinfo *abs)
1073 return libevdev_kernel_set_abs_info(dev, code, abs);
1077 libevdev_kernel_set_abs_info(struct libevdev *dev, unsigned int code, const struct input_absinfo *abs)
1084 rc = ioctl(dev->fd, EVIOCSABS(code), abs);
1088 rc = libevdev_enable_event_code(dev, EV_ABS, code, abs);
1094 libevdev_grab(struct libevdev *dev, int grab)
1098 if (grab != LIBEVDEV_GRAB && grab != LIBEVDEV_UNGRAB)
1101 if (grab == dev->grabbed)
1104 if (grab == LIBEVDEV_GRAB)
1105 rc = ioctl(dev->fd, EVIOCGRAB, (void *)1);
1106 else if (grab == LIBEVDEV_UNGRAB)
1107 rc = ioctl(dev->fd, EVIOCGRAB, (void *)0);
1110 dev->grabbed = grab;
1112 return rc < 0 ? -errno : 0;
1116 libevdev_is_event_type(const struct input_event *ev, unsigned int type)
1118 return type < EV_MAX && ev->type == type;
1122 libevdev_is_event_code(const struct input_event *ev, unsigned int type, unsigned int code)
1124 return type < EV_MAX &&
1126 (type == EV_SYN || code <= libevdev_get_event_type_max(type)) &&
1131 libevdev_get_event_type_name(unsigned int type)
1136 return ev_map[type];
1140 libevdev_get_event_code_name(unsigned int type, unsigned int code)
1145 if (code > ev_max[type])
1148 return event_type_map[type][code];
1153 libevdev_get_input_prop_name(unsigned int prop)
1155 return libevdev_get_property_name(prop);
1159 libevdev_get_property_name(unsigned int prop)
1161 if (prop > INPUT_PROP_MAX)
1164 return input_prop_map[prop];
1168 libevdev_get_event_type_max(unsigned int type)
1173 return ev_max[type];
1177 libevdev_get_repeat(struct libevdev *dev, int *delay, int *period)
1179 if (!libevdev_has_event_type(dev, EV_REP))
1183 *delay = dev->rep_values[REP_DELAY];
1185 *period = dev->rep_values[REP_PERIOD];
1191 libevdev_kernel_set_led_value(struct libevdev *dev, unsigned int code, enum EvdevLEDValues value)
1193 return libevdev_kernel_set_led_values(dev, code, value, -1);
1197 libevdev_kernel_set_led_values(struct libevdev *dev, ...)
1199 struct input_event ev[LED_MAX + 1];
1200 enum EvdevLEDValues val;
1206 memset(ev, 0, sizeof(ev));
1208 va_start(args, dev);
1209 code = va_arg(args, unsigned int);
1210 while (code != -1) {
1211 if (code > LED_MAX) {
1215 val = va_arg(args, enum EvdevLEDValues);
1216 if (val != LIBEVDEV_LED_ON && val != LIBEVDEV_LED_OFF) {
1221 if (libevdev_has_event_code(dev, EV_LED, code)) {
1222 struct input_event *e = ev;
1224 while (e->type > 0 && e->code != code)
1231 e->value = (val == LIBEVDEV_LED_ON);
1233 code = va_arg(args, unsigned int);
1237 if (rc == 0 && nleds > 0) {
1238 ev[nleds].type = EV_SYN;
1239 ev[nleds++].code = SYN_REPORT;
1241 rc = write(libevdev_get_fd(dev), ev, nleds * sizeof(ev[0]));
1243 nleds--; /* last is EV_SYN */
1245 update_led_state(dev, &ev[nleds]);
1247 rc = (rc != -1) ? 0 : -errno;