输入子系统原理分析和编程方法

前提：input 核心层代码和input handler层需要在内核中必须有：
	drivers/input/evdev.c	//  event handler
	drivers/input/input.c  // 核心层

 make menuconfig
	Device Drivers  --->
	Input device support  ---> 
	-*- Generic input layer (needed for keyboard, mouse, ...)  // input.c
	 <*>   Event interface   //input handler层--evdev.c
编写步骤：
	1，分配一个input device对象
	2， 初始化input  device对象
	3，注册input device对象

struct input_dev {
	void *private;				//输入设备私有指针，一般指向用于描述设备驱动层的设备结构
	const char *name;			//提供给用户的输入设备的名称
	const char *phys;			//提供给编程者的设备节点的名称
	const char *uniq;			//指定唯一的ID号，就像MAC地址一样
	struct input_id 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;		//同步事件完成标识，为1说明事件同步完成
	int abs[ABS_MAX + 1];		//记录坐标的值
	int rep[REP_MAX + 1];		//记录重复按键的参数值
	unsigned long key[NBITS(KEY_MAX)];		//位图，按键的状态
	unsigned long led[NBITS(LED_MAX)];		//位图，led的状态
	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;		//类似私有指针，可以直接访问到事件处理接口event
	struct mutex mutex;		//用于open、close函数的连续访问互斥
	unsigned int users;		//设备使用计数
	struct class_device cdev;	//输入设备的类信息
	union {				//设备结构体
		struct device *parent;
	} dev;
	struct list_head	h_list;	//handle链表
	struct list_head	node;	//input_dev链表
};

struct input_dev *input_allocate_device(void)
{
	struct input_dev *dev;
//动态申请内存，使用GFP_KERNEL方式，注意GFP_KERNEL可能导致睡眠，不能在中断中调用这个函数
	dev = kzalloc(sizeof(struct input_dev), GFP_KERNEL);
//分配成功执行的代码，进行成员的默认填充
	if (dev) {
		dev->cdev.class = &input_class;			//支持热插拔的结构体
		dev->cdev.groups = input_dev_attr_groups; //描述设备的硬件信息和支持的事件类型
		class_device_initialize(&dev->cdev);		//类设备初始化，添加进input类设备模型中
		mutex_init(&dev->mutex);				//初始化互斥锁
		INIT_LIST_HEAD(&dev->h_list);		//初始化handle链表
		INIT_LIST_HEAD(&dev->node);			//初始化输入设备链表
	}
}

//添加设备信息--/sys/class/input/eventx/device/
inputdev->name = "simple input key";
inputdev->phys = "key/input/input0";
inputdev->uniq = "simple key0 for 4412";
inputdev->id.bustype = BUS_HOST;
input_dev->id.vendor = 0x0001;
input_dev->id.product = 0x0002;
input_dev->id.version = 0x0100;

input_dev->evbit[0] = BIT_MASK(EV_SYN) | BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH); 

input_set_abs_params(input_dev, ABS_X, X_AXIS_MIN, X_AXIS_MAX, 0, 0);
input_set_abs_params(input_dev, ABS_Y, Y_AXIS_MIN, Y_AXIS_MAX, 0, 0);
input_set_abs_params(input_dev, ABS_PRESSURE, PRESSURE_MIN, PRESSURE_MAX, 0, 0);

