Chinaunix首页 | 论坛 | 博客

_ChinaUnix的ChinaUnix博客

首页　| 　博文目录　| 　关于我

_ChinaUnix

  • 博客访问： 230714
  • 博文数量： 27
  • 博客积分： 465
  • 博客等级： 下士
  • 技术积分： 1340
  • 用 户 组： 普通用户
  • 注册时间： 2012-08-23 22:33
文章分类

全部博文（27）

文章存档

2014年（1）

2013年（2）

2012年（24）

我的朋友
最近访客
推荐博文
相关博文
输入子系统一

分类： LINUX

2012-08-29 21:17:43

    Input子系统是分层结构，由上图可以分为三层，核心层，硬件驱动层，事件处理层，各个层之间的通信的是通过事件，其传送方向为硬件驱动层-à子系统核心层à事件处理层-à用户空间，下面来分析下每层具体做的工作。
Input子系统结构与功能实现
（1）其中硬件驱动层负责操作具体的硬件设备，这层的代码是针对具体的驱动程序的，需要驱动程序的作者来编写。
    （2）子系统核心层是链接其他两个层之间的纽带与桥梁，向下提供驱动层的接口，向上提供事件处理层的接口。
（3）事件处理层负责与用户程序打交道，将硬件驱动层传来的事件报告给用户程序。
1.核心层
输入子系统核心对应于/drivers/input/input.c文件，也是作为一个模块注册到内核的，先分析模块初始化函数。

点击(此处)折叠或打开

  1. static int __init input_init(void)
  2. {
  3.     int err;

  5.     err = class_register(&input_class);//向内核注册一个类，用于linux设备模型，注册后会在/sys/class下面出现input目录。
  6.     if (err) {
  7.         printk(KERN_ERR "input: unable to register input_dev class\n");
  8.         return err;
  9.     }

  11.     err = input_proc_init();//proc文件系统相关初始化

  12.     if (err)
  13.         goto fail1;

  15.     err = register_chrdev(INPUT_MAJOR, "input", &input_fops);//注册字符设备
  16.     if (err) {
  17.         printk(KERN_ERR "input: unable to register char major %d", INPUT_MAJOR);
  18.         goto fail2;
  19.     }

  21.     return 0;

  23.  fail2:    input_proc_exit();
  24.  fail1:    class_unregister(&input_class);
  25.     return err;
  26. }

    从上面可以看出其实input设备也是一类字符设备，只不过操作方法交给了输入子系统。所有的主设备号为13的字符设备的操作最终都会转入到input_fops,Input_fops定义如下：

点击(此处)折叠或打开

  1. static const struct file_operations input_fops = {
  2.     .owner = THIS_MODULE,
  3.     .open = input_open_file,
  4. };

    仔细看看，这个和以前的字符设备不一样，该fops只有一个open函数，那么怎么样实现从输入设备获取到值呢？我们来看看input_open_file做了些什么。


点击(此处)折叠或打开

  1. static int input_open_file(struct inode *inode, struct file *file)
  2. {
  3.     struct input_handler *handler = input_table[iminor(inode) >> 5];
  4. //根据次设备号在input_table数组中查询相应的处理函数(Input_table[]在input_register_handler中初始化)

  5.     const struct file_operations *old_fops, *new_fops = NULL;
  6.     int err;

  8.     /* No load-on-demand here? */
  9.     if (!handler || !(new_fops = fops_get(handler->fops)))//获取handler结构体的fops
  10.         return -ENODEV;

  12.     /*
  13.      * That's _really_ odd. Usually NULL ->open means "nothing special",
  14.      * not "no device". Oh, well...
  15.      */
  16.     if (!new_fops->open) {
  17.         fops_put(new_fops);
  18.         return -ENODEV;
  19.     }
  20.     old_fops = file->f_op;
  21.     file->f_op = new_fops;// 将handler中的fops换掉当前的fops
  22.     err = new_fops->open(inode, file);//调用新的fops中的open函数
  23.     if (err) {
  24.         fops_put(file->f_op);
  25.         file->f_op = fops_get(old_fops);
  26.     }
  27.     fops_put(old_fops);
  28.     return err;
  29. }

       通过input_table将handler的fops重新获取，那么来分析下input_table是怎么实现的，这个主要是通过iinput_register_handler来注册一个事件处理器。该函数主要是对于每个注册的handler进行保存 input_table[handler->minor >> 5] = handler;

