Input Core和evdev基本知识 - Kernel3.0.8

1. 基本数据结构和使用示例

input_event数据结构如下:

[cpp] view plain copy
  1. struct input_event {  
  2.     struct timeval time;  
  3.     __u16 type;  
  4.     __u16 code;  
  5.     __s32 value;  
  6. };  

input_dev数据结构如下:

[cpp] view plain copy
  1. struct input_dev {  
  2.     const char *name;  
  3.     const char *phys;  
  4.     const char *uniq;  
  5.     struct input_id id;  
  6.   
  7.     unsigned long propbit[BITS_TO_LONGS(INPUT_PROP_CNT)];  
  8.   
  9.     unsigned long evbit[BITS_TO_LONGS(EV_CNT)];  
  10.     unsigned long keybit[BITS_TO_LONGS(KEY_CNT)];  
  11.     unsigned long relbit[BITS_TO_LONGS(REL_CNT)];  
  12.     unsigned long absbit[BITS_TO_LONGS(ABS_CNT)];  
  13.     unsigned long mscbit[BITS_TO_LONGS(MSC_CNT)];  
  14.     unsigned long ledbit[BITS_TO_LONGS(LED_CNT)];  
  15.     unsigned long sndbit[BITS_TO_LONGS(SND_CNT)];  
  16.     unsigned long ffbit[BITS_TO_LONGS(FF_CNT)];  
  17.     unsigned long swbit[BITS_TO_LONGS(SW_CNT)];  
  18.   
  19.     unsigned int hint_events_per_packet;  
  20.   
  21.     unsigned int keycodemax;  
  22.     unsigned int keycodesize;  
  23.     void *keycode;  
  24.   
  25.     int (*setkeycode)(struct input_dev *dev,  
  26.               const struct input_keymap_entry *ke,  
  27.               unsigned int *old_keycode);  
  28.     int (*getkeycode)(struct input_dev *dev,  
  29.               struct input_keymap_entry *ke);  
  30.   
  31.     struct ff_device *ff;  
  32.   
  33.     unsigned int repeat_key;  
  34.     struct timer_list timer;  
  35.   
  36.     int rep[REP_CNT];  
  37.   
  38.     struct input_mt_slot *mt;  
  39.     int mtsize;  
  40.     int slot;  
  41.     int trkid;  
  42.   
  43.     struct input_absinfo *absinfo;  
  44.   
  45.     unsigned long key[BITS_TO_LONGS(KEY_CNT)];  
  46.     unsigned long led[BITS_TO_LONGS(LED_CNT)];  
  47.     unsigned long snd[BITS_TO_LONGS(SND_CNT)];  
  48.     unsigned long sw[BITS_TO_LONGS(SW_CNT)];  
  49.   
  50.     int (*open)(struct input_dev *dev);  
  51.     void (*close)(struct input_dev *dev);  
  52.     int (*flush)(struct input_dev *dev, struct file *file);  
  53.     int (*event)(struct input_dev *dev, unsigned int type, unsigned int code, int value);  
  54.   
  55.     struct input_handle __rcu *grab;  
  56.   
  57.     spinlock_t event_lock;  
  58.     struct mutex mutex;  
  59.   
  60.     unsigned int users;  
  61.     bool going_away;  
  62.   
  63.     bool sync;  
  64.   
  65.     struct device dev;  
  66.   
  67.     struct list_head    h_list;  
  68.     struct list_head    node;  
  69. }  


比如TouchScrenn报告一个TouchDown事件给Input子系统,其代码如下:

[cpp] view plain copy
  1. input_report_abs(inputdevice, ABS_X, 100);  
  2. input_report_abs(inputdevice, ABS_Y, 200);  
  3. input_report_key(inputdevice, BTN_TOUCH,  1);  
  4.   
  5. static inline void input_report_abs(struct input_dev *dev, unsigned int code, int value)  
  6. {  
  7.     input_event(dev, EV_ABS, code, value);  
  8. }  
  9.   
  10. static inline void input_report_key(struct input_dev *dev, unsigned int code, int value)  
  11. {  
  12.     input_event(dev, EV_KEY, code, !!value);  
  13. }  
  14.   
  15. /** 
  16.  * input_event() - report new input event 
  17.  * @dev: device that generated the event 
  18.  * @type: type of the event 
  19.  * @code: event code 
  20.  * @value: value of the event 
  21.  * 
  22.  * This function should be used by drivers implementing various input 
  23.  * devices to report input events. See also input_inject_event(). 
  24.  */  
  25. void input_event(struct input_dev *dev,  
  26.          unsigned int type, unsigned int code, int value)  
  27. {  
  28.     unsigned long flags;  
  29.   
  30.     if (is_event_supported(type, dev->evbit, EV_MAX)) {  
  31.   
  32.         spin_lock_irqsave(&dev->event_lock, flags);  
  33.         add_input_randomness(type, code, value);  
  34.         input_handle_event(dev, type, code, value);  
  35.         spin_unlock_irqrestore(&dev->event_lock, flags);  
  36.     }  
  37. }  

它将调用input_pass_event,input_pass_event代码如下:

[cpp] view plain copy
  1. static void input_pass_event(struct input_dev *dev,  
  2.                  unsigned int type, unsigned int code, int value)  
  3. {  
  4.     struct input_handler *handler;  
  5.     struct input_handle *handle;  
  6.   
  7.     rcu_read_lock();  
  8.   
  9.     handle = rcu_dereference(dev->grab);  
  10.     if (handle)  
  11.         handle->handler->event(handle, type, code, value);  
  12.     else {  
  13.         bool filtered = false;  
  14.   
  15.         list_for_each_entry_rcu(handle, &dev->h_list, d_node) {  
  16.             if (!handle->open)  
  17.                 continue;  
  18.   
  19.             handler = handle->handler;  
  20.             if (!handler->filter) {  
  21.                 if (filtered)  
  22.                     break;  
  23.   
  24.                 handler->event(handle, type, code, value);  
  25.   
  26.             } else if (handler->filter(handle, type, code, value))  
  27.                 filtered = true;  
  28.         }  
  29.     }  
  30.   
  31.     rcu_read_unlock();  
  32. }  

上面的handler就是下面的evdev_handler.
2. evdev & input core & input_dev初始化

在kernel中,调用函数evdev_read,此函数从client->buffer中(evdev_client *client = file->private_data;)copy对应的input_event到用户提供的buffer。这些input_event数据如何从input_handle_event到client->buffer中的呢? 它是在evdev_event中实现的。

[plain] view plain copy
  1. <span style="font-size:10px;">static struct input_handler evdev_handler = {  
  2.     .event      = evdev_event,  
  3.     .connect    = evdev_connect,  
  4.     .disconnect = evdev_disconnect,  
  5.     .fops       = &evdev_fops,  
  6.     .minor      = EVDEV_MINOR_BASE,  
  7.     .name       = "evdev",  
  8.     .id_table   = evdev_ids,  
  9. };</span>  


    input_dev如何与evdev_handler关联起来的呢? 它只在evdev_init中调用input_register_handler(&evdev_handler)被注册了。其关联关系如下:   

   a)在input_register_handler中,把evdev_handler增加到input_handler_list中   

   b)在input_register_device中,通过input_attach_handler(dev, handler),寻找input_handler_list中哪一个input_handler与需要注册的设备相匹配,找到匹配的,则调用此input_handler的connect把input_handler与注册的input_device关联起来,这样新注册的input_device就有对应的处理方法了。

 

[plain] view plain copy
  1. <span style="font-size:10px;">static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)  
  2. {  
  3.     const struct input_device_id *id;  
  4.     int error;  
  5.   
  6.     id = input_match_device(handler, dev);  
  7.     if (!id)  
  8.         return -ENODEV;  
  9.   
  10.     error = handler->connect(handler, dev, id);  
  11.     if (error && error != -ENODEV)  
  12.         pr_err("failed to attach handler %s to device %s, error: %d\n",  
  13.                handler->name, kobject_name(&dev->dev.kobj), error);  
  14.   
  15.     return error;  
  16. } </span>  


     c)如果匹配上了,就调用evdev_handler->connect函数(evdev_connect),它把此evdev_handler保存在新设备的handle->handler中(evdev->handle.handler = handler;)。这样在input_pass_event就可以调用evdev->handle.handler.event了。        

    d)input_handle把input_device和input_handler关联起来,其数据结构如下: 

 