int input_register_device(struct input_dev *dev)
{
	/* 用于记录输入设备名称的索引值 */
	static atomic_t input_no = ATOMIC_INIT(0);
	/* 输入事件的处理接口指针，用于和设备的事件类型进行匹配 */
	struct input_handler *handler;
	const char *path;
	int error;
 
	/* 默认所有的输入设备都支持EV_SYN同步事件 */
	set_bit(EV_SYN, dev->evbit);
	/*
	 * 如果设备驱动没有指定重复按键（连击），系统默认提供以下的支持
	 * 其中init_timer为连击产生的定时器，时间到调用input_repeat_key函数
	 * 上报，REP_DELAY用于设置重复按键的键值，REP_PERIOD设置延时时间
	 */
	init_timer(&dev->timer);
	if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD]) {
		dev->timer.data = (long) dev;
		dev->timer.function = input_repeat_key;
		dev->rep[REP_DELAY] = 250;
		dev->rep[REP_PERIOD] = 33;
	}
 
	/* 如果设备驱动没有设置自己的获取键值的函数，系统默认 */
	if (!dev->getkeycode)
		dev->getkeycode = input_default_getkeycode;
 
	/* 如果设备驱动没有指定按键重置函数，系统默认 */
	if (!dev->setkeycode)
		dev->setkeycode = input_default_setkeycode;
 
	/* 重要，把设备挂到全局的input子系统设备链表input_dev_list上 */
	list_add_tail(&dev->node, &input_dev_list);
 
	/* 动态获取input设备的ID号，名称为input*，其中后面的“*”动态获得，唯一的 */
	snprintf(dev->cdev.class_id, sizeof(dev->cdev.class_id),
		 "input%ld", (unsigned long) atomic_inc_return(&input_no) - 1);
 
	/* 如果这个值没有设置，系统把输入设备挂入设备链表 */
	if (!dev->cdev.dev)
		dev->cdev.dev = dev->dev.parent;
 
	/* 在/sys目录下创建设备目录和文件 */
	error = class_device_add(&dev->cdev);
	if (error)
		return error;
 
	/* 获取并打印设备的绝对路径名称 */
	path = kobject_get_path(&dev->cdev.kobj, GFP_KERNEL);
	printk(KERN_INFO "input: %s as %s\n",
		dev->name ? dev->name : "Unspecified device", path ? path : "N/A");
	kfree(path);
 
	/* 核心重点，input设备在增加到input_dev_list链表上之后，会查找
	 * input_handler_list事件处理链表上的handler进行匹配，这里的匹配
	 * 方式与设备模型的device和driver匹配过程很相似，所有的input
	 * 都挂在input_dev_list上，所有类型的事件都挂在input_handler_list
	 * 上，进行“匹配相亲”*/
	list_for_each_entry(handler, &input_handler_list, node)
		input_attach_handler(dev, handler);
 
	input_wakeup_procfs_readers();
	return 0;
}
EXPORT_SYMBOL(input_register_handler);//导出驱动函数其他调用，其实input也是驱动模块

static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)
{
	const struct input_device_id *id;
	int error;

/* 如果handler的blacklist被赋值了并且则优先匹配 */
	id = input_match_device(handler, dev);
	if (!id)
		return -ENODEV;
	/* 否则利用handler->id_table和dev进行匹配，后面讲述匹配什么和过程 */
	id = input_match_device(handler->id_table, dev);
	if (!id)
		return -ENODEV;

	/* 这是一根“红线”，虽然你可能觉的是黑色的，但不可否认，他们真的匹配上了
 	 * 调用handler->connnect函数进行匹配，匹配详细过程后面讲述
 	 */
	error = handler->connect(handler, dev, id);
	if (error && error != -ENODEV)
		pr_err("failed to attach handler %s to device %s, error: %d\n",
		       handler->name, kobject_name(&dev->dev.kobj), error);

	return error;
}

