Lines Matching +full:linux +full:- +full:event +full:- +full:codes
1 // SPDX-License-Identifier: GPL-2.0-only
3 * Event char devices, giving access to raw input device events.
5 * Copyright (c) 1999-2002 Vojtech Pavlik
15 #include <linux/poll.h>
16 #include <linux/sched.h>
17 #include <linux/slab.h>
18 #include <linux/vmalloc.h>
19 #include <linux/mm.h>
20 #include <linux/module.h>
21 #include <linux/init.h>
22 #include <linux/input/mt.h>
23 #include <linux/major.h>
24 #include <linux/device.h>
25 #include <linux/cdev.h>
26 #include "input-compat.h"
82 /* EV_SYN and unknown codes are never filtered */ in __evdev_is_filtered()
87 mask = client->evmasks[0]; in __evdev_is_filtered()
96 mask = client->evmasks[type]; in __evdev_is_filtered()
100 /* flush queued events of type @type, caller must hold client->buffer_lock */
104 unsigned int mask = client->bufsize - 1; in __evdev_flush_queue()
110 head = client->tail; in __evdev_flush_queue()
111 client->packet_head = client->tail; in __evdev_flush_queue()
116 for (i = client->tail; i != client->head; i = (i + 1) & mask) { in __evdev_flush_queue()
117 ev = &client->buffer[i]; in __evdev_flush_queue()
118 is_report = ev->type == EV_SYN && ev->code == SYN_REPORT; in __evdev_flush_queue()
120 if (ev->type == type) { in __evdev_flush_queue()
128 client->buffer[head] = *ev; in __evdev_flush_queue()
136 client->packet_head = head; in __evdev_flush_queue()
140 client->head = head; in __evdev_flush_queue()
145 ktime_t *ev_time = input_get_timestamp(client->evdev->handle.dev); in __evdev_queue_syn_dropped()
146 struct timespec64 ts = ktime_to_timespec64(ev_time[client->clk_type]); in __evdev_queue_syn_dropped()
155 client->buffer[client->head++] = ev; in __evdev_queue_syn_dropped()
156 client->head &= client->bufsize - 1; in __evdev_queue_syn_dropped()
158 if (unlikely(client->head == client->tail)) { in __evdev_queue_syn_dropped()
159 /* drop queue but keep our SYN_DROPPED event */ in __evdev_queue_syn_dropped()
160 client->tail = (client->head - 1) & (client->bufsize - 1); in __evdev_queue_syn_dropped()
161 client->packet_head = client->tail; in __evdev_queue_syn_dropped()
169 spin_lock_irqsave(&client->buffer_lock, flags); in evdev_queue_syn_dropped()
171 spin_unlock_irqrestore(&client->buffer_lock, flags); in evdev_queue_syn_dropped()
191 return -EINVAL; in evdev_set_clk_type()
194 if (client->clk_type != clk_type) { in evdev_set_clk_type()
195 client->clk_type = clk_type; in evdev_set_clk_type()
198 * Flush pending events and queue SYN_DROPPED event, in evdev_set_clk_type()
201 spin_lock_irqsave(&client->buffer_lock, flags); in evdev_set_clk_type()
203 if (client->head != client->tail) { in evdev_set_clk_type()
204 client->packet_head = client->head = client->tail; in evdev_set_clk_type()
208 spin_unlock_irqrestore(&client->buffer_lock, flags); in evdev_set_clk_type()
215 const struct input_event *event) in __pass_event() argument
217 client->buffer[client->head++] = *event; in __pass_event()
218 client->head &= client->bufsize - 1; in __pass_event()
220 if (unlikely(client->head == client->tail)) { in __pass_event()
223 * EV_SYN/SYN_DROPPED plus the newest event in the queue. in __pass_event()
225 client->tail = (client->head - 2) & (client->bufsize - 1); in __pass_event()
227 client->buffer[client->tail] = (struct input_event) { in __pass_event()
228 .input_event_sec = event->input_event_sec, in __pass_event()
229 .input_event_usec = event->input_event_usec, in __pass_event()
235 client->packet_head = client->tail; in __pass_event()
238 if (event->type == EV_SYN && event->code == SYN_REPORT) { in __pass_event()
239 client->packet_head = client->head; in __pass_event()
240 kill_fasync(&client->fasync, SIGIO, POLL_IN); in __pass_event()
249 struct input_event event; in evdev_pass_values() local
253 if (client->revoked) in evdev_pass_values()
256 ts = ktime_to_timespec64(ev_time[client->clk_type]); in evdev_pass_values()
257 event.input_event_sec = ts.tv_sec; in evdev_pass_values()
258 event.input_event_usec = ts.tv_nsec / NSEC_PER_USEC; in evdev_pass_values()
261 spin_lock(&client->buffer_lock); in evdev_pass_values()
264 if (__evdev_is_filtered(client, v->type, v->code)) in evdev_pass_values()
267 if (v->type == EV_SYN && v->code == SYN_REPORT) { in evdev_pass_values()
269 if (client->packet_head == client->head) in evdev_pass_values()
275 event.type = v->type; in evdev_pass_values()
276 event.code = v->code; in evdev_pass_values()
277 event.value = v->value; in evdev_pass_values()
278 __pass_event(client, &event); in evdev_pass_values()
281 spin_unlock(&client->buffer_lock); in evdev_pass_values()
284 wake_up_interruptible_poll(&client->wait, in evdev_pass_values()
294 struct evdev *evdev = handle->private; in evdev_events()
296 ktime_t *ev_time = input_get_timestamp(handle->dev); in evdev_events()
300 client = rcu_dereference(evdev->grab); in evdev_events()
305 list_for_each_entry_rcu(client, &evdev->client_list, node) in evdev_events()
312 * Pass incoming event to all connected clients.
324 struct evdev_client *client = file->private_data; in evdev_fasync()
326 return fasync_helper(fd, file, on, &client->fasync); in evdev_fasync()
333 input_put_device(evdev->handle.dev); in evdev_free()
338 * Grabs an event device (along with underlying input device).
339 * This function is called with evdev->mutex taken.
345 if (evdev->grab) in evdev_grab()
346 return -EBUSY; in evdev_grab()
348 error = input_grab_device(&evdev->handle); in evdev_grab()
352 rcu_assign_pointer(evdev->grab, client); in evdev_grab()
359 struct evdev_client *grab = rcu_dereference_protected(evdev->grab, in evdev_ungrab()
360 lockdep_is_held(&evdev->mutex)); in evdev_ungrab()
363 return -EINVAL; in evdev_ungrab()
365 rcu_assign_pointer(evdev->grab, NULL); in evdev_ungrab()
367 input_release_device(&evdev->handle); in evdev_ungrab()
375 spin_lock(&evdev->client_lock); in evdev_attach_client()
376 list_add_tail_rcu(&client->node, &evdev->client_list); in evdev_attach_client()
377 spin_unlock(&evdev->client_lock); in evdev_attach_client()
383 spin_lock(&evdev->client_lock); in evdev_detach_client()
384 list_del_rcu(&client->node); in evdev_detach_client()
385 spin_unlock(&evdev->client_lock); in evdev_detach_client()
393 retval = mutex_lock_interruptible(&evdev->mutex); in evdev_open_device()
397 if (!evdev->exist) in evdev_open_device()
398 retval = -ENODEV; in evdev_open_device()
399 else if (!evdev->open++) { in evdev_open_device()
400 retval = input_open_device(&evdev->handle); in evdev_open_device()
402 evdev->open--; in evdev_open_device()
405 mutex_unlock(&evdev->mutex); in evdev_open_device()
411 mutex_lock(&evdev->mutex); in evdev_close_device()
413 if (evdev->exist && !--evdev->open) in evdev_close_device()
414 input_close_device(&evdev->handle); in evdev_close_device()
416 mutex_unlock(&evdev->mutex); in evdev_close_device()
427 spin_lock(&evdev->client_lock); in evdev_hangup()
428 list_for_each_entry(client, &evdev->client_list, node) { in evdev_hangup()
429 kill_fasync(&client->fasync, SIGIO, POLL_HUP); in evdev_hangup()
430 wake_up_interruptible_poll(&client->wait, EPOLLHUP | EPOLLERR); in evdev_hangup()
432 spin_unlock(&evdev->client_lock); in evdev_hangup()
437 struct evdev_client *client = file->private_data; in evdev_release()
438 struct evdev *evdev = client->evdev; in evdev_release()
441 mutex_lock(&evdev->mutex); in evdev_release()
443 if (evdev->exist && !client->revoked) in evdev_release()
444 input_flush_device(&evdev->handle, file); in evdev_release()
447 mutex_unlock(&evdev->mutex); in evdev_release()
452 bitmap_free(client->evmasks[i]); in evdev_release()
464 max(dev->hint_events_per_packet * EVDEV_BUF_PACKETS, in evdev_compute_buffer_size()
472 struct evdev *evdev = container_of(inode->i_cdev, struct evdev, cdev); in evdev_open()
473 unsigned int bufsize = evdev_compute_buffer_size(evdev->handle.dev); in evdev_open()
479 return -ENOMEM; in evdev_open()
481 init_waitqueue_head(&client->wait); in evdev_open()
482 client->bufsize = bufsize; in evdev_open()
483 spin_lock_init(&client->buffer_lock); in evdev_open()
484 client->evdev = evdev; in evdev_open()
491 file->private_data = client; in evdev_open()
505 struct evdev_client *client = file->private_data; in evdev_write()
506 struct evdev *evdev = client->evdev; in evdev_write()
507 struct input_event event; in evdev_write() local
511 return -EINVAL; in evdev_write()
513 retval = mutex_lock_interruptible(&evdev->mutex); in evdev_write()
517 if (!evdev->exist || client->revoked) { in evdev_write()
518 retval = -ENODEV; in evdev_write()
524 if (input_event_from_user(buffer + retval, &event)) { in evdev_write()
525 retval = -EFAULT; in evdev_write()
530 input_inject_event(&evdev->handle, in evdev_write()
531 event.type, event.code, event.value); in evdev_write()
536 mutex_unlock(&evdev->mutex); in evdev_write()
541 struct input_event *event) in evdev_fetch_next_event() argument
545 spin_lock_irq(&client->buffer_lock); in evdev_fetch_next_event()
547 have_event = client->packet_head != client->tail; in evdev_fetch_next_event()
549 *event = client->buffer[client->tail++]; in evdev_fetch_next_event()
550 client->tail &= client->bufsize - 1; in evdev_fetch_next_event()
553 spin_unlock_irq(&client->buffer_lock); in evdev_fetch_next_event()
561 struct evdev_client *client = file->private_data; in evdev_read()
562 struct evdev *evdev = client->evdev; in evdev_read()
563 struct input_event event; in evdev_read() local
568 return -EINVAL; in evdev_read()
571 if (!evdev->exist || client->revoked) in evdev_read()
572 return -ENODEV; in evdev_read()
574 if (client->packet_head == client->tail && in evdev_read()
575 (file->f_flags & O_NONBLOCK)) in evdev_read()
576 return -EAGAIN; in evdev_read()
579 * count == 0 is special - no IO is done but we check in evdev_read()
586 evdev_fetch_next_event(client, &event)) { in evdev_read()
588 if (input_event_to_user(buffer + read, &event)) in evdev_read()
589 return -EFAULT; in evdev_read()
597 if (!(file->f_flags & O_NONBLOCK)) { in evdev_read()
598 error = wait_event_interruptible(client->wait, in evdev_read()
599 client->packet_head != client->tail || in evdev_read()
600 !evdev->exist || client->revoked); in evdev_read()
609 /* No kernel lock - fine */
612 struct evdev_client *client = file->private_data; in evdev_poll()
613 struct evdev *evdev = client->evdev; in evdev_poll()
616 poll_wait(file, &client->wait, wait); in evdev_poll()
618 if (evdev->exist && !client->revoked) in evdev_poll()
623 if (client->packet_head != client->tail) in evdev_poll()
632 #define BITS_TO_LONGS_COMPAT(x) ((((x) - 1) / BITS_PER_LONG_COMPAT) + 1)
648 i + 1 - ((i % 2) << 1), in bits_to_user()
650 return -EFAULT; in bits_to_user()
657 return -EFAULT; in bits_to_user()
670 return -EINVAL; in bits_from_user()
678 i + 1 - ((i % 2) << 1), in bits_from_user()
681 return -EFAULT; in bits_from_user()
683 *((compat_long_t *) bits + i - 1) = 0; in bits_from_user()
687 return -EINVAL; in bits_from_user()
694 return -EFAULT; in bits_from_user()
712 return copy_to_user(p, bits, len) ? -EFAULT : len; in bits_to_user()
722 return -EINVAL; in bits_from_user()
729 return copy_from_user(bits, p, len) ? -EFAULT : len; in bits_from_user()
744 return copy_to_user(p, bits, len) ? -EFAULT : len; in bits_to_user()
753 return -EINVAL; in bits_from_user()
759 return copy_from_user(bits, p, len) ? -EFAULT : len; in bits_from_user()
769 return -ENOENT; in str_to_user()
775 return copy_to_user(p, str, len) ? -EFAULT : len; in str_to_user()
787 case 0: bits = dev->evbit; len = EV_MAX; break; in handle_eviocgbit()
788 case EV_KEY: bits = dev->keybit; len = KEY_MAX; break; in handle_eviocgbit()
789 case EV_REL: bits = dev->relbit; len = REL_MAX; break; in handle_eviocgbit()
790 case EV_ABS: bits = dev->absbit; len = ABS_MAX; break; in handle_eviocgbit()
791 case EV_MSC: bits = dev->mscbit; len = MSC_MAX; break; in handle_eviocgbit()
792 case EV_LED: bits = dev->ledbit; len = LED_MAX; break; in handle_eviocgbit()
793 case EV_SND: bits = dev->sndbit; len = SND_MAX; break; in handle_eviocgbit()
794 case EV_FF: bits = dev->ffbit; len = FF_MAX; break; in handle_eviocgbit()
795 case EV_SW: bits = dev->swbit; len = SW_MAX; break; in handle_eviocgbit()
796 default: return -EINVAL; in handle_eviocgbit()
813 return -EFAULT; in evdev_handle_get_keycode()
820 return -EFAULT; in evdev_handle_get_keycode()
831 return -EFAULT; in evdev_handle_get_keycode_v2()
838 return -EFAULT; in evdev_handle_get_keycode_v2()
852 return -EFAULT; in evdev_handle_set_keycode()
855 return -EFAULT; in evdev_handle_set_keycode()
865 return -EFAULT; in evdev_handle_set_keycode_v2()
868 return -EINVAL; in evdev_handle_set_keycode_v2()
878 * event so user-space will notice missing events.
881 * We need to take event_lock before buffer_lock to avoid dead-locks. But we
883 * it while flushing the queue. This allows input-core to handle filters while
897 return -ENOMEM; in evdev_handle_get_val()
899 spin_lock_irq(&dev->event_lock); in evdev_handle_get_val()
900 spin_lock(&client->buffer_lock); in evdev_handle_get_val()
904 spin_unlock(&dev->event_lock); in evdev_handle_get_val()
908 spin_unlock_irq(&client->buffer_lock); in evdev_handle_get_val()
923 const struct input_mt *mt = dev->mt; in evdev_handle_mt_request()
929 return -EFAULT; in evdev_handle_mt_request()
931 return -EINVAL; in evdev_handle_mt_request()
933 max_slots = (size - sizeof(__u32)) / sizeof(__s32); in evdev_handle_mt_request()
934 for (i = 0; i < mt->num_slots && i < max_slots; i++) { in evdev_handle_mt_request()
935 int value = input_mt_get_value(&mt->slots[i], code); in evdev_handle_mt_request()
937 return -EFAULT; in evdev_handle_mt_request()
946 client->revoked = true; in evdev_revoke()
948 input_flush_device(&evdev->handle, file); in evdev_revoke()
949 wake_up_interruptible_poll(&client->wait, EPOLLHUP | EPOLLERR); in evdev_revoke()
954 /* must be called with evdev-mutex held */
957 const void __user *codes, in evdev_set_mask() argument
965 /* we allow unknown types and 'codes_size > size' for forward-compat */ in evdev_set_mask()
972 return -ENOMEM; in evdev_set_mask()
974 error = bits_from_user(mask, cnt - 1, codes_size, codes, compat); in evdev_set_mask()
980 spin_lock_irqsave(&client->buffer_lock, flags); in evdev_set_mask()
981 oldmask = client->evmasks[type]; in evdev_set_mask()
982 client->evmasks[type] = mask; in evdev_set_mask()
983 spin_unlock_irqrestore(&client->buffer_lock, flags); in evdev_set_mask()
990 /* must be called with evdev-mutex held */
993 void __user *codes, in evdev_get_mask() argument
1002 /* we allow unknown types and 'codes_size > size' for forward-compat */ in evdev_get_mask()
1008 mask = client->evmasks[type]; in evdev_get_mask()
1010 error = bits_to_user(mask, cnt - 1, in evdev_get_mask()
1011 xfer_size, codes, compat); in evdev_get_mask()
1017 if (put_user(0xffU, (u8 __user *)codes + i)) in evdev_get_mask()
1018 return -EFAULT; in evdev_get_mask()
1023 if (clear_user(codes + xfer_size, codes_size - xfer_size)) in evdev_get_mask()
1024 return -EFAULT; in evdev_get_mask()
1032 struct evdev_client *client = file->private_data; in evdev_do_ioctl()
1033 struct evdev *evdev = client->evdev; in evdev_do_ioctl()
1034 struct input_dev *dev = evdev->handle.dev; in evdev_do_ioctl()
1043 /* First we check for fixed-length commands */ in evdev_do_ioctl()
1050 if (copy_to_user(p, &dev->id, sizeof(struct input_id))) in evdev_do_ioctl()
1051 return -EFAULT; in evdev_do_ioctl()
1055 if (!test_bit(EV_REP, dev->evbit)) in evdev_do_ioctl()
1056 return -ENOSYS; in evdev_do_ioctl()
1057 if (put_user(dev->rep[REP_DELAY], ip)) in evdev_do_ioctl()
1058 return -EFAULT; in evdev_do_ioctl()
1059 if (put_user(dev->rep[REP_PERIOD], ip + 1)) in evdev_do_ioctl()
1060 return -EFAULT; in evdev_do_ioctl()
1064 if (!test_bit(EV_REP, dev->evbit)) in evdev_do_ioctl()
1065 return -ENOSYS; in evdev_do_ioctl()
1067 return -EFAULT; in evdev_do_ioctl()
1069 return -EFAULT; in evdev_do_ioctl()
1071 input_inject_event(&evdev->handle, EV_REP, REP_DELAY, u); in evdev_do_ioctl()
1072 input_inject_event(&evdev->handle, EV_REP, REP_PERIOD, v); in evdev_do_ioctl()
1080 i = test_bit(EV_FF, dev->evbit) ? in evdev_do_ioctl()
1081 dev->ff->max_effects : 0; in evdev_do_ioctl()
1083 return -EFAULT; in evdev_do_ioctl()
1094 return -EINVAL; in evdev_do_ioctl()
1102 return -EFAULT; in evdev_do_ioctl()
1114 return -EFAULT; in evdev_do_ioctl()
1124 return -EFAULT; in evdev_do_ioctl()
1143 /* Now check variable-length commands */ in evdev_do_ioctl()
1148 return bits_to_user(dev->propbit, INPUT_PROP_MAX, in evdev_do_ioctl()
1155 return evdev_handle_get_val(client, dev, EV_KEY, dev->key, in evdev_do_ioctl()
1159 return evdev_handle_get_val(client, dev, EV_LED, dev->led, in evdev_do_ioctl()
1163 return evdev_handle_get_val(client, dev, EV_SND, dev->snd, in evdev_do_ioctl()
1167 return evdev_handle_get_val(client, dev, EV_SW, dev->sw, in evdev_do_ioctl()
1171 return str_to_user(dev->name, size, p); in evdev_do_ioctl()
1174 return str_to_user(dev->phys, size, p); in evdev_do_ioctl()
1177 return str_to_user(dev->uniq, size, p); in evdev_do_ioctl()
1181 return -EFAULT; in evdev_do_ioctl()
1187 if (put_user(effect.id, &(((struct ff_effect __user *)p)->id))) in evdev_do_ioctl()
1188 return -EFAULT; in evdev_do_ioctl()
1193 /* Multi-number variable-length handlers */ in evdev_do_ioctl()
1195 return -EINVAL; in evdev_do_ioctl()
1206 if (!dev->absinfo) in evdev_do_ioctl()
1207 return -EINVAL; in evdev_do_ioctl()
1210 abs = dev->absinfo[t]; in evdev_do_ioctl()
1214 return -EFAULT; in evdev_do_ioctl()
1224 if (!dev->absinfo) in evdev_do_ioctl()
1225 return -EINVAL; in evdev_do_ioctl()
1231 return -EFAULT; in evdev_do_ioctl()
1238 return -EINVAL; in evdev_do_ioctl()
1241 * Take event lock to ensure that we are not in evdev_do_ioctl()
1243 * of event. in evdev_do_ioctl()
1245 spin_lock_irq(&dev->event_lock); in evdev_do_ioctl()
1246 dev->absinfo[t] = abs; in evdev_do_ioctl()
1247 spin_unlock_irq(&dev->event_lock); in evdev_do_ioctl()
1253 return -EINVAL; in evdev_do_ioctl()
1259 struct evdev_client *client = file->private_data; in evdev_ioctl_handler()
1260 struct evdev *evdev = client->evdev; in evdev_ioctl_handler()
1263 retval = mutex_lock_interruptible(&evdev->mutex); in evdev_ioctl_handler()
1267 if (!evdev->exist || client->revoked) { in evdev_ioctl_handler()
1268 retval = -ENODEV; in evdev_ioctl_handler()
1275 mutex_unlock(&evdev->mutex); in evdev_ioctl_handler()
1308 * Mark device non-existent. This disables writes, ioctls and
1314 mutex_lock(&evdev->mutex); in evdev_mark_dead()
1315 evdev->exist = false; in evdev_mark_dead()
1316 mutex_unlock(&evdev->mutex); in evdev_mark_dead()
1321 struct input_handle *handle = &evdev->handle; in evdev_cleanup()
1326 /* evdev is marked dead so no one else accesses evdev->open */ in evdev_cleanup()
1327 if (evdev->open) { in evdev_cleanup()
1354 error = -ENOMEM; in evdev_connect()
1358 INIT_LIST_HEAD(&evdev->client_list); in evdev_connect()
1359 spin_lock_init(&evdev->client_lock); in evdev_connect()
1360 mutex_init(&evdev->mutex); in evdev_connect()
1361 evdev->exist = true; in evdev_connect()
1366 dev_no -= EVDEV_MINOR_BASE; in evdev_connect()
1367 dev_set_name(&evdev->dev, "event%d", dev_no); in evdev_connect()
1369 evdev->handle.dev = input_get_device(dev); in evdev_connect()
1370 evdev->handle.name = dev_name(&evdev->dev); in evdev_connect()
1371 evdev->handle.handler = handler; in evdev_connect()
1372 evdev->handle.private = evdev; in evdev_connect()
1374 evdev->dev.devt = MKDEV(INPUT_MAJOR, minor); in evdev_connect()
1375 evdev->dev.class = &input_class; in evdev_connect()
1376 evdev->dev.parent = &dev->dev; in evdev_connect()
1377 evdev->dev.release = evdev_free; in evdev_connect()
1378 device_initialize(&evdev->dev); in evdev_connect()
1380 error = input_register_handle(&evdev->handle); in evdev_connect()
1384 cdev_init(&evdev->cdev, &evdev_fops); in evdev_connect()
1386 error = cdev_device_add(&evdev->cdev, &evdev->dev); in evdev_connect()
1394 input_unregister_handle(&evdev->handle); in evdev_connect()
1396 put_device(&evdev->dev); in evdev_connect()
1404 struct evdev *evdev = handle->private; in evdev_disconnect()
1406 cdev_device_del(&evdev->cdev, &evdev->dev); in evdev_disconnect()
1408 input_free_minor(MINOR(evdev->dev.devt)); in evdev_disconnect()
1410 put_device(&evdev->dev); in evdev_disconnect()
1421 .event = evdev_event,
1445 MODULE_DESCRIPTION("Input driver event char devices");