Chinaunix首页 | 论坛 | 博客

Jinlongdragon16888.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

dragonerer

  • 博客访问： 677447
  • 博文数量： 516
  • 博客积分： 4119
  • 博客等级： 上校
  • 技术积分： 4288
  • 用 户 组： 普通用户
  • 注册时间： 2012-10-30 17:29
文章分类

全部博文（516）

文章存档

2014年（4）

2013年（160）

2012年（352）

我的朋友
最近访客
推荐博文
输入子系统架构分析

分类：

2013-01-04 17:47:21

原文地址：输入子系统架构分析 作者：mutes

         内核的输入子系统是对分散的，多种不同类别的输入设备(如键盘，鼠标，跟踪球，操纵杆，触摸屏，加速计和手写板)等字符设备进行统一处理的一层抽象，就是在字符设备驱动上抽象出的一层。输入子系统包括两类驱动程序：事件驱动程序和设备驱动程序。事件驱动程序负责和应用程序的接口，而设备驱动程序负责和底层输入设备的通信。鼠标事件生成文件mousedev属于事件驱动程序，而PS/2鼠标驱动程序是设备驱动程序。事件驱动程序是标准的，对所有的输入类都是可用的，所以要实现的是设备驱动程序而不是事件驱动程序。设备驱动程序可以利用一个已经存在的，合适的事件驱动程序通过输入核心和用户应用程序接口。
输入子系统带来了如下好处：
1.统一了物理形态各异的相似的输入设备的处理功能
2.提供了用于分发输入报告给用户应用程序的简单的事件接口
3.抽取出了输入驱动程序的通用部分，简化了驱动，并引入了一致性

       现在 Android、X windows、qt等众多应用对于linux系统中键盘、鼠标、触摸屏等输入设备的支持都通过、或越来越倾向于标准的input输入子系统。因为input子系统已经完成了字符驱动的文件操作接口，所以编写驱动的核心工作是完成input系统留出的接口，工作量不大。但如果你想更灵活的应用它，就需要好好的分析下input子系统了。


先来看一下输入子系统体系架构图：


再对照下图（input输入子系统框架），很清楚的知道输入子系统是由输入子系统核心层（ Input Core ），驱动层和事件处理层（Event Handler）三部份组成。一个输入事件，如鼠标移动，键盘按键按下，joystick的移动等等通过 input driver -> Input core -> Event handler -> userspace 到达用户空间传给应用程序。

注意：keyboard.c不会在/dev/input下产生节点，而是作为ttyn终端（不包括串口终端）的输入。

设备描述
       在linux内核中，input设备用input_dev结构体描述，使用input子系统实现输入设备驱动的时候，驱动的核心工作是向系统报告按键、触摸屏、键盘、鼠标等输入事件（event,通过input_event结构体描述），一再需要关心文件操作接口，因为input子系统已经完成了文件操作接口。驱动报告的事件经过InputCore和EventHandler最终到达用户空间。