bool input_match_device_id(const struct input_dev *dev,
			   const struct input_device_id *id)
			   /* 以下通过flags中设置的位来匹配设备的总线类型、经销商、生产ID和版本ID
 		  如果没有匹配上将进行MATCH_BIT匹配 */
{
	if (id->flags & INPUT_DEVICE_ID_MATCH_BUS)
		if (id->bustype != dev->id.bustype)
			return false;

	if (id->flags & INPUT_DEVICE_ID_MATCH_VENDOR)
		if (id->vendor != dev->id.vendor)
			return false;

	if (id->flags & INPUT_DEVICE_ID_MATCH_PRODUCT)
		if (id->product != dev->id.product)
			return false;

	if (id->flags & INPUT_DEVICE_ID_MATCH_VERSION)
		if (id->version != dev->id.version)
			return false;
	   /* MATCH_BIT用于匹配设备驱动中是否设置了这些为，MATCH_BIT的宏
		* 被定义在input.c中，我们在设备驱动中设置的事件类型会与事件链表中的
		* 所有事件类型进行比较，匹配成功了将返回id，证明真的很合适，否则NULL
		*/
	if (!bitmap_subset(id->evbit, dev->evbit, EV_MAX) ||
	    !bitmap_subset(id->keybit, dev->keybit, KEY_MAX) ||
	    !bitmap_subset(id->relbit, dev->relbit, REL_MAX) ||
	    !bitmap_subset(id->absbit, dev->absbit, ABS_MAX) ||
	    !bitmap_subset(id->mscbit, dev->mscbit, MSC_MAX) ||
	    !bitmap_subset(id->ledbit, dev->ledbit, LED_MAX) ||
	    !bitmap_subset(id->sndbit, dev->sndbit, SND_MAX) ||
	    !bitmap_subset(id->ffbit, dev->ffbit, FF_MAX) ||
	    !bitmap_subset(id->swbit, dev->swbit, SW_MAX) ||
	    !bitmap_subset(id->propbit, dev->propbit, INPUT_PROP_MAX)) {
		return false;
	}
	return true;
}

static int evdev_connect(struct input_handler *handler, struct input_dev *dev,
			 const struct input_device_id *id)
{
	struct evdev *evdev;
	int minor;
	int dev_no;
	int error;
/* EVDEV_MINORS为32，代表共能容纳32个evdev事件层设备，下面代码在找到空的地方，用于保存evdev事件层的数据，即上面定义的evdev */
	minor = input_get_new_minor(EVDEV_MINOR_BASE, EVDEV_MINORS, true);
	if (minor < 0) {
		error = minor;
		pr_err("failed to reserve new minor: %d\n", error);
		return error;
	}/* 这说明内核已经没办法再分配这种类型的设备了 */
	
	/* 开始给evdev事件层驱动分配空间了 */
	evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL);
	if (!evdev) {
		error = -ENOMEM;
		goto err_free_minor;
	}
	/* 初始化client_list列表和evdev_wait队列，后面介绍 */
	INIT_LIST_HEAD(&evdev->client_list);
	spin_lock_init(&evdev->client_lock);
	mutex_init(&evdev->mutex);
	init_waitqueue_head(&evdev->wait);
	evdev->exist = true;

	dev_no = minor;
	/* Normalize device number if it falls into legacy range */
	if (dev_no < EVDEV_MINOR_BASE + EVDEV_MINORS)
		dev_no -= EVDEV_MINOR_BASE;
	dev_set_name(&evdev->dev, "event%d", dev_no);
	/* 初始化evdev结构体，其中handle为输入设备和事件处理的关联接口 */
	evdev->handle.dev = input_get_device(dev);
	evdev->handle.name = dev_name(&evdev->dev);
	evdev->handle.handler = handler;
	evdev->handle.private = evdev;

	evdev->dev.devt = MKDEV(INPUT_MAJOR, minor);
	evdev->dev.class = &input_class;
	evdev->dev.parent = &dev->dev;
	evdev->dev.release = evdev_free;
	device_initialize(&evdev->dev);

	/* input_dev设备驱动和handler事件处理层的关联，由handle完成 */
	error = input_register_handle(&evdev->handle);
	if (error)
		goto err_free_evdev;

	cdev_init(&evdev->cdev, &evdev_fops);

	error = cdev_device_add(&evdev->cdev, &evdev->dev);
	if (error)
		goto err_cleanup_evdev;
	return 0;
}