点击(此处)折叠或打开

  1. int input_register_handler(struct input_handler *handler)
  2. {
  3.     struct input_dev *dev;

  5.     INIT_LIST_HEAD(&handler->h_list);

  7.     if (handler->fops != NULL) {
  8.         if (input_table[handler->minor >> 5])
  9.             return -EBUSY;
  10.   input_table[handler->minor >> 5] = handler;//连接到input_handler_list链表
  11. // 因为每个handler都会处理最大32个input_dev，所以要以minor的32为倍数对齐,这个minor是传进来的handler的MINOR_BASE        
  12. }
  13.     list_add_tail(&handler->node, &input_handler_list);//连接到input_handler_list链表
  14.     list_for_each_entry(dev, &input_dev_list, node)
  15.         input_attach_handler(dev, handler);//     将handler与dev进行配对，不过这次主要是遍历input_dev


  17.     input_wakeup_procfs_readers();
  18.     return 0;
  19. }

其 其上主要是完成加handler加入到链表，同时完成handler与dev的匹配。下面看看input_attach_handler的处理过程。

点击(此处)折叠或打开

  1. static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)
  2. {
  3.     const struct input_device_id *id;
  4.     int error;

  6.     if (handler->blacklist && input_match_device(handler->blacklist, dev))
  7.         return -ENODEV;
  8.       //blacklist是handler因该忽略的input设备类型，如果应该忽略的input设备也配对上了，那就出错了   
  9.     id = input_match_device(handler->id_table, dev);//其主要是配对handler->id_table与dev
  10.     if (!id)
  11.         return -ENODEV;

  13.     error = handler->connect(handler, dev, id);
  14.     if (error && error != -ENODEV)
  15.         printk(KERN_ERR
  16.             "input: failed to attach handler %s to device %s, "
  17.             "error: %d\n",
  18.             handler->name, kobject_name(&dev->cdev.kobj), error);

  20.     return error;
  21. }
从      从上可以看出，其主要是配对handler->id_table与dev是否有mattch，如果配对成功，则调用handler的connect函数。

点击(此处)折叠或打开

  1. static const struct input_device_id *input_match_device(const struct input_device_id *id,
  2.                             struct input_dev *dev)
  3. {
  4.     int i;

  6.     for (; id->flags || id->driver_info; id++) {

  8.         if (id->flags & INPUT_DEVICE_ID_MATCH_BUS)
  9.             if (id->bustype != dev->id.bustype)
  10.                 continue;

  12.         if (id->flags & INPUT_DEVICE_ID_MATCH_VENDOR)
  13.             if (id->vendor != dev->id.vendor)
  14.                 continue;

  16.         if (id->flags & INPUT_DEVICE_ID_MATCH_PRODUCT)
  17.             if (id->product != dev->id.product)
  18.                 continue;

  20.         if (id->flags & INPUT_DEVICE_ID_MATCH_VERSION)
  21.             if (id->version != dev->id.version)
  22.                 continue;

  24.         MATCH_BIT(evbit, EV_MAX);
  25.         MATCH_BIT(keybit, KEY_MAX);
  26.         MATCH_BIT(relbit, REL_MAX);
  27.         MATCH_BIT(absbit, ABS_MAX);
  28.         MATCH_BIT(mscbit, MSC_MAX);
  29.         MATCH_BIT(ledbit, LED_MAX);
  30.         MATCH_BIT(sndbit, SND_MAX);
  31.         MATCH_BIT(ffbit, FF_MAX);
  32.         MATCH_BIT(swbit, SW_MAX);

  34.         return id;
  35.     }

  37.     return NULL;
  38. }
主       比较input_dev中的id和handler支持的id，这个存放在handler的id_table中，首先看id->driver_info是否有设置，如果设置了，表明他匹配所有的id，例如evdev。然后在根据id->flag来比较，如果成功进入MATCH_BIT，这个宏用来进行按位比较，比较所支持的事件类型。

点击(此处)折叠或打开

  1. #define MATCH_BIT(bit, max) \
  2.         for (i = 0; i < NBITS(max); i++) \
  3.             if ((id->bit[i] & dev->bit[i]) != id->bit[i]) \
  4.                 break; \
  5.         if (i != NBITS(max)) \
  6.             continue;

