输入子系统驱动详解
框架分析
转载自：https://www.cnblogs.com/big-devil/p/8590063.html
<输入子系统简介>
背景
内核的输入子系统是对"分散的、多种不同类别"的输入设备（键盘，鼠标，跟踪杆，触摸屏，加速度计等）进行"统一处理"的驱动程序。
具有如下特点：
1、统一各种形态各异的相似的输入设备的处理功能（鼠标，不论是PS/2形的鼠标，还是usb形式的鼠标，还是蓝牙形式的鼠标），都做一样的处理。
2、提供用于分发"输入报告"给用户应用程序的简单事件（event）接口。（驱动程序不必创建和管理/dev节点,以及相关的访问方法（fops））。因此能够很方便的调用API发送鼠标移动，键盘按键或触摸屏事件给用户空间。
3、抽取出输入驱动的通用部分，简化了驱动程序，并引入了一致性。（比如，输入子系统提供了一个底层驱动程序（serio）的集合，支持对串口和键盘控制器等硬件输入设备的访问）
输入子系统的组成示意图
输入子系统的事件处理机制示意图
输入子系统剖析
input子系统调用过程分析
1、当外部应用程序需要调用输入子系统的open函数时，会先通过主设备号进入到核心层，然后通过次设备号进入handler层，再调用.fops内的open函数返回fd；
2、当外部应用程序需要调用输入子系统的read函数时，会通过返回的fd调用.fop内的read函数，然后休眠，等待被.event函数唤醒；
3、当外部中断到达的时候，会先确定中断事件，然后用input_event上报事件，再通过h_list里面的所有handle调用对应的handler中的.event函数，对read进行唤醒，然后在read中返回（也就是当device有多个对应的handler的时候,input_event会向所有的handler上报事件）
4、当需要加入新的handler时，需要先构建handler结构体，然后调用input_register_handler对该handler进行注册
input_register_handler的内部实现：
往input_handler_list加入新增的handler节点，然后对input_device_list的所有结点（也就是所有的device）进行遍历，
通过.id_table查看该device是否支持该handler,对支持的device调用.connect,一一地构建input_handle结构体,连接handler跟device
5、当需要加入新的device时，需要先构建input_dev结构体，然后调用input_register_device对该input_dev进行注册
input_register_dev的内部实现：
往input_device_list加入新增的device节点，然后对input_handler_list的所有结点（也就是所有的handler）进行遍历，通过handler的.id_table查看该handler是否支持该device,对支持的device调用该handler的.connect,一一地构建input_handle结构体,连接handler跟device
<input输入子系统数据结构分析一>
struct input_dev{}
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 propbit[BITS_TO_LONGS(INPUT_PROP_CNT)]; //位图的设备属性
8
9
unsigned long evbit[BITS_TO_LONGS(EV_CNT)]; //支持的所有事件类型
10
11
//下面是每种类型支持的编码
12
unsigned long keybit[BITS_TO_LONGS(KEY_CNT)]; //支持的键盘事件
13
unsigned long relbit[BITS_TO_LONGS(REL_CNT)]; //支持的鼠标相对值事件
14
unsigned long absbit[BITS_TO_LONGS(ABS_CNT)]; //支持的鼠标绝对值事件
15
unsigned long mscbit[BITS_TO_LONGS(MSC_CNT)]; //支持的其它事件类型
16
unsigned long ledbit[BITS_TO_LONGS(LED_CNT)]; //支持的LED灯事件
17
unsigned long sndbit[BITS_TO_LONGS(SND_CNT)]; //支持的声效事件
18
unsigned long ffbit[BITS_TO_LONGS(FF_CNT)]; //支持的力反馈事件
19
unsigned long swbit[BITS_TO_LONGS(SW_CNT)]; //支持的开关事件
20
21
unsigned int hint_events_per_packet; //事件生成的平均数量
22
23
unsigned int keycodemax; //keycode表的大小
24
unsigned int keycodesize; //keycode表中元素个数
25
void *keycode; //设备的键盘表
26
27
int (*setkeycode)(struct input_dev *dev,const struct input_keymap_entry *ke,
28
unsigned int *old_keycode); //配置keycode表
29
int (*getkeycode)(struct input_dev *dev,
30
struct input_keymap_entry *ke); //获取keycode表
31
32
struct ff_device *ff; //力反馈设备结构
33
34
unsigned int repeat_key; //保存上一个键值
35
struct timer_list timer; //软件计时器
36
37
int rep[REP_CNT]; //autorepeat参数当前值
38
39
struct input_mt_slot *mt;
40
int mtsize;
41
int slot;
42
int trkid;
43
44
struct input_absinfo *absinfo; //绝对坐标轴的信息
45
46
unsigned long key[BITS_TO_LONGS(KEY_CNT)]; //按键有两种状态，按下和抬起，这个字段就是记录这两个状态。
47
unsigned long led[BITS_TO_LONGS(LED_CNT)];
48
unsigned long snd[BITS_TO_LONGS(SND_CNT)];
49
unsigned long sw[BITS_TO_LONGS(SW_CNT)];
50
51
//操作接口
52
int (*open)(struct input_dev *dev);
53
void (*close)(struct input_dev *dev);
54
int (*flush)(struct input_dev *dev, struct file *file);
55
int (*event)(struct input_dev *dev, unsigned int type, unsigned int code, int value);
56
57
struct input_handle __rcu *grab; //当前使用的handle
58
59
spinlock_t event_lock;
60
struct mutex mutex;
61
62
unsigned int users;
63
bool going_away;
64
65
bool sync;
66
67
struct device dev; //这个设备的驱动程序模型的视图
68
69
struct list_head h_list; //h_list是一个链表头，用来把handle挂载在这个上
70
struct list_head node; //这个node是用来连到input_dev_list上的
71 };
struct input_handler{}
1 struct input_handler {
2
void *private; //驱动特有的数据
3
4
//当事件处理器接收到了来自input设备传来的事件时调用的处理函数，负责处理事件
5
void (*event)(struct input_handle *handle, unsigned int type, unsigned int code, int value); //该函数将被输入子系统调用区处理发送给"设备"的事件。例如,发送一个事件命令led灯点亮，实际控制硬件的操作可以放在event()函数中实现
6
bool (*filter)(struct input_handle *handle, unsigned int type, unsigned int code, int value); //事件过滤
7
bool (*match)(struct input_handler *handler, struct input_dev *dev);
8
9
//当一个input设备模块注册到内核的时候调用的，将事件处理器与输入设备联系起来的函数，
10
//也就是将input_dev和input_handler配对的函数
11
int (*connect)(struct input_handler *handler, struct input_dev *dev, const struct input_device_id *id);
12
void (*disconnect)(struct input_handle *handle); //实现connect相反的功能
13
void (*start)(struct input_handle *handle);
14
15
const struct file_operations *fops; //文件操作函数集合
16
int minor; //次设备号
17
const char *name;
18
19
const struct input_device_id *id_table; //事件处理器所支持的input设备
20
21
//这个链表用来链接他所支持的input_handle结构,input_dev与input_handler配对之后就会生成一个input_handle结构
22
struct list_head h_list;
23
24
//链接到input_handler_list，这个链表链接了所有注册到内核的事件处理器
25
struct list_head node;
26};
struct input_handle{}
1 struct input_handle {
2
//每个配对的事件处理器都会分配一个对应的设备结构，如evdev事件处理器的evdev结构，注意这个结构与设备
3
//驱动层的input_dev不同，初始化handle时，保存到这里。
4
void *private;
5
6
int open; //打开标志，每个input_handle打开后才能操作，这个一般通过事件处理器的open方法间接设置
7
const char *name;
8
9
struct input_dev *dev; //关联的input_dev结构
10
struct input_handler *handler; //关联的input_handler结构
11
12
struct list_head d_node; //input_handle通过d_node连接到了input_dev上的h_list链表上
13
struct list_head h_node; //input_handle通过h_node连接到了input_handler的h_list链表上
14 };
input_dev、input_handler、input_handle 三者之间的关系
input_dev是硬件驱动层，代表一个input设备；input_dev通过全局的input_dev_list链接在一起，设备注册的时候实现这个操作。
input_handler是事件处理层，代表一个事件处理器；input_handler通过全局的input_handler_list链接在一起，事件处理器注册的时候实现这个操作。
input_handle代表一个配对的input设备与input事件处理器，input_hande没有一个全局的链表，它注册的时候将自己分别挂在了input_dev和input_handler的h_list上了；
通过input_dev和input_handler就可以找到input_handle在设备注册和事件处理器，注册的时候都要进行配对工作，配对后就会实现链接。
通过input_handle也可以找到input_dev和input_handler。
<Input输入子系统数据结构分析二>
input_dev
input_dev 这是input设备基本的设备结构，每个input驱动程序中都必须分配初始化这样一个结构，成员比较多
A:有以下几个数组：
1 unsigned long evbit[BITS_TO_LONGS(EV_CNT)];
A-1:下面是每种类型支持的编码
1 unsigned long keybit[BITS_TO_LONGS(KEY_CNT)]; //按键
2 unsigned long relbit[BITS_TO_LONGS(REL_CNT)];
3 unsigned long absbit[BITS_TO_LONGS(ABS_CNT)]; //绝对坐标，其中触摸屏驱动使用的就是这个
4 unsigned long mscbit[BITS_TO_LONGS(MSC_CNT)];
5 unsigned long ledbit[BITS_TO_LONGS(LED_CNT)];
6 unsigned long sndbit[BITS_TO_LONGS(SND_CNT)];
7 unsigned long ffbit[BITS_TO_LONGS(FF_CNT)];
8 unsigned long swbit[BITS_TO_LONGS(SW_CNT)];
9 unsigned long evbit[BITS_TO_LONGS(EV_CNT)]; //这个数组以位掩码的形式，代表了这个设备支持的事件的类型。
A-1-2:设置方式：
1 dev->evbit[0] = BIT(EV_SYN) | BIT(EV_KEY) | BIT(EV_ABS);
2 //absbit[BITS_TO_LONGS(ABS_CNT)]; 这个数组也是以位掩码的形式，代表这个类型的事件支持的编码触摸屏驱动支持EV_ABS,所以要设置这个数组。
A-1-2-1: 有一个专门设置这个数组的函数input_set_abs_params()
1 static inline void input_set_abs_params(struct input_dev *dev, int axis, int min, int max, int fuzz, int flat)
2 {
3 dev->absmin[axis] = min;
4 dev->absmax[axis] = max;
5 dev->absfuzz[axis] = fuzz;
6 dev->absflat[axis] = flat;
7 dev->absbit[BIT_WORD(axis)] |= BIT_MASK(axis); //填充了absbit这个数组
8 }
A-1-2-2:触摸屏驱动中是这样调用的
1 input_set_abs_params(dev, ABS_X, 0, 0x3FF, 0, 0)； //这个是设置ad转换的x坐标
2 input_set_abs_params(dev, ABS_Y, 0, 0x3FF, 0, 0); //这个是设置ad转换的y坐标
3 input_set_abs_params(dev, ABS_PRESSURE, 0, 1, 0, 0); //这个是设置触摸屏是否按下的标志
4 //设置ABS_X编码值范围为0-0x3ff，因为mini2440的AD转换出的数据最大为10位，所以不会超过0x3ff。
B:struct input_id id 成员
这个是标识设备驱动特征的
1 struct input_id {
2 __u16 bustype; //总线类型
3 __u16 vendor; //生产厂商
4 __u16 product; //产品类型
5 __u16 version; //版本
6 };
如果需要特定的事件处理器来处理这个设备的话，这几个就非常重要，因为子系统核心是通过他们，将设备驱动与事件处理层联系起来的。但是因为触摸屏驱动所
用的事件处理器为evdev，匹配所有，所有这个初始化也无关紧要。
C:input_handler
input_handler 这是事件处理器的数据结构，代表一个事件处理器
C-1:几个操作函数
1 void (*event)(struct input_handle *handle, unsigned int type, unsigned int code, int value);
2 int (*connect)(struct input_handler *handler, struct input_dev *dev, const struct input_device_id *id);
3 void (*disconnect)(struct input_handle *handle);
4 void (*start)(struct input_handle *handle);
C-1-1:event 函数是当事件处理器接收到了来自input设备传来的事件时调用的处理函数，负责处理事件，非常重要。
C-1-2:connect 函数是当一个input设备模块注册到内核的时候调用的，将事件处理器与输入设备联系起来的函数，也就是将input_dev和input_handler配对的函数。
C-1-3:disconnect 函数实现connect相反的功能。
D:两个id
1 const struct input_device_id *id_table; //这个是事件处理器所支持的input设备
2 const struct input_device_id *blacklist; //这个是事件处理器应该忽略的input设备
D-1:这两个数组都会用在connect函数中，input_device_id结构与input_id结构类似，但是input_device_id有一个flag，用来让程序选择比较哪项，如：busytype,vendor还是其他。
E:两个链表
1 struct list_headh_list; //这个链表用来链接他所支持的input_handle结构,input_dev与input_handler配对之后就会生成一个input_handle结构
2 struct list_headnode;
F:input_handle
input_handle 结构体代表一个成功配对的input_dev和input_handler
1 struct input_handle
2 {
3
void *private; //每个配对的事件处理器都会分配一个对应的设备结构，如evdev事件处理器的evdev结构，注意这个结构与设备驱动层的input_dev不同，初始化handle时，保存到这里。
4
int open; //打开标志，每个input_handle 打开后才能操作，这个一般通过事件处理器的open方法间接设置
5
const char *name;
6
struct input_dev *dev; //关联的input_dev结构
7
struct input_handler *handler; //关联的input_handler结构
8
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链表上
9 };
三个数据结构之间的关系
input_dev 是硬件驱动层，代表一个input设备
input_handler 是事件处理层，代表一个事件处理器
input_handle 属于核心层，代表一个配对的input设备与input事件处理器
input_dev 通过全局的input_dev_list链接在一起。设备注册的时候实现这个操作。
input_handler 通过全局的input_handler_list链接在一起。事件处理器注册的时候实现这个操作（事件处理器一般内核自带，一般不需要我们来写）
input_hande 没有一个全局的链表，它注册的时候将自己分别挂在了input_dev 和 input_handler 的h_list上了。
通过input_dev 和input_handler就可以找到input_handle 在设备注册和事件处理器， 注册的时候都要进行配对工作，配对后就会实现链接。
通过input_handle也可以找到input_dev和input_handler。
G:补充两个结构体
G-1:evdev设备结构
1 struct evdev
2 {
3
int exist;
4
int open; //打开标志
5
int minor; //次设备号
6
struct input_handle handle; //关联的input_handle
7
wait_queue_head_t wait; //等待队列，当进程读取设备，而没有事件产生的时候，进程就会睡在其上面
8
struct evdev_client *grab; //强制绑定的evdev_client结构，这个结构后面再分析
9
struct list_head client_list; //evdev_client 链表，这说明一个evdev设备可以处理多个evdev_client，可以有多个进程访问evdev设备
10
spinlock_t client_lock; /* protects client_list */
11
struct mutex mutex;
12
struct device dev; //device结构，说明这是一个设备结构
13 };
evdev结构体在配对成功的时候生成，由handler->connect生成，对应设备文件为/class/input/event(n)。
如触摸屏驱动的event0，这个设备是用户空间要访问的设备，可以理解它是一个虚拟设备，因为没有对应的硬件，但是通过handle->dev 就可以找到input_dev结构，而它对应着触摸屏，设备文件为/class/input/input0。这个设备结构生成之后保存在evdev_table中，索引值是minor
G-2:evdev用户端结构
1 struct evdev_client
2 {
3
struct input_event buffer[EVDEV_BUFFER_SIZE]; //这个是一个input_event数据结构的数组，input_event代表一个事件，基本成员：类型（type），编码（code），值（value）
4
int head; //针对buffer数组的索引
5
int tail; //针对buffer数组的索引，当head与tail相等的时候，说明没有事件 spinlock_t buffer_lock; /* protects access to buffer, head and tail */
6
struct fasync_struct *fasync; //异步通知函数
7
struct evdev *evdev; //evdev设备
8
struct list_head node; //evdev_client 链表项
9 };
这个结构在进程打开event0设备的时候调用evdev的open方法，在open中创建这个结构，并初始化。在关闭设备文件的时候释放这个结构。
H:各数据结构之间的关系
<输入设备简单实例>
a:代码详情
b:代码分析
b-1:函数struct input_dev *input_allocate_device()
b-2:函数input_register_device()
input_register_device()函数是输入子系统核心（input_core）提供的函数，用来将input_device注册进入输入子系统核心。
b-2-1:函数__set_bit()
第"07"行的该函数用来设置input_dev所支持的事件类型，事件类型由input_dev中的evbit成员表示。这里将EV_SYN置位（设备支持所有的事件）
b-2-2:一个input_dev可以支持许多事件，常用的如下：
b-2-3:第"21"使用device_add()将内嵌的在input_dev中的device注册到Linux的设备管理模型中
b-2-4:第"33"调用list_add_tail()将input_dev加入到intput_handle中的input_dev_list链表中
b-2-5:第"36"行input_attach_handler()用来匹配input_dev和handler，代码详情：
b-2-5-1:第"3"行定义了input_device_id指针，该结构体在内核中的定义如下：
b-2-5-2:第"5"行首先判断handler->blacklist是否被赋值（blacklist是一个input_device_id类型的指针，其中存放了handler应该忽略的设备）
b-2-5-3：第"7"行调用函数input_match_device()函数用来对handler->id_table和dev->id进行匹配，如果成功就会调用函数handler->connect()将handler和input_dev连接起来。
总结：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：参数分析
dev:产生事件的设备
code:产生的事件（在input_dev初始化的时候，初始化相应的事件）
value:事件的值（针对不同的事件，这个值也有相应的变化）
b-3-2:函数input_event()
b-3-2-1:参数分析
dev:产生事件的设备
type:产生的事件类型（用来和支持的类型进行匹配）
code:产生的事件（在input_dev初始化的时候，初始化相应的事件）
value:事件的值（针对不同的事件，这个值也有相应的变化）
b-3-2-2：函数static inline int is_event_supported(unsignd int code ,unsigned long *bm,unsigned int max)
b-3-2-2-1：该函数检查input_dev.evbit中相应的位是否设置，如果设置返回1,否者返回0.
b-3-2-2-2:evbit位图
input_dev可以支持很多事件，通过evbit中的位图来表示（evbit是一个long型变量，每一位表示一种事件，为1表示支持，反之不支持）
b-3-2-3:函数input_handle_event()
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:函数input_pass_event()
b-3-2-3-3-1:第"4"行，分配一个input_handle结构指针
b-3-2-3-3-2:第"6"行，grab是强制为input device的handler
b-3-2-3-3-3：第"10-13"行，如果没有为input_device强制指定handler，这将遍历handle所有的handler，然后为其指定handler
-----------------------------------------------------------------------------------------------
input子系统剖析
<handler注册分析>
a：简介
input_handler用来对输入的事件进行具体的处理（input_handler为输入设备的功能实现接口，handler根据一定的规则，然后对事件进行处理）
b:输入子系统的组成
输入子系统由驱动层，输入子系统核心层，和事件处理层.
c:handler数据结构
详情见前文
d:注册handle,函数int input_register_handle(struct input_handler *handler)
d-1:第"3-4"行，从handle中取出一个指向input_handler和input_dev的指针
d_2:第"9,12"行，将handle分别加入到dev->h-list和handler->h_list链表中
<input子系统>
a:背景
到目前为止，系统已经做好了所有的与硬件相关的工作，但是作为一个驱动需要提供相应的设备操作接口，输入子系统本身就是为了统一所有的输入设备，所以相应的用户空间接口统一在输入子系统进行注册。(注意：输入子系统是一个字符设备)
b:子系统初始化函数input_init()
b-1："4"行，class_register()函数先注册一个名为input的类，所有的input设备都属于这个类，在文件系统中的表现形式就是所有的input_dev都在/dev/class/input 目录下。
b-2:第"12"行，调用字符设备注册函数register_chrdev（）向Linux系统核心注册"输入字符设备"，所有的输入设备的主设备号为13.
input_fosp：
其中就一个input_open_file函数。该函数将控制转到input_handler中定义的fops文件指针的open()函数。
b-2-1：input_handler中的input_open_file()
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字符设备驱动接口 */
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 };
15 /*evdev设备open函数的实现过程 */
16 static int evdev_open(struct inode *inode, struct file *file)
17 {
18
struct evdev_client *client;
19
struct evdev *evdev;
20
/* 如果是event0，对于evdev设备来说，次设备号当然是0 */
21
int i = iminor(inode) - EVDEV_MINOR_BASE;
22
int error;
23
/* 如果大于32，说明超出了evdev能够容纳的最大输入设备个数 */
24
if (i >= EVDEV_MINORS)
25
return -ENODEV;
26
/* 由于evdev中能容纳32个输入设备，因此通过设备号event0中的0定位到是要处理的是哪一个输入设备，evdev_table中的内容在输入设备驱动注册时通过evdev_connect填充 */
27 evdev = evdev_table[i];
28
/* 判断是否设备接口存在，evdev_exist也是在evdev_connect填充为1 */
29
if (!evdev || !evdev->exist)
30
return -ENODEV;
31
/* 存在则分配evdev中的client来处理event* */
32 client = kzalloc(sizeof(struct evdev_client),GFP_KERNEL);
33
if (!client)
34
return -ENOMEM;
35
36
/* 把event*中的接口指向evdev_table中对应项 */
37 client->evdev = evdev;
38
/* 把client->node链接到evdev子集中 */
39 list_add_tail(&client->node,&evdev->client_list);
40
/* 如果open是第一个打开，则会执行input_open_device*/
41
if (!evdev->open++ &&evdev->exist) {
42 error =input_open_device(&evdev->handle);
43
if (error) {
44 list_del(&client->node);
45 kfree(client);
46
return error;
47 }
48 }
49
/* 将file私有指针指向client*/
50 file->private_data = client;
51
return 0;
52 }
由上的代码可以看出，最终是要执行input_open_device去执行设备驱动程序中的代码，然而我们在定义设备驱动的时候并没有给input_dev中的open字段填充内容，因此可以看到input_open_device函数的执行过程：
if(!dev->users++ && dev->open)
err = dev->open(dev);
if (err)
handle->open--;
因为input子系统支持很多输入设备，但是针对不同的输入设备，用户空间接口的具体操作应该不应.这样索引到不同的handler,做不同的处理。
<其他>
input_register_handle()函数注册一个input_handle
1 int input_register_handle(struct
input_handle *handle)
2 {
3
struct input_handler *handler = handle->handler;
4
struct input_dev *dev = handle->dev;
5
int error;
6
7
/*
8 * We take dev->mutex here to prevent race with
9 * input_release_device().
10 */
11 error = mutex_lock_interruptible(&dev->mutex);
12
if (error)
13
return error;
14
15
/*
16 * Filters go to the head of the list, normal handlers
17 * to the tail.
18 */
19
if (handler->filter)
20
//将handle的d_node，链接到其相关的input_dev的h_list链表中
21 list_add_rcu(&handle->d_node, &dev->h_list);
22
else
23 list_add_tail_rcu(&handle->d_node, &dev->h_list);
24
25 mutex_unlock(&dev->mutex);
26
27
/*
28 * Since we are supposed to be called from ->connect()
29 * which is mutually exclusive with ->disconnect()
30 * we can't be racing with input_unregister_handle()
31 * and so separate lock is not needed here.
32 */
33
//将handle的d_node，链接到其相关的input_handler的h_list链表中
34 list_add_tail_rcu(&handle->h_node, &handler->h_list);
35
36
if (handler->start)
37 handler->start(handle);
38
39
return 0;
40 }
这个函数基本没做什么事，就是把一个handle结构体通过d_node链表项，分别链接到input_dev的h_list,
input_handler的h_list上。以后通过这个h_list就可以遍历相关的input_handle了
3、input_register_handler()函数注册一个input_handler
1 int input_register_handler(struct input_handler *handler)
2 {
3
struct input_dev *dev;
4
int retval;
5
6 retval = mutex_lock_interruptible(&input_mutex);
7
if (retval)
8
return retval;
9
10 INIT_LIST_HEAD(&handler->h_list);
11
12
if (handler->fops != NULL) {
13
if (input_table[handler->minor >> 5]) {
14 retval = -EBUSY;
15
goto out;
16 }
17 input_table[handler->minor >> 5] = handler;
18 }
19
//连接到input_handler_list链表中
20 list_add_tail(&handler->node, &input_handler_list);
21
//配对，遍历input_dev，和注册input_dev过程一样的
22 list_for_each_entry(dev, &input_dev_list, node)
23 input_attach_handler(dev, handler);
24
25 input_wakeup_procfs_readers();
26
27
out:
28 mutex_unlock(&input_mutex);
29
return retval;
30 }
这个函数其实和input_register_device类似，都是要注册、配对
四、input输入子系统核心层
1、input输入子系统初始化定义在driver/input/input.c中，如下
1 static int __init input_init(void)
2 {
3
int err;
4
//向内核注册一个类，用于linux设备模型。注册后会在/sys/class下面出现input目录
5 err = class_register(&input_class);
6
if (err) {
7 pr_err("unable to register input_dev class\n");
8
return err;
9 }
10
//在/proc下创建入口项
11 err = input_proc_init();
12
if (err)
13
goto fail1;
14
//注册字符设备，设备号INPUT_MAJOR为13，设备名为input
15 err = register_chrdev(INPUT_MAJOR, "input", &input_fops);
16
if (err) {
17 pr_err("unable to register char major %d", INPUT_MAJOR);
18
goto fail2;
19 }
20
21
return 0;
22
23 fail2: input_proc_exit();
24 fail1: class_unregister(&input_class);
25
return err;
26 }
27 //子系统初始化时调用
28 subsys_initcall(input_init);
这个函数主要是注册了字符设备，这里和杂项设备的原理是一样，所以input设备也是一类字符设备，只不过操作
方法交给了输入子系统。从这里可以看出无论linux设备驱动这块有多复杂，他们都是由一些基本的组件构成的
2.输入子系统的核心其他部分都是提供的接口，向上连接事件处理层，向下连接驱动层。
向下对驱动层的接口主要有：
input_allocate_device这个函数主要是分配一个input_dev接口，并初始化一些基本的成员
input_unregister_device注册一个input设备input_event这个函数很重要，是驱动层向input子系统核心报告事件
的函数。
input_allocate_device分配并初始化一个input_dev结构
向上对事件处理层接口主要有：
input_register_handler注册一个事件处理器
input_register_handle注册一个input_handle结构
五、事件处理层
事件处理层与用户程序和输入子系统核心打交道，是他们两层的桥梁。一般内核有好几个事件处理器，
像evdev、mousedev、jotdev。evdev事件处理器可以处理所有的事件，触摸屏驱动就是用的这个。
1、evdev_init()事件处理层初始化
1 static int __init evdev_init(void)
2 {
3
return input_register_handler(&evdev_handler);
4 }
调用一个注册handler函数，将evdev_handler注册到系统中
2、主要的数据结构
1）evdev设备结构
1 struct evdev {
2 int open; //打开标志
3 int minor; //次设备号
4 struct input_handle handle; //关联的input_handle
5 wait_queue_head_t wait; //等待队列，当进程读取设备，而没有事件产生的时候，进程就会睡在其上面
6 struct evdev_client __rcu *grab; //强制绑定的evdev_client结构
7 struct list_head client_list; //evdev_client链表，这说明一个evdev设备可以处理多个evdev_client，可以有多个进程访问evdev设备
8 spinlock_t client_lock; /* protects client_list */
9 struct mutex mutex;
10 struct device dev; //device结构，说明这是一个设备结构
11 bool exist;
12 };
evdev结构体在配对成功的时候生成，由handler->connect生成，对应设备文件为/class/input/event(n)，
如触摸屏驱动的event0，这个设备是用户空间要访问的设备，可以理解它是一个虚拟设备，因为没有对应的硬件，
但是通过handle->dev就可以找到input_dev结构，而它对应着触摸屏，设备文件为/class/input/input0。这个设备
结构生成之后保存在evdev_table中，索引值是minor
2）evdev用户端结构
1 struct evdev_client {
2
unsigned int head; //针对buffer数组的索引
3
unsigned int tail; //针对buffer数组的索引，当head与tail相等的时候，说明没有事件
4
unsigned int packet_head; /* [future] position of the first element of next packet */
5
spinlock_t buffer_lock; /* protects access to buffer, head and tail */
6
struct fasync_struct *fasync;//异步通知函数
7
struct evdev *evdev; //evdev设备
8
struct list_head node; //evdev_client链表项
9
unsigned int bufsize;
10
struct input_event buffer[];//这个是一个input_event数据结构的数组，input_event代表一个事件，基本成员：类型（type），编码（code），值（value）
11 };
这个结构在进程打开event0设备的时候调用evdev的open方法，在open中创建这个结构，并初始化。在关闭设备文
件的时候释放这个结构
3、主要的函数
1）evdev设备打开函数
1 static int evdev_open(struct inode *inode, struct file *file)
2 {
3
struct evdev *evdev;
4
struct evdev_client *client;
5
int i = iminor(inode) - EVDEV_MINOR_BASE;
6
unsigned int bufsize;
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
16
//得到evdev设备结构,每次调用evdev_connect配对成功后都会把分配的evdev结构以minor为索引，保存在evdev_table数组中
17 evdev = evdev_table[i];
18
if (evdev)
19 get_device(&evdev->dev); //增加device引用计数
20 mutex_unlock(&evdev_table_mutex);
21
22
if (!evdev)
23
return -ENODEV;
24
25 bufsize = evdev_compute_buffer_size(evdev->handle.dev);
26
27 //分配用户端结构
28 client = kzalloc(sizeof(struct evdev_client) +
29 bufsize * sizeof(struct input_event),
30 GFP_KERNEL);
31
if (!client) {
32 error = -ENOMEM;
33
goto err_put_evdev;
34 }
35
36 client->bufsize = bufsize;
37 spin_lock_init(&client->buffer_lock);
38 client->evdev = evdev; //使用户端与evdev设备结构联系起来
39 evdev_attach_client(evdev, client); //把client连接到evdev的client链表中
40
41
//打开设备
42 error = evdev_open_device(evdev);
43
if (error)
44
goto err_free_client;
45
46 file->private_data = client;
47 nonseekable_open(inode, file);
48
49
return 0;
50
51 err_free_client:
52 evdev_detach_client(evdev, client);
53 kfree(client);
54 err_put_evdev:
55 put_device(&evdev->dev);
56
return error;
57 }
2）evdev_open_device()函数
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
//判断设备结构是否存在，在evdev_connect中初始话此成员为1
9
if (!evdev->exist)
10 retval = -ENODEV;
11
else if (!evdev->open++) {//evdev->open分配结构的时候没有初始化，默认为0，也就是没有打开，每次打开都会加1
12 retval = input_open_device(&evdev->handle);
13
if (retval)
14 evdev->open--;
15 }
16
17 mutex_unlock(&evdev->mutex);
18
return retval;
19 }
3）input_open_device()函数
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
//将handle的打开计数加1，注意和evdev的open的区别
15 handle->open++;
16
//如果此input_dev没有进程在引用，并且定义了open方法，就调用open方法
17
if (!dev->users++ && dev->open)
18 retval = dev->open(dev);
19
20
if (retval) {//retval=1说明没有打开成功
21 dev->users--;
22
if (!--handle->open) {//说明有其他的进程已经打开了这个handle
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 }
4）evdev_read()函数
1 static ssize_t evdev_read(struct file *file, char __user *buffer,
2
size_t count, loff_t *ppos)
3 {
4
//这个客户端结构在打开的时候分配并保存在file->private_data中
5
struct evdev_client *client = file->private_data;
6
struct evdev *evdev = client->evdev;
7
struct input_event event;
8
int retval;
9
//用户进程每次读取设备的字节数，不要少于input_event结构的大小
10
if (count < input_event_size())
11
return -EINVAL;
12
//head等于tail说明目前还没有事件传回来，如果设置了非阻塞操作，则会立刻返回
13
if (client->packet_head == client->tail && evdev->exist &&
14 (file->f_flags & O_NONBLOCK))
15
return -EAGAIN;
16
//没有事件就会睡在evdev的等待队列上了，等待条件是有事件到来或者设备不存在了
17 retval = wait_event_interruptible(evdev->wait,
18 client->packet_head != client->tail || !evdev->exist);
19
20
if (retval)
21
//如果能执行上面这条语句说明有事件传来或者，设备被关闭了，或者内核发过来终止信号
22
return retval;
23
24
if (!evdev->exist)
25
return -ENODEV;
26
27
while (retval + input_event_size() <= count &&
28 evdev_fetch_next_event(client, &event)) {
29 //evdev_fetch_next_event这个函数遍历client里面的input_eventbuffer数组
30
if (input_event_to_user(buffer + retval, &event))//将事件复制到用户空间
31
return -EFAULT;
32
33 retval += input_event_size();
34 }
六、事件传递过程
1.事件产生
当按下触摸屏时，进入触摸屏按下中断，开始ad转换，ad转换完成进入ad完成中断，在这个中端中将事件发送出去，调用
input_report_abs(dev,ABS_X,xp);
input_report_abs(dev,ABS_Y,yp);
这两个函数调用了input_event(dev,EV_ABS,code,value)
所有的事件报告函数都调用这个函数。
2、事件报告
1）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
//事件处理函数
12 input_handle_event(dev, type, code, value);
13 spin_unlock_irqrestore(&dev->event_lock, flags);
14 }
15 }
2）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
case EV_SYN:
9
switch (code) {
10
case SYN_CONFIG:
11 disposition = INPUT_PASS_TO_ALL;
12
break;
13
14
case SYN_REPORT:
15
if (!dev->sync) {
16 dev->sync = true;
17 disposition = INPUT_PASS_TO_HANDLERS;
18 }
19
break;
20
case SYN_MT_REPORT:
21 dev->sync = false;
22 disposition = INPUT_PASS_TO_HANDLERS;
23
break;
24 }
25
break;
26
27
case EV_KEY:
28
if (is_event_supported(code, dev->keybit, KEY_MAX) &&
29
!!test_bit(code, dev->key) != value) {
30
31
if (value != 2) {
32 __change_bit(code, dev->key);
33
if (value)
34 input_start_autorepeat(dev, code);
35
else
36 input_stop_autorepeat(dev);
37 }
38
39 disposition = INPUT_PASS_TO_HANDLERS;
40 }
41
break;
42
43
case EV_SW:
44
if (is_event_supported(code, dev->swbit, SW_MAX) &&
45
!!test_bit(code, dev->sw) != value) {
46
47 __change_bit(code, dev->sw);
48 disposition = INPUT_PASS_TO_HANDLERS;
49 }
50
break;
51
52
case EV_ABS:
53
if (is_event_supported(code, dev->absbit, ABS_MAX))
54 disposition = input_handle_abs_event(dev, code, &value);
55
56
break;
57
58
case EV_REL:
59
if (is_event_supported(code, dev->relbit, REL_MAX) && value)
60 disposition = INPUT_PASS_TO_HANDLERS;
61
62
break;
63
64
case EV_MSC:
65
if (is_event_supported(code, dev->mscbit, MSC_MAX))
66 disposition = INPUT_PASS_TO_ALL;
67
68
break;
69
70
case EV_LED:
71
if (is_event_supported(code, dev->ledbit, LED_MAX) &&
72
!!test_bit(code, dev->led) != value) {
73
74 __change_bit(code, dev->led);
75 disposition = INPUT_PASS_TO_ALL;
76 }
77
break;
78
79
case EV_SND:
80
if (is_event_supported(code, dev->sndbit, SND_MAX)) {
81
82
if (!!test_bit(code, dev->snd) != !!value)
83 __change_bit(code, dev->snd);
84 disposition = INPUT_PASS_TO_ALL;
85 }
86
break;
87
88
case EV_REP:
89
if (code <= REP_MAX && value >= 0 && dev->rep[code] != value) {
90 dev->rep[code] = value;
91 disposition = INPUT_PASS_TO_ALL;
92 }
93
break;
94
95
case EV_FF:
96
if (value >= 0)
97 disposition = INPUT_PASS_TO_ALL;
98
break;
99
100
case EV_PWR:
101 disposition = INPUT_PASS_TO_ALL;
102
break;
103 }
104
105
if (disposition != INPUT_IGNORE_EVENT && type != EV_SYN)
106 dev->sync = false;
107
108
if ((disposition & INPUT_PASS_TO_DEVICE) && dev->event)
109 dev->event(dev, type, code, value);
110
111
if (disposition & INPUT_PASS_TO_HANDLERS)
112 input_pass_event(dev, type, code, value);
113 }
这个函数主要是根据事件类型的不同，做相应的处理。disposition这个是事件处理的方式，默认的是
INPUT_IGNORE_EVENT，忽略这个事件，如果是INPUT_PASS_TO_HANDLERS则是传递给事件处理器，如果是
INPUT_PASS_TO_DEVICE，则是传递给设备处理。
3）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_handler *handler;
5
struct input_handle *handle;
6
7 rcu_read_lock();
8 //如果是绑定的handle，则调用绑定的handler->event函数
9 handle = rcu_dereference(dev->grab);
10
if (handle)
11 handle->handler->event(handle, type, code, value);
12
else {
13
bool filtered = false;
14 //如果没有绑定，则遍历dev的h_list链表，寻找handle，如果handle已经打开，说明有进程读取设备关联的evdev
15 list_for_each_entry_rcu(handle, &dev->h_list, d_node) {
16
if (!handle->open)
17
continue;
18
19 handler = handle->handler;
20
if (!handler->filter) {
21
if (filtered)
22
break;
23 //调用相关的事件处理器的event函数，进行事件的处理
24 handler->event(handle, type, code, value);
25
26 } else if (handler->filter(handle, type, code, value))
27 filtered = true;
28 }
29 }
30
31 rcu_read_unlock();
32 }
4）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
//将传过来的事件，赋值给input_event结构
8 do_gettimeofday(&event.time);
9 event.type = type;
10 event.code = code;
11 event.value = value;
12
13 rcu_read_lock();
14
//如果evdev绑定了client那么，处理这个客户端
15 client = rcu_dereference(evdev->grab);
16
if (client)
17 evdev_pass_event(client, &event);
18
else
19
//遍历client链表，调用evdev_pass_event函数
20 list_for_each_entry_rcu(client, &evdev->client_list, node)
21 evdev_pass_event(client, &event);
22
23 rcu_read_unlock();
24
if (type == EV_SYN && code == SYN_REPORT)
25 {//唤醒等待的进程
26 wake_up_interruptible(&evdev->wait);
27 }
5）evdev_pass_event()函数
1 static void evdev_pass_event(struct evdev_client *client,
2
struct input_event *event)
3 {
4
/* Interrupts are disabled, just acquire the lock. */
5 spin_lock(&client->buffer_lock);
6 //将事件赋值给客户端的input_event数组
7 client->buffer[client->head++] = *event;
8 client->head &= client->bufsize - 1;
9
10
if (unlikely(client->head == client->tail)) {
11
/*
12 * This effectively "drops" all unconsumed events, leaving
13 * EV_SYN/SYN_DROPPED plus the newest event in the queue.
14 */
15 client->tail = (client->head - 2) & (client->bufsize - 1);
16
17 client->buffer[client->tail].time = event->time;
18 client->buffer[client->tail].type = EV_SYN;
19 client->buffer[client->tail].code = SYN_DROPPED;
20 client->buffer[client->tail].value = 0;
21
22 client->packet_head = client->tail;
23 }
24
25
if (event->type == EV_SYN && event->code == SYN_REPORT) {
26 client->packet_head = client->head;
27 kill_fasync(&client->fasync, SIGIO, POLL_IN);
28 }
29
30 spin_unlock(&client->buffer_lock);
31 }
实例
buttons.c
1 /* 参考C:\Users\liang\Desktop\linux-2.6.22.6\drivers\input\keyboard\gpio_keys.c */
2
3 /* 1、包含头文件 */
4 #include <linux/module.h>
5 #include <linux/version.h>
6
7 #include <linux/init.h>
8 #include <linux/fs.h>
9 #include <linux/interrupt.h>
10 #include <linux/irq.h>
11 #include <linux/sched.h>
12 #include <linux/pm.h>
13 #include <linux/sysctl.h>
14 #include <linux/proc_fs.h>
15 #include <linux/delay.h>
16 #include <linux/platform_device.h>
17 #include <linux/input.h>
18 #include <linux/irq.h>
19
20 #include <asm/gpio.h>
21 /******** 1 END ********/
22
23 static struct input_dev *buttons_dev;
24
25 //定义一个定时器
26 struct pin_desc* irq_pd;
27 static struct timer_list buttons_timer;
28
29 static struct pin_desc {
30 int irq;
31 char *name;
32 unsigned int pin;
33 unsigned int key_val;
34 };
35
36 static struct pin_desc pins_desc[3] = {
37 {IRQ_EINT0, "S2", S3C2410_GPF0, KEY_L},
38 {IRQ_EINT2, "S3", S3C2410_GPF2, KEY_S},
39 {IRQ_EINT19, "S5", S3C2410_GPG11, KEY_ENTER},
40 };
41
42 /* 按键中断处理函数――启动定时器 */
43
44 static irqreturn_t handle_buttons(int irq, void *pin_dc)
45 {
46 /* 每次发生中断，10ms后启动定时器，定时器超时，再读取键值，实现按键消抖 */
47 irq_pd = (struct pin_desc*)pin_dc;
48 mod_timer(&buttons_timer, jiffies+HZ/100); //修改定时器超时时间，启动定时器
49
50 return IRQ_RETVAL(IRQ_HANDLED);
51 }
52
53 /* 定时器超时处理函数――读取键值 */
54 static void handle_buttons_timer(unsigned long data)
55 {
56 unsigned int kval;
57 struct pin_desc *pinDesc = irq_pd;
58
59 //定时器初次初始化完成，超时处理，此时并未发生过按键中断
60 if (!pinDesc)
61 {
62 return;
63 }
64
65 /* 7、上报事件 */
66 kval = s3c2410_gpio_getpin(pinDesc->pin);
67 //松开:param 4:0
68 if (kval)
69 {
70 input_event(buttons_dev, EV_KEY, pinDesc->key_val, 0);
71 input_sync(buttons_dev);
72 }
73 //按下:param 4:1
74 else
75 {
76 input_event(buttons_dev, EV_KEY, pinDesc->key_val, 1);
77 input_sync(buttons_dev);
78 }
79 /******** 7 END ********/
80
81 //唤醒休眠进程
82 //ev_press = 1; //中断发生标志
83 //wake_up_interruptible(&button_waitq);
84
85 //kill_fasync(&button_fasyncq, SIGIO, POLL_IN);
86 }
87
88
89 /* 2、编写出入口函数 */
90 static int __init buttons_init(void)
91 {
92 char i;
93
94 /* 3、分配一个input_dev结构体 */
95 buttons_dev = input_allocate_device();
96 /******** 3 END ********/
97
98 /* 4、设置 */
99 //a、设置事件类――按键类事件
100 set_bit(EV_KEY, buttons_dev->evbit);
101
102 //b、产生哪些按键――l、s、enter
103 set_bit(KEY_L, buttons_dev->keybit);
104 set_bit(KEY_S, buttons_dev->keybit);
105 set_bit(KEY_ENTER, buttons_dev->keybit);
106 /******** 4 END ********/
107
108 /* 5、注册 */
109 input_register_device(buttons_dev);
110 /******** 5 END ********/
111
112 /* 6、硬件相关操作 */
113 /* 初始化定时器 */
114 init_timer(&buttons_timer);
115 buttons_timer.expires = 0; //设置定时器超时，默认初始化完成后进入休眠
116 buttons_timer.function = handle_buttons_timer; //注册定时器超时处理函数
117 add_timer(&buttons_timer);
118
119 /* 申请中断 */
120 for(i=0; i<3; i++)
121 {
122 request_irq(pins_desc[i].irq, handle_buttons, IRQT_BOTHEDGE, pins_desc[i].name, &pins_desc[i]);
123 }
124 /******** 6 END ********/
125
126 return 0;
127 }
128
129 static void __exit buttons_exit(void)
130 {
131 char i;
132
133 /* 释放中断 */
134 for(i=0; i<3; i++)
135 {
136 free_irq(pins_desc[0].irq, &pins_desc[i]);
137 }
138 del_timer(&buttons_timer);
139 input_unregister_device(buttons_dev);
140 input_free_device(buttons_dev);
141 return 0;
142 }
143
144 module_init(buttons_init);
145 module_exit(buttons_exit);
146 MODULE_LICENSE("GPL");
147 /******** 2 END ********/
调试
操作：
运行结果：
调试方法：
