linux 输入设备驱动

 c:输入子系统的事件处理机制示意图

 

dev->absmax[axis] = max;      

dev->absfuzz[axis] = fuzz;      

dev->absflat[axis] = flat;        

dev->absbit[BIT_WORD(axis)] |= BIT_MASK(axis);  //填充了absbit这个数组  

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

int open;        //打开标志，每个input_handle 打开后才能操作，这个一般通过事件处理器的open方法间接设置      

const char *name;       

struct input_dev *dev;  //关联的input_dev结构      

struct input_handler *handler; //关联的input_handler结构      

struct list_head    d_node;  //input_handle通过d_node连接到了input_dev上的h_list链表上     struct list_head    h_node;  //input_handle通过h_node连接到了input_handler的h_list链表上 

int exist;      

int open;           //打开标志      

int minor;          //次设备号      

struct input_handle handle;  //关联的input_handle      

wait_queue_head_t wait;      //等待队列，当进程读取设备，而没有事件产生的时候，进程就会睡在其上面      

struct evdev_client *grab;   //强制绑定的evdev_client结构，这个结构后面再分析      

struct list_head client_list;  //evdev_client 链表，这说明一个evdev设备可以处理多个evdev_client，可以有多个进程访问evdev设备      

spinlock_t client_lock; /* protects client_list */      

struct mutex mutex;      

struct device dev;       //device结构，说明这是一个设备结构  

struct input_event buffer[EVDEV_BUFFER_SIZE];            //这个是一个input_event数据结构的数组，input_event代表一个事件，基本成员：类型（type），编码（code），值（value） 

int head;              //针对buffer数组的索引      

int tail;              //针对buffer数组的索引，当head与tail相等的时候，说明没有事件 spinlock_t buffer_lock; /* protects access to buffer, head and tail */      

struct fasync_struct *fasync;  //异步通知函数      

struct evdev *evdev;           //evdev设备      

struct list_head node;         // evdev_client 链表项  

};  

　　这个结构在进程打开event0设备的时候调用evdev的open方法，在open中创建这个结构，并初始化。在关闭设备文件的时候释放这个结构。

H:各数据结构之间的关系

 

 

b:代码分析

 

b-2:函数input_register_device()

input_register_device()函数是输入子系统核心（input_core）提供的函数，用来将input_device注册进入输入子系统核心。

b-2-3:第"21"使用device_add()将内嵌的在input_dev中的device注册到Linux的设备管理模型中

b-2-5-1:第"3"行定义了input_device_id指针，该结构体在内核中的定义如下：

b-2-5-2:第"5"行首先判断handler->blacklist是否被赋值（blacklist是一个input_device_id类型的指针，其中存放了handler应该忽略的设备）

总结：input_reigister_dev()函数的目的就是为了将输入设备加进input_handle中的设备链表中，并和在input_handle中的handler链表进行匹配，如果匹配成功就通过connect()将两者结合起来。

 

b-3：函数static inline void input_report_key(struct input_dev*dev,usigned int code,int value)

b-3-1：参数分析

b-3-2-2-1：该函数检查input_dev.evbit中相应的位是否设置，如果设置返回1,否者返回0.

b-3-2-3-1:参数分析

dev:产生事件的设备

type:产生事件的类型

code:键码

value:键值

b-3-2-3-2:主要关注"19-29"行，首先调用函数is_event_supported()函数判断是否支持该按键，如果支持，则将变量disposition设置成INPUT_PASS_TO_HANDLERS,表示事件需要交给handler来进一步处理。dispositon取值有以下几种：

b-3-2-3-3-1:第"4"行，分配一个input_handle结构指针

d-1:第"3-4"行，从handle中取出一个指向input_handler和input_dev的指针

其中就一个input_open_file函数。该函数将控制转到input_handler中定义的fops文件指针的open()函数。

b-2-1-1:第"8"行，在分析open函数之前，解释一下为什么要右移5位，这说明一个问题，次设备号的低5位被忽略，这说明evdev的最大支持的输入设备驱动个数为2^5次方等于32个，你可能会看到你的/dev目录下面有event0、event1、event2等设备，他们的次设备号分别为64、65、66等等。但最大是64+32-1，因此input_table为这些输入设备增加的一个统一接口，通过上层打开设备时，只要次设备号在64+32-1之间的设备都会重新定位到evdev_handler中，即event*设备打开后执行的底层函数将被重新定义到evdev_handler中。

相信上面的问题已经描述清楚，如果还是不明白，你最起码应该知道的是，input设备中的open函数只是一个接口，通过次设备号才找到了真正的事件处理接口。接下来要看新的open接口的实现了，evdev_handler-> fops->open实现如下：

/*evdev字符设备驱动接口 */  

static const struct file_operations evdev_fops = {  

       .owner = THIS_MODULE,  

       .read =           evdev_read,  

       .write =   evdev_write,  

       .poll =            evdev_poll,  

       .open =          evdev_open,  

       .release = evdev_release,  

       .unlocked_ioctl = evdev_ioctl,  

#ifdef CONFIG_COMPAT  

       .compat_ioctl =      evdev_ioctl_compat,  

#endif  

       .fasync = evdev_fasync,  

       .flush =   evdev_flush  

};  

/*evdev设备open函数的实现过程 */  

static int evdev_open(struct inode *inode, struct file *file)  

{  

       struct evdev_client *client;  

       struct evdev *evdev;  

       /* 如果是event0，对于evdev设备来说，次设备号当然是0 */  

       int i = iminor(inode) - EVDEV_MINOR_BASE;  

       int error;  

       /* 如果大于32，说明超出了evdev能够容纳的最大输入设备个数 */  

       if (i >= EVDEV_MINORS)  

              return -ENODEV;  

       /* 由于evdev中能容纳32个输入设备，因此通过设备号event0中的0定位到是要处理的是哪一个输入设备，evdev_table中的内容在输入设备驱动注册时通过evdev_connect填充 */  

       evdev = evdev_table[i];  

       /* 判断是否设备接口存在，evdev_exist也是在evdev_connect填充为1 */  

       if (!evdev || !evdev->exist)  

              return -ENODEV;  

       /* 存在则分配evdev中的client来处理event* */  

       client = kzalloc(sizeof(struct evdev_client),GFP_KERNEL);  

       if (!client)  

              return -ENOMEM;  

   

       /* 把event*中的接口指向evdev_table中对应项 */  

       client->evdev = evdev;  

       /* 把client->node链接到evdev子集中 */  

       list_add_tail(&client->node,&evdev->client_list);  

       /* 如果open是第一个打开，则会执行input_open_device*/  

       if (!evdev->open++ &&evdev->exist) {  

              error =input_open_device(&evdev->handle);  

              if (error) {  

                     list_del(&client->node);  

                     kfree(client);  

                     return error;  

              }  

       }  

       /* 将file私有指针指向client*/  

       file->private_data = client;  

       return 0;  

}  

由上的代码可以看出，最终是要执行input_open_device去执行设备驱动程序中的代码，然而我们在定义设备驱动的时候并没有给input_dev中的open字段填充内容，因此可以看到input_open_device函数的执行过程：  

if(!dev->users++ && dev->open)  

              err = dev->open(dev);  

   

       if (err)  

              handle->open--;

<wiz_tmp_tag id="wiz-table-range-border" contenteditable="false" style="display: none;">