输入子系统流程分析

一个驱动设备对应多个驱动程序
dev层负责写与硬件相关的驱动程序，中断函数，事件上报等；handler层负责构造file_operations结构体，创建handle。
Input层是中转层，接口层，dev层需要向input层注册input_dev，handler层需要向input层注册input_handler和input_handle，input层有很多功能函数，把dev层和handler层链接起来。

 
【核心层】
//input作为模块，安装该模块时会执行input_init
subsys_initcall(input_init);   

static int __init input_init(void)
	class_register(&input_class);   // 类创建—类名input
	input_proc_init(); 		        // 在/proc下面建立相关文件 
	register_chrdev(INPUT_MAJOR, "input", &input_fops);  // 注册字符设备proc/devices，主设备号13，次设备号从64开始
		
static const  struct  file_operations  input_fops = {
	.owner = THIS_MODULE,
	.open = input_open_file, };  



【输入事件驱动】
// subsys_initcall比module_init优先级高，所以先执行input_init，再执行evdev_init
**module_init(evdev_init);**	

**static int __init evdev_init(void)**
	input_register_handler(&evdev_handler);	

**static struct input_handler evdev_handler = {**
	.event =	evdev_event,	       // 事件发生时会调用
	.connect =	evdev_connect,	       // 当input_dev和evdev_handler匹配成功时调用
	.disconnect =	evdev_disconnect,
	.fops =		&evdev_fops,           // file_operations结构体
	.minor =	EVDEV_MINOR_BASE,      // 次设备号最小值64，其他类型的输入设备比如mousedev.c的次设备号最小值为32
	.name =		"evdev",  	           // 设备名称evdev – 实际注册设备时给设备命名为evdev0，evdev1...
	.id_table =	evdev_ids,             // 和input_dev的id比较，匹配则说明evdev_handler能支持这个设备
};



**int input_register_handler(struct input_handler *handler)**
	INIT_LIST_HEAD(&handler->h_list);	          // 该节点会被用于存放到handle->h_node
	input_table[handler->minor >> 5] = handler;   // 将evdev_handler存入到input_table[2]
	list_add_tail(&handler->node, &input_handler_list); 
	
	list_for_each_entry(dev, &input_dev_list, node)    //根据成员node依次从input_dev_list链表找出所有struct input_dev结构体
		input_attach_handler(dev, handler);		       //id匹配
		


**input_attach_handler(struct input_dev *dev, struct input_handler *handler)**
	id = input_match_device(handler->id_table, dev);   //匹配两者id
		error = handler->connect(handler, dev, id);	   // 匹配成功则调用
	//匹配失败接着匹配下一个input_dev




**evdev_connect(struct input_handler *handler, struct input_dev *dev,const struct input_device_id *id)**
	// 找到一个还没有用过的minor就退出for循环
	for (minor = 0; minor < EVDEV_MINORS && evdev_table[minor]; minor++);    //evdev_table[minor]=0，说明该minor还没有被使用
	
	evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL);
	INIT_LIST_HEAD(&evdev->client_list);	// 该节点在evdev_open()中使用到
	init_waitqueue_head(&evdev->wait);	    // 该队列头在read函数中休眠，在event函数中唤醒；
	
	evdev->exist = 1;			            // 存在标志；
	evdev->handle.dev = dev;		
	evdev->handle.handler = handler;  
	evdev->handle.name = evdev->name;		
	evdev->handle.private = evdev;
	
	sprintf(evdev->name, "event%d", minor);   //evdev->name = event‘minor’
	evdev_table[minor] = evdev;			   
	
	devt = MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor);   //次设备号64+minor
	class_device_create(&input_class, &dev->cdev, devt,dev->cdev.dev, evdev->name);
	input_register_handle(&evdev->handle);         //handle结构体存储了input_dev和input_handler的信息


**input_register_handle(&evdev->handle)**
	list_add_tail(&handle->d_node, &handle->dev->h_list);
	list_add_tail(&handle->h_node, &handler->h_list);
	结束该函数后返回到list_for_each_entry()这个for循环，继续匹配




**分析gpio_keys.c驱动程序**
**module_init(gpio_keys_init)**
**gpio_keys_init(void)**
	platform_driver_register(&gpio_keys_device_driver);	   //注册设备驱动
	
**struct platform_driver gpio_keys_device_driver = {**
	.probe		= gpio_keys_probe,
	.remove		= __devexit_p(gpio_keys_remove),
	.driver		= {
		.name	= "gpio-keys",
	}
};


**gpio_keys_probe(struct platform_device *pdev)**
	struct input_dev *input;  	
	input = input_allocate_device();	
	input->evbit[0] = BIT(EV_KEY);	 
	input->name = pdev->name;		 
	request_irq()	
	input_register_device(input);	
	


**input_register_device(struct input_dev *dev)**
	set_bit(EV_SYN, dev->evbit);	// 设置为同步事件
	init_timer(&dev->timer);		
	list_add_tail(&dev->node, &input_dev_list);	
	list_for_each_entry(handler, &input_handler_list, node)
		input_attach_handler(dev, handler);	



**驱动层在中断处理函数中通过input_event()发送事件到input层
经input层中转后调用evdev_handler->event()
static irqreturn_t gpio_keys_isr(int irq, void *dev_id)  //中断处理函数**
	gpio_get_value();	                                 // 进入中断处理函数后,获得I/O电平
	input_event(input, type, button->code, !!state);	
	input_sync(input);                        


**input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)**
	switch (type) 
		...
		case EV_KEY:
		...
		
	list_for_each_entry(handle, &dev->h_list, d_node)  
		if (handle->open)   //如果evdev_handler->open=1,表示设备已经打开数据可以传递
			handle->handler->event(handle, type, code, value);  
.

**evdev_event(struct input_handle *handle, unsigned int type, unsigned int code, int value)**
	struct evdev_client *client;	        //将数据放到环形缓冲区
	wake_up_interruptible(&evdev->wait);	//唤醒
	kill_fasync(&client->fasync, SIGIO, POLL_IN);	// 发送数据给进程,进程接收到数据后跳转到read函数；



**evdev_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)**
	//从这里被唤醒
	retval=wait_event_interruptible(evdev->wait,client->head!=client->tail || !evdev->exist);    
	// 开始发送数据发送