现在了解了input子系统的基本思想，下面来看一下input子系统的3个基本的数据结构：
  1. struct input_dev {  
  2.     const char *name;     //名称                              
  3.     const char *phys;  //设备在系统中的物理路径
  4.     const char *uniq;  //设备唯一识别符
  5.     struct input_id id; //设备ID，包含总线ID（PCI、USB）、厂商ID，与input_handler匹配的时会用到  
  6.   
  7.     unsigned long evbit[BITS_TO_LONGS(EV_CNT)];     //支持的所有事件类型  
  8.     unsigned long keybit[BITS_TO_LONGS(KEY_CNT)];   //支持的键盘事件  
  9.     unsigned long relbit[BITS_TO_LONGS(REL_CNT)];   //支持的鼠标相对值事件  
  10.     unsigned long absbit[BITS_TO_LONGS(ABS_CNT)];   //支持的鼠标绝对值事件  
  11.     unsigned long mscbit[BITS_TO_LONGS(MSC_CNT)];   //支持的其它事件类型  
  12.     unsigned long ledbit[BITS_TO_LONGS(LED_CNT)];   //支持的LED灯事件  
  13.     unsigned long sndbit[BITS_TO_LONGS(SND_CNT)];   //支持的声效事件 
  14.     unsigned long ffbit[BITS_TO_LONGS(FF_CNT)];     //支持的力反馈事件  
  15.     unsigned long swbit[BITS_TO_LONGS(SW_CNT)];     //支持的开关事件  
  16.   
  17.     unsigned int keycodemax;  //keycode表的大小
  18.     unsigned int keycodesize;  //keycode表中元素个数
  19.     void *keycode;  //设备的键盘表
  20.     int (*setkeycode)(struct input_dev *dev, int scancode, int keycode);//配置keycode表  
  21.     int (*getkeycode)(struct input_dev *dev, int scancode, int *keycode);//获取keycode表  
  22.   
  23.     struct ff_device *ff;  
  24.   
  25.     unsigned int repeat_key;//保存上一个键值  
  26.     struct timer_list timer;  
  27.   
  28.     int sync;  
  29.   
  30.     int abs[ABS_MAX + 1];             //绝对坐标上报的当前值  
  31.     int rep[REP_MAX + 1];             //这个参数主要是处理重复按键，后面遇到再讲  
  32.     unsigned long key[BITS_TO_LONGS(KEY_CNT)]; //按键有两种状态，按下和抬起，这个字段就是记录这两个状态。  
  33.     unsigned long led[BITS_TO_LONGS(LED_CNT)];  
  34.     unsigned long snd[BITS_TO_LONGS(SND_CNT)];  
  35.     unsigned long sw[BITS_TO_LONGS(SW_CNT)];  
  36.   
  37.     int absmax[ABS_MAX + 1];           //绝对坐标的最大值  
  38.     int absmin[ABS_MAX + 1];       //绝对坐标的最小值  
  39.     int absfuzz[ABS_MAX + 1];            
  40.     int absflat[ABS_MAX + 1];            
  41.     //操作接口
  42.     int (*open)(struct input_dev *dev);  
  43.     void (*close)(struct input_dev *dev);  
  44.     int (*flush)(struct input_dev *dev, struct file *file);  
  45.     int (*event)(struct input_dev *dev, unsigned int type, unsigned int code, int value);  
  46.   
  47.     struct input_handle *grab;         //当前使用的handle  
  48.   
  49.     spinlock_t event_lock;  
  50.     struct mutex mutex;  
  51.   
  52.     unsigned int users;  
  53.     int going_away;  
  54.   
  55.     struct device dev;  
  56.   
  57.     struct list_head    h_list;    //h_list是一个链表头，用来把handle挂载在这个上  
  58.     struct list_head    node;      //这个node是用来连到input_dev_list上的  
  59. };  
  60.  // input_dev->evbit表示设备支持的事件类型，可以是下列值的组合
           #define EV_SYN           0x00  //同步事件
            #define EV_KEY           0x01 //绝对二进制值，如键盘或按钮
            #define EV_REL           0x02 //绝对结果，如鼠标设备
            #define EV_ABS           0x03 //绝对整数值，如操纵杆或书写板
            #define EV_MSC          0x04 //其它类
            #define EV_SW            0x05 //开关事件
            #define EV_LED          0x11 //LED或其它指示设备
            #define EV_SND         0x12 //声音输出，如蜂鸣器
            #define EV_REP         0x14 //允许按键自重复
            #define EV_FF             0x15 //力反馈
            #define EV_PWR        0x16 //电源管理事件
    include/linux/input.h中定义了支持的类型
  61. struct input_handler {  
  62.   
  63.     void *private;  
  64.   
  65.     void (*event)(struct input_handle *handle, unsigned int type, unsigned int code, int value);  
  66.     int (*connect)(struct input_handler *handler, struct input_dev *dev, const struct input_device_id *id);  
  67.     void (*disconnect)(struct input_handle *handle);  
  68.     void (*start)(struct input_handle *handle);  
  69.   
  70.     const struct file_operations *fops;  
  71.     int minor;                               //次设备号  
  72.     const char *name;  
  73.   
  74.     const struct input_device_id *id_table;  
  75.     const struct input_device_id *blacklist;  
  76.   
  77.     struct list_head    h_list;    //h_list是一个链表头，用来把handle挂载在这个上  
  78.     struct list_head    node;      //这个node是用来连到input_handler_list上的  
  79. };  
  80.   
  81. struct input_handle {  
  82.   
  83.     void *private;  
  84.   
  85.     int open;  
  86.     const char *name;  
  87.   
  88.     struct input_dev *dev;              //指向input_dev  
  89.     struct input_handler *handler;      //指向input_handler  
  90.   
  91.     struct list_head    d_node;     //连到input_dev的h_list上  
  92.     struct list_head    h_node;     //连到input_handler的h_list上  
  93. };  
如下图代表了input_dev，input_handler，input_handle，3者之间的关系。一类handler可以和多个硬件设备相关联，一个硬件设备可以和多个handler相关联。例如：一个触摸屏设备可以作为一个event设备，作为一个鼠标设备，也可以作为一个触摸设备，所以一个设备需要与多个平台驱动进行连接。而一个平台驱动也不只为一个设备服务，一个触摸平台驱动可能要为A,B,C3个触摸设备提供上层驱动，所以需要这样一对多的连接。


