Linux 输入子系统input分析

分析input.c

input_init

input_init(void)
	//注册一个class
	err = class_register(&input_class);
	//在/proc项下创建input子项
	err = input_proc_init();
		proc_bus_input_dir = proc_mkdir("input", proc_bus);
		//在input项下创建devices和handlers子项，并设置相应的操作
        //input_devices_fileops，input_handlers_fileops
		//提供目录的读写如cat /proc/input/devices
		struct proc_dir_entry *entry = create_proc_entry("devices", 0, proc_bus_input_dir);
		entry->owner = THIS_MODULE;
		entry->proc_fops = &input_devices_fileops;
		entry = create_proc_entry("handlers", 0, proc_bus_input_dir);
		entry->owner = THIS_MODULE;
		entry->proc_fops = &input_handlers_fileops;
	
	//注册字符设备主设备号为13
	err = register_chrdev(INPUT_MAJOR, "input", &input_fops);

input_fops结构只实现了.open操作	
static const struct file_operations input_fops = {
	.owner = THIS_MODULE,
	.open = input_open_file,
};

open操作的实现

 

input_open_file
	//从数组中得到一个input_handler类型的变量
	struct input_handler *handler = input_table[iminor(inode) >> 5];
	const struct file_operations *old_fops, *new_fops = NULL;
	//从handler变量中得到了一个fops，
	if (!handler || !(new_fops = fops_get(handler->fops)))
	//保存原来的fops，将新的到fops赋值文件操作
	old_fops = file->f_op;
	file->f_op = new_fops;
	//用新的fops打开
	err = new_fops->open(inode, file);

查看数组input_table是怎么赋值的：static 只在input.c文件中使用
static struct input_handler *input_table[8];
input_register_handler和input_unregister_handler函数中对其进行了赋值和删除操作。

在外部通过input_register_handler给input注册一个handler

input_handler注册
input_register_handler(struct input_handler *handler)
	//初始化handler里的链表
	INIT_LIST_HEAD(&handler->h_list);
	//将handler放到数组中
	input_table[handler->minor >> 5] = handler;
	//将handler添加到保存input_handler的链表input_handler_list中
	//static LIST_HEAD(input_handler_list);
	list_add_tail(&handler->node, &input_handler_list);

	//遍历保存input_dev链表中所有的input_dev，看是能够跟这个handler匹配上
	//static LIST_HEAD(input_dev_list);
	list_for_each_entry(dev, &input_dev_list, node)
		input_attach_handler(dev, handler);

input_dev设备注册		
input_register_device(struct input_dev *dev)
	//将dev添加到保存input_dev的链表input_dev_list中
	list_add_tail(&dev->node, &input_dev_list);
	
	//遍历保存input_handler链表input_handler_list中所有的handler，看是否能够跟这个dev匹配上
	//static LIST_HEAD(input_handler_list);
	list_for_each_entry(handler, &input_handler_list, node)
		input_attach_handler(dev, handler);

检测input_dev和input_handler是否匹配

input_attach_handler(struct input_dev *dev, struct input_handler *handler)
	id = input_match_device(handler->id_table, dev);
	//匹配成功调用input_handler的connect函数做进一步的处理
	error = handler->connect(handler, dev, id);

注册input_dev或input_handler时，会两两比较input_dev_list和input_handler_list,
根据input_handler的id_table判断这个input_handler能否支持这个input_dev，
如果能支持，则调用input_handler的connect函数建立"连接"

怎么建立连接？
1. 分配一个input_handle结构体
2. 
    input_handle.dev = input_dev;  // 指向左边的input_dev
    input_handle.handler = input_handler;  // 指向右边的input_handler
3. 注册：
   input_handler->h_list = &input_handle;
   inpu_dev->h_list      = &input_handle;

以evdev_connect为例/drivers/input/evdev.c
evdev_connect(struct input_handler *handler, struct input_dev *dev, const struct input_device_id *id)
	...
	evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL);

	evdev->handle.dev = dev;
	evdev->handle.name = evdev->name;
	evdev->handle.handler = handler;
	evdev->handle.private = evdev;
	
	error = input_register_handle(&evdev->handle);

input_handle注册

