三、Linux input 子系统学习之register_input_handler 分析 1、看看入口函数 2、详细分析下input_register_handler 这个函数

54 阅读 0 评论 36 点赞

我是靠谱客的博主孤独学姐，最近开发中收集的这篇文章主要介绍三、Linux input 子系统学习之register_input_handler 分析 1、看看入口函数 2、详细分析下input_register_handler 这个函数，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

这一篇，我们来分析input_register_handler 这个非常重要的函数。就像之前说过的一样，这是注册一个驱动。

我们去input目录下看看那些文件调用的这个函数，分别有：evdev.c（evdev驱动）、joydev.c（joydev驱动）、keychord.c（按键驱动）、mousedev.c（鼠标驱动）。
也即是每个文件，对于一种驱动，并在里面进行注册驱动。

好的，那么我们以evdev.c为例子分析就好了。因为，触摸屏设备也是对应这个驱动。

1、看看入口函数

点击(此处)折叠或打开

 
   static const struct input_device_id evdev_ids[] = {
 
     { .driver_info = 1 },    /* Matches all devices */
 
     { },            /* Terminating zero entry */
 
 };
 
 MODULE_DEVICE_TABLE(input, evdev_ids);
 
 static struct input_handler evdev_handler = {
 
     .event        = evdev_event,
 
     .connect    = evdev_connect,
 
     .disconnect    = evdev_disconnect,
 
     .fops        = &evdev_fops,
 
     .minor        = EVDEV_MINOR_BASE,
 
     .name        = "evdev",
 
     .id_table    = evdev_ids,
 
 };
 
 static int __init evdev_init(void)
 
 {
 
     return input_register_handler(&evdev_handler);
 
 }

入口函数里面，啥都没干，就直接注册了一个evdev_handler，够直接把。哈哈!
struct input_handler evdev_handler 这几个机构体里面的几个元素都比较重要，后面都会用到，现在先来个大概的了解。

  .event = evdev_event,   ：当时间上报的时候，会调用到此函数。
  .connect = evdev_connect,   ：当驱动和设备匹配的时候会调用到
  .disconnect = evdev_disconnect,   ：这个还没研究
  .fops = &evdev_fops, ：这个handler的操作函数
  .minor = EVDEV_MINOR_BASE, ：EVDEV 此设备号的基值
  .name = "evdev", ：名字啦
  .id_table = evdev_ids, ：驱动和设备是否匹配，需要通过id_table来验证。这里的evdev_ids 看到上面的注释没“match all devices ”，就是匹配所有设
  备。

2、详细分析下input_register_handler 这个函数

点击(此处)折叠或打开

 
   /**
 
  * input_register_handler - register a new input handler
 
  * @handler: handler to be registered
 
  *
 
  * This function registers a new input handler (interface) for input
 
  * devices in the system and attaches it to all input devices that
 
  * are compatible with the handler.
 
  */
 
 int input_register_handler(struct input_handler *handler)
 
 {
 
     struct input_dev *dev;
 
     int retval;
 
     retval = mutex_lock_interruptible(&input_mutex);
 
     if (retval)
 
         return retval;
 
     INIT_LIST_HEAD(&handler->h_list);    //初始化h_list头部
 
     if (handler->fops != NULL) {
 
         if (input_table[handler->minor >> 5]) {
 
             retval = -EBUSY;
 
             goto out;
 
         }
 
         input_table[handler->minor >> 5] = handler;  //将handler插入数组，其位置是handler->minor >> 5，也就是除以32
     }
 
     list_add_tail(&handler->node, &input_handler_list); // 将handler->node插入到input_handler_list链表，深入代码分析可知，是插在input_handler_list头部的后面
 
     list_for_each_entry(dev, &input_dev_list, node) //遍历input_dev_list链表，对每一个dev调用input_attach_handler函数，看是否匹配。
 
         input_attach_handler(dev, handler);
 
     input_wakeup_procfs_readers();
 
  out:
 
     mutex_unlock(&input_mutex);
 
     return retval;
 
 }
 
 EXPORT_SYMBOL(input_register_handler);

上面的注释也说的很清楚，就是注册一个input_handler。函数的分析，代码旁边的注释也说了。

2.1 我们将重点集中下面这句代码。

list_for_each_entry ( dev , & input_dev_list , node )
input_attach_handler ( dev , handler ) ;

先看看list_for_each_entry是怎么定义的

点击(此处)折叠或打开