struct input_handler *handler = handle->handler;
	/* 将d_node链接到输入设备的h_list，h_node链接到事件层的h_list链表上
	* 因此，在handle中是输入设备和事件层的关联结构体，通过输入设备可以
	* 找到对应的事件处理层接口，通过事件处理层也可找到匹配的输入设备
	*/
	list_add_tail(&handle->d_node, &handle->dev->h_list);
	list_add_tail(&handle->h_node, &handler->h_list);
 
	/* 如果start函数有定义则调用，但是evdev结构体中并未初始化这个函数 */
	if (handler->start)
		handler->start(handle);

/* 输入设备初始化函数 */
static int __init input_init(void)
{
     err = class_register(&input_class);
	err = input_proc_init();
	err = register_chrdev_region(MKDEV(INPUT_MAJOR, 0),
				     INPUT_MAX_CHAR_DEVICES, "input");
}
input_proc_init()中
proc_create("handlers", 0, proc_bus_input_dir, &input_handlers_fileops);

static const struct file_operations input_handlers_fileops = {
	.owner		= THIS_MODULE,
	.open		= input_proc_handlers_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= seq_release,
};

static struct input_handler evdev_handler = {
	.event		= evdev_event,				 //事件处理
	.events		= evdev_events,
	.connect	= evdev_connect,			//设备连接
	.disconnect	= evdev_disconnect,			 //设备注销
	.legacy_minors	= true,
	.minor		= EVDEV_MINOR_BASE,			//evdev的值为64
	.name		= "evdev",				   //设备名称
	.id_table	= evdev_ids,			   //用于匹配设备驱动的数组
};

static int __init evdev_init(void)
{
	return input_register_handler(&evdev_handler);	//evdev设备驱动注册
}

evdev_connect(struct input_handler *handler, struct input_dev *dev,
			 const struct input_device_id *id)
	|
	//找到一个没有被使用的次设备号， 从64开始， 65,66 
	minor = input_get_new_minor(EVDEV_MINOR_BASE, EVDEV_MINORS, true);

	// 实例化 一个evdev对象
	evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL);
	//初始化evdev对象
	INIT_LIST_HEAD(&evdev->client_list);
	spin_lock_init(&evdev->client_lock);
	mutex_init(&evdev->mutex);
	//等待队列是完成阻塞
	init_waitqueue_head(&evdev->wait);
	evdev->exist = true;

	dev_no = minor;
	dev_no -= EVDEV_MINOR_BASE; //减去了64

	// 创建设备文件/dev/event0,1,2
	dev_set_name(&evdev->dev, "event%d", dev_no);
	evdev->dev.devt = MKDEV(INPUT_MAJOR, minor);// 12, 64
	evdev->dev.class = &input_class;
	evdev->dev.parent = &dev->dev;
	evdev->dev.release = evdev_free;
	device_initialize(&evdev->dev)
	device_add(&evdev->dev); 
	//以上代码和device_create是一样

	//利用handle记录input device和input handler
	evdev->handle.dev = input_get_device(dev);
	evdev->handle.name = dev_name(&evdev->dev);
	evdev->handle.handler = handler;
	//你中有有我，我中有你
	evdev->handle.private = evdev;
	
	//将儿子关联到父亲(input handler)和母亲(input dev)
	error = input_register_handle(&evdev->handle);
					|
				list_add_tail_rcu(&handle->d_node, &dev->h_list);
				list_add_tail_rcu(&handle->h_node, &handler->h_list);

	//初始化了cdev,完成了fops, 为用户提供文件io
	cdev_init(&evdev->cdev, &evdev_fops);
	evdev->cdev.kobj.parent = &evdev->dev.kobj;
	error = cdev_add(&evdev->cdev, evdev->dev.devt, 1);

