BKL: remove extraneous #include <smp_lock.h>
[linux-3.10.git] / drivers / input / input.c
1 /*
2  * The input core
3  *
4  * Copyright (c) 1999-2002 Vojtech Pavlik
5  */
6
7 /*
8  * This program is free software; you can redistribute it and/or modify it
9  * under the terms of the GNU General Public License version 2 as published by
10  * the Free Software Foundation.
11  */
12
13 #include <linux/init.h>
14 #include <linux/types.h>
15 #include <linux/input.h>
16 #include <linux/module.h>
17 #include <linux/slab.h>
18 #include <linux/random.h>
19 #include <linux/major.h>
20 #include <linux/proc_fs.h>
21 #include <linux/sched.h>
22 #include <linux/seq_file.h>
23 #include <linux/poll.h>
24 #include <linux/device.h>
25 #include <linux/mutex.h>
26 #include <linux/rcupdate.h>
27 #include "input-compat.h"
28
29 MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>");
30 MODULE_DESCRIPTION("Input core");
31 MODULE_LICENSE("GPL");
32
33 #define INPUT_DEVICES   256
34
35 static LIST_HEAD(input_dev_list);
36 static LIST_HEAD(input_handler_list);
37
38 /*
39  * input_mutex protects access to both input_dev_list and input_handler_list.
40  * This also causes input_[un]register_device and input_[un]register_handler
41  * be mutually exclusive which simplifies locking in drivers implementing
42  * input handlers.
43  */
44 static DEFINE_MUTEX(input_mutex);
45
46 static struct input_handler *input_table[8];
47
48 static inline int is_event_supported(unsigned int code,
49                                      unsigned long *bm, unsigned int max)
50 {
51         return code <= max && test_bit(code, bm);
52 }
53
54 static int input_defuzz_abs_event(int value, int old_val, int fuzz)
55 {
56         if (fuzz) {
57                 if (value > old_val - fuzz / 2 && value < old_val + fuzz / 2)
58                         return old_val;
59
60                 if (value > old_val - fuzz && value < old_val + fuzz)
61                         return (old_val * 3 + value) / 4;
62
63                 if (value > old_val - fuzz * 2 && value < old_val + fuzz * 2)
64                         return (old_val + value) / 2;
65         }
66
67         return value;
68 }
69
70 /*
71  * Pass event first through all filters and then, if event has not been
72  * filtered out, through all open handles. This function is called with
73  * dev->event_lock held and interrupts disabled.
74  */
75 static void input_pass_event(struct input_dev *dev,
76                              struct input_handler *src_handler,
77                              unsigned int type, unsigned int code, int value)
78 {
79         struct input_handler *handler;
80         struct input_handle *handle;
81
82         rcu_read_lock();
83
84         handle = rcu_dereference(dev->grab);
85         if (handle)
86                 handle->handler->event(handle, type, code, value);
87         else {
88                 bool filtered = false;
89
90                 list_for_each_entry_rcu(handle, &dev->h_list, d_node) {
91                         if (!handle->open)
92                                 continue;
93
94                         handler = handle->handler;
95
96                         /*
97                          * If this is the handler that injected this
98                          * particular event we want to skip it to avoid
99                          * filters firing again and again.
100                          */
101                         if (handler == src_handler)
102                                 continue;
103
104                         if (!handler->filter) {
105                                 if (filtered)
106                                         break;
107
108                                 handler->event(handle, type, code, value);
109
110                         } else if (handler->filter(handle, type, code, value))
111                                 filtered = true;
112                 }
113         }
114
115         rcu_read_unlock();
116 }
117
118 /*
119  * Generate software autorepeat event. Note that we take
120  * dev->event_lock here to avoid racing with input_event
121  * which may cause keys get "stuck".
122  */
123 static void input_repeat_key(unsigned long data)
124 {
125         struct input_dev *dev = (void *) data;
126         unsigned long flags;
127
128         spin_lock_irqsave(&dev->event_lock, flags);
129
130         if (test_bit(dev->repeat_key, dev->key) &&
131             is_event_supported(dev->repeat_key, dev->keybit, KEY_MAX)) {
132
133                 input_pass_event(dev, NULL, EV_KEY, dev->repeat_key, 2);
134
135                 if (dev->sync) {
136                         /*
137                          * Only send SYN_REPORT if we are not in a middle
138                          * of driver parsing a new hardware packet.
139                          * Otherwise assume that the driver will send
140                          * SYN_REPORT once it's done.
141                          */
142                         input_pass_event(dev, NULL, EV_SYN, SYN_REPORT, 1);
143                 }
144
145                 if (dev->rep[REP_PERIOD])
146                         mod_timer(&dev->timer, jiffies +
147                                         msecs_to_jiffies(dev->rep[REP_PERIOD]));
148         }
149
150         spin_unlock_irqrestore(&dev->event_lock, flags);
151 }
152
153 static void input_start_autorepeat(struct input_dev *dev, int code)
154 {
155         if (test_bit(EV_REP, dev->evbit) &&
156             dev->rep[REP_PERIOD] && dev->rep[REP_DELAY] &&
157             dev->timer.data) {
158                 dev->repeat_key = code;
159                 mod_timer(&dev->timer,
160                           jiffies + msecs_to_jiffies(dev->rep[REP_DELAY]));
161         }
162 }
163
164 static void input_stop_autorepeat(struct input_dev *dev)
165 {
166         del_timer(&dev->timer);
167 }
168
169 #define INPUT_IGNORE_EVENT      0
170 #define INPUT_PASS_TO_HANDLERS  1
171 #define INPUT_PASS_TO_DEVICE    2
172 #define INPUT_PASS_TO_ALL       (INPUT_PASS_TO_HANDLERS | INPUT_PASS_TO_DEVICE)
173
174 static int input_handle_abs_event(struct input_dev *dev,
175                                   struct input_handler *src_handler,
176                                   unsigned int code, int *pval)
177 {
178         bool is_mt_event;
179         int *pold;
180
181         if (code == ABS_MT_SLOT) {
182                 /*
183                  * "Stage" the event; we'll flush it later, when we
184                  * get actual touch data.
185                  */
186                 if (*pval >= 0 && *pval < dev->mtsize)
187                         dev->slot = *pval;
188
189                 return INPUT_IGNORE_EVENT;
190         }
191
192         is_mt_event = code >= ABS_MT_FIRST && code <= ABS_MT_LAST;
193
194         if (!is_mt_event) {
195                 pold = &dev->absinfo[code].value;
196         } else if (dev->mt) {
197                 struct input_mt_slot *mtslot = &dev->mt[dev->slot];
198                 pold = &mtslot->abs[code - ABS_MT_FIRST];
199         } else {
200                 /*
201                  * Bypass filtering for multi-touch events when
202                  * not employing slots.
203                  */
204                 pold = NULL;
205         }
206
207         if (pold) {
208                 *pval = input_defuzz_abs_event(*pval, *pold,
209                                                 dev->absinfo[code].fuzz);
210                 if (*pold == *pval)
211                         return INPUT_IGNORE_EVENT;
212
213                 *pold = *pval;
214         }
215
216         /* Flush pending "slot" event */
217         if (is_mt_event && dev->slot != input_abs_get_val(dev, ABS_MT_SLOT)) {
218                 input_abs_set_val(dev, ABS_MT_SLOT, dev->slot);
219                 input_pass_event(dev, src_handler,
220                                  EV_ABS, ABS_MT_SLOT, dev->slot);
221         }
222
223         return INPUT_PASS_TO_HANDLERS;
224 }
225
226 static void input_handle_event(struct input_dev *dev,
227                                struct input_handler *src_handler,
228                                unsigned int type, unsigned int code, int value)
229 {
230         int disposition = INPUT_IGNORE_EVENT;
231
232         switch (type) {
233
234         case EV_SYN:
235                 switch (code) {
236                 case SYN_CONFIG:
237                         disposition = INPUT_PASS_TO_ALL;
238                         break;
239
240                 case SYN_REPORT:
241                         if (!dev->sync) {
242                                 dev->sync = true;
243                                 disposition = INPUT_PASS_TO_HANDLERS;
244                         }
245                         break;
246                 case SYN_MT_REPORT:
247                         dev->sync = false;
248                         disposition = INPUT_PASS_TO_HANDLERS;
249                         break;
250                 }
251                 break;
252
253         case EV_KEY:
254                 if (is_event_supported(code, dev->keybit, KEY_MAX) &&
255                     !!test_bit(code, dev->key) != value) {
256
257                         if (value != 2) {
258                                 __change_bit(code, dev->key);
259                                 if (value)
260                                         input_start_autorepeat(dev, code);
261                                 else
262                                         input_stop_autorepeat(dev);
263                         }
264
265                         disposition = INPUT_PASS_TO_HANDLERS;
266                 }
267                 break;
268
269         case EV_SW:
270                 if (is_event_supported(code, dev->swbit, SW_MAX) &&
271                     !!test_bit(code, dev->sw) != value) {
272
273                         __change_bit(code, dev->sw);
274                         disposition = INPUT_PASS_TO_HANDLERS;
275                 }
276                 break;
277
278         case EV_ABS:
279                 if (is_event_supported(code, dev->absbit, ABS_MAX))
280                         disposition = input_handle_abs_event(dev, src_handler,
281                                                              code, &value);
282
283                 break;
284
285         case EV_REL:
286                 if (is_event_supported(code, dev->relbit, REL_MAX) && value)
287                         disposition = INPUT_PASS_TO_HANDLERS;
288
289                 break;
290
291         case EV_MSC:
292                 if (is_event_supported(code, dev->mscbit, MSC_MAX))
293                         disposition = INPUT_PASS_TO_ALL;
294
295                 break;
296
297         case EV_LED:
298                 if (is_event_supported(code, dev->ledbit, LED_MAX) &&
299                     !!test_bit(code, dev->led) != value) {
300
301                         __change_bit(code, dev->led);
302                         disposition = INPUT_PASS_TO_ALL;
303                 }
304                 break;
305
306         case EV_SND:
307                 if (is_event_supported(code, dev->sndbit, SND_MAX)) {
308
309                         if (!!test_bit(code, dev->snd) != !!value)
310                                 __change_bit(code, dev->snd);
311                         disposition = INPUT_PASS_TO_ALL;
312                 }
313                 break;
314
315         case EV_REP:
316                 if (code <= REP_MAX && value >= 0 && dev->rep[code] != value) {
317                         dev->rep[code] = value;
318                         disposition = INPUT_PASS_TO_ALL;
319                 }
320                 break;
321
322         case EV_FF:
323                 if (value >= 0)
324                         disposition = INPUT_PASS_TO_ALL;
325                 break;
326
327         case EV_PWR:
328                 disposition = INPUT_PASS_TO_ALL;
329                 break;
330         }
331
332         if (disposition != INPUT_IGNORE_EVENT && type != EV_SYN)
333                 dev->sync = false;
334
335         if ((disposition & INPUT_PASS_TO_DEVICE) && dev->event)
336                 dev->event(dev, type, code, value);
337
338         if (disposition & INPUT_PASS_TO_HANDLERS)
339                 input_pass_event(dev, src_handler, type, code, value);
340 }
341
342 /**
343  * input_event() - report new input event
344  * @dev: device that generated the event
345  * @type: type of the event
346  * @code: event code
347  * @value: value of the event
348  *
349  * This function should be used by drivers implementing various input
350  * devices to report input events. See also input_inject_event().
351  *
352  * NOTE: input_event() may be safely used right after input device was
353  * allocated with input_allocate_device(), even before it is registered
354  * with input_register_device(), but the event will not reach any of the
355  * input handlers. Such early invocation of input_event() may be used
356  * to 'seed' initial state of a switch or initial position of absolute
357  * axis, etc.
358  */
359 void input_event(struct input_dev *dev,
360                  unsigned int type, unsigned int code, int value)
361 {
362         unsigned long flags;
363
364         if (is_event_supported(type, dev->evbit, EV_MAX)) {
365
366                 spin_lock_irqsave(&dev->event_lock, flags);
367                 add_input_randomness(type, code, value);
368                 input_handle_event(dev, NULL, type, code, value);
369                 spin_unlock_irqrestore(&dev->event_lock, flags);
370         }
371 }
372 EXPORT_SYMBOL(input_event);
373
374 /**
375  * input_inject_event() - send input event from input handler
376  * @handle: input handle to send event through
377  * @type: type of the event
378  * @code: event code
379  * @value: value of the event
380  *
381  * Similar to input_event() but will ignore event if device is
382  * "grabbed" and handle injecting event is not the one that owns
383  * the device.
384  */
385 void input_inject_event(struct input_handle *handle,
386                         unsigned int type, unsigned int code, int value)
387 {
388         struct input_dev *dev = handle->dev;
389         struct input_handle *grab;
390         unsigned long flags;
391
392         if (is_event_supported(type, dev->evbit, EV_MAX)) {
393                 spin_lock_irqsave(&dev->event_lock, flags);
394
395                 rcu_read_lock();
396                 grab = rcu_dereference(dev->grab);
397                 if (!grab || grab == handle)
398                         input_handle_event(dev, handle->handler,
399                                            type, code, value);
400                 rcu_read_unlock();
401
402                 spin_unlock_irqrestore(&dev->event_lock, flags);
403         }
404 }
405 EXPORT_SYMBOL(input_inject_event);
406
407 /**
408  * input_alloc_absinfo - allocates array of input_absinfo structs
409  * @dev: the input device emitting absolute events
410  *
411  * If the absinfo struct the caller asked for is already allocated, this
412  * functions will not do anything.
413  */
414 void input_alloc_absinfo(struct input_dev *dev)
415 {
416         if (!dev->absinfo)
417                 dev->absinfo = kcalloc(ABS_CNT, sizeof(struct input_absinfo),
418                                         GFP_KERNEL);
419
420         WARN(!dev->absinfo, "%s(): kcalloc() failed?\n", __func__);
421 }
422 EXPORT_SYMBOL(input_alloc_absinfo);
423
424 void input_set_abs_params(struct input_dev *dev, unsigned int axis,
425                           int min, int max, int fuzz, int flat)
426 {
427         struct input_absinfo *absinfo;
428
429         input_alloc_absinfo(dev);
430         if (!dev->absinfo)
431                 return;
432
433         absinfo = &dev->absinfo[axis];
434         absinfo->minimum = min;
435         absinfo->maximum = max;
436         absinfo->fuzz = fuzz;
437         absinfo->flat = flat;
438
439         dev->absbit[BIT_WORD(axis)] |= BIT_MASK(axis);
440 }
441 EXPORT_SYMBOL(input_set_abs_params);
442
443
444 /**
445  * input_grab_device - grabs device for exclusive use
446  * @handle: input handle that wants to own the device
447  *
448  * When a device is grabbed by an input handle all events generated by
449  * the device are delivered only to this handle. Also events injected
450  * by other input handles are ignored while device is grabbed.
451  */
452 int input_grab_device(struct input_handle *handle)
453 {
454         struct input_dev *dev = handle->dev;
455         int retval;
456
457         retval = mutex_lock_interruptible(&dev->mutex);
458         if (retval)
459                 return retval;
460
461         if (dev->grab) {
462                 retval = -EBUSY;
463                 goto out;
464         }
465
466         rcu_assign_pointer(dev->grab, handle);
467         synchronize_rcu();
468
469  out:
470         mutex_unlock(&dev->mutex);
471         return retval;
472 }
473 EXPORT_SYMBOL(input_grab_device);
474
475 static void __input_release_device(struct input_handle *handle)
476 {
477         struct input_dev *dev = handle->dev;
478
479         if (dev->grab == handle) {
480                 rcu_assign_pointer(dev->grab, NULL);
481                 /* Make sure input_pass_event() notices that grab is gone */
482                 synchronize_rcu();
483
484                 list_for_each_entry(handle, &dev->h_list, d_node)
485                         if (handle->open && handle->handler->start)
486                                 handle->handler->start(handle);
487         }
488 }
489
490 /**
491  * input_release_device - release previously grabbed device
492  * @handle: input handle that owns the device
493  *
494  * Releases previously grabbed device so that other input handles can
495  * start receiving input events. Upon release all handlers attached
496  * to the device have their start() method called so they have a change
497  * to synchronize device state with the rest of the system.
498  */
499 void input_release_device(struct input_handle *handle)
500 {
501         struct input_dev *dev = handle->dev;
502
503         mutex_lock(&dev->mutex);
504         __input_release_device(handle);
505         mutex_unlock(&dev->mutex);
506 }
507 EXPORT_SYMBOL(input_release_device);
508
509 /**
510  * input_open_device - open input device
511  * @handle: handle through which device is being accessed
512  *
513  * This function should be called by input handlers when they
514  * want to start receive events from given input device.
515  */
516 int input_open_device(struct input_handle *handle)
517 {
518         struct input_dev *dev = handle->dev;
519         int retval;
520
521         retval = mutex_lock_interruptible(&dev->mutex);
522         if (retval)
523                 return retval;
524
525         if (dev->going_away) {
526                 retval = -ENODEV;
527                 goto out;
528         }
529
530         handle->open++;
531
532         if (!dev->users++ && dev->open)
533                 retval = dev->open(dev);
534
535         if (retval) {
536                 dev->users--;
537                 if (!--handle->open) {
538                         /*
539                          * Make sure we are not delivering any more events
540                          * through this handle
541                          */
542                         synchronize_rcu();
543                 }
544         }
545
546  out:
547         mutex_unlock(&dev->mutex);
548         return retval;
549 }
550 EXPORT_SYMBOL(input_open_device);
551
552 int input_flush_device(struct input_handle *handle, struct file *file)
553 {
554         struct input_dev *dev = handle->dev;
555         int retval;
556
557         retval = mutex_lock_interruptible(&dev->mutex);
558         if (retval)
559                 return retval;
560
561         if (dev->flush)
562                 retval = dev->flush(dev, file);
563
564         mutex_unlock(&dev->mutex);
565         return retval;
566 }
567 EXPORT_SYMBOL(input_flush_device);
568
569 /**
570  * input_close_device - close input device
571  * @handle: handle through which device is being accessed
572  *
573  * This function should be called by input handlers when they
574  * want to stop receive events from given input device.
575  */
576 void input_close_device(struct input_handle *handle)
577 {
578         struct input_dev *dev = handle->dev;
579
580         mutex_lock(&dev->mutex);
581
582         __input_release_device(handle);
583
584         if (!--dev->users && dev->close)
585                 dev->close(dev);
586
587         if (!--handle->open) {
588                 /*
589                  * synchronize_rcu() makes sure that input_pass_event()
590                  * completed and that no more input events are delivered
591                  * through this handle
592                  */
593                 synchronize_rcu();
594         }
595
596         mutex_unlock(&dev->mutex);
597 }
598 EXPORT_SYMBOL(input_close_device);
599
600 /*
601  * Simulate keyup events for all keys that are marked as pressed.
602  * The function must be called with dev->event_lock held.
603  */
604 static void input_dev_release_keys(struct input_dev *dev)
605 {
606         int code;
607
608         if (is_event_supported(EV_KEY, dev->evbit, EV_MAX)) {
609                 for (code = 0; code <= KEY_MAX; code++) {
610                         if (is_event_supported(code, dev->keybit, KEY_MAX) &&
611                             __test_and_clear_bit(code, dev->key)) {
612                                 input_pass_event(dev, NULL, EV_KEY, code, 0);
613                         }
614                 }
615                 input_pass_event(dev, NULL, EV_SYN, SYN_REPORT, 1);
616         }
617 }
618
619 /*
620  * Prepare device for unregistering
621  */
622 static void input_disconnect_device(struct input_dev *dev)
623 {
624         struct input_handle *handle;
625
626         /*
627          * Mark device as going away. Note that we take dev->mutex here
628          * not to protect access to dev->going_away but rather to ensure
629          * that there are no threads in the middle of input_open_device()
630          */
631         mutex_lock(&dev->mutex);
632         dev->going_away = true;
633         mutex_unlock(&dev->mutex);
634
635         spin_lock_irq(&dev->event_lock);
636
637         /*
638          * Simulate keyup events for all pressed keys so that handlers
639          * are not left with "stuck" keys. The driver may continue
640          * generate events even after we done here but they will not
641          * reach any handlers.
642          */
643         input_dev_release_keys(dev);
644
645         list_for_each_entry(handle, &dev->h_list, d_node)
646                 handle->open = 0;
647
648         spin_unlock_irq(&dev->event_lock);
649 }
650
651 /**
652  * input_scancode_to_scalar() - converts scancode in &struct input_keymap_entry
653  * @ke: keymap entry containing scancode to be converted.
654  * @scancode: pointer to the location where converted scancode should
655  *      be stored.
656  *
657  * This function is used to convert scancode stored in &struct keymap_entry
658  * into scalar form understood by legacy keymap handling methods. These
659  * methods expect scancodes to be represented as 'unsigned int'.
660  */
661 int input_scancode_to_scalar(const struct input_keymap_entry *ke,
662                              unsigned int *scancode)
663 {
664         switch (ke->len) {
665         case 1:
666                 *scancode = *((u8 *)ke->scancode);
667                 break;
668
669         case 2:
670                 *scancode = *((u16 *)ke->scancode);
671                 break;
672
673         case 4:
674                 *scancode = *((u32 *)ke->scancode);
675                 break;
676
677         default:
678                 return -EINVAL;
679         }
680
681         return 0;
682 }
683 EXPORT_SYMBOL(input_scancode_to_scalar);
684
685 /*
686  * Those routines handle the default case where no [gs]etkeycode() is
687  * defined. In this case, an array indexed by the scancode is used.
688  */
689
690 static unsigned int input_fetch_keycode(struct input_dev *dev,
691                                         unsigned int index)
692 {
693         switch (dev->keycodesize) {
694         case 1:
695                 return ((u8 *)dev->keycode)[index];
696
697         case 2:
698                 return ((u16 *)dev->keycode)[index];
699
700         default:
701                 return ((u32 *)dev->keycode)[index];
702         }
703 }
704
705 static int input_default_getkeycode(struct input_dev *dev,
706                                     struct input_keymap_entry *ke)
707 {
708         unsigned int index;
709         int error;
710
711         if (!dev->keycodesize)
712                 return -EINVAL;
713
714         if (ke->flags & INPUT_KEYMAP_BY_INDEX)
715                 index = ke->index;
716         else {
717                 error = input_scancode_to_scalar(ke, &index);
718                 if (error)
719                         return error;
720         }
721
722         if (index >= dev->keycodemax)
723                 return -EINVAL;
724
725         ke->keycode = input_fetch_keycode(dev, index);
726         ke->index = index;
727         ke->len = sizeof(index);
728         memcpy(ke->scancode, &index, sizeof(index));
729
730         return 0;
731 }
732
733 static int input_default_setkeycode(struct input_dev *dev,
734                                     const struct input_keymap_entry *ke,
735                                     unsigned int *old_keycode)
736 {
737         unsigned int index;
738         int error;
739         int i;
740
741         if (!dev->keycodesize)
742                 return -EINVAL;
743
744         if (ke->flags & INPUT_KEYMAP_BY_INDEX) {
745                 index = ke->index;
746         } else {
747                 error = input_scancode_to_scalar(ke, &index);
748                 if (error)
749                         return error;
750         }
751
752         if (index >= dev->keycodemax)
753                 return -EINVAL;
754
755         if (dev->keycodesize < sizeof(dev->keycode) &&
756                         (ke->keycode >> (dev->keycodesize * 8)))
757                 return -EINVAL;
758
759         switch (dev->keycodesize) {
760                 case 1: {
761                         u8 *k = (u8 *)dev->keycode;
762                         *old_keycode = k[index];
763                         k[index] = ke->keycode;
764                         break;
765                 }
766                 case 2: {
767                         u16 *k = (u16 *)dev->keycode;
768                         *old_keycode = k[index];
769                         k[index] = ke->keycode;
770                         break;
771                 }
772                 default: {
773                         u32 *k = (u32 *)dev->keycode;
774                         *old_keycode = k[index];
775                         k[index] = ke->keycode;
776                         break;
777                 }
778         }
779
780         __clear_bit(*old_keycode, dev->keybit);
781         __set_bit(ke->keycode, dev->keybit);
782
783         for (i = 0; i < dev->keycodemax; i++) {
784                 if (input_fetch_keycode(dev, i) == *old_keycode) {
785                         __set_bit(*old_keycode, dev->keybit);
786                         break; /* Setting the bit twice is useless, so break */
787                 }
788         }
789
790         return 0;
791 }
792
793 /**
794  * input_get_keycode - retrieve keycode currently mapped to a given scancode
795  * @dev: input device which keymap is being queried
796  * @ke: keymap entry
797  *
798  * This function should be called by anyone interested in retrieving current
799  * keymap. Presently evdev handlers use it.
800  */
801 int input_get_keycode(struct input_dev *dev, struct input_keymap_entry *ke)
802 {
803         unsigned long flags;
804         int retval;
805
806         spin_lock_irqsave(&dev->event_lock, flags);
807
808         if (dev->getkeycode) {
809                 /*
810                  * Support for legacy drivers, that don't implement the new
811                  * ioctls
812                  */
813                 u32 scancode = ke->index;
814
815                 memcpy(ke->scancode, &scancode, sizeof(scancode));
816                 ke->len = sizeof(scancode);
817                 retval = dev->getkeycode(dev, scancode, &ke->keycode);
818         } else {
819                 retval = dev->getkeycode_new(dev, ke);
820         }
821
822         spin_unlock_irqrestore(&dev->event_lock, flags);
823         return retval;
824 }
825 EXPORT_SYMBOL(input_get_keycode);
826
827 /**
828  * input_set_keycode - attribute a keycode to a given scancode
829  * @dev: input device which keymap is being updated
830  * @ke: new keymap entry
831  *
832  * This function should be called by anyone needing to update current
833  * keymap. Presently keyboard and evdev handlers use it.
834  */
835 int input_set_keycode(struct input_dev *dev,
836                       const struct input_keymap_entry *ke)
837 {
838         unsigned long flags;
839         unsigned int old_keycode;
840         int retval;
841
842         if (ke->keycode > KEY_MAX)
843                 return -EINVAL;
844
845         spin_lock_irqsave(&dev->event_lock, flags);
846
847         if (dev->setkeycode) {
848                 /*
849                  * Support for legacy drivers, that don't implement the new
850                  * ioctls
851                  */
852                 unsigned int scancode;
853
854                 retval = input_scancode_to_scalar(ke, &scancode);
855                 if (retval)
856                         goto out;
857
858                 /*
859                  * We need to know the old scancode, in order to generate a
860                  * keyup effect, if the set operation happens successfully
861                  */
862                 if (!dev->getkeycode) {
863                         retval = -EINVAL;
864                         goto out;
865                 }
866
867                 retval = dev->getkeycode(dev, scancode, &old_keycode);
868                 if (retval)
869                         goto out;
870
871                 retval = dev->setkeycode(dev, scancode, ke->keycode);
872         } else {
873                 retval = dev->setkeycode_new(dev, ke, &old_keycode);
874         }
875
876         if (retval)
877                 goto out;
878
879         /* Make sure KEY_RESERVED did not get enabled. */
880         __clear_bit(KEY_RESERVED, dev->keybit);
881
882         /*
883          * Simulate keyup event if keycode is not present
884          * in the keymap anymore
885          */
886         if (test_bit(EV_KEY, dev->evbit) &&
887             !is_event_supported(old_keycode, dev->keybit, KEY_MAX) &&
888             __test_and_clear_bit(old_keycode, dev->key)) {
889
890                 input_pass_event(dev, NULL, EV_KEY, old_keycode, 0);
891                 if (dev->sync)
892                         input_pass_event(dev, NULL, EV_SYN, SYN_REPORT, 1);
893         }
894
895  out:
896         spin_unlock_irqrestore(&dev->event_lock, flags);
897
898         return retval;
899 }
900 EXPORT_SYMBOL(input_set_keycode);
901
902 #define MATCH_BIT(bit, max) \
903                 for (i = 0; i < BITS_TO_LONGS(max); i++) \
904                         if ((id->bit[i] & dev->bit[i]) != id->bit[i]) \
905                                 break; \
906                 if (i != BITS_TO_LONGS(max)) \
907                         continue;
908
909 static const struct input_device_id *input_match_device(struct input_handler *handler,
910                                                         struct input_dev *dev)
911 {
912         const struct input_device_id *id;
913         int i;
914
915         for (id = handler->id_table; id->flags || id->driver_info; id++) {
916
917                 if (id->flags & INPUT_DEVICE_ID_MATCH_BUS)
918                         if (id->bustype != dev->id.bustype)
919                                 continue;
920
921                 if (id->flags & INPUT_DEVICE_ID_MATCH_VENDOR)
922                         if (id->vendor != dev->id.vendor)
923                                 continue;
924
925                 if (id->flags & INPUT_DEVICE_ID_MATCH_PRODUCT)
926                         if (id->product != dev->id.product)
927                                 continue;
928
929                 if (id->flags & INPUT_DEVICE_ID_MATCH_VERSION)
930                         if (id->version != dev->id.version)
931                                 continue;
932
933                 MATCH_BIT(evbit,  EV_MAX);
934                 MATCH_BIT(keybit, KEY_MAX);
935                 MATCH_BIT(relbit, REL_MAX);
936                 MATCH_BIT(absbit, ABS_MAX);
937                 MATCH_BIT(mscbit, MSC_MAX);
938                 MATCH_BIT(ledbit, LED_MAX);
939                 MATCH_BIT(sndbit, SND_MAX);
940                 MATCH_BIT(ffbit,  FF_MAX);
941                 MATCH_BIT(swbit,  SW_MAX);
942
943                 if (!handler->match || handler->match(handler, dev))
944                         return id;
945         }
946
947         return NULL;
948 }
949
950 static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)
951 {
952         const struct input_device_id *id;
953         int error;
954
955         id = input_match_device(handler, dev);
956         if (!id)
957                 return -ENODEV;
958
959         error = handler->connect(handler, dev, id);
960         if (error && error != -ENODEV)
961                 printk(KERN_ERR
962                         "input: failed to attach handler %s to device %s, "
963                         "error: %d\n",
964                         handler->name, kobject_name(&dev->dev.kobj), error);
965
966         return error;
967 }
968
969 #ifdef CONFIG_COMPAT
970
971 static int input_bits_to_string(char *buf, int buf_size,
972                                 unsigned long bits, bool skip_empty)
973 {
974         int len = 0;
975
976         if (INPUT_COMPAT_TEST) {
977                 u32 dword = bits >> 32;
978                 if (dword || !skip_empty)
979                         len += snprintf(buf, buf_size, "%x ", dword);
980
981                 dword = bits & 0xffffffffUL;
982                 if (dword || !skip_empty || len)
983                         len += snprintf(buf + len, max(buf_size - len, 0),
984                                         "%x", dword);
985         } else {
986                 if (bits || !skip_empty)
987                         len += snprintf(buf, buf_size, "%lx", bits);
988         }
989
990         return len;
991 }
992
993 #else /* !CONFIG_COMPAT */
994
995 static int input_bits_to_string(char *buf, int buf_size,
996                                 unsigned long bits, bool skip_empty)
997 {
998         return bits || !skip_empty ?
999                 snprintf(buf, buf_size, "%lx", bits) : 0;
1000 }
1001
1002 #endif
1003
1004 #ifdef CONFIG_PROC_FS
1005
1006 static struct proc_dir_entry *proc_bus_input_dir;
1007 static DECLARE_WAIT_QUEUE_HEAD(input_devices_poll_wait);
1008 static int input_devices_state;
1009
1010 static inline void input_wakeup_procfs_readers(void)
1011 {
1012         input_devices_state++;
1013         wake_up(&input_devices_poll_wait);
1014 }
1015
1016 static unsigned int input_proc_devices_poll(struct file *file, poll_table *wait)
1017 {
1018         poll_wait(file, &input_devices_poll_wait, wait);
1019         if (file->f_version != input_devices_state) {
1020                 file->f_version = input_devices_state;
1021                 return POLLIN | POLLRDNORM;
1022         }
1023
1024         return 0;
1025 }
1026
1027 union input_seq_state {
1028         struct {
1029                 unsigned short pos;
1030                 bool mutex_acquired;
1031         };
1032         void *p;
1033 };
1034
1035 static void *input_devices_seq_start(struct seq_file *seq, loff_t *pos)
1036 {
1037         union input_seq_state *state = (union input_seq_state *)&seq->private;
1038         int error;
1039
1040         /* We need to fit into seq->private pointer */
1041         BUILD_BUG_ON(sizeof(union input_seq_state) != sizeof(seq->private));
1042
1043         error = mutex_lock_interruptible(&input_mutex);
1044         if (error) {
1045                 state->mutex_acquired = false;
1046                 return ERR_PTR(error);
1047         }
1048
1049         state->mutex_acquired = true;
1050
1051         return seq_list_start(&input_dev_list, *pos);
1052 }
1053
1054 static void *input_devices_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1055 {
1056         return seq_list_next(v, &input_dev_list, pos);
1057 }
1058
1059 static void input_seq_stop(struct seq_file *seq, void *v)
1060 {
1061         union input_seq_state *state = (union input_seq_state *)&seq->private;
1062
1063         if (state->mutex_acquired)
1064                 mutex_unlock(&input_mutex);
1065 }
1066
1067 static void input_seq_print_bitmap(struct seq_file *seq, const char *name,
1068                                    unsigned long *bitmap, int max)
1069 {
1070         int i;
1071         bool skip_empty = true;
1072         char buf[18];
1073
1074         seq_printf(seq, "B: %s=", name);
1075
1076         for (i = BITS_TO_LONGS(max) - 1; i >= 0; i--) {
1077                 if (input_bits_to_string(buf, sizeof(buf),
1078                                          bitmap[i], skip_empty)) {
1079                         skip_empty = false;
1080                         seq_printf(seq, "%s%s", buf, i > 0 ? " " : "");
1081                 }
1082         }
1083
1084         /*
1085          * If no output was produced print a single 0.
1086          */
1087         if (skip_empty)
1088                 seq_puts(seq, "0");
1089
1090         seq_putc(seq, '\n');
1091 }
1092
1093 static int input_devices_seq_show(struct seq_file *seq, void *v)
1094 {
1095         struct input_dev *dev = container_of(v, struct input_dev, node);
1096         const char *path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
1097         struct input_handle *handle;
1098
1099         seq_printf(seq, "I: Bus=%04x Vendor=%04x Product=%04x Version=%04x\n",
1100                    dev->id.bustype, dev->id.vendor, dev->id.product, dev->id.version);
1101
1102         seq_printf(seq, "N: Name=\"%s\"\n", dev->name ? dev->name : "");
1103         seq_printf(seq, "P: Phys=%s\n", dev->phys ? dev->phys : "");
1104         seq_printf(seq, "S: Sysfs=%s\n", path ? path : "");
1105         seq_printf(seq, "U: Uniq=%s\n", dev->uniq ? dev->uniq : "");
1106         seq_printf(seq, "H: Handlers=");
1107
1108         list_for_each_entry(handle, &dev->h_list, d_node)
1109                 seq_printf(seq, "%s ", handle->name);
1110         seq_putc(seq, '\n');
1111
1112         input_seq_print_bitmap(seq, "EV", dev->evbit, EV_MAX);
1113         if (test_bit(EV_KEY, dev->evbit))
1114                 input_seq_print_bitmap(seq, "KEY", dev->keybit, KEY_MAX);
1115         if (test_bit(EV_REL, dev->evbit))
1116                 input_seq_print_bitmap(seq, "REL", dev->relbit, REL_MAX);
1117         if (test_bit(EV_ABS, dev->evbit))
1118                 input_seq_print_bitmap(seq, "ABS", dev->absbit, ABS_MAX);
1119         if (test_bit(EV_MSC, dev->evbit))
1120                 input_seq_print_bitmap(seq, "MSC", dev->mscbit, MSC_MAX);
1121         if (test_bit(EV_LED, dev->evbit))
1122                 input_seq_print_bitmap(seq, "LED", dev->ledbit, LED_MAX);
1123         if (test_bit(EV_SND, dev->evbit))
1124                 input_seq_print_bitmap(seq, "SND", dev->sndbit, SND_MAX);
1125         if (test_bit(EV_FF, dev->evbit))
1126                 input_seq_print_bitmap(seq, "FF", dev->ffbit, FF_MAX);
1127         if (test_bit(EV_SW, dev->evbit))
1128                 input_seq_print_bitmap(seq, "SW", dev->swbit, SW_MAX);
1129
1130         seq_putc(seq, '\n');
1131
1132         kfree(path);
1133         return 0;
1134 }
1135
1136 static const struct seq_operations input_devices_seq_ops = {
1137         .start  = input_devices_seq_start,
1138         .next   = input_devices_seq_next,
1139         .stop   = input_seq_stop,
1140         .show   = input_devices_seq_show,
1141 };
1142
1143 static int input_proc_devices_open(struct inode *inode, struct file *file)
1144 {
1145         return seq_open(file, &input_devices_seq_ops);
1146 }
1147
1148 static const struct file_operations input_devices_fileops = {
1149         .owner          = THIS_MODULE,
1150         .open           = input_proc_devices_open,
1151         .poll           = input_proc_devices_poll,
1152         .read           = seq_read,
1153         .llseek         = seq_lseek,
1154         .release        = seq_release,
1155 };
1156
1157 static void *input_handlers_seq_start(struct seq_file *seq, loff_t *pos)
1158 {
1159         union input_seq_state *state = (union input_seq_state *)&seq->private;
1160         int error;
1161
1162         /* We need to fit into seq->private pointer */
1163         BUILD_BUG_ON(sizeof(union input_seq_state) != sizeof(seq->private));
1164
1165         error = mutex_lock_interruptible(&input_mutex);
1166         if (error) {
1167                 state->mutex_acquired = false;
1168                 return ERR_PTR(error);
1169         }
1170
1171         state->mutex_acquired = true;
1172         state->pos = *pos;
1173
1174         return seq_list_start(&input_handler_list, *pos);
1175 }
1176
1177 static void *input_handlers_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1178 {
1179         union input_seq_state *state = (union input_seq_state *)&seq->private;
1180
1181         state->pos = *pos + 1;
1182         return seq_list_next(v, &input_handler_list, pos);
1183 }
1184
1185 static int input_handlers_seq_show(struct seq_file *seq, void *v)
1186 {
1187         struct input_handler *handler = container_of(v, struct input_handler, node);
1188         union input_seq_state *state = (union input_seq_state *)&seq->private;
1189
1190         seq_printf(seq, "N: Number=%u Name=%s", state->pos, handler->name);
1191         if (handler->filter)
1192                 seq_puts(seq, " (filter)");
1193         if (handler->fops)
1194                 seq_printf(seq, " Minor=%d", handler->minor);
1195         seq_putc(seq, '\n');
1196
1197         return 0;
1198 }
1199
1200 static const struct seq_operations input_handlers_seq_ops = {
1201         .start  = input_handlers_seq_start,
1202         .next   = input_handlers_seq_next,
1203         .stop   = input_seq_stop,
1204         .show   = input_handlers_seq_show,
1205 };
1206
1207 static int input_proc_handlers_open(struct inode *inode, struct file *file)
1208 {
1209         return seq_open(file, &input_handlers_seq_ops);
1210 }
1211
1212 static const struct file_operations input_handlers_fileops = {
1213         .owner          = THIS_MODULE,
1214         .open           = input_proc_handlers_open,
1215         .read           = seq_read,
1216         .llseek         = seq_lseek,
1217         .release        = seq_release,
1218 };
1219
1220 static int __init input_proc_init(void)
1221 {
1222         struct proc_dir_entry *entry;
1223
1224         proc_bus_input_dir = proc_mkdir("bus/input", NULL);
1225         if (!proc_bus_input_dir)
1226                 return -ENOMEM;
1227
1228         entry = proc_create("devices", 0, proc_bus_input_dir,
1229                             &input_devices_fileops);
1230         if (!entry)
1231                 goto fail1;
1232
1233         entry = proc_create("handlers", 0, proc_bus_input_dir,
1234                             &input_handlers_fileops);
1235         if (!entry)
1236                 goto fail2;
1237
1238         return 0;
1239
1240  fail2: remove_proc_entry("devices", proc_bus_input_dir);
1241  fail1: remove_proc_entry("bus/input", NULL);
1242         return -ENOMEM;
1243 }
1244
1245 static void input_proc_exit(void)
1246 {
1247         remove_proc_entry("devices", proc_bus_input_dir);
1248         remove_proc_entry("handlers", proc_bus_input_dir);
1249         remove_proc_entry("bus/input", NULL);
1250 }
1251
1252 #else /* !CONFIG_PROC_FS */
1253 static inline void input_wakeup_procfs_readers(void) { }
1254 static inline int input_proc_init(void) { return 0; }
1255 static inline void input_proc_exit(void) { }
1256 #endif
1257
1258 #define INPUT_DEV_STRING_ATTR_SHOW(name)                                \
1259 static ssize_t input_dev_show_##name(struct device *dev,                \
1260                                      struct device_attribute *attr,     \
1261                                      char *buf)                         \
1262 {                                                                       \
1263         struct input_dev *input_dev = to_input_dev(dev);                \
1264                                                                         \
1265         return scnprintf(buf, PAGE_SIZE, "%s\n",                        \
1266                          input_dev->name ? input_dev->name : "");       \
1267 }                                                                       \
1268 static DEVICE_ATTR(name, S_IRUGO, input_dev_show_##name, NULL)
1269
1270 INPUT_DEV_STRING_ATTR_SHOW(name);
1271 INPUT_DEV_STRING_ATTR_SHOW(phys);
1272 INPUT_DEV_STRING_ATTR_SHOW(uniq);
1273
1274 static int input_print_modalias_bits(char *buf, int size,
1275                                      char name, unsigned long *bm,
1276                                      unsigned int min_bit, unsigned int max_bit)
1277 {
1278         int len = 0, i;
1279
1280         len += snprintf(buf, max(size, 0), "%c", name);
1281         for (i = min_bit; i < max_bit; i++)
1282                 if (bm[BIT_WORD(i)] & BIT_MASK(i))
1283                         len += snprintf(buf + len, max(size - len, 0), "%X,", i);
1284         return len;
1285 }
1286
1287 static int input_print_modalias(char *buf, int size, struct input_dev *id,
1288                                 int add_cr)
1289 {
1290         int len;
1291
1292         len = snprintf(buf, max(size, 0),
1293                        "input:b%04Xv%04Xp%04Xe%04X-",
1294                        id->id.bustype, id->id.vendor,
1295                        id->id.product, id->id.version);
1296
1297         len += input_print_modalias_bits(buf + len, size - len,
1298                                 'e', id->evbit, 0, EV_MAX);
1299         len += input_print_modalias_bits(buf + len, size - len,
1300                                 'k', id->keybit, KEY_MIN_INTERESTING, KEY_MAX);
1301         len += input_print_modalias_bits(buf + len, size - len,
1302                                 'r', id->relbit, 0, REL_MAX);
1303         len += input_print_modalias_bits(buf + len, size - len,
1304                                 'a', id->absbit, 0, ABS_MAX);
1305         len += input_print_modalias_bits(buf + len, size - len,
1306                                 'm', id->mscbit, 0, MSC_MAX);
1307         len += input_print_modalias_bits(buf + len, size - len,
1308                                 'l', id->ledbit, 0, LED_MAX);
1309         len += input_print_modalias_bits(buf + len, size - len,
1310                                 's', id->sndbit, 0, SND_MAX);
1311         len += input_print_modalias_bits(buf + len, size - len,
1312                                 'f', id->ffbit, 0, FF_MAX);
1313         len += input_print_modalias_bits(buf + len, size - len,
1314                                 'w', id->swbit, 0, SW_MAX);
1315
1316         if (add_cr)
1317                 len += snprintf(buf + len, max(size - len, 0), "\n");
1318
1319         return len;
1320 }
1321
1322 static ssize_t input_dev_show_modalias(struct device *dev,
1323                                        struct device_attribute *attr,
1324                                        char *buf)
1325 {
1326         struct input_dev *id = to_input_dev(dev);
1327         ssize_t len;
1328
1329         len = input_print_modalias(buf, PAGE_SIZE, id, 1);
1330
1331         return min_t(int, len, PAGE_SIZE);
1332 }
1333 static DEVICE_ATTR(modalias, S_IRUGO, input_dev_show_modalias, NULL);
1334
1335 static struct attribute *input_dev_attrs[] = {
1336         &dev_attr_name.attr,
1337         &dev_attr_phys.attr,
1338         &dev_attr_uniq.attr,
1339         &dev_attr_modalias.attr,
1340         NULL
1341 };
1342
1343 static struct attribute_group input_dev_attr_group = {
1344         .attrs  = input_dev_attrs,
1345 };
1346
1347 #define INPUT_DEV_ID_ATTR(name)                                         \
1348 static ssize_t input_dev_show_id_##name(struct device *dev,             \
1349                                         struct device_attribute *attr,  \
1350                                         char *buf)                      \
1351 {                                                                       \
1352         struct input_dev *input_dev = to_input_dev(dev);                \
1353         return scnprintf(buf, PAGE_SIZE, "%04x\n", input_dev->id.name); \
1354 }                                                                       \
1355 static DEVICE_ATTR(name, S_IRUGO, input_dev_show_id_##name, NULL)
1356
1357 INPUT_DEV_ID_ATTR(bustype);
1358 INPUT_DEV_ID_ATTR(vendor);
1359 INPUT_DEV_ID_ATTR(product);
1360 INPUT_DEV_ID_ATTR(version);
1361
1362 static struct attribute *input_dev_id_attrs[] = {
1363         &dev_attr_bustype.attr,
1364         &dev_attr_vendor.attr,
1365         &dev_attr_product.attr,
1366         &dev_attr_version.attr,
1367         NULL
1368 };
1369
1370 static struct attribute_group input_dev_id_attr_group = {
1371         .name   = "id",
1372         .attrs  = input_dev_id_attrs,
1373 };
1374
1375 static int input_print_bitmap(char *buf, int buf_size, unsigned long *bitmap,
1376                               int max, int add_cr)
1377 {
1378         int i;
1379         int len = 0;
1380         bool skip_empty = true;
1381
1382         for (i = BITS_TO_LONGS(max) - 1; i >= 0; i--) {
1383                 len += input_bits_to_string(buf + len, max(buf_size - len, 0),
1384                                             bitmap[i], skip_empty);
1385                 if (len) {
1386                         skip_empty = false;
1387                         if (i > 0)
1388                                 len += snprintf(buf + len, max(buf_size - len, 0), " ");
1389                 }
1390         }
1391
1392         /*
1393          * If no output was produced print a single 0.
1394          */
1395         if (len == 0)
1396                 len = snprintf(buf, buf_size, "%d", 0);
1397
1398         if (add_cr)
1399                 len += snprintf(buf + len, max(buf_size - len, 0), "\n");
1400
1401         return len;
1402 }
1403
1404 #define INPUT_DEV_CAP_ATTR(ev, bm)                                      \
1405 static ssize_t input_dev_show_cap_##bm(struct device *dev,              \
1406                                        struct device_attribute *attr,   \
1407                                        char *buf)                       \
1408 {                                                                       \
1409         struct input_dev *input_dev = to_input_dev(dev);                \
1410         int len = input_print_bitmap(buf, PAGE_SIZE,                    \
1411                                      input_dev->bm##bit, ev##_MAX,      \
1412                                      true);                             \
1413         return min_t(int, len, PAGE_SIZE);                              \
1414 }                                                                       \
1415 static DEVICE_ATTR(bm, S_IRUGO, input_dev_show_cap_##bm, NULL)
1416
1417 INPUT_DEV_CAP_ATTR(EV, ev);
1418 INPUT_DEV_CAP_ATTR(KEY, key);
1419 INPUT_DEV_CAP_ATTR(REL, rel);
1420 INPUT_DEV_CAP_ATTR(ABS, abs);
1421 INPUT_DEV_CAP_ATTR(MSC, msc);
1422 INPUT_DEV_CAP_ATTR(LED, led);
1423 INPUT_DEV_CAP_ATTR(SND, snd);
1424 INPUT_DEV_CAP_ATTR(FF, ff);
1425 INPUT_DEV_CAP_ATTR(SW, sw);
1426
1427 static struct attribute *input_dev_caps_attrs[] = {
1428         &dev_attr_ev.attr,
1429         &dev_attr_key.attr,
1430         &dev_attr_rel.attr,
1431         &dev_attr_abs.attr,
1432         &dev_attr_msc.attr,
1433         &dev_attr_led.attr,
1434         &dev_attr_snd.attr,
1435         &dev_attr_ff.attr,
1436         &dev_attr_sw.attr,
1437         NULL
1438 };
1439
1440 static struct attribute_group input_dev_caps_attr_group = {
1441         .name   = "capabilities",
1442         .attrs  = input_dev_caps_attrs,
1443 };
1444
1445 static const struct attribute_group *input_dev_attr_groups[] = {
1446         &input_dev_attr_group,
1447         &input_dev_id_attr_group,
1448         &input_dev_caps_attr_group,
1449         NULL
1450 };
1451
1452 static void input_dev_release(struct device *device)
1453 {
1454         struct input_dev *dev = to_input_dev(device);
1455
1456         input_ff_destroy(dev);
1457         input_mt_destroy_slots(dev);
1458         kfree(dev->absinfo);
1459         kfree(dev);
1460
1461         module_put(THIS_MODULE);
1462 }
1463
1464 /*
1465  * Input uevent interface - loading event handlers based on
1466  * device bitfields.
1467  */
1468 static int input_add_uevent_bm_var(struct kobj_uevent_env *env,
1469                                    const char *name, unsigned long *bitmap, int max)
1470 {
1471         int len;
1472
1473         if (add_uevent_var(env, "%s=", name))
1474                 return -ENOMEM;
1475
1476         len = input_print_bitmap(&env->buf[env->buflen - 1],
1477                                  sizeof(env->buf) - env->buflen,
1478                                  bitmap, max, false);
1479         if (len >= (sizeof(env->buf) - env->buflen))
1480                 return -ENOMEM;
1481
1482         env->buflen += len;
1483         return 0;
1484 }
1485
1486 static int input_add_uevent_modalias_var(struct kobj_uevent_env *env,
1487                                          struct input_dev *dev)
1488 {
1489         int len;
1490
1491         if (add_uevent_var(env, "MODALIAS="))
1492                 return -ENOMEM;
1493
1494         len = input_print_modalias(&env->buf[env->buflen - 1],
1495                                    sizeof(env->buf) - env->buflen,
1496                                    dev, 0);
1497         if (len >= (sizeof(env->buf) - env->buflen))
1498                 return -ENOMEM;
1499
1500         env->buflen += len;
1501         return 0;
1502 }
1503
1504 #define INPUT_ADD_HOTPLUG_VAR(fmt, val...)                              \
1505         do {                                                            \
1506                 int err = add_uevent_var(env, fmt, val);                \
1507                 if (err)                                                \
1508                         return err;                                     \
1509         } while (0)
1510
1511 #define INPUT_ADD_HOTPLUG_BM_VAR(name, bm, max)                         \
1512         do {                                                            \
1513                 int err = input_add_uevent_bm_var(env, name, bm, max);  \
1514                 if (err)                                                \
1515                         return err;                                     \
1516         } while (0)
1517
1518 #define INPUT_ADD_HOTPLUG_MODALIAS_VAR(dev)                             \
1519         do {                                                            \
1520                 int err = input_add_uevent_modalias_var(env, dev);      \
1521                 if (err)                                                \
1522                         return err;                                     \
1523         } while (0)
1524
1525 static int input_dev_uevent(struct device *device, struct kobj_uevent_env *env)
1526 {
1527         struct input_dev *dev = to_input_dev(device);
1528
1529         INPUT_ADD_HOTPLUG_VAR("PRODUCT=%x/%x/%x/%x",
1530                                 dev->id.bustype, dev->id.vendor,
1531                                 dev->id.product, dev->id.version);
1532         if (dev->name)
1533                 INPUT_ADD_HOTPLUG_VAR("NAME=\"%s\"", dev->name);
1534         if (dev->phys)
1535                 INPUT_ADD_HOTPLUG_VAR("PHYS=\"%s\"", dev->phys);
1536         if (dev->uniq)
1537                 INPUT_ADD_HOTPLUG_VAR("UNIQ=\"%s\"", dev->uniq);
1538
1539         INPUT_ADD_HOTPLUG_BM_VAR("EV=", dev->evbit, EV_MAX);
1540         if (test_bit(EV_KEY, dev->evbit))
1541                 INPUT_ADD_HOTPLUG_BM_VAR("KEY=", dev->keybit, KEY_MAX);
1542         if (test_bit(EV_REL, dev->evbit))
1543                 INPUT_ADD_HOTPLUG_BM_VAR("REL=", dev->relbit, REL_MAX);
1544         if (test_bit(EV_ABS, dev->evbit))
1545                 INPUT_ADD_HOTPLUG_BM_VAR("ABS=", dev->absbit, ABS_MAX);
1546         if (test_bit(EV_MSC, dev->evbit))
1547                 INPUT_ADD_HOTPLUG_BM_VAR("MSC=", dev->mscbit, MSC_MAX);
1548         if (test_bit(EV_LED, dev->evbit))
1549                 INPUT_ADD_HOTPLUG_BM_VAR("LED=", dev->ledbit, LED_MAX);
1550         if (test_bit(EV_SND, dev->evbit))
1551                 INPUT_ADD_HOTPLUG_BM_VAR("SND=", dev->sndbit, SND_MAX);
1552         if (test_bit(EV_FF, dev->evbit))
1553                 INPUT_ADD_HOTPLUG_BM_VAR("FF=", dev->ffbit, FF_MAX);
1554         if (test_bit(EV_SW, dev->evbit))
1555                 INPUT_ADD_HOTPLUG_BM_VAR("SW=", dev->swbit, SW_MAX);
1556
1557         INPUT_ADD_HOTPLUG_MODALIAS_VAR(dev);
1558
1559         return 0;
1560 }
1561
1562 #define INPUT_DO_TOGGLE(dev, type, bits, on)                            \
1563         do {                                                            \
1564                 int i;                                                  \
1565                 bool active;                                            \
1566                                                                         \
1567                 if (!test_bit(EV_##type, dev->evbit))                   \
1568                         break;                                          \
1569                                                                         \
1570                 for (i = 0; i < type##_MAX; i++) {                      \
1571                         if (!test_bit(i, dev->bits##bit))               \
1572                                 continue;                               \
1573                                                                         \
1574                         active = test_bit(i, dev->bits);                \
1575                         if (!active && !on)                             \
1576                                 continue;                               \
1577                                                                         \
1578                         dev->event(dev, EV_##type, i, on ? active : 0); \
1579                 }                                                       \
1580         } while (0)
1581
1582 static void input_dev_toggle(struct input_dev *dev, bool activate)
1583 {
1584         if (!dev->event)
1585                 return;
1586
1587         INPUT_DO_TOGGLE(dev, LED, led, activate);
1588         INPUT_DO_TOGGLE(dev, SND, snd, activate);
1589
1590         if (activate && test_bit(EV_REP, dev->evbit)) {
1591                 dev->event(dev, EV_REP, REP_PERIOD, dev->rep[REP_PERIOD]);
1592                 dev->event(dev, EV_REP, REP_DELAY, dev->rep[REP_DELAY]);
1593         }
1594 }
1595
1596 /**
1597  * input_reset_device() - reset/restore the state of input device
1598  * @dev: input device whose state needs to be reset
1599  *
1600  * This function tries to reset the state of an opened input device and
1601  * bring internal state and state if the hardware in sync with each other.
1602  * We mark all keys as released, restore LED state, repeat rate, etc.
1603  */
1604 void input_reset_device(struct input_dev *dev)
1605 {
1606         mutex_lock(&dev->mutex);
1607
1608         if (dev->users) {
1609                 input_dev_toggle(dev, true);
1610
1611                 /*
1612                  * Keys that have been pressed at suspend time are unlikely
1613                  * to be still pressed when we resume.
1614                  */
1615                 spin_lock_irq(&dev->event_lock);
1616                 input_dev_release_keys(dev);
1617                 spin_unlock_irq(&dev->event_lock);
1618         }
1619
1620         mutex_unlock(&dev->mutex);
1621 }
1622 EXPORT_SYMBOL(input_reset_device);
1623
1624 #ifdef CONFIG_PM
1625 static int input_dev_suspend(struct device *dev)
1626 {
1627         struct input_dev *input_dev = to_input_dev(dev);
1628
1629         mutex_lock(&input_dev->mutex);
1630
1631         if (input_dev->users)
1632                 input_dev_toggle(input_dev, false);
1633
1634         mutex_unlock(&input_dev->mutex);
1635
1636         return 0;
1637 }
1638
1639 static int input_dev_resume(struct device *dev)
1640 {
1641         struct input_dev *input_dev = to_input_dev(dev);
1642
1643         input_reset_device(input_dev);
1644
1645         return 0;
1646 }
1647
1648 static const struct dev_pm_ops input_dev_pm_ops = {
1649         .suspend        = input_dev_suspend,
1650         .resume         = input_dev_resume,
1651         .poweroff       = input_dev_suspend,
1652         .restore        = input_dev_resume,
1653 };
1654 #endif /* CONFIG_PM */
1655
1656 static struct device_type input_dev_type = {
1657         .groups         = input_dev_attr_groups,
1658         .release        = input_dev_release,
1659         .uevent         = input_dev_uevent,
1660 #ifdef CONFIG_PM
1661         .pm             = &input_dev_pm_ops,
1662 #endif
1663 };
1664
1665 static char *input_devnode(struct device *dev, mode_t *mode)
1666 {
1667         return kasprintf(GFP_KERNEL, "input/%s", dev_name(dev));
1668 }
1669
1670 struct class input_class = {
1671         .name           = "input",
1672         .devnode        = input_devnode,
1673 };
1674 EXPORT_SYMBOL_GPL(input_class);
1675
1676 /**
1677  * input_allocate_device - allocate memory for new input device
1678  *
1679  * Returns prepared struct input_dev or NULL.
1680  *
1681  * NOTE: Use input_free_device() to free devices that have not been
1682  * registered; input_unregister_device() should be used for already
1683  * registered devices.
1684  */
1685 struct input_dev *input_allocate_device(void)
1686 {
1687         struct input_dev *dev;
1688
1689         dev = kzalloc(sizeof(struct input_dev), GFP_KERNEL);
1690         if (dev) {
1691                 dev->dev.type = &input_dev_type;
1692                 dev->dev.class = &input_class;
1693                 device_initialize(&dev->dev);
1694                 mutex_init(&dev->mutex);
1695                 spin_lock_init(&dev->event_lock);
1696                 INIT_LIST_HEAD(&dev->h_list);
1697                 INIT_LIST_HEAD(&dev->node);
1698
1699                 __module_get(THIS_MODULE);
1700         }
1701
1702         return dev;
1703 }
1704 EXPORT_SYMBOL(input_allocate_device);
1705
1706 /**
1707  * input_free_device - free memory occupied by input_dev structure
1708  * @dev: input device to free
1709  *
1710  * This function should only be used if input_register_device()
1711  * was not called yet or if it failed. Once device was registered
1712  * use input_unregister_device() and memory will be freed once last
1713  * reference to the device is dropped.
1714  *
1715  * Device should be allocated by input_allocate_device().
1716  *
1717  * NOTE: If there are references to the input device then memory
1718  * will not be freed until last reference is dropped.
1719  */
1720 void input_free_device(struct input_dev *dev)
1721 {
1722         if (dev)
1723                 input_put_device(dev);
1724 }
1725 EXPORT_SYMBOL(input_free_device);
1726
1727 /**
1728  * input_mt_create_slots() - create MT input slots
1729  * @dev: input device supporting MT events and finger tracking
1730  * @num_slots: number of slots used by the device
1731  *
1732  * This function allocates all necessary memory for MT slot handling in the
1733  * input device, and adds ABS_MT_SLOT to the device capabilities. All slots
1734  * are initially marked as unused by setting ABS_MT_TRACKING_ID to -1.
1735  */
1736 int input_mt_create_slots(struct input_dev *dev, unsigned int num_slots)
1737 {
1738         int i;
1739
1740         if (!num_slots)
1741                 return 0;
1742
1743         dev->mt = kcalloc(num_slots, sizeof(struct input_mt_slot), GFP_KERNEL);
1744         if (!dev->mt)
1745                 return -ENOMEM;
1746
1747         dev->mtsize = num_slots;
1748         input_set_abs_params(dev, ABS_MT_SLOT, 0, num_slots - 1, 0, 0);
1749
1750         /* Mark slots as 'unused' */
1751         for (i = 0; i < num_slots; i++)
1752                 dev->mt[i].abs[ABS_MT_TRACKING_ID - ABS_MT_FIRST] = -1;
1753
1754         return 0;
1755 }
1756 EXPORT_SYMBOL(input_mt_create_slots);
1757
1758 /**
1759  * input_mt_destroy_slots() - frees the MT slots of the input device
1760  * @dev: input device with allocated MT slots
1761  *
1762  * This function is only needed in error path as the input core will
1763  * automatically free the MT slots when the device is destroyed.
1764  */
1765 void input_mt_destroy_slots(struct input_dev *dev)
1766 {
1767         kfree(dev->mt);
1768         dev->mt = NULL;
1769         dev->mtsize = 0;
1770 }
1771 EXPORT_SYMBOL(input_mt_destroy_slots);
1772
1773 /**
1774  * input_set_capability - mark device as capable of a certain event
1775  * @dev: device that is capable of emitting or accepting event
1776  * @type: type of the event (EV_KEY, EV_REL, etc...)
1777  * @code: event code
1778  *
1779  * In addition to setting up corresponding bit in appropriate capability
1780  * bitmap the function also adjusts dev->evbit.
1781  */
1782 void input_set_capability(struct input_dev *dev, unsigned int type, unsigned int code)
1783 {
1784         switch (type) {
1785         case EV_KEY:
1786                 __set_bit(code, dev->keybit);
1787                 break;
1788
1789         case EV_REL:
1790                 __set_bit(code, dev->relbit);
1791                 break;
1792
1793         case EV_ABS:
1794                 __set_bit(code, dev->absbit);
1795                 break;
1796
1797         case EV_MSC:
1798                 __set_bit(code, dev->mscbit);
1799                 break;
1800
1801         case EV_SW:
1802                 __set_bit(code, dev->swbit);
1803                 break;
1804
1805         case EV_LED:
1806                 __set_bit(code, dev->ledbit);
1807                 break;
1808
1809         case EV_SND:
1810                 __set_bit(code, dev->sndbit);
1811                 break;
1812
1813         case EV_FF:
1814                 __set_bit(code, dev->ffbit);
1815                 break;
1816
1817         case EV_PWR:
1818                 /* do nothing */
1819                 break;
1820
1821         default:
1822                 printk(KERN_ERR
1823                         "input_set_capability: unknown type %u (code %u)\n",
1824                         type, code);
1825                 dump_stack();
1826                 return;
1827         }
1828
1829         __set_bit(type, dev->evbit);
1830 }
1831 EXPORT_SYMBOL(input_set_capability);
1832
1833 #define INPUT_CLEANSE_BITMASK(dev, type, bits)                          \
1834         do {                                                            \
1835                 if (!test_bit(EV_##type, dev->evbit))                   \
1836                         memset(dev->bits##bit, 0,                       \
1837                                 sizeof(dev->bits##bit));                \
1838         } while (0)
1839
1840 static void input_cleanse_bitmasks(struct input_dev *dev)
1841 {
1842         INPUT_CLEANSE_BITMASK(dev, KEY, key);
1843         INPUT_CLEANSE_BITMASK(dev, REL, rel);
1844         INPUT_CLEANSE_BITMASK(dev, ABS, abs);
1845         INPUT_CLEANSE_BITMASK(dev, MSC, msc);
1846         INPUT_CLEANSE_BITMASK(dev, LED, led);
1847         INPUT_CLEANSE_BITMASK(dev, SND, snd);
1848         INPUT_CLEANSE_BITMASK(dev, FF, ff);
1849         INPUT_CLEANSE_BITMASK(dev, SW, sw);
1850 }
1851
1852 /**
1853  * input_register_device - register device with input core
1854  * @dev: device to be registered
1855  *
1856  * This function registers device with input core. The device must be
1857  * allocated with input_allocate_device() and all it's capabilities
1858  * set up before registering.
1859  * If function fails the device must be freed with input_free_device().
1860  * Once device has been successfully registered it can be unregistered
1861  * with input_unregister_device(); input_free_device() should not be
1862  * called in this case.
1863  */
1864 int input_register_device(struct input_dev *dev)
1865 {
1866         static atomic_t input_no = ATOMIC_INIT(0);
1867         struct input_handler *handler;
1868         const char *path;
1869         int error;
1870
1871         /* Every input device generates EV_SYN/SYN_REPORT events. */
1872         __set_bit(EV_SYN, dev->evbit);
1873
1874         /* KEY_RESERVED is not supposed to be transmitted to userspace. */
1875         __clear_bit(KEY_RESERVED, dev->keybit);
1876
1877         /* Make sure that bitmasks not mentioned in dev->evbit are clean. */
1878         input_cleanse_bitmasks(dev);
1879
1880         /*
1881          * If delay and period are pre-set by the driver, then autorepeating
1882          * is handled by the driver itself and we don't do it in input.c.
1883          */
1884         init_timer(&dev->timer);
1885         if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD]) {
1886                 dev->timer.data = (long) dev;
1887                 dev->timer.function = input_repeat_key;
1888                 dev->rep[REP_DELAY] = 250;
1889                 dev->rep[REP_PERIOD] = 33;
1890         }
1891
1892         if (!dev->getkeycode && !dev->getkeycode_new)
1893                 dev->getkeycode_new = input_default_getkeycode;
1894
1895         if (!dev->setkeycode && !dev->setkeycode_new)
1896                 dev->setkeycode_new = input_default_setkeycode;
1897
1898         dev_set_name(&dev->dev, "input%ld",
1899                      (unsigned long) atomic_inc_return(&input_no) - 1);
1900
1901         error = device_add(&dev->dev);
1902         if (error)
1903                 return error;
1904
1905         path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
1906         printk(KERN_INFO "input: %s as %s\n",
1907                 dev->name ? dev->name : "Unspecified device", path ? path : "N/A");
1908         kfree(path);
1909
1910         error = mutex_lock_interruptible(&input_mutex);
1911         if (error) {
1912                 device_del(&dev->dev);
1913                 return error;
1914         }
1915
1916         list_add_tail(&dev->node, &input_dev_list);
1917
1918         list_for_each_entry(handler, &input_handler_list, node)
1919                 input_attach_handler(dev, handler);
1920
1921         input_wakeup_procfs_readers();
1922
1923         mutex_unlock(&input_mutex);
1924
1925         return 0;
1926 }
1927 EXPORT_SYMBOL(input_register_device);
1928
1929 /**
1930  * input_unregister_device - unregister previously registered device
1931  * @dev: device to be unregistered
1932  *
1933  * This function unregisters an input device. Once device is unregistered
1934  * the caller should not try to access it as it may get freed at any moment.
1935  */
1936 void input_unregister_device(struct input_dev *dev)
1937 {
1938         struct input_handle *handle, *next;
1939
1940         input_disconnect_device(dev);
1941
1942         mutex_lock(&input_mutex);
1943
1944         list_for_each_entry_safe(handle, next, &dev->h_list, d_node)
1945                 handle->handler->disconnect(handle);
1946         WARN_ON(!list_empty(&dev->h_list));
1947
1948         del_timer_sync(&dev->timer);
1949         list_del_init(&dev->node);
1950
1951         input_wakeup_procfs_readers();
1952
1953         mutex_unlock(&input_mutex);
1954
1955         device_unregister(&dev->dev);
1956 }
1957 EXPORT_SYMBOL(input_unregister_device);
1958
1959 /**
1960  * input_register_handler - register a new input handler
1961  * @handler: handler to be registered
1962  *
1963  * This function registers a new input handler (interface) for input
1964  * devices in the system and attaches it to all input devices that
1965  * are compatible with the handler.
1966  */
1967 int input_register_handler(struct input_handler *handler)
1968 {
1969         struct input_dev *dev;
1970         int retval;
1971
1972         retval = mutex_lock_interruptible(&input_mutex);
1973         if (retval)
1974                 return retval;
1975
1976         INIT_LIST_HEAD(&handler->h_list);
1977
1978         if (handler->fops != NULL) {
1979                 if (input_table[handler->minor >> 5]) {
1980                         retval = -EBUSY;
1981                         goto out;
1982                 }
1983                 input_table[handler->minor >> 5] = handler;
1984         }
1985
1986         list_add_tail(&handler->node, &input_handler_list);
1987
1988         list_for_each_entry(dev, &input_dev_list, node)
1989                 input_attach_handler(dev, handler);
1990
1991         input_wakeup_procfs_readers();
1992
1993  out:
1994         mutex_unlock(&input_mutex);
1995         return retval;
1996 }
1997 EXPORT_SYMBOL(input_register_handler);
1998
1999 /**
2000  * input_unregister_handler - unregisters an input handler
2001  * @handler: handler to be unregistered
2002  *
2003  * This function disconnects a handler from its input devices and
2004  * removes it from lists of known handlers.
2005  */
2006 void input_unregister_handler(struct input_handler *handler)
2007 {
2008         struct input_handle *handle, *next;
2009
2010         mutex_lock(&input_mutex);
2011
2012         list_for_each_entry_safe(handle, next, &handler->h_list, h_node)
2013                 handler->disconnect(handle);
2014         WARN_ON(!list_empty(&handler->h_list));
2015
2016         list_del_init(&handler->node);
2017
2018         if (handler->fops != NULL)
2019                 input_table[handler->minor >> 5] = NULL;
2020
2021         input_wakeup_procfs_readers();
2022
2023         mutex_unlock(&input_mutex);
2024 }
2025 EXPORT_SYMBOL(input_unregister_handler);
2026
2027 /**
2028  * input_handler_for_each_handle - handle iterator
2029  * @handler: input handler to iterate
2030  * @data: data for the callback
2031  * @fn: function to be called for each handle
2032  *
2033  * Iterate over @bus's list of devices, and call @fn for each, passing
2034  * it @data and stop when @fn returns a non-zero value. The function is
2035  * using RCU to traverse the list and therefore may be usind in atonic
2036  * contexts. The @fn callback is invoked from RCU critical section and
2037  * thus must not sleep.
2038  */
2039 int input_handler_for_each_handle(struct input_handler *handler, void *data,
2040                                   int (*fn)(struct input_handle *, void *))
2041 {
2042         struct input_handle *handle;
2043         int retval = 0;
2044
2045         rcu_read_lock();
2046
2047         list_for_each_entry_rcu(handle, &handler->h_list, h_node) {
2048                 retval = fn(handle, data);
2049                 if (retval)
2050                         break;
2051         }
2052
2053         rcu_read_unlock();
2054
2055         return retval;
2056 }
2057 EXPORT_SYMBOL(input_handler_for_each_handle);
2058
2059 /**
2060  * input_register_handle - register a new input handle
2061  * @handle: handle to register
2062  *
2063  * This function puts a new input handle onto device's
2064  * and handler's lists so that events can flow through
2065  * it once it is opened using input_open_device().
2066  *
2067  * This function is supposed to be called from handler's
2068  * connect() method.
2069  */
2070 int input_register_handle(struct input_handle *handle)
2071 {
2072         struct input_handler *handler = handle->handler;
2073         struct input_dev *dev = handle->dev;
2074         int error;
2075
2076         /*
2077          * We take dev->mutex here to prevent race with
2078          * input_release_device().
2079          */
2080         error = mutex_lock_interruptible(&dev->mutex);
2081         if (error)
2082                 return error;
2083
2084         /*
2085          * Filters go to the head of the list, normal handlers
2086          * to the tail.
2087          */
2088         if (handler->filter)
2089                 list_add_rcu(&handle->d_node, &dev->h_list);
2090         else
2091                 list_add_tail_rcu(&handle->d_node, &dev->h_list);
2092
2093         mutex_unlock(&dev->mutex);
2094
2095         /*
2096          * Since we are supposed to be called from ->connect()
2097          * which is mutually exclusive with ->disconnect()
2098          * we can't be racing with input_unregister_handle()
2099          * and so separate lock is not needed here.
2100          */
2101         list_add_tail_rcu(&handle->h_node, &handler->h_list);
2102
2103         if (handler->start)
2104                 handler->start(handle);
2105
2106         return 0;
2107 }
2108 EXPORT_SYMBOL(input_register_handle);
2109
2110 /**
2111  * input_unregister_handle - unregister an input handle
2112  * @handle: handle to unregister
2113  *
2114  * This function removes input handle from device's
2115  * and handler's lists.
2116  *
2117  * This function is supposed to be called from handler's
2118  * disconnect() method.
2119  */
2120 void input_unregister_handle(struct input_handle *handle)
2121 {
2122         struct input_dev *dev = handle->dev;
2123
2124         list_del_rcu(&handle->h_node);
2125
2126         /*
2127          * Take dev->mutex to prevent race with input_release_device().
2128          */
2129         mutex_lock(&dev->mutex);
2130         list_del_rcu(&handle->d_node);
2131         mutex_unlock(&dev->mutex);
2132
2133         synchronize_rcu();
2134 }
2135 EXPORT_SYMBOL(input_unregister_handle);
2136
2137 static int input_open_file(struct inode *inode, struct file *file)
2138 {
2139         struct input_handler *handler;
2140         const struct file_operations *old_fops, *new_fops = NULL;
2141         int err;
2142
2143         err = mutex_lock_interruptible(&input_mutex);
2144         if (err)
2145                 return err;
2146
2147         /* No load-on-demand here? */
2148         handler = input_table[iminor(inode) >> 5];
2149         if (handler)
2150                 new_fops = fops_get(handler->fops);
2151
2152         mutex_unlock(&input_mutex);
2153
2154         /*
2155          * That's _really_ odd. Usually NULL ->open means "nothing special",
2156          * not "no device". Oh, well...
2157          */
2158         if (!new_fops || !new_fops->open) {
2159                 fops_put(new_fops);
2160                 err = -ENODEV;
2161                 goto out;
2162         }
2163
2164         old_fops = file->f_op;
2165         file->f_op = new_fops;
2166
2167         err = new_fops->open(inode, file);
2168         if (err) {
2169                 fops_put(file->f_op);
2170                 file->f_op = fops_get(old_fops);
2171         }
2172         fops_put(old_fops);
2173 out:
2174         return err;
2175 }
2176
2177 static const struct file_operations input_fops = {
2178         .owner = THIS_MODULE,
2179         .open = input_open_file,
2180         .llseek = noop_llseek,
2181 };
2182
2183 static int __init input_init(void)
2184 {
2185         int err;
2186
2187         err = class_register(&input_class);
2188         if (err) {
2189                 printk(KERN_ERR "input: unable to register input_dev class\n");
2190                 return err;
2191         }
2192
2193         err = input_proc_init();
2194         if (err)
2195                 goto fail1;
2196
2197         err = register_chrdev(INPUT_MAJOR, "input", &input_fops);
2198         if (err) {
2199                 printk(KERN_ERR "input: unable to register char major %d", INPUT_MAJOR);
2200                 goto fail2;
2201         }
2202
2203         return 0;
2204
2205  fail2: input_proc_exit();
2206  fail1: class_unregister(&input_class);
2207         return err;
2208 }
2209
2210 static void __exit input_exit(void)
2211 {
2212         input_proc_exit();
2213         unregister_chrdev(INPUT_MAJOR, "input");
2214         class_unregister(&input_class);
2215 }
2216
2217 subsys_initcall(input_init);
2218 module_exit(input_exit);