/**
* list_for_each_entry - iterate over list of given type
* @pos: the type * to use as a loop cursor.
* @head: the head for your list.
* @member: the name of the list_struct within the struct.
*/
#define list_for_each_entry(pos, head, member)
for (pos = list_entry((head)->next, typeof(*pos), member);
&pos->member != (head);
pos = list_entry(pos->member.next, typeof(*pos), member))

注释说得很清楚，就是对于给定的某种类型的链表进行遍历，其实就是一个for 循环。我们带入就是下面这样

点击(此处)折叠或打开

#define list_for_each_entry(dev, input_dev_list, node)
for (dev= list_entry((input_dev_list)->next, typeof(*dev), node);
&dev->node!= (input_dev_list);
dev= list_entry(dev->node.next, typeof(*dev), node))
{
input_attach_handler(dev, handler);
}

再看看， list_entry的定义，就是我们熟悉的container_of,通过结构体里面某个元素的指针，找到结构体本身的指针，这里要找到的当然就dev结构体本身了，也就是input_device (关于这个我们留在下一篇分析)

点击(此处)折叠或打开

/**
* list_entry - get the struct for this entry
* @ptr: the &struct list_head pointer.
* @type: the type of the struct this is embedded in.
* @member: the name of the list_struct within the struct.
*/
#define list_entry(ptr, type, member)
container_of(ptr, type, member)

到了这里很明了，就是遍历 input_dev_list链表，对每一个dev（input_device）调用 input_attach_handler函数，看是否匹配。

2.2 input_attach_handler分析

先看看函数的定义

点击(此处)折叠或打开

 
   static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)
 
 {
 
     const struct input_device_id *id;
 
     int error;
 
     id = input_match_device(handler, dev);
 
     if (!id)
 
         return -ENODEV;
 
     error = handler->connect(handler, dev, id);
 
     if (error && error != -ENODEV)
 
         pr_err("failed to attach handler %s to device %s, error: %dn",
 
          handler->name, kobject_name(&dev->dev.kobj), error);
 
     return error;
 
 }

小伙伴，惊呆了吧，看！首先是调用input_match_device函数，看驱动handler和dev是否匹配，如果匹配成功，就会返回相应的ID，并调用handler里面的connect函数

2.2.1 input_match_device 函数分析

点击(此处)折叠或打开

 static const struct input_device_id *input_match_device(struct input_handler *handler,
 
                             struct input_dev *dev)
 
 {
 
     const struct input_device_id *id;
 
     int i;
 
     for (id = handler->id_table; id->flags || id->driver_info; id++) {
 
         if (id->flags & INPUT_DEVICE_ID_MATCH_BUS)
 
             if (id->bustype != dev->id.bustype)
 
                 continue;
 
         if (id->flags & INPUT_DEVICE_ID_MATCH_VENDOR)
 
             if (id->vendor != dev->id.vendor)
 
                 continue;
 
         if (id->flags & INPUT_DEVICE_ID_MATCH_PRODUCT)
 
             if (id->product != dev->id.product)
 
                 continue;
 
         if (id->flags & INPUT_DEVICE_ID_MATCH_VERSION)
 
             if (id->version != dev->id.version)
 
                 continue;
 
         MATCH_BIT(evbit, EV_MAX);
 
         MATCH_BIT(keybit, KEY_MAX);
 
         MATCH_BIT(relbit, REL_MAX);
 
         MATCH_BIT(absbit, ABS_MAX);
 
         MATCH_BIT(mscbit, MSC_MAX);
 
         MATCH_BIT(ledbit, LED_MAX);
 
         MATCH_BIT(sndbit, SND_MAX);
 
         MATCH_BIT(ffbit, FF_MAX);
 
         MATCH_BIT(swbit, SW_MAX);
 
         if (!handler->match || handler->match(handler, dev))
 
             return id;
 
     }
 
     return NULL;
 
 }

因为evdev_handle->flag元素为空，并且 evdev_handle->match也为空，所以 evdev_handle->id_table，所以匹配是成功的。

2.2.2 分析下handler->connect这个函数

也就是下面的代码