static int input_open_file(struct inode *inode, struct file *file)
{
	struct input_handler *handler;
	const struct file_operations *old_fops, *new_fops = NULL;
	int err;
	lock_kernel();
	/* No load-on-demand here? */
	/*32个设备是共用一个handler的,通过此设备号得到设备对应的handler*/
	handler = input_table[iminor(inode) >> 5];
	if (!handler || !(new_fops = fops_get(handler->fops))) {
		err = -ENODEV;
		goto out;
	}
	/*
	 * That's _really_ odd. Usually NULL ->open means "nothing special",
	 * not "no device". Oh, well...
	 */
	if (!new_fops->open) {
		fops_put(new_fops);
		err = -ENODEV;
		goto out;
	}
	old_fops = file->f_op;
	/*定位fops*/
	file->f_op = new_fops;
 
	err = new_fops->open(inode, file);
 
	if (err) {
		fops_put(file->f_op);
		file->f_op = fops_get(old_fops);
	}
	fops_put(old_fops);
out:
	unlock_kernel();
	return err;
}

// 实际cdev是谁，就是evdev_connect注册的那个
		struct evdev *evdev = container_of(inode->i_cdev, struct evdev, cdev);

		// 通过儿子，找到老母input device
		unsigned int bufsize = evdev_compute_buffer_size(evdev->handle.dev);

		// size就包含了很多input_event
		unsigned int size = sizeof(struct evdev_client) +
						bufsize * sizeof(struct input_event);
		struct evdev_client *client;
		// 分配一个client对像，描述一个缓冲队列，存放的就是input_event
		client = kzalloc(size, GFP_KERNEL | __GFP_NOWARN);
		// client中有一个缓冲区
		client->bufsize = bufsize;
		spin_lock_init(&client->buffer_lock);
		//在client中记录evdev
		client->evdev = evdev;
		// 将client加入到evdev中一个小链表
		evdev_attach_client(evdev, client);
				list_add_tail_rcu(&client->node, &evdev->client_list);
		// 将client记录到file，方面其他的接口使用
		file->private_data = client;

static const struct file_operations evdev_fops = {

							.read = evdev_read,

		evdev_read(struct file *file, char __user *buffer,size_t count, loff_t *ppos)
		// 获取到open中分配的缓冲区对象
		struct evdev_client *client = file->private_data;
		//获取到evdev
		struct evdev *evdev = client->evdev;
		//表示一个数据包，要给用户
  		struct input_event event;
for (;;) {
		// 实现非阻塞
		if (client->packet_head == client->tail &&
			(file->f_flags & O_NONBLOCK))
			return -EAGAIN;

			while (read + input_event_size() <= count &&
			// 1从缓冲区获取数据，存放在 input_event数据包
			   evdev_fetch_next_event(client, &event)) {
						|
						*event = client->buffer[client->tail++];
			// 2, 将数据上报给用户
			if (input_event_to_user(buffer + read, &event))
						|
						copy_to_user(buffer, event, sizeof(struct input_event)

			// 3，统计上报多少数据
			read += input_event_size();
		}

		// 如果当前是阻塞模式
		if (!(file->f_flags & O_NONBLOCK)) {
			//等待---休眠，需要被唤醒，有数据时候唤醒
			error = wait_event_interruptible(evdev->wait,
					client->packet_head != client->tail ||
					!evdev->exist || client->revoked);
	} 总结：
		1，如果没有数据，就会休眠等待
		2，如果有数据，就从缓冲区client->buffer[client->tail++]拿数据
			通过copy_to_user上报给用户

input_report_key(inputdev, KEY_POWER, 1);
input_sync(inputdev);//上报数据结束

void input_event(struct input_dev *dev,unsigned int type, unsigned int code, int value)
{
	unsigned long flags;
	if (is_event_supported(type, dev->evbit, EV_MAX)) 
	{
		spin_lock_irqsave(&dev->event_lock, flags);
		input_handle_event(dev, type, code, value);
		spin_unlock_irqrestore(&dev->event_lock, flags);
	}
}