下面来看看input字符设备注册过程：

  1. static int __init input_init(void)  
  2. {  
  3.     int err;  
  4.   
  5.     input_init_abs_bypass();  
  6.     /*创建一个类input_class*/  
  7.     err = class_register(&input_class);                       
  8.     if (err) {  
  9.         printk(KERN_ERR "input: unable to register input_dev class/n");  
  10.         return err;  
  11.     }  
  12.     /*在/proc下创建入口项*/  
  13.     err = input_proc_init();  
  14.     if (err)  
  15.         goto fail1;  
  16.     /*注册设备号INPUT_MAJOR的设备，记住input子系统的设备的主设备号都是13，即INPUT_MAJOR为13，并与input_fops相关联*/  
  17.     err = register_chrdev(INPUT_MAJOR, "input", &input_fops);       
  18.     if (err) {  
  19.         printk(KERN_ERR "input: unable to register char major %d", INPUT_MAJOR);  
  20.         goto fail2;  
  21.     }  
  22.   
  23.     return 0;  
  24.   
  25.  fail2: input_proc_exit();  
  26.  fail1: class_unregister(&input_class);  
  27.     return err;  
  28. }  
  29. subsys_initcall(input_init);  
下面来看input子系统的file_operations，这里只有一个打开函数input_open_file，这个在事件传递部分讲解。
  1. static const struct file_operations input_fops = {  
  2.     .owner = THIS_MODULE,  
  3.     .open = input_open_file,  
  4. };  
下边来看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;  
  7.   
  8.     __set_bit(EV_SYN, dev->evbit);  
  9.   
  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.      */  
  14.   
  15.     init_timer(&dev->timer);  
  16.     /*  
  17.      *rep主要是处理重复按键，如果没有定义dev->rep[REP_DELAY]和dev->rep[REP_PERIOD], 
  18.      *则将其赋值为默认值。dev->rep[REP_DELAY]是指第一次按下多久算一次，这里是250ms， 
  19.      *dev->rep[REP_PERIOD]指如果按键没有被抬起，每33ms算一次。 
  20.      */  
  21.     if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD]) {  
  22.         dev->timer.data = (long) dev;  
  23.         dev->timer.function = input_repeat_key;  
  24.         dev->rep[REP_DELAY] = 250;  
  25.         dev->rep[REP_PERIOD] = 33;  
  26.     }  
  27.     /*如果dev没有定义getkeycode和setkeycode，则赋默认值。他们的作用一个是获得键的扫描码，一个是设置键的扫描码*/  
  28.     if (!dev->getkeycode)  
  29.         dev->getkeycode = input_default_getkeycode;  
  30.   
  31.     if (!dev->setkeycode)  
  32.         dev->setkeycode = input_default_setkeycode;  
  33.   
  34.     dev_set_name(&dev->dev, "input%ld",  
  35.              (unsigned long) atomic_inc_return(&input_no) - 1);  
  36.     /*将input_dev封装的dev注册到sysfs*/  
  37.     error = device_add(&dev->dev);  
  38.     if (error)  
  39.         return error;  
  40.   
  41.     path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);  
  42.     printk(KERN_INFO "input: %s as %s/n",  
  43.         dev->name ? dev->name : "Unspecified device", path ? path : "N/A");  
  44.     kfree(path);  
  45.   
  46.     error = mutex_lock_interruptible(&input_mutex);  
  47.     if (error) {  
  48.         device_del(&dev->dev);  
  49.         return error;  
  50.     }  
  51.     /*将input_dev挂在input_dev_list上*/  
  52.     list_add_tail(&dev->node, &input_dev_list);  
  53.     /*匹配所有的input_handler，这个就是刚才那幅图里的一个设备对应多个handler的由来*/  
  54.     list_for_each_entry(handler, &input_handler_list, node)  
  55.         input_attach_handler(dev, handler);  
  56.   
  57.     input_wakeup_procfs_readers();  
  58.   
  59.     mutex_unlock(&input_mutex);  
  60.   
  61.     return 0;  
  62. }  
跟踪程序，来看看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;  
  5.     /*handler有一个黑名单，如果存在黑名单，并且这个id匹配就退出*/  
  6.     if (handler->blacklist && input_match_device(handler->blacklist, dev))  
  7.         return -ENODEV;  
  8.     /*匹配id，实现在下边可以看到*/  
  9.     id = input_match_device(handler->id_table, dev);  
  10.     if (!id)  
  11.         return -ENODEV;  
  12.     /*如果匹配，则调用具体的handler的connect函数*/  
  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->dev.kobj), error);  
  19.   
  20.     return error;  
  21. }  