点击(此处)折叠或打开

  1. struct input_device_id {

  3.     kernel_ulong_t flags;

  5.     __u16 bustype;
  6.     __u16 vendor;
  7.     __u16 product;
  8.     __u16 version;

  10.     kernel_ulong_t evbit[INPUT_DEVICE_ID_EV_MAX / BITS_PER_LONG + 1];
  11.     kernel_ulong_t keybit[INPUT_DEVICE_ID_KEY_MAX / BITS_PER_LONG + 1];
  12.     kernel_ulong_t relbit[INPUT_DEVICE_ID_REL_MAX / BITS_PER_LONG + 1];
  13.     kernel_ulong_t absbit[INPUT_DEVICE_ID_ABS_MAX / BITS_PER_LONG + 1];
  14.     kernel_ulong_t mscbit[INPUT_DEVICE_ID_MSC_MAX / BITS_PER_LONG + 1];
  15.     kernel_ulong_t ledbit[INPUT_DEVICE_ID_LED_MAX / BITS_PER_LONG + 1];
  16.     kernel_ulong_t sndbit[INPUT_DEVICE_ID_SND_MAX / BITS_PER_LONG + 1];
  17.     kernel_ulong_t ffbit[INPUT_DEVICE_ID_FF_MAX / BITS_PER_LONG + 1];
  18.     kernel_ulong_t swbit[INPUT_DEVICE_ID_SW_MAX / BITS_PER_LONG + 1];

  20.     kernel_ulong_t driver_info;
  21. };
每      由此看出，在id->flag中第一了要匹配的项，定义INPUT_DEVICE_ID_MATCH_BUS，则要比较input_device和input_handler的总线类型。其他分别为设备厂商，设备号和设备版本。如果匹配成功，就会调用handler的connect函数。对于不同的connect函数处理的方式不同，下面以evdev为例

点击(此处)折叠或打开

  1. static int evdev_connect(struct input_handler *handler, struct input_dev *dev,
  2.              const struct input_device_id *id)
  3. {
  4.     struct evdev *evdev;
  5.     struct class_device *cdev;
  6.     dev_t devt;
  7.     int minor;
  8.     int error;
  9. //说明evdev这个handler可以同时有32个输入设备与他配对，evdev_table中以minor存放evdev结构体。
  10.     for (minor = 0; minor < EVDEV_MINORS && evdev_table[minor]; minor++);
  11.     if (minor == EVDEV_MINORS) {
  12.         printk(KERN_ERR "evdev: no more free evdev devices\n");
  13.         return -ENFILE;
  14.     }

  16.  //分配一个evdev结构体，这个结构体是evdev事件处理器特有
  17.    evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL);
  18.     if (!evdev)
  19.         return -ENOMEM;

  21.     INIT_LIST_HEAD(&evdev->client_list);
  22.     init_waitqueue_head(&evdev->wait);
  23. //以上主要是注册一个evdev结构体的handle，然后初始化，连接到input_handler和input_dev      
  24.     evdev->exist = 1;
  25.     evdev->minor = minor;
  26.     evdev->handle.dev = dev;
  27.     evdev->handle.name = evdev->name;
  28.     evdev->handle.handler = handler;
  29.     evdev->handle.private = evdev;
  30.     sprintf(evdev->name, "event%d", minor);

  32.     evdev_table[minor] = evdev;

  34.     devt = MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor),

  36.     cdev = class_device_create(&input_class, &dev->cdev, devt,
  37.                  dev->cdev.dev, evdev->name);   //注册handle结构体
  38.     if (IS_ERR(cdev)) {
  39.         error = PTR_ERR(cdev);
  40.         goto err_free_evdev;
  41.     }

  43.     /* temporary symlink to keep userspace happy */
  44.     error = sysfs_create_link(&input_class.subsys.kobj,
  45.                  &cdev->kobj, evdev->name);
  46.     if (error)
  47.         goto err_cdev_destroy;

  49.     error = input_register_handle(&evdev->handle);
  50.     if (error)
  51.         goto err_remove_link;

  53.     return 0;

  55.  err_remove_link:
  56.     sysfs_remove_link(&input_class.subsys.kobj, evdev->name);
  57.  err_cdev_destroy:
  58.     class_device_destroy(&input_class, devt);
  59.  err_free_evdev:
  60.     kfree(evdev);
  61.     evdev_table[minor] = NULL;
  62.     return error;
  63. }

       函数主要做的都是一些善后的工作，分配一个evdev结构体，并初始化相关成员，evdev结构体中也有input_handle结构，并初始化并注册。那么看看这个handle的实现。

