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) {
510 dev->current_slot = e->value;
512 } else if (dev->current_slot == -1)
515 dev->mt_slot_vals[dev->current_slot][e->code - ABS_MT_MIN] = e->value;
521 update_abs_state(struct libevdev *dev, const struct input_event *e)
523 if (!libevdev_has_event_type(dev, EV_ABS))
526 if (e->code > ABS_MAX)
529 if (e->code >= ABS_MT_MIN && e->code <= ABS_MT_MAX)
530 return update_mt_state(dev, e);
532 dev->abs_info[e->code].value = e->value;
538 update_led_state(struct libevdev *dev, const struct input_event *e)
540 if (!libevdev_has_event_type(dev, EV_LED))
543 if (e->code > LED_MAX)
546 set_bit_state(dev->led_values, e->code, e->value != 0);
552 update_state(struct libevdev *dev, const struct input_event *e)
561 rc = update_key_state(dev, e);
564 rc = update_abs_state(dev, e);
567 rc = update_led_state(dev, e);
571 dev->last_event_time = e->time;
577 read_more_events(struct libevdev *dev)
581 struct input_event *next;
583 free_elem = queue_num_free_elements(dev);
587 next = queue_next_element(dev);
588 len = read(dev->fd, next, free_elem * sizeof(struct input_event));
591 } else if (len > 0 && len % sizeof(struct input_event) != 0)
594 int nev = len/sizeof(struct input_event);
595 queue_set_num_elements(dev, queue_num_elements(dev) + nev);
601 int libevdev_next_event(struct libevdev *dev, unsigned int flags, struct input_event *ev)
608 if (!(flags & (LIBEVDEV_READ_NORMAL|LIBEVDEV_READ_SYNC|LIBEVDEV_FORCE_SYNC)))
611 if (flags & LIBEVDEV_READ_SYNC) {
612 if (dev->sync_state == SYNC_NEEDED) {
613 rc = sync_state(dev);
616 dev->sync_state = SYNC_IN_PROGRESS;
619 if (dev->queue_nsync == 0) {
620 dev->sync_state = SYNC_NONE;
624 } else if (dev->sync_state != SYNC_NONE) {
625 struct input_event e;
627 /* call update_state for all events here, otherwise the library has the wrong view
629 while (queue_shift(dev, &e) == 0) {
631 update_state(dev, &e);
634 dev->sync_state = SYNC_NONE;
637 /* FIXME: if the first event after SYNC_IN_PROGRESS is a SYN_DROPPED, log this */
639 /* Always read in some more events. Best case this smoothes over a potential SYN_DROPPED,
640 worst case we don't read fast enough and end up with SYN_DROPPED anyway.
642 Except if the fd is in blocking mode and we still have events from the last read, don't
646 if (!(flags & LIBEVDEV_READ_BLOCKING) ||
647 queue_num_elements(dev) == 0) {
648 rc = read_more_events(dev);
649 if (rc < 0 && rc != -EAGAIN)
653 if (flags & LIBEVDEV_FORCE_SYNC) {
654 dev->sync_state = SYNC_NEEDED;
660 if (queue_shift(dev, ev) != 0)
663 update_state(dev, ev);
665 /* if we disabled a code, get the next event instead */
666 } while(!libevdev_has_event_code(dev, ev->type, ev->code));
669 if (ev->type == EV_SYN && ev->code == SYN_DROPPED) {
670 dev->sync_state = SYNC_NEEDED;
674 if (flags & LIBEVDEV_READ_SYNC && dev->queue_nsync > 0) {
677 if (dev->queue_nsync == 0)
678 dev->sync_state = SYNC_NONE;
685 int libevdev_has_event_pending(struct libevdev *dev)
687 struct pollfd fds = { dev->fd, POLLIN, 0 };
693 if (queue_num_elements(dev) != 0)
696 rc = poll(&fds, 1, 0);
697 return (rc >= 0) ? rc : -errno;
701 libevdev_get_name(const struct libevdev *dev)
703 return dev->name ? dev->name : "";
707 libevdev_get_phys(const struct libevdev *dev)
713 libevdev_get_uniq(const struct libevdev *dev)
718 #define STRING_SETTER(field) \
719 void libevdev_set_##field(struct libevdev *dev, const char *field) \
724 dev->field = strdup(field); \
732 #define PRODUCT_GETTER(name, field) \
733 int libevdev_get_##name(const struct libevdev *dev) \
735 return dev->ids.field; \
738 PRODUCT_GETTER(product_id, product); /* DEPRECATED */
739 PRODUCT_GETTER(vendor_id, vendor); /* DEPRECATED */
740 PRODUCT_GETTER(bustype, bustype); /* DEPRECATED */
741 PRODUCT_GETTER(version, version); /* DEPRECATED */
743 PRODUCT_GETTER(id_product, product);
744 PRODUCT_GETTER(id_vendor, vendor);
745 PRODUCT_GETTER(id_bustype, bustype);
746 PRODUCT_GETTER(id_version, version);
748 #define PRODUCT_SETTER(field) \
749 void libevdev_set_id_##field(struct libevdev *dev, int field) \
751 dev->ids.field = field;\
754 PRODUCT_SETTER(product);
755 PRODUCT_SETTER(vendor);
756 PRODUCT_SETTER(bustype);
757 PRODUCT_SETTER(version);
759 int libevdev_get_driver_version(const struct libevdev *dev)
761 return dev->driver_version;
765 libevdev_has_property(const struct libevdev *dev, unsigned int prop)
767 return (prop <= INPUT_PROP_MAX) && bit_is_set(dev->props, prop);
771 libevdev_enable_property(struct libevdev *dev, unsigned int prop)
773 if (prop > INPUT_PROP_MAX)
776 set_bit(dev->props, prop);
781 libevdev_has_event_type(const struct libevdev *dev, unsigned int type)
783 return (type <= EV_MAX) && bit_is_set(dev->bits, type);
787 libevdev_has_event_code(const struct libevdev *dev, unsigned int type, unsigned int code)
789 const unsigned long *mask;
792 if (!libevdev_has_event_type(dev, type))
798 max = type_to_mask_const(dev, type, &mask);
800 if (max == -1 || code > max)
803 return bit_is_set(mask, code);
807 libevdev_get_event_value(const struct libevdev *dev, unsigned int type, unsigned int code)
811 if (!libevdev_has_event_type(dev, type) || !libevdev_has_event_code(dev, type, code))
815 case EV_ABS: value = dev->abs_info[code].value; break;
816 case EV_KEY: value = bit_is_set(dev->key_values, code); break;
817 case EV_LED: value = bit_is_set(dev->led_values, code); break;
826 int libevdev_set_event_value(struct libevdev *dev, unsigned int type, unsigned int code, int value)
829 struct input_event e;
831 if (!libevdev_has_event_type(dev, type) || !libevdev_has_event_code(dev, type, code))
839 case EV_ABS: rc = update_abs_state(dev, &e); break;
840 case EV_KEY: rc = update_key_state(dev, &e); break;
841 case EV_LED: rc = update_led_state(dev, &e); break;
851 libevdev_fetch_event_value(const struct libevdev *dev, unsigned int type, unsigned int code, int *value)
853 if (libevdev_has_event_type(dev, type) &&
854 libevdev_has_event_code(dev, type, code)) {
855 *value = libevdev_get_event_value(dev, type, code);
862 libevdev_get_slot_value(const struct libevdev *dev, unsigned int slot, unsigned int code)
864 if (!libevdev_has_event_type(dev, EV_ABS) || !libevdev_has_event_code(dev, EV_ABS, code))
867 if (slot >= dev->num_slots || slot >= MAX_SLOTS)
870 if (code > ABS_MT_MAX || code < ABS_MT_MIN)
873 return dev->mt_slot_vals[slot][code - ABS_MT_MIN];
877 libevdev_set_slot_value(struct libevdev *dev, unsigned int slot, unsigned int code, int value)
879 if (!libevdev_has_event_type(dev, EV_ABS) || !libevdev_has_event_code(dev, EV_ABS, code))
882 if (slot >= dev->num_slots || slot >= MAX_SLOTS)
885 if (code > ABS_MT_MAX || code < ABS_MT_MIN)
888 if (code == ABS_MT_SLOT) {
889 if (value < 0 || value >= libevdev_get_num_slots(dev))
891 dev->current_slot = value;
894 dev->mt_slot_vals[slot][code - ABS_MT_MIN] = value;
901 libevdev_fetch_slot_value(const struct libevdev *dev, unsigned int slot, unsigned int code, int *value)
903 if (libevdev_has_event_type(dev, EV_ABS) &&
904 libevdev_has_event_code(dev, EV_ABS, code) &&
905 slot < dev->num_slots && slot < MAX_SLOTS) {
906 *value = libevdev_get_slot_value(dev, slot, code);
913 libevdev_get_num_slots(const struct libevdev *dev)
915 return dev->num_slots;
919 libevdev_get_current_slot(const struct libevdev *dev)
921 return dev->current_slot;
924 const struct input_absinfo*
925 libevdev_get_abs_info(const struct libevdev *dev, unsigned int code)
927 if (!libevdev_has_event_type(dev, EV_ABS) ||
928 !libevdev_has_event_code(dev, EV_ABS, code))
931 return &dev->abs_info[code];
934 #define ABS_GETTER(name, field) \
935 int libevdev_get_abs_##name(const struct libevdev *dev, unsigned int code) \
937 const struct input_absinfo *absinfo = libevdev_get_abs_info(dev, code); \
938 return absinfo ? absinfo->field : 0; \
941 ABS_GETTER(max, maximum); /* DEPRECATED */
942 ABS_GETTER(min, minimum); /* DEPRECATED */
943 ABS_GETTER(maximum, maximum);
944 ABS_GETTER(minimum, minimum);
945 ABS_GETTER(fuzz, fuzz)
946 ABS_GETTER(flat, flat)
947 ABS_GETTER(resolution, resolution)
949 #define ABS_SETTER(field) \
950 void libevdev_set_abs_##field(struct libevdev *dev, unsigned int code, int val) \
952 if (!libevdev_has_event_code(dev, EV_ABS, code)) \
954 dev->abs_info[code].field = val; \
961 ABS_SETTER(resolution)
963 void libevdev_set_abs_info(struct libevdev *dev, unsigned int code, const struct input_absinfo *abs)
965 if (!libevdev_has_event_code(dev, EV_ABS, code))
968 dev->abs_info[code] = *abs;
972 libevdev_enable_event_type(struct libevdev *dev, unsigned int type)
977 if (libevdev_has_event_type(dev, type))
980 set_bit(dev->bits, type);
982 if (type == EV_REP) {
983 int delay = 0, period = 0;
984 libevdev_enable_event_code(dev, EV_REP, REP_DELAY, &delay);
985 libevdev_enable_event_code(dev, EV_REP, REP_PERIOD, &period);
991 libevdev_disable_event_type(struct libevdev *dev, unsigned int type)
993 if (type > EV_MAX || type == EV_SYN)
996 clear_bit(dev->bits, type);
1002 libevdev_enable_event_code(struct libevdev *dev, unsigned int type,
1003 unsigned int code, const void *data)
1006 unsigned long *mask;
1008 if (libevdev_enable_event_type(dev, type))
1025 max = type_to_mask(dev, type, &mask);
1030 set_bit(mask, code);
1032 if (type == EV_ABS) {
1033 const struct input_absinfo *abs = data;
1034 dev->abs_info[code] = *abs;
1035 } else if (type == EV_REP) {
1036 const int *value = data;
1037 dev->rep_values[code] = *value;
1044 libevdev_disable_event_code(struct libevdev *dev, unsigned int type, unsigned int code)
1047 unsigned long *mask;
1052 max = type_to_mask(dev, type, &mask);
1057 clear_bit(mask, code);
1064 libevdev_kernel_set_abs_value(struct libevdev *dev, unsigned int code, const struct input_absinfo *abs)
1066 return libevdev_kernel_set_abs_info(dev, code, abs);
1070 libevdev_kernel_set_abs_info(struct libevdev *dev, unsigned int code, const struct input_absinfo *abs)
1077 rc = ioctl(dev->fd, EVIOCSABS(code), abs);
1081 rc = libevdev_enable_event_code(dev, EV_ABS, code, abs);
1087 libevdev_grab(struct libevdev *dev, int grab)
1091 if (grab != LIBEVDEV_GRAB && grab != LIBEVDEV_UNGRAB)
1094 if (grab == dev->grabbed)
1097 if (grab == LIBEVDEV_GRAB)
1098 rc = ioctl(dev->fd, EVIOCGRAB, (void *)1);
1099 else if (grab == LIBEVDEV_UNGRAB)
1100 rc = ioctl(dev->fd, EVIOCGRAB, (void *)0);
1103 dev->grabbed = grab;
1105 return rc < 0 ? -errno : 0;
1109 libevdev_is_event_type(const struct input_event *ev, unsigned int type)
1111 return type < EV_MAX && ev->type == type;
1115 libevdev_is_event_code(const struct input_event *ev, unsigned int type, unsigned int code)
1117 return type < EV_MAX &&
1119 (type == EV_SYN || code <= libevdev_get_event_type_max(type)) &&
1124 libevdev_get_event_type_name(unsigned int type)
1129 return ev_map[type];
1133 libevdev_get_event_code_name(unsigned int type, unsigned int code)
1138 if (code > ev_max[type])
1141 return event_type_map[type][code];
1146 libevdev_get_input_prop_name(unsigned int prop)
1148 return libevdev_get_property_name(prop);
1152 libevdev_get_property_name(unsigned int prop)
1154 if (prop > INPUT_PROP_MAX)
1157 return input_prop_map[prop];
1161 libevdev_get_event_type_max(unsigned int type)
1166 return ev_max[type];
1170 libevdev_get_repeat(struct libevdev *dev, int *delay, int *period)
1172 if (!libevdev_has_event_type(dev, EV_REP))
1176 *delay = dev->rep_values[REP_DELAY];
1178 *period = dev->rep_values[REP_PERIOD];
1184 libevdev_kernel_set_led_value(struct libevdev *dev, unsigned int code, enum EvdevLEDValues value)
1186 return libevdev_kernel_set_led_values(dev, code, value, -1);
1190 libevdev_kernel_set_led_values(struct libevdev *dev, ...)
1192 struct input_event ev[LED_MAX];
1193 enum EvdevLEDValues val;
1199 memset(ev, 0, sizeof(ev));
1201 va_start(args, dev);
1202 code = va_arg(args, unsigned int);
1203 while (code != -1) {
1204 if (code > LED_MAX) {
1208 val = va_arg(args, enum EvdevLEDValues);
1209 if (val != LIBEVDEV_LED_ON && val != LIBEVDEV_LED_OFF) {
1214 if (libevdev_has_event_code(dev, EV_LED, code)) {
1215 struct input_event *e = ev;
1217 while (e->type > 0 && e->code != code)
1224 e->value = (val == LIBEVDEV_LED_ON);
1226 code = va_arg(args, unsigned int);
1230 if (rc == 0 && nleds > 0) {
1231 rc = write(libevdev_get_fd(dev), ev, nleds * sizeof(ev[0]));
1234 update_led_state(dev, &ev[nleds]);
1236 rc = (rc != -1) ? 0 : -errno;