[plain] view plain copy
  1. struct input_handle {  
  2.   
  3.     void *private;  
  4.   
  5.     int open;  
  6.     const char *name;  
  7.   
  8.     struct input_dev *dev;  
  9.     struct input_handler *handler;  
  10.   
  11.     struct list_head    d_node;  
  12.     struct list_head    h_node;  
  13. };  

  e)evdev为事件字符设备( Event char devices)提供了访问原始输入设备事件的方法,即它是做具体事的东东,对于事件字符设备,当我们调用open, read, write最终都会调用它的函数,即evdev_fops中的对应函数。有了evdev和input core,设备驱动程序就很简单了.

   e.1)首先调用input_allocate_device 创建一个input_dev对象

   e.2)然后设备input_dev的各种属性以告诉input core你将提供哪些事件

   e.3)最后调用input_register_device把input_dev注册到input core

   f)input_register_device

       前面讲过,在input_register_device中,它将在input_handler_list 寻找与input_dev匹配的input_handler,然后调用input_handler的connect函数,即evdev_connect。在evdev_connect中,它将创建evdev对象,并以evdev->minor作为索引把它放在evdev_table数组中。evdev数据结构如下:

[plain] view plain copy
  1. struct evdev {  
  2.     int open;  
  3.     int minor;   //在evdev_table中的索引  
  4.     struct input_handle handle;  //连接input_dev和input_handler  
  5.     wait_queue_head_t wait;  
  6.     struct evdev_client __rcu *grab;   // 用户每调用一次open,将创建一个evdev_client  
  7.     struct list_head client_list;  
  8.     spinlock_t client_lock; /* protects client_list */  
  9.     struct mutex mutex;  
  10.     struct device dev;  
  11.     bool exist;  
  12. };  
  13.   
  14. struct evdev_client {  
  15.     unsigned int head;  
  16.     unsigned int tail;  
  17.     unsigned int packet_head; /* [future] position of the first element of next packet */  
  18.     spinlock_t buffer_lock; /* protects access to buffer, head and tail */  
  19.     struct wake_lock wake_lock;  
  20.     char name[28];  
  21.     struct fasync_struct *fasync;  
  22.     struct evdev *evdev;  
  23.     struct list_head node;  
  24.     unsigned int bufsize;  
  25.     struct input_event buffer[];  //存放所有这个设备产生的input_event,由evdev_event写入  
  26. };  

        在evdev_connect,它设置设备名,初始化input_handle中各个数据成员(关键是其input_dev和input_handler),然后再调用input_register_handle把evdev中的input_handle添加到input_dev的h_lis链表中,并且把此input_handle添加到input_handler的h_list链表中。从此它们的三角关系建立完成。注:当用户每打开一次它就要创建一个evdev_client,并加入到client_list链表中,当input_dev产生事件时,evdev_event函数将把此input_event放入evdev->client_list链表中的每个evdev_client的buffer中。它们的关系如下图所示:

Input Core和evdev基本知识 - Kernel3.0.8_第1张图片

3. Kernel中数据读取流程

     在kernel中调用evdev_read来读取数据,其函数原型如下:

static ssize_t evdev_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)

    其读取流程为:

    1)从前面得知在打开设备文件时,创建了一个evdev_client,并把此client保存在file的private_data中,所以现在从file->private_data中取出evdev_client

    2)从前面得知此evdev_client中保存有在evdev_connect时创建的evdev,从而可以得到对应的evdev对象

    3)从client->buffer中读取事件,并copy到用户提供的buffer中。前面讲过,client->buffer中的事件是当input_dev报告事件给Input core时,由evdev_event把input_event事件放入client->buffer中的。

你可能感兴趣的:(Input Core和evdev基本知识 - Kernel3.0.8)