下边来看看这个匹配函数：如果id->flags存在，并且相应的标志为被设定则进行比较。
  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;  
  5.   
  6.     for (; id->flags || id->driver_info; id++) {  
  7.   
  8.         if (id->flags & INPUT_DEVICE_ID_MATCH_BUS)  
  9.             if (id->bustype != dev->id.bustype)  
  10.                 continue;  
  11.   
  12.         if (id->flags & INPUT_DEVICE_ID_MATCH_VENDOR)  
  13.             if (id->vendor != dev->id.vendor)  
  14.                 continue;  
  15.   
  16.         if (id->flags & INPUT_DEVICE_ID_MATCH_PRODUCT)  
  17.             if (id->product != dev->id.product)  
  18.                 continue;  
  19.   
  20.         if (id->flags & INPUT_DEVICE_ID_MATCH_VERSION)  
  21.             if (id->version != dev->id.version)  
  22.                 continue;  
  23.   
  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);  
  33.   
  34.         return id;  
  35.     }  
  36.   
  37.     return NULL;  
  38. }  
  1. #define MATCH_BIT(bit, max) /  
  2.         for (i = 0; i < BITS_TO_LONGS(max); i++) /  
  3.             if ((id->bit[i] & dev->bit[i]) != id->bit[i]) /  
  4.                 break; /  
  5.         if (i != BITS_TO_LONGS(max)) /  
  6.             continue; 
Input_dev和input_handler匹配后调用input_handler的connect。以evdev_handler为例：如果匹配上了就会创建一个evdev，它里边封装了一个handle，会把input_dev和input_handler关联到一起。
  1. /* 
  2.  * Create new evdev device. Note that input core serializes calls 
  3.  * to connect and disconnect so we don't need to lock evdev_table here. 
  4.  */  
  5. static int evdev_connect(struct input_handler *handler, struct input_dev *dev,  
  6.              const struct input_device_id *id)  
  7. {  
  8.     struct evdev *evdev;  
  9.     int minor;  
  10.     int error;  
  11.     /* 
  12.      *首先补充几个知识点： 
  13.      *static struct input_handler *input_table[8]; 
  14.      *#define INPUT_DEVICES 256 
  15.      *一共有8个input_handler，对应256个设备，所以一个handler对应32个设备。 
  16.      *这个问题在我参加的一次linux驱动的面试中被问到，当时真是汗啊！！！ 
  17.      *static struct evdev *evdev_table[EVDEV_MINORS]; 
  18.      *#define EVDEV_MINORS  32 
  19.      *evdev理论上可对应32个设备，其对应的设备节点一般位于/dev/input/event0~/dev/input/event4 
  20.      *下边的for循环，在evdev_table数组中找一个未使用的地方  
  21.      */  
  22.     for (minor = 0; minor < EVDEV_MINORS; minor++)  
  23.         if (!evdev_table[minor])  
  24.             break;  
  25.   
  26.     if (minor == EVDEV_MINORS) {  
  27.         printk(KERN_ERR "evdev: no more free evdev devices/n");  
  28.         return -ENFILE;  
  29.     }  
  30.     /*下边的代码是为每一个匹配的设备分配一个evdev结构体，并对成员进行初始化*/  
  31.     evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL);  
  32.     if (!evdev)  
  33.         return -ENOMEM;  
  34.   
  35.     INIT_LIST_HEAD(&evdev->client_list);  
  36.     spin_lock_init(&evdev->client_lock);  
  37.     mutex_init(&evdev->mutex);  
  38.     init_waitqueue_head(&evdev->wait);  
  39.   
  40.     snprintf(evdev->name, sizeof(evdev->name), "event%d", minor);  
  41.     evdev->exist = 1;  
  42.     evdev->minor = minor;  
  43.   
  44.     evdev->handle.dev = input_get_device(dev);  
  45.     evdev->handle.name = evdev->name;  
  46.     evdev->handle.handler = handler;  
  47.     evdev->handle.private = evdev;  
  48.   
  49.     dev_set_name(&evdev->dev, evdev->name);  
  50.     evdev->dev.devt = MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor);  
  51.     evdev->dev.class = &input_class; /*调用函数创建字符设备节点*/   
  52.     evdev->dev.parent = &dev->dev;  
  53.     evdev->dev.release = evdev_free;  
  54.     /**/  
  55.     device_initialize(&evdev->dev);  
  56.     /* 
  57.          *input_register_handle完成的主要功能是: 
  58.          *list_add_tail_rcu(&handle->d_node, &dev->h_list); 
  59.      *list_add_tail(&handle->h_node, &handler->h_list); 
  60.      */  
  61.     error = input_register_handle(&evdev->handle);  
  62.     if (error)  
  63.         goto err_free_evdev;  
  64.     /*evdev_install_chrdev完成的功能是evdev_table[evdev->minor]=evdev;*/  
  65.     error = evdev_install_chrdev(evdev);  
  66.     if (error)  
  67.         goto err_unregister_handle;  
  68.   
  69.     error = device_add(&evdev->dev);  
  70.     if (error)  
  71.         goto err_cleanup_evdev;  
  72.   
  73.     return 0;  
  74.     。。。。。。。。。。  
  75. }  
