Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input
[~shefty/rdma-dev.git] / drivers / input / evdev.c
1 /*
2  * Event char devices, giving access to raw input device events.
3  *
4  * Copyright (c) 1999-2002 Vojtech Pavlik
5  *
6  * This program is free software; you can redistribute it and/or modify it
7  * under the terms of the GNU General Public License version 2 as published by
8  * the Free Software Foundation.
9  */
10
11 #define EVDEV_MINOR_BASE        64
12 #define EVDEV_MINORS            32
13 #define EVDEV_MIN_BUFFER_SIZE   64U
14 #define EVDEV_BUF_PACKETS       8
15
16 #include <linux/poll.h>
17 #include <linux/sched.h>
18 #include <linux/slab.h>
19 #include <linux/module.h>
20 #include <linux/init.h>
21 #include <linux/input.h>
22 #include <linux/major.h>
23 #include <linux/device.h>
24 #include "input-compat.h"
25
26 struct evdev {
27         int open;
28         int minor;
29         struct input_handle handle;
30         wait_queue_head_t wait;
31         struct evdev_client __rcu *grab;
32         struct list_head client_list;
33         spinlock_t client_lock; /* protects client_list */
34         struct mutex mutex;
35         struct device dev;
36         bool exist;
37 };
38
39 struct evdev_client {
40         int head;
41         int tail;
42         spinlock_t buffer_lock; /* protects access to buffer, head and tail */
43         struct fasync_struct *fasync;
44         struct evdev *evdev;
45         struct list_head node;
46         int bufsize;
47         struct input_event buffer[];
48 };
49
50 static struct evdev *evdev_table[EVDEV_MINORS];
51 static DEFINE_MUTEX(evdev_table_mutex);
52
53 static void evdev_pass_event(struct evdev_client *client,
54                              struct input_event *event)
55 {
56         /*
57          * Interrupts are disabled, just acquire the lock.
58          * Make sure we don't leave with the client buffer
59          * "empty" by having client->head == client->tail.
60          */
61         spin_lock(&client->buffer_lock);
62         do {
63                 client->buffer[client->head++] = *event;
64                 client->head &= client->bufsize - 1;
65         } while (client->head == client->tail);
66         spin_unlock(&client->buffer_lock);
67
68         if (event->type == EV_SYN)
69                 kill_fasync(&client->fasync, SIGIO, POLL_IN);
70 }
71
72 /*
73  * Pass incoming event to all connected clients.
74  */
75 static void evdev_event(struct input_handle *handle,
76                         unsigned int type, unsigned int code, int value)
77 {
78         struct evdev *evdev = handle->private;
79         struct evdev_client *client;
80         struct input_event event;
81
82         do_gettimeofday(&event.time);
83         event.type = type;
84         event.code = code;
85         event.value = value;
86
87         rcu_read_lock();
88
89         client = rcu_dereference(evdev->grab);
90         if (client)
91                 evdev_pass_event(client, &event);
92         else
93                 list_for_each_entry_rcu(client, &evdev->client_list, node)
94                         evdev_pass_event(client, &event);
95
96         rcu_read_unlock();
97
98         wake_up_interruptible(&evdev->wait);
99 }
100
101 static int evdev_fasync(int fd, struct file *file, int on)
102 {
103         struct evdev_client *client = file->private_data;
104
105         return fasync_helper(fd, file, on, &client->fasync);
106 }
107
108 static int evdev_flush(struct file *file, fl_owner_t id)
109 {
110         struct evdev_client *client = file->private_data;
111         struct evdev *evdev = client->evdev;
112         int retval;
113
114         retval = mutex_lock_interruptible(&evdev->mutex);
115         if (retval)
116                 return retval;
117
118         if (!evdev->exist)
119                 retval = -ENODEV;
120         else
121                 retval = input_flush_device(&evdev->handle, file);
122
123         mutex_unlock(&evdev->mutex);
124         return retval;
125 }
126
127 static void evdev_free(struct device *dev)
128 {
129         struct evdev *evdev = container_of(dev, struct evdev, dev);
130
131         input_put_device(evdev->handle.dev);
132         kfree(evdev);
133 }
134
135 /*
136  * Grabs an event device (along with underlying input device).
137  * This function is called with evdev->mutex taken.
138  */
139 static int evdev_grab(struct evdev *evdev, struct evdev_client *client)
140 {
141         int error;
142
143         if (evdev->grab)
144                 return -EBUSY;
145
146         error = input_grab_device(&evdev->handle);
147         if (error)
148                 return error;
149
150         rcu_assign_pointer(evdev->grab, client);
151         synchronize_rcu();
152
153         return 0;
154 }
155
156 static int evdev_ungrab(struct evdev *evdev, struct evdev_client *client)
157 {
158         if (evdev->grab != client)
159                 return  -EINVAL;
160
161         rcu_assign_pointer(evdev->grab, NULL);
162         synchronize_rcu();
163         input_release_device(&evdev->handle);
164
165         return 0;
166 }
167
168 static void evdev_attach_client(struct evdev *evdev,
169                                 struct evdev_client *client)
170 {
171         spin_lock(&evdev->client_lock);
172         list_add_tail_rcu(&client->node, &evdev->client_list);
173         spin_unlock(&evdev->client_lock);
174         synchronize_rcu();
175 }
176
177 static void evdev_detach_client(struct evdev *evdev,
178                                 struct evdev_client *client)
179 {
180         spin_lock(&evdev->client_lock);
181         list_del_rcu(&client->node);
182         spin_unlock(&evdev->client_lock);
183         synchronize_rcu();
184 }
185
186 static int evdev_open_device(struct evdev *evdev)
187 {
188         int retval;
189
190         retval = mutex_lock_interruptible(&evdev->mutex);
191         if (retval)
192                 return retval;
193
194         if (!evdev->exist)
195                 retval = -ENODEV;
196         else if (!evdev->open++) {
197                 retval = input_open_device(&evdev->handle);
198                 if (retval)
199                         evdev->open--;
200         }
201
202         mutex_unlock(&evdev->mutex);
203         return retval;
204 }
205
206 static void evdev_close_device(struct evdev *evdev)
207 {
208         mutex_lock(&evdev->mutex);
209
210         if (evdev->exist && !--evdev->open)
211                 input_close_device(&evdev->handle);
212
213         mutex_unlock(&evdev->mutex);
214 }
215
216 /*
217  * Wake up users waiting for IO so they can disconnect from
218  * dead device.
219  */
220 static void evdev_hangup(struct evdev *evdev)
221 {
222         struct evdev_client *client;
223
224         spin_lock(&evdev->client_lock);
225         list_for_each_entry(client, &evdev->client_list, node)
226                 kill_fasync(&client->fasync, SIGIO, POLL_HUP);
227         spin_unlock(&evdev->client_lock);
228
229         wake_up_interruptible(&evdev->wait);
230 }
231
232 static int evdev_release(struct inode *inode, struct file *file)
233 {
234         struct evdev_client *client = file->private_data;
235         struct evdev *evdev = client->evdev;
236
237         mutex_lock(&evdev->mutex);
238         if (evdev->grab == client)
239                 evdev_ungrab(evdev, client);
240         mutex_unlock(&evdev->mutex);
241
242         evdev_detach_client(evdev, client);
243         kfree(client);
244
245         evdev_close_device(evdev);
246         put_device(&evdev->dev);
247
248         return 0;
249 }
250
251 static unsigned int evdev_compute_buffer_size(struct input_dev *dev)
252 {
253         unsigned int n_events =
254                 max(dev->hint_events_per_packet * EVDEV_BUF_PACKETS,
255                     EVDEV_MIN_BUFFER_SIZE);
256
257         return roundup_pow_of_two(n_events);
258 }
259
260 static int evdev_open(struct inode *inode, struct file *file)
261 {
262         struct evdev *evdev;
263         struct evdev_client *client;
264         int i = iminor(inode) - EVDEV_MINOR_BASE;
265         unsigned int bufsize;
266         int error;
267
268         if (i >= EVDEV_MINORS)
269                 return -ENODEV;
270
271         error = mutex_lock_interruptible(&evdev_table_mutex);
272         if (error)
273                 return error;
274         evdev = evdev_table[i];
275         if (evdev)
276                 get_device(&evdev->dev);
277         mutex_unlock(&evdev_table_mutex);
278
279         if (!evdev)
280                 return -ENODEV;
281
282         bufsize = evdev_compute_buffer_size(evdev->handle.dev);
283
284         client = kzalloc(sizeof(struct evdev_client) +
285                                 bufsize * sizeof(struct input_event),
286                          GFP_KERNEL);
287         if (!client) {
288                 error = -ENOMEM;
289                 goto err_put_evdev;
290         }
291
292         client->bufsize = bufsize;
293         spin_lock_init(&client->buffer_lock);
294         client->evdev = evdev;
295         evdev_attach_client(evdev, client);
296
297         error = evdev_open_device(evdev);
298         if (error)
299                 goto err_free_client;
300
301         file->private_data = client;
302         nonseekable_open(inode, file);
303
304         return 0;
305
306  err_free_client:
307         evdev_detach_client(evdev, client);
308         kfree(client);
309  err_put_evdev:
310         put_device(&evdev->dev);
311         return error;
312 }
313
314 static ssize_t evdev_write(struct file *file, const char __user *buffer,
315                            size_t count, loff_t *ppos)
316 {
317         struct evdev_client *client = file->private_data;
318         struct evdev *evdev = client->evdev;
319         struct input_event event;
320         int retval;
321
322         retval = mutex_lock_interruptible(&evdev->mutex);
323         if (retval)
324                 return retval;
325
326         if (!evdev->exist) {
327                 retval = -ENODEV;
328                 goto out;
329         }
330
331         while (retval < count) {
332
333                 if (input_event_from_user(buffer + retval, &event)) {
334                         retval = -EFAULT;
335                         goto out;
336                 }
337
338                 input_inject_event(&evdev->handle,
339                                    event.type, event.code, event.value);
340                 retval += input_event_size();
341         }
342
343  out:
344         mutex_unlock(&evdev->mutex);
345         return retval;
346 }
347
348 static int evdev_fetch_next_event(struct evdev_client *client,
349                                   struct input_event *event)
350 {
351         int have_event;
352
353         spin_lock_irq(&client->buffer_lock);
354
355         have_event = client->head != client->tail;
356         if (have_event) {
357                 *event = client->buffer[client->tail++];
358                 client->tail &= client->bufsize - 1;
359         }
360
361         spin_unlock_irq(&client->buffer_lock);
362
363         return have_event;
364 }
365
366 static ssize_t evdev_read(struct file *file, char __user *buffer,
367                           size_t count, loff_t *ppos)
368 {
369         struct evdev_client *client = file->private_data;
370         struct evdev *evdev = client->evdev;
371         struct input_event event;
372         int retval;
373
374         if (count < input_event_size())
375                 return -EINVAL;
376
377         if (client->head == client->tail && evdev->exist &&
378             (file->f_flags & O_NONBLOCK))
379                 return -EAGAIN;
380
381         retval = wait_event_interruptible(evdev->wait,
382                 client->head != client->tail || !evdev->exist);
383         if (retval)
384                 return retval;
385
386         if (!evdev->exist)
387                 return -ENODEV;
388
389         while (retval + input_event_size() <= count &&
390                evdev_fetch_next_event(client, &event)) {
391
392                 if (input_event_to_user(buffer + retval, &event))
393                         return -EFAULT;
394
395                 retval += input_event_size();
396         }
397
398         return retval;
399 }
400
401 /* No kernel lock - fine */
402 static unsigned int evdev_poll(struct file *file, poll_table *wait)
403 {
404         struct evdev_client *client = file->private_data;
405         struct evdev *evdev = client->evdev;
406         unsigned int mask;
407
408         poll_wait(file, &evdev->wait, wait);
409
410         mask = evdev->exist ? POLLOUT | POLLWRNORM : POLLHUP | POLLERR;
411         if (client->head != client->tail)
412                 mask |= POLLIN | POLLRDNORM;
413
414         return mask;
415 }
416
417 #ifdef CONFIG_COMPAT
418
419 #define BITS_PER_LONG_COMPAT (sizeof(compat_long_t) * 8)
420 #define BITS_TO_LONGS_COMPAT(x) ((((x) - 1) / BITS_PER_LONG_COMPAT) + 1)
421
422 #ifdef __BIG_ENDIAN
423 static int bits_to_user(unsigned long *bits, unsigned int maxbit,
424                         unsigned int maxlen, void __user *p, int compat)
425 {
426         int len, i;
427
428         if (compat) {
429                 len = BITS_TO_LONGS_COMPAT(maxbit) * sizeof(compat_long_t);
430                 if (len > maxlen)
431                         len = maxlen;
432
433                 for (i = 0; i < len / sizeof(compat_long_t); i++)
434                         if (copy_to_user((compat_long_t __user *) p + i,
435                                          (compat_long_t *) bits +
436                                                 i + 1 - ((i % 2) << 1),
437                                          sizeof(compat_long_t)))
438                                 return -EFAULT;
439         } else {
440                 len = BITS_TO_LONGS(maxbit) * sizeof(long);
441                 if (len > maxlen)
442                         len = maxlen;
443
444                 if (copy_to_user(p, bits, len))
445                         return -EFAULT;
446         }
447
448         return len;
449 }
450 #else
451 static int bits_to_user(unsigned long *bits, unsigned int maxbit,
452                         unsigned int maxlen, void __user *p, int compat)
453 {
454         int len = compat ?
455                         BITS_TO_LONGS_COMPAT(maxbit) * sizeof(compat_long_t) :
456                         BITS_TO_LONGS(maxbit) * sizeof(long);
457
458         if (len > maxlen)
459                 len = maxlen;
460
461         return copy_to_user(p, bits, len) ? -EFAULT : len;
462 }
463 #endif /* __BIG_ENDIAN */
464
465 #else
466
467 static int bits_to_user(unsigned long *bits, unsigned int maxbit,
468                         unsigned int maxlen, void __user *p, int compat)
469 {
470         int len = BITS_TO_LONGS(maxbit) * sizeof(long);
471
472         if (len > maxlen)
473                 len = maxlen;
474
475         return copy_to_user(p, bits, len) ? -EFAULT : len;
476 }
477
478 #endif /* CONFIG_COMPAT */
479
480 static int str_to_user(const char *str, unsigned int maxlen, void __user *p)
481 {
482         int len;
483
484         if (!str)
485                 return -ENOENT;
486
487         len = strlen(str) + 1;
488         if (len > maxlen)
489                 len = maxlen;
490
491         return copy_to_user(p, str, len) ? -EFAULT : len;
492 }
493
494 #define OLD_KEY_MAX     0x1ff
495 static int handle_eviocgbit(struct input_dev *dev,
496                             unsigned int type, unsigned int size,
497                             void __user *p, int compat_mode)
498 {
499         static unsigned long keymax_warn_time;
500         unsigned long *bits;
501         int len;
502
503         switch (type) {
504
505         case      0: bits = dev->evbit;  len = EV_MAX;  break;
506         case EV_KEY: bits = dev->keybit; len = KEY_MAX; break;
507         case EV_REL: bits = dev->relbit; len = REL_MAX; break;
508         case EV_ABS: bits = dev->absbit; len = ABS_MAX; break;
509         case EV_MSC: bits = dev->mscbit; len = MSC_MAX; break;
510         case EV_LED: bits = dev->ledbit; len = LED_MAX; break;
511         case EV_SND: bits = dev->sndbit; len = SND_MAX; break;
512         case EV_FF:  bits = dev->ffbit;  len = FF_MAX;  break;
513         case EV_SW:  bits = dev->swbit;  len = SW_MAX;  break;
514         default: return -EINVAL;
515         }
516
517         /*
518          * Work around bugs in userspace programs that like to do
519          * EVIOCGBIT(EV_KEY, KEY_MAX) and not realize that 'len'
520          * should be in bytes, not in bits.
521          */
522         if (type == EV_KEY && size == OLD_KEY_MAX) {
523                 len = OLD_KEY_MAX;
524                 if (printk_timed_ratelimit(&keymax_warn_time, 10 * 1000))
525                         printk(KERN_WARNING
526                                 "evdev.c(EVIOCGBIT): Suspicious buffer size %u, "
527                                 "limiting output to %zu bytes. See "
528                                 "http://userweb.kernel.org/~dtor/eviocgbit-bug.html\n",
529                                 OLD_KEY_MAX,
530                                 BITS_TO_LONGS(OLD_KEY_MAX) * sizeof(long));
531         }
532
533         return bits_to_user(bits, len, size, p, compat_mode);
534 }
535 #undef OLD_KEY_MAX
536
537 static int evdev_handle_get_keycode(struct input_dev *dev,
538                                     void __user *p, size_t size)
539 {
540         struct input_keymap_entry ke;
541         int error;
542
543         memset(&ke, 0, sizeof(ke));
544
545         if (size == sizeof(unsigned int[2])) {
546                 /* legacy case */
547                 int __user *ip = (int __user *)p;
548
549                 if (copy_from_user(ke.scancode, p, sizeof(unsigned int)))
550                         return -EFAULT;
551
552                 ke.len = sizeof(unsigned int);
553                 ke.flags = 0;
554
555                 error = input_get_keycode(dev, &ke);
556                 if (error)
557                         return error;
558
559                 if (put_user(ke.keycode, ip + 1))
560                         return -EFAULT;
561
562         } else {
563                 size = min(size, sizeof(ke));
564
565                 if (copy_from_user(&ke, p, size))
566                         return -EFAULT;
567
568                 error = input_get_keycode(dev, &ke);
569                 if (error)
570                         return error;
571
572                 if (copy_to_user(p, &ke, size))
573                         return -EFAULT;
574         }
575         return 0;
576 }
577
578 static int evdev_handle_set_keycode(struct input_dev *dev,
579                                     void __user *p, size_t size)
580 {
581         struct input_keymap_entry ke;
582
583         memset(&ke, 0, sizeof(ke));
584
585         if (size == sizeof(unsigned int[2])) {
586                 /* legacy case */
587                 int __user *ip = (int __user *)p;
588
589                 if (copy_from_user(ke.scancode, p, sizeof(unsigned int)))
590                         return -EFAULT;
591
592                 if (get_user(ke.keycode, ip + 1))
593                         return -EFAULT;
594
595                 ke.len = sizeof(unsigned int);
596                 ke.flags = 0;
597
598         } else {
599                 size = min(size, sizeof(ke));
600
601                 if (copy_from_user(&ke, p, size))
602                         return -EFAULT;
603
604                 if (ke.len > sizeof(ke.scancode))
605                         return -EINVAL;
606         }
607
608         return input_set_keycode(dev, &ke);
609 }
610
611 static long evdev_do_ioctl(struct file *file, unsigned int cmd,
612                            void __user *p, int compat_mode)
613 {
614         struct evdev_client *client = file->private_data;
615         struct evdev *evdev = client->evdev;
616         struct input_dev *dev = evdev->handle.dev;
617         struct input_absinfo abs;
618         struct ff_effect effect;
619         int __user *ip = (int __user *)p;
620         unsigned int i, t, u, v;
621         unsigned int size;
622         int error;
623
624         /* First we check for fixed-length commands */
625         switch (cmd) {
626
627         case EVIOCGVERSION:
628                 return put_user(EV_VERSION, ip);
629
630         case EVIOCGID:
631                 if (copy_to_user(p, &dev->id, sizeof(struct input_id)))
632                         return -EFAULT;
633                 return 0;
634
635         case EVIOCGREP:
636                 if (!test_bit(EV_REP, dev->evbit))
637                         return -ENOSYS;
638                 if (put_user(dev->rep[REP_DELAY], ip))
639                         return -EFAULT;
640                 if (put_user(dev->rep[REP_PERIOD], ip + 1))
641                         return -EFAULT;
642                 return 0;
643
644         case EVIOCSREP:
645                 if (!test_bit(EV_REP, dev->evbit))
646                         return -ENOSYS;
647                 if (get_user(u, ip))
648                         return -EFAULT;
649                 if (get_user(v, ip + 1))
650                         return -EFAULT;
651
652                 input_inject_event(&evdev->handle, EV_REP, REP_DELAY, u);
653                 input_inject_event(&evdev->handle, EV_REP, REP_PERIOD, v);
654
655                 return 0;
656
657         case EVIOCRMFF:
658                 return input_ff_erase(dev, (int)(unsigned long) p, file);
659
660         case EVIOCGEFFECTS:
661                 i = test_bit(EV_FF, dev->evbit) ?
662                                 dev->ff->max_effects : 0;
663                 if (put_user(i, ip))
664                         return -EFAULT;
665                 return 0;
666
667         case EVIOCGRAB:
668                 if (p)
669                         return evdev_grab(evdev, client);
670                 else
671                         return evdev_ungrab(evdev, client);
672         }
673
674         size = _IOC_SIZE(cmd);
675
676         /* Now check variable-length commands */
677 #define EVIOC_MASK_SIZE(nr)     ((nr) & ~(_IOC_SIZEMASK << _IOC_SIZESHIFT))
678         switch (EVIOC_MASK_SIZE(cmd)) {
679
680         case EVIOCGKEY(0):
681                 return bits_to_user(dev->key, KEY_MAX, size, p, compat_mode);
682
683         case EVIOCGLED(0):
684                 return bits_to_user(dev->led, LED_MAX, size, p, compat_mode);
685
686         case EVIOCGSND(0):
687                 return bits_to_user(dev->snd, SND_MAX, size, p, compat_mode);
688
689         case EVIOCGSW(0):
690                 return bits_to_user(dev->sw, SW_MAX, size, p, compat_mode);
691
692         case EVIOCGNAME(0):
693                 return str_to_user(dev->name, size, p);
694
695         case EVIOCGPHYS(0):
696                 return str_to_user(dev->phys, size, p);
697
698         case EVIOCGUNIQ(0):
699                 return str_to_user(dev->uniq, size, p);
700
701         case EVIOC_MASK_SIZE(EVIOCSFF):
702                 if (input_ff_effect_from_user(p, size, &effect))
703                         return -EFAULT;
704
705                 error = input_ff_upload(dev, &effect, file);
706
707                 if (put_user(effect.id, &(((struct ff_effect __user *)p)->id)))
708                         return -EFAULT;
709
710                 return error;
711
712         case EVIOC_MASK_SIZE(EVIOCGKEYCODE):
713                 return evdev_handle_get_keycode(dev, p, size);
714
715         case EVIOC_MASK_SIZE(EVIOCSKEYCODE):
716                 return evdev_handle_set_keycode(dev, p, size);
717         }
718
719         /* Multi-number variable-length handlers */
720         if (_IOC_TYPE(cmd) != 'E')
721                 return -EINVAL;
722
723         if (_IOC_DIR(cmd) == _IOC_READ) {
724
725                 if ((_IOC_NR(cmd) & ~EV_MAX) == _IOC_NR(EVIOCGBIT(0, 0)))
726                         return handle_eviocgbit(dev,
727                                                 _IOC_NR(cmd) & EV_MAX, size,
728                                                 p, compat_mode);
729
730                 if ((_IOC_NR(cmd) & ~ABS_MAX) == _IOC_NR(EVIOCGABS(0))) {
731
732                         if (!dev->absinfo)
733                                 return -EINVAL;
734
735                         t = _IOC_NR(cmd) & ABS_MAX;
736                         abs = dev->absinfo[t];
737
738                         if (copy_to_user(p, &abs, min_t(size_t,
739                                         size, sizeof(struct input_absinfo))))
740                                 return -EFAULT;
741
742                         return 0;
743                 }
744         }
745
746         if (_IOC_DIR(cmd) == _IOC_WRITE) {
747
748                 if ((_IOC_NR(cmd) & ~ABS_MAX) == _IOC_NR(EVIOCSABS(0))) {
749
750                         if (!dev->absinfo)
751                                 return -EINVAL;
752
753                         t = _IOC_NR(cmd) & ABS_MAX;
754
755                         if (copy_from_user(&abs, p, min_t(size_t,
756                                         size, sizeof(struct input_absinfo))))
757                                 return -EFAULT;
758
759                         if (size < sizeof(struct input_absinfo))
760                                 abs.resolution = 0;
761
762                         /* We can't change number of reserved MT slots */
763                         if (t == ABS_MT_SLOT)
764                                 return -EINVAL;
765
766                         /*
767                          * Take event lock to ensure that we are not
768                          * changing device parameters in the middle
769                          * of event.
770                          */
771                         spin_lock_irq(&dev->event_lock);
772                         dev->absinfo[t] = abs;
773                         spin_unlock_irq(&dev->event_lock);
774
775                         return 0;
776                 }
777         }
778
779         return -EINVAL;
780 }
781
782 static long evdev_ioctl_handler(struct file *file, unsigned int cmd,
783                                 void __user *p, int compat_mode)
784 {
785         struct evdev_client *client = file->private_data;
786         struct evdev *evdev = client->evdev;
787         int retval;
788
789         retval = mutex_lock_interruptible(&evdev->mutex);
790         if (retval)
791                 return retval;
792
793         if (!evdev->exist) {
794                 retval = -ENODEV;
795                 goto out;
796         }
797
798         retval = evdev_do_ioctl(file, cmd, p, compat_mode);
799
800  out:
801         mutex_unlock(&evdev->mutex);
802         return retval;
803 }
804
805 static long evdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
806 {
807         return evdev_ioctl_handler(file, cmd, (void __user *)arg, 0);
808 }
809
810 #ifdef CONFIG_COMPAT
811 static long evdev_ioctl_compat(struct file *file,
812                                 unsigned int cmd, unsigned long arg)
813 {
814         return evdev_ioctl_handler(file, cmd, compat_ptr(arg), 1);
815 }
816 #endif
817
818 static const struct file_operations evdev_fops = {
819         .owner          = THIS_MODULE,
820         .read           = evdev_read,
821         .write          = evdev_write,
822         .poll           = evdev_poll,
823         .open           = evdev_open,
824         .release        = evdev_release,
825         .unlocked_ioctl = evdev_ioctl,
826 #ifdef CONFIG_COMPAT
827         .compat_ioctl   = evdev_ioctl_compat,
828 #endif
829         .fasync         = evdev_fasync,
830         .flush          = evdev_flush,
831         .llseek         = no_llseek,
832 };
833
834 static int evdev_install_chrdev(struct evdev *evdev)
835 {
836         /*
837          * No need to do any locking here as calls to connect and
838          * disconnect are serialized by the input core
839          */
840         evdev_table[evdev->minor] = evdev;
841         return 0;
842 }
843
844 static void evdev_remove_chrdev(struct evdev *evdev)
845 {
846         /*
847          * Lock evdev table to prevent race with evdev_open()
848          */
849         mutex_lock(&evdev_table_mutex);
850         evdev_table[evdev->minor] = NULL;
851         mutex_unlock(&evdev_table_mutex);
852 }
853
854 /*
855  * Mark device non-existent. This disables writes, ioctls and
856  * prevents new users from opening the device. Already posted
857  * blocking reads will stay, however new ones will fail.
858  */
859 static void evdev_mark_dead(struct evdev *evdev)
860 {
861         mutex_lock(&evdev->mutex);
862         evdev->exist = false;
863         mutex_unlock(&evdev->mutex);
864 }
865
866 static void evdev_cleanup(struct evdev *evdev)
867 {
868         struct input_handle *handle = &evdev->handle;
869
870         evdev_mark_dead(evdev);
871         evdev_hangup(evdev);
872         evdev_remove_chrdev(evdev);
873
874         /* evdev is marked dead so no one else accesses evdev->open */
875         if (evdev->open) {
876                 input_flush_device(handle, NULL);
877                 input_close_device(handle);
878         }
879 }
880
881 /*
882  * Create new evdev device. Note that input core serializes calls
883  * to connect and disconnect so we don't need to lock evdev_table here.
884  */
885 static int evdev_connect(struct input_handler *handler, struct input_dev *dev,
886                          const struct input_device_id *id)
887 {
888         struct evdev *evdev;
889         int minor;
890         int error;
891
892         for (minor = 0; minor < EVDEV_MINORS; minor++)
893                 if (!evdev_table[minor])
894                         break;
895
896         if (minor == EVDEV_MINORS) {
897                 printk(KERN_ERR "evdev: no more free evdev devices\n");
898                 return -ENFILE;
899         }
900
901         evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL);
902         if (!evdev)
903                 return -ENOMEM;
904
905         INIT_LIST_HEAD(&evdev->client_list);
906         spin_lock_init(&evdev->client_lock);
907         mutex_init(&evdev->mutex);
908         init_waitqueue_head(&evdev->wait);
909
910         dev_set_name(&evdev->dev, "event%d", minor);
911         evdev->exist = true;
912         evdev->minor = minor;
913
914         evdev->handle.dev = input_get_device(dev);
915         evdev->handle.name = dev_name(&evdev->dev);
916         evdev->handle.handler = handler;
917         evdev->handle.private = evdev;
918
919         evdev->dev.devt = MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor);
920         evdev->dev.class = &input_class;
921         evdev->dev.parent = &dev->dev;
922         evdev->dev.release = evdev_free;
923         device_initialize(&evdev->dev);
924
925         error = input_register_handle(&evdev->handle);
926         if (error)
927                 goto err_free_evdev;
928
929         error = evdev_install_chrdev(evdev);
930         if (error)
931                 goto err_unregister_handle;
932
933         error = device_add(&evdev->dev);
934         if (error)
935                 goto err_cleanup_evdev;
936
937         return 0;
938
939  err_cleanup_evdev:
940         evdev_cleanup(evdev);
941  err_unregister_handle:
942         input_unregister_handle(&evdev->handle);
943  err_free_evdev:
944         put_device(&evdev->dev);
945         return error;
946 }
947
948 static void evdev_disconnect(struct input_handle *handle)
949 {
950         struct evdev *evdev = handle->private;
951
952         device_del(&evdev->dev);
953         evdev_cleanup(evdev);
954         input_unregister_handle(handle);
955         put_device(&evdev->dev);
956 }
957
958 static const struct input_device_id evdev_ids[] = {
959         { .driver_info = 1 },   /* Matches all devices */
960         { },                    /* Terminating zero entry */
961 };
962
963 MODULE_DEVICE_TABLE(input, evdev_ids);
964
965 static struct input_handler evdev_handler = {
966         .event          = evdev_event,
967         .connect        = evdev_connect,
968         .disconnect     = evdev_disconnect,
969         .fops           = &evdev_fops,
970         .minor          = EVDEV_MINOR_BASE,
971         .name           = "evdev",
972         .id_table       = evdev_ids,
973 };
974
975 static int __init evdev_init(void)
976 {
977         return input_register_handler(&evdev_handler);
978 }
979
980 static void __exit evdev_exit(void)
981 {
982         input_unregister_handler(&evdev_handler);
983 }
984
985 module_init(evdev_init);
986 module_exit(evdev_exit);
987
988 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
989 MODULE_DESCRIPTION("Input driver event char devices");
990 MODULE_LICENSE("GPL");