点击(此处)折叠或打开

  1. int input_register_handle(struct input_handle *handle)
  2. {
  3.     struct input_handler *handler = handle->handler;

  5.     list_add_tail(&handle->d_node, &handle->dev->h_list);
  6.     list_add_tail(&handle->h_node, &handler->h_list);

  8.     if (handler->start)
  9.         handler->start(handle);

  11.     return 0;
  12. }

        这个函数只做了两个工作，把一个handle结构体通过d_node链表项，分别连接到input_dev的h_list，input_handler的h_list上，以后就可以通过h_list就可以遍历相关的input_handle了。input_hande 没有一个全局的链表，它注册的时候将自己分别挂在了input_dev 和input_handler 的h_list上了。通过input_dev 和input_handler就可以找到input_handle 在设备注册和事件处理器， 注册的时候都要进行配对工作，配对后就会实现链接。通过input_handle也可以找到input_dev和input_handler。那么input_dev怎么注册到链表中呢？

点击(此处)折叠或打开

  1. int input_register_device(struct input_dev *dev)
  2. {
  3.     static atomic_t input_no = ATOMIC_INIT(0);
  4.     struct input_handler *handler;
  5.     const char *path;
  6.     int error;

  8.     set_bit(EV_SYN, dev->evbit);  //EN_SYN 这个是设备都要支持的事件类型 


  10.     /*
  11.      * If delay and period are pre-set by the driver, then autorepeating
  12.      * is handled by the driver itself and we don't do it in input.c.
  13.      */

  15.     init_timer(&dev->timer);// 这个内核定时器是为了重复按键而设置的 
  16.     if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD]) {
  17.         dev->timer.data = (long) dev;
  18.         dev->timer.function = input_repeat_key;
  19.         dev->rep[REP_DELAY] = 250;
  20.         dev->rep[REP_PERIOD] = 33;//如果没有定义有关重复按键的相关值，就用内核默认的  
  21.     }

  23.     if (!dev->getkeycode)
  24.         dev->getkeycode = input_default_getkeycode;

  26.     if (!dev->setkeycode)
  27.         dev->setkeycode = input_default_setkeycode;
  28. //以上设置的默认函数由input核心提供 
  29.     list_add_tail(&dev->node, &input_dev_list); // 将新分配的input设备连接到input_dev_list链表上   
  30.     snprintf(dev->cdev.class_id, sizeof(dev->cdev.class_id),
  31.          "input%ld", (unsigned long) atomic_inc_return(&input_no) - 1);

  33.     if (!dev->cdev.dev)
  34.         dev->cdev.dev = dev->dev.parent;

  36.     error = class_device_add(&dev->cdev);//添加设备节点
  37.     if (error)
  38.         return error;

  40.     path = kobject_get_path(&dev->cdev.kobj, GFP_KERNEL);
  41.     printk(KERN_INFO "input: %s as %s\n",
  42.         dev->name ? dev->name : "Unspecified device", path ? path : "N/A");
  43.     kfree(path);
、、 / /遍历input_handler_list链表，配对 input_dev 和 input_handler   
  1.     list_for_each_entry(handler, &input_handler_list, node)
  2.         input_attach_handler(dev, handler);

  4.     input_wakeup_procfs_readers();

  6.     return 0;
  7. }

   input_register_device完成的主要功能就是：初始化一些默认的值，将自己的device结构添加到linux设备模型当中，将input_dev添加到input_dev_list链表中，然后寻找合适的handler与input_handler配对,配对的核心函数是input_attach_handler,而该函数在input_register_handler中已经分析过了。

   下面总结下上面的分析过程，如下图：

in    input_dev 是硬件驱动层，代表一个input设备, 通过全局的input_dev_list链接在一起。设备注册的时候实现这个操作。input_handler 是事件处理层，代表一个事件处理器, nput_handler 通过全局的input_handler_list链接在一起。事件处理器注册的时候实现这个操作。input_handle 个人认为属于核心层，代表一个配对的input设备与input事件处理器    

下面看看其中比较重要的数据结构input_handle

点击(此处)折叠或打开

  1. struct input_handle {
  2. //每个配对的事件处理器都会分配一个对应的设备结构，如evdev事件处理器的evdev结构，注意这个结构与设备驱动层的input_dev不同，初始化handle时，保存到这里。   

  3.     void *private;

  4.     int open;
  5.     const char *name;

  7.     struct input_dev *dev;
  8.     struct input_handler *handler;

  10.     struct list_head    d_node;   //input_handle通过d_node连接到了input_dev上的h_list链表上
  11.     struct list_head    h_node; //input_handle通过h_node连接到了input_handler的h_list链表上
  12. };
     那么写输入子系统的驱动程序方法：
 1.分配一个input_dev结构体(input_allocate_device)
 2.设置 包括设置是哪类事件等
 3.注册  input_register_device
 4.硬件相关的初始化

阅读(2382) | 评论(0) | 转发(4) |
0

上一篇：对Linux系统休眠的理解

下一篇：输入子系统二

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6