input子系统最重要的部分就是向上层report了。这里还是先介绍几个数据结构：
  1. struct input_event {  
  2.     struct timeval time;  //事件发生的时间  
  3.     __u16 type;           //事件类型  
  4.     __u16 code;           //子事件  
  5.     __s32 value;          //事件的value  
  6. };  

  1. struct evdev_client {  
  2.     struct input_event buffer[EVDEV_BUFFER_SIZE];        //可以同时管理EVDEV_BUFFER_SIZE(64)个事件  
  3.     int head;                                            //存储事件从head开始  
  4.     int tail;                                            //取出事件从tail开始  
  5.     spinlock_t buffer_lock; /* protects access to buffer, head and tail */     
  6.     struct fasync_struct *fasync;                        //异步通知事件发生  
  7.     struct evdev *evdev;                                 //指向本evdev_client归属的evdev  
  8.     struct list_head node;                               //用于挂载到evdev的链表头client_list上  
  9. };  

  1. static struct input_handler evdev_handler = {  
  2.     .event      = evdev_event,  //向系统报告input事件，系统通过read方法读取
  3.     .connect    = evdev_connect,   //和input_dev匹配后调用connect构建
  4.     .disconnect = evdev_disconnect,  
  5.     .fops       = &evdev_fops, //event设备文件的操作方法 
  6.     .minor      = EVDEV_MINOR_BASE,//次设备号基准值  
  7.     .name       = "evdev",  
  8.     .id_table   = evdev_ids,  //匹配规则 
  9. };  
这里的次设备号是EVDEV_MINOR_BASE(64)，也就是说evdev_handler所表示的设备文件范围(13,64)~(13,64+32)。
如下一个结构体:evdev_handler匹配所有设备。
  1. static const struct input_device_id evdev_ids[] = {  
  2.     { .driver_info = 1 },   /* Matches all devices */  
  3.     { },            /* Terminating zero entry */  
  4. };  
看一下这张图会对上边的结构有清楚的认知了：

这个是evdev_handler是fops，下面的讲解中会用到其中的open,read函数。
  1. static const struct file_operations evdev_fops = {  
  2.     .owner      = THIS_MODULE,  
  3.     .read       = evdev_read,  
  4.     .write      = evdev_write,  
  5.     .poll       = evdev_poll,  
  6.     .open       = evdev_open,  
  7.     .release    = evdev_release,  
  8.     .unlocked_ioctl = evdev_ioctl,  
  9. #ifdef CONFIG_COMPAT  
  10.     .compat_ioctl   = evdev_ioctl_compat,  
  11. #endif  
  12.     .fasync     = evdev_fasync,  
  13.     .flush      = evdev_flush  
  14. };  
在驱动程序中我们会调用input_report_abs等函数：

设备驱动通过宏set_bit()告诉input子系统它支持哪些事件，如下所示
set_bit(EV_KEY, input_dev->keybit); //EV_KEY事件支持的事件码
struct input_dev中有两个成员，一个是unsigned long evbit，一个是unsigned long keybit，分别用来表示设备所支持的事件类型和按键类型。 

用于报告EV_KEY、EV_REL、EV_ABS、EV_FF、EV_SW等事件的函数有：

        void input_report_key(struct input_dev *dev, unsigned int code, int value)
        void input_report_rel(struct input_dev *dev, unsigned int code, int value)
        void input_report_abs(struct input_dev *dev, unsigned int code, int value)
         void input_report_ff_status(struct input_dev *dev, unsigned int code, int value)

        void input_report_switch(struct input_dev *dev, unsigned int code, int value)     

如果你觉得麻烦，你也可以只记住1个函数（因为上述函数都是通过它实现的）

void input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)

相关参数介绍：
code：
事件的代码。如果事件的类型是EV_KEY,该代码code为设备键盘代码。代码值0-127为键盘上的按键代码，0x110-0x116为鼠标上按键代码，其中0x110(BTN_LEFT)为鼠标左键，0x111(BTN_RIGHT)为鼠标右键，0x112(BTN_MIDDLE)为鼠标中键。其它代码含义请参看include/linux/input.h文件。

value：
事件的值。如果事件的类型是EV_KEY，当按键按下时值为1,松开时值为0.