input_register_handle(struct input_handle *handle)
	struct input_handler *handler = handle->handler;
	//将handle添加到input_handler和input_dev的h_list链表中
	list_add_tail(&handle->d_node, &handle->dev->h_list);
	list_add_tail(&handle->h_node, &handler->h_list);

怎么读按键？

app: read
--------------------------
   .......
   		evdev_read
   			// 无数据并且是非阻塞方式打开，则立刻返回
			if (client->head == client->tail && evdev->exist && (file->f_flags & O_NONBLOCK))
				return -EAGAIN;
			
			// 否则休眠
			retval = wait_event_interruptible(evdev->wait,
				client->head != client->tail || !evdev->exist);

谁来唤醒？

evdev_event
	wake_up_interruptible(&evdev->wait);

evdev_event被谁调用？
猜：应该是硬件相关的代码，input_dev那层调用的
在设备的中断服务程序里，确定事件是什么，然后调用相应的input_handler的event处理函数

gpio_keys_isr
	// 上报事件
	input_event(input, type, button->code, !!state);
	input_sync(input);

input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
	struct input_handle *handle;

	list_for_each_entry(handle, &dev->h_list, d_node)
		if (handle->open)
			handle->handler->event(handle, type, code, value);

struct input_dev {

	void *private;

	const char *name;
	const char *phys;
	const char *uniq;
	struct input_id id;

	unsigned long evbit[NBITS(EV_MAX)];
	unsigned long keybit[NBITS(KEY_MAX)];
	unsigned long relbit[NBITS(REL_MAX)];
	unsigned long absbit[NBITS(ABS_MAX)];
	unsigned long mscbit[NBITS(MSC_MAX)];
	unsigned long ledbit[NBITS(LED_MAX)];
	unsigned long sndbit[NBITS(SND_MAX)];
	unsigned long ffbit[NBITS(FF_MAX)];
	unsigned long swbit[NBITS(SW_MAX)];

	unsigned int keycodemax;
	unsigned int keycodesize;
	void *keycode;
	int (*setkeycode)(struct input_dev *dev, int scancode, int keycode);
	int (*getkeycode)(struct input_dev *dev, int scancode, int *keycode);

	struct ff_device *ff;

	unsigned int repeat_key;
	struct timer_list timer;

	int state;

	int sync;

	int abs[ABS_MAX + 1];
	int rep[REP_MAX + 1];

	unsigned long key[NBITS(KEY_MAX)];
	unsigned long led[NBITS(LED_MAX)];
	unsigned long snd[NBITS(SND_MAX)];
	unsigned long sw[NBITS(SW_MAX)];

	int absmax[ABS_MAX + 1];
	int absmin[ABS_MAX + 1];
	int absfuzz[ABS_MAX + 1];
	int absflat[ABS_MAX + 1];

	int (*open)(struct input_dev *dev);
	void (*close)(struct input_dev *dev);
	int (*flush)(struct input_dev *dev, struct file *file);
	int (*event)(struct input_dev*dev,unsigned int type,unsigned int code,int value);

	struct input_handle *grab;

	struct mutex mutex;	/* serializes open and close operations */
	unsigned int users;

	struct class_device cdev;
	union {			/* temporarily so while we switching to struct device */
		struct device *parent;
	} dev;

	struct list_head	h_list;	//保存到匹配成功后的input_handle链表
	struct list_head	node;	//将input_dev放入到input_dev_list
};

struct input_handler {

	void *private;

	void (*event)(struct input_handle *handle, unsigned int type, unsigned int code, int value);
	int (*connect)(struct input_handler *handler, struct input_dev *dev, const struct input_device_id *id);
	void (*disconnect)(struct input_handle *handle);
	void (*start)(struct input_handle *handle);

	const struct file_operations *fops;
	int minor;
	const char *name;

	const struct input_device_id *id_table;
	const struct input_device_id *blacklist;

	struct list_head	h_list;	//保存到匹配成功后的input_handle链表
	struct list_head	node;	//将input_handler放入到input_handler_list
};

struct input_handle {

	void *private;

	int open;
	const char *name;

	struct input_dev *dev;			//保存匹配后的input_dev
	struct input_handler *handler;	//保存匹配后的input_handler

	struct list_head	d_node;	//将input_handle放入到dev的h_list中
	struct list_head	h_node;	//将input_handle放入到handler的h_list中
};