点击(此处)折叠或打开

 
   /*
 
  * Create new evdev device. Note that input core serializes calls
 
  * to connect and disconnect so we don't need to lock evdev_table here.
 
  */
 
 static int evdev_connect(struct input_handler *handler, struct input_dev *dev,
 
              const struct input_device_id *id)
 
 {
 
     struct evdev *evdev;
 
     int minor;
 
     int error;
 
    //先在evdev_table[ ] 数组里面，找到一个还没有使用过的索引
     for (minor = 0; minor < EVDEV_MINORS; minor++)  
 
         if (!evdev_table[minor])
 
             break;
 
     if (minor == EVDEV_MINORS) {
 
         pr_err("no more free evdev devicesn");
 
         return -ENFILE;
 
     }
 
     //申请一个evdev对象
     evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL);
 
     if (!evdev)
 
         return -ENOMEM;
 
     //对evdev进行一些初始化
     INIT_LIST_HEAD(&evdev->client_list);
 
     spin_lock_init(&evdev->client_lock);
 
     mutex_init(&evdev->mutex);
 
     init_waitqueue_head(&evdev->wait);
 
     //赋值一些元素
     dev_set_name(&evdev->dev, "event%d", minor);
 
     evdev->exist = true;
 
     evdev->minor = minor;
 
     //特别注意到evdev里面有一个handle的元素，以及对它的赋值，特别是handle.dev和handle.handler非常重要，这样才能把handle、dev、handler关联起来
     evdev->handle.dev = input_get_device(dev);  //指向我们的dev
 
     evdev->handle.name = dev_name(&evdev->dev);
 
     evdev->handle.handler = handler; //指向我们的handler
 
     evdev->handle.private = evdev;
 
     //也要特别注意到evdev里面有一个dev的元素，设备节点的生产就是靠它生成的
     evdev->dev.devt = MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor);  //得到设备号
 
     evdev->dev.class = &input_class; //第二篇里面分析，有提到这个input_class哦！！
 
     evdev->dev.parent = &dev->dev;
 
     evdev->dev.release = evdev_free;
 
     device_initialize(&evdev->dev);
 
     //注册evdev里面的handle
     error = input_register_handle(&evdev->handle);
 
     if (error)
 
         goto err_free_evdev;
 
     //其实就是把evdev放入到evdev_table[]数组里面
     error = evdev_install_chrdev(evdev);
 
     if (error)
 
         goto err_unregister_handle;
 
    //生成设备节点
     error = device_add(&evdev->dev);
 
     if (error)
 
         goto err_cleanup_evdev;
 
     return 0;
 
  err_cleanup_evdev:
 
     evdev_cleanup(evdev);
 
  err_unregister_handle:
 
     input_unregister_handle(&evdev->handle);
 
  err_free_evdev:
 
     put_device(&evdev->dev);
 
     return error;
 
 }

如上面的注释所述，先在evdev_talble[ ]数组里面找到一个没有使用过的索引，然后申请一个evdev，再就是初始化里面的元素，最后这个通过evdev_install_chrdev函数，将evdev放入到
evdev_talble[ ]数组里面。当然最后还要创建设备节点。

2.2.2.1 input_register_handle 分析

点击(此处)折叠或打开

 
   /**
 
  * input_register_handle - register a new input handle
 
  * @handle: handle to register
 
  *
 
  * This function puts a new input handle onto device's
 
  * and handler's lists so that events can flow through
 
  * it once it is opened using input_open_device().
 
  *
 
  * This function is supposed to be called from handler's
 
  * connect() method.
 
  */
 
 int input_register_handle(struct input_handle *handle)
 
 {
 
     struct input_handler *handler = handle->handler;
 
     struct input_dev *dev = handle->dev;
 
     int error;
 
     /*
 
      * We take dev->mutex here to prevent race with
 
      * input_release_device().
 
      */
 
     error = mutex_lock_interruptible(&dev->mutex);
 
     if (error)
 
         return error;
 
     /*
 
      * Filters go to the head of the list, normal handlers
 
      * to the tail.
 
      */
 
     if (handler->filter)
 
         list_add_rcu(&handle->d_node, &dev->h_list);
 
     else
 
         list_add_tail_rcu(&handle->d_node, &dev->h_list);
 
     mutex_unlock(&dev->mutex);
 
     /*
 
      * Since we are supposed to be called from ->connect()
 
      * which is mutually exclusive with ->disconnect()
 
      * we can't be racing with input_unregister_handle()
 
      * and so separate lock is not needed here.
 
      */
 
     list_add_tail_rcu(&handle->h_node, &handler->h_list);
 
     if (handler->start)
 
         handler->start(handle);
 
     return 0;
 
 }

函数的头部说的很明白了，将handle放到device's list 和 handler list ，这样通过dev或者handler 就可以找到 handle ,结合之前的分析，通过handle 也可以找到dev和handler，这样他们就都关联起来了。

2.2.2.1 input_register_handle 分析

点击(此处)折叠或打开

 
    static int evdev_install_chrdev(struct evdev *evdev)
 
 {
 
     /*
 
      * No need to do any locking here as calls to connect and
 
      * disconnect are serialized by the input core
 
      */
 
     evdev_table[evdev->minor] = evdev;
 
     return 0;
 
 }