事件报告完毕后，设备驱动需要使用input_sync函数告诉输入子系统一个完整的报告已经发送。
void input_sync(struct input_dev *dev)
{
      input_event(dev,EV_SYN,SYN_REPORT,0);
}
这一点在鼠标移动处理中很重要，因为鼠标坐标的X分量和Y分量是分开传送的，需要利用input_sync函数来同步。
跟踪input_event如下：
  1. void input_event(struct input_dev *dev,  
  2.          unsigned int type, unsigned int code, int value)  
  3. {  
  4.     unsigned long flags;  
  5.   
  6.     if (is_event_supported(type, dev->evbit, EV_MAX)) {  
  7.   
  8.         spin_lock_irqsave(&dev->event_lock, flags);  
  9.         /*利用输入值调正随机数产生器*/  
  10.         add_input_randomness(type, code, value);  
  11.         input_handle_event(dev, type, code, value);  
  12.         spin_unlock_irqrestore(&dev->event_lock, flags);  
  13.     }  
  14. }  
跟踪input_handle_event如下：
  1. static void input_handle_event(struct input_dev *dev,  
  2.                    unsigned int type, unsigned int code, int value)  
  3. {  
  4.     int disposition = INPUT_IGNORE_EVENT;  
  5.   
  6.     switch (type) {  
  7.     。。。。。。。。。。。。。。。。  
  8.     if (disposition != INPUT_IGNORE_EVENT && type != EV_SYN)  
  9.         dev->sync = 0;  
  10.   
  11.     if ((disposition & INPUT_PASS_TO_DEVICE) && dev->event)  
  12.         dev->event(dev, type, code, value);  
  13.   
  14.     if (disposition & INPUT_PASS_TO_HANDLERS)  
  15.         input_pass_event(dev, type, code, value);  
  16. }  
如果该事件需要input device来完成，就会将disposition设置成INPUT_PASS_TO_DEVICE，如果需要input handler来完成，就会将disposition设置成INPUT_PASS_TO_DEVICE，如果需要两者都参与，则将disposition设置成INPUT_PASS_TO_ALL。
跟踪input_pass_event如下：
  1. static void input_pass_event(struct input_dev *dev,  
  2.                  unsigned int type, unsigned int code, int value)  
  3. {  
  4.     struct input_handle *handle;  
  5.   
  6.     rcu_read_lock();  
  7.     /**/  
  8.     handle = rcu_dereference(dev->grab);  
  9.     if (handle)  
  10.         /*如果input_dev的grab指向了一个handle，就用这个handle关联的handler的event，否则遍历整个挂在input_dev的h_list上的handle关联的handler*/  
  11.         handle->handler->event(handle, type, code, value);  
  12.     else  
  13.         list_for_each_entry_rcu(handle, &dev->h_list, d_node)  
  14.             if (handle->open)  
  15.                 handle->handler->event(handle,  
  16.                             type, code, value);  
  17.     rcu_read_unlock();  
  18. }  
比如下边的evdev_handler的evdev_event：
  1. static void evdev_event(struct input_handle *handle,  
  2.             unsigned int type, unsigned int code, int value)  
  3. {  
  4.     struct evdev *evdev = handle->private;  
  5.     struct evdev_client *client;  
  6.     struct input_event event;  
  7.   
  8.     do_gettimeofday(&event.time);  
  9.     event.type = type;  
  10.     event.code = code;  
  11.     event.value = value;  
  12.   
  13.     rcu_read_lock();  
  14.     client = rcu_dereference(evdev->grab);  
  15.     if (client)  
  16.     /*如果evdev->grab指向一个当前使用的client就将event放到这个client的buffer中，否则放到整个client_list上的client的链表中*/  
  17.         evdev_pass_event(client, &event);  
  18.     else  
  19.         list_for_each_entry_rcu(client, &evdev->client_list, node)  
  20.             evdev_pass_event(client, &event);  
  21.   
  22.     rcu_read_unlock();  
  23.   
  24.     wake_up_interruptible(&evdev->wait);  
  25. }  
  1. static void evdev_pass_event(struct evdev_client *client,  
  2.                  struct input_event *event)  
  3. {  
  4.     /* 
  5.      * Interrupts are disabled, just acquire the lock 
  6.      */  
  7.     spin_lock(&client->buffer_lock);  
  8.     /*将event装入client的buffer中，buffer是一个环形缓存区*/  
  9.     client->buffer[client->head++] = *event;  
  10.     client->head &= EVDEV_BUFFER_SIZE - 1;  
  11.     spin_unlock(&client->buffer_lock);  
  12.   
  13.     kill_fasync(&client->fasync, SIGIO, POLL_IN);  
  14. }  

这里总结一下事件的传递过程：首先在驱动层中，调用inport_report_abs，然后他调用了input core层的input_event，input_event调用了input_handle_event对事件进行分派，调用input_pass_event，在这里他会把事件传递给具体的handler层，然后在相应handler的event处理函数中，封装一个event，然后把它投入evdev的那个client_list上的client的事件buffer中，等待用户空间来读取。

当用户空间打开设备节点/dev/input/event0~/dev/input/event4的时候，会使用input_fops中的input_open_file()函数，input_open_file()->evdev_open()(如果handler是evdev的话)->evdev_open_device()->input_open_device()->dev->open()。也就是struct file_operations input_fops提供了通用接口，最终会调用具体input_dev的open函数。下边看一下用户程序打开文件时的过程，首先调用了input_open_file:

  1. static int input_open_file(struct inode *inode, struct file *file)  
  2. {  
  3.     struct input_handler *handler;  
  4.     const struct file_operations *old_fops, *new_fops = NULL;  
  5.     int err;  
  6.   
  7.     lock_kernel();  
  8.     /* No load-on-demand here? */  
  9.     /*因为32个input_dev公共一个handler所以低5位应该是相同的*/  
  10.     handler = input_table[iminor(inode) >> 5];  
  11.     if (!handler || !(new_fops = fops_get(handler->fops))) {  
  12.         err = -ENODEV;  
  13.         goto out;  
  14.     }  
  15.   
  16.     /* 
  17.      * That's _really_ odd. Usually NULL ->open means "nothing special", 
  18.      * not "no device". Oh, well... 
  19.      */  
  20.     if (!new_fops->open) {  
  21.         fops_put(new_fops);  
  22.         err = -ENODEV;  
  23.         goto out;  
  24.     }  
  25.     /*保存以前的fops，使用相应的handler的fops*/  
  26.     old_fops = file->f_op;  
  27.     file->f_op = new_fops;  
  28.   
  29.     err = new_fops->open(inode, file);  
  30.   
  31.     if (err) {  
  32.         fops_put(file->f_op);  
  33.         file->f_op = fops_get(old_fops);  
  34.     }  
  35.     fops_put(old_fops);  
  36. out:  
  37.     unlock_kernel();  
  38.     return err;  
  39. }  

这里还是假设handler是evdev_handler。
  1. static int evdev_open(struct inode *inode, struct file *file)  
  2. {  
  3.     struct evdev *evdev;  
  4.     struct evdev_client *client;  
  5.     /*因为次设备号是从EVDEV_MINOR_BASE开始的*/  
  6.     int i = iminor(inode) - EVDEV_MINOR_BASE;  
  7.     int error;  
  8.       
  9.     if (i >= EVDEV_MINORS)  
  10.         return -ENODEV;  
  11.   
  12.     error = mutex_lock_interruptible(&evdev_table_mutex);  
  13.     if (error)  
  14.         return error;  
  15.     /*evdev_table一共可容纳32个成员，找到次设备号对应的那个*/  
  16.     evdev = evdev_table[i];  
  17.     if (evdev)  
  18.         get_device(&evdev->dev);  
  19.     mutex_unlock(&evdev_table_mutex);  
  20.   
  21.     if (!evdev)  
  22.         return -ENODEV;  
  23.     /*打开的时候创建一个client*/  
  24.     client = kzalloc(sizeof(struct evdev_client), GFP_KERNEL);  
  25.     if (!client) {  
  26.         error = -ENOMEM;  
  27.         goto err_put_evdev;  
  28.     }  
  29.   
  30.     spin_lock_init(&client->buffer_lock);  
  31.     /*下边两句的作用就是将evdev和client绑定到一起*/  
  32.     client->evdev = evdev;  
  33.     evdev_attach_client(evdev, client);  
  34.   
  35.     error = evdev_open_device(evdev);  
  36.     if (error)  
  37.         goto err_free_client;  
  38.     /*将file->private_data指向刚刚建的client，后边会用到的*/  
  39.     file->private_data = client;  
  40.     return 0;  
  41.   
  42.  err_free_client:  
  43.     evdev_detach_client(evdev, client);  
  44.     kfree(client);  
  45.  err_put_evdev:  
  46.     put_device(&evdev->dev);  
  47.     return error;  
  48. }  

  1. static int evdev_open_device(struct evdev *evdev)  
  2. {  
  3.     int retval;  
  4.   
  5.     retval = mutex_lock_interruptible(&evdev->mutex);  
  6.     if (retval)  
  7.         return retval;  
  8.     /*如果设备不存在，返回错误*/  
  9.     if (!evdev->exist)  
  10.         retval = -ENODEV;  
  11.     /*如果是被第一次打开，则调用input_open_device*/  
  12.     else if (!evdev->open++) {  
  13.         retval = input_open_device(&evdev->handle);  
  14.         if (retval)  
  15.             evdev->open--;  
  16.     }  
  17.   
  18.     mutex_unlock(&evdev->mutex);  
  19.     return retval;  
  20. }  

  1. int input_open_device(struct input_handle *handle)  
  2. {  
  3.     struct input_dev *dev = handle->dev;  
  4.     int retval;  
  5.   
  6.     retval = mutex_lock_interruptible(&dev->mutex);  
  7.     if (retval)  
  8.         return retval;  
  9.   
  10.     if (dev->going_away) {  
  11.         retval = -ENODEV;  
  12.         goto out;  
  13.     }  
  14.   
  15.     handle->open++;  
  16.   
  17.     if (!dev->users++ && dev->open)  
  18.         retval = dev->open(dev);  
  19.   
  20.     if (retval) {  
  21.         dev->users--;  
  22.         if (!--handle->open) {  
  23.             /* 
  24.              * Make sure we are not delivering any more events 
  25.              * through this handle 
  26.              */  
  27.             synchronize_rcu();  
  28.         }  
  29.     }  
  30.   
  31.  out:  
  32.     mutex_unlock(&dev->mutex);  
  33.     return retval;  
  34. }  
下面是用户进程读取event的底层实现：
  1. static ssize_t evdev_read(struct file *file, char __user *buffer,  
  2.               size_t count, loff_t *ppos)  
  3. {  
  4.     /*这个就是刚才在open函数中*/  
  5.     struct evdev_client *client = file->private_data;  
  6.     struct evdev *evdev = client->evdev;  
  7.     struct input_event event;  
  8.     int retval;  
  9.   
  10.     if (count < input_event_size())  
  11.         return -EINVAL;  
  12.     /*如果client的环形缓冲区中没有数据并且是非阻塞的，那么返回-EAGAIN，也就是try again*/  
  13.     if (client->head == client->tail && evdev->exist &&  
  14.         (file->f_flags & O_NONBLOCK))  
  15.         return -EAGAIN;  
  16.     /*如果没有数据，并且是阻塞的，则在等待队列上等待吧*/  
  17.     retval = wait_event_interruptible(evdev->wait,  
  18.         client->head != client->tail || !evdev->exist);  
  19.     if (retval)  
  20.         return retval;  
  21.   
  22.     if (!evdev->exist)  
  23.         return -ENODEV;  
  24.     /*如果获得了数据则取出来，调用evdev_fetch_next_event*/  
  25.     while (retval + input_event_size() <= count &&  
  26.            evdev_fetch_next_event(client, &event)) {  
  27.         /*input_event_to_user调用copy_to_user传入用户程序中，这样读取完成*/  
  28.         if (input_event_to_user(buffer + retval, &event))  
  29.             return -EFAULT;  
  30.   
  31.         retval += input_event_size();  
  32.     }  
  33.   
  34.     return retval;  
  35. }  

  1. static int evdev_fetch_next_event(struct evdev_client *client,  
  2.                   struct input_event *event)  
  3. {  
  4.     int have_event;  
  5.   
  6.     spin_lock_irq(&client->buffer_lock);  
  7.     /*先判断一下是否有数据*/  
  8.     have_event = client->head != client->tail;  
  9.     /*如果有就从环形缓冲区的取出来，记得是从head存储，tail取出*/  
  10.     if (have_event) {  
  11.         *event = client->buffer[client->tail++];  
  12.         client->tail &= EVDEV_BUFFER_SIZE - 1;  
  13.     }  
  14.   
  15.     spin_unlock_irq(&client->buffer_lock);  
  16.   
  17.     return have_event;  
  18. }  

  1. int input_event_to_user(char __user *buffer,  
  2.             const struct input_event *event)  
  3. {  
  4.     /*如果设置了标志INPUT_COMPAT_TEST就将事件event包装成结构体compat_event*/  
  5.     if (INPUT_COMPAT_TEST) {  
  6.         struct input_event_compat compat_event;  
  7.   
  8.         compat_event.time.tv_sec = event->time.tv_sec;  
  9.         compat_event.time.tv_usec = event->time.tv_usec;  
  10.         compat_event.type = event->type;  
  11.         compat_event.code = event->code;  
  12.         compat_event.value = event->value;  
  13.         /*将包装成的compat_event拷贝到用户空间*/  
  14.         if (copy_to_user(buffer, &compat_event,  
  15.                  sizeof(struct input_event_compat)))  
  16.             return -EFAULT;  
  17.   
  18.     } else {  
  19.         /*否则，将event拷贝到用户空间*/  
  20.         if (copy_to_user(buffer, event, sizeof(struct input_event)))  
  21.             return -EFAULT;  
  22.     }  
  23.   
  24.     return 0;  
  25. }  
这里总结一下：如果两个进程打开同一个文件，每个进程在打开时都会生成一个evdev_client，evdev_client被挂在evdev的client_list，在handle收到一个事件的时候，会把事件copy到挂在client_list上的所有evdev_client的buffer中。这样所有打开同一个设备的进程都会收到这个消息而唤醒。
阅读(448) | 评论(0) | 转发(0) |
0

上一篇：linux内核input子系统解析（转）

下一篇：内核启动参数机制学习笔记

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

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

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

16024965号-6