LCOV - code coverage report
Current view: top level - drivers/input - input.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 355 892 39.8 %
Date: 2017-01-25 Functions: 43 77 55.8 %

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

Generated by: LCOV version 1.10