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