- 为什么要引入输入子系统？
在前面我们写了一些简单的字符设备的驱动程序，我们是怎么样打开一个设备并操作的呢？
一般都是在执行应用程序时，open一个特定的设备文件，如：/dev/buttons
1 ..... 2 int main(int argc, char **argv) 3 { 4 unsigned char key_val; 5 int ret; 6 fd = open("/dev/buttons", O_RDWR); //默认为阻塞操作 7 if (fd < 0) 8 { 9 printf("can't open! "); 10 return -1; 11 } 12 ......
但是实际上，一般的应用程序不会去打开这样设备文件“/dev/buttons”。一般打开的都是系统原有的文件，如“ dev/tty* ” ,还有可能是不需要打开什么tty，
而是直接“scanf()”就去获得了按键的输入。
以前我们写一些输入设备（键盘、鼠标等）的驱动都是采用字符设备、混杂设备处理的。问题由此而来，Linux开源社区的大神们看到了这大量输入设备如此分散不堪，有木有可以实现一种机制，可以对分散的、不同类别的输入设备进行统一的驱动，所以才出现了输入子系统。
输入子系统引入的好处：
（1）统一了物理形态各异的相似的输入设备的处理功能。例如，各种鼠标，不论PS/2、USB、还是蓝牙，都被同样处理。
（2）提供了用于分发输入报告给用户应用程序的简单的事件（event）接口。你的驱动不必创建、管理/dev节点以及相关的访问方法。因此它能够很方便的调用输入API以发送鼠标移动、键盘按键，或触摸事件给用户空间。X windows这样的应用程序能够无缝地运行于输入子系统提供的event接口之上。
（3）抽取出了输入驱动的通用部分，简化了驱动，并提供了一致性。例如，输入子系统提供了一个底层驱动（成为serio）的集合，支持对串口和键盘控制器等硬件输入的访问
详见《精通Linux设备驱动程序开发》
1.Linux输入子系统框架
linux输入子系统（linux input subsystem）从上到下由三层实现，分别为：
输入子系统事件处理层（EventHandler）
输入子系统核心层（InputCore）
输入子系统设备驱动层（input driver）
1.输入子系统设备驱动层：主要实现对硬件设备的读写访问，中断设置，并把硬件产生的事件转换为核心层定义的规范提交给事件处理层。
2.核心层：承上启下。为驱动层提供输入设备注册与操作接口，如：input_register_device;通知事件处理层对事件进行处理；在/Proc下产生相应的设备信息。
设备驱动层只要关心如何驱动硬件并获得硬件数据（例如按下的按键数据），然后调用核心层提供的接口，核心层会自动把数据提交给事件处理层。
3.事件处理层：是用户编程的接口（设备节点），并处理驱动层提交的数据处理。
（Linux中在用户空间将所有的设备都当做文件来处理，由于在一般的驱动程序中都有提供fops接口，以及在/dev下生成相应的设备文件nod，这些操作在输入子系统中由事件处理层完成）
输入子系统中有两个类型的驱动，当我们要为一个输入设备（如触摸屏）的编写驱动的时候，我们是要编写两个驱动：输入设备驱动和输入事件驱动？
答案是否定的。在子系统中，事件驱动是标准的，对所有的输入类都是可以用的，所以你更可能的是实现输入设备驱动而不是输入事件驱动。你的设备可以利用一个已经存在的，合适的输入事件驱动通过输入核心和用户应用程序接口。
输入设备都各有不同，那么输入子系统也就只能实现他们的共性，差异性则由设备驱动来实现。差异性又体现在哪里？
最直观体现在设备功能上的不同。对于驱动编写者来说，在设备驱动中就只要使用输入子系统提供的工具（也就是函数）来完成这些“差异”就行了，其他的则是输入子系统的工作。这个思想不仅存在于输入子系统，其他子系统也是一样(比如:usb子系统、video子系统等)
先分析核心层的代码 Input.c
以下转载自Linux之输入子系统分析(详解)
Input.c
在最后有一下两段：
subsys_initcall(input_init); //修饰入口函数 module_exit(input_exit); //修饰出口函数
可知，子系统是作为一个模块存在的。
1.先来分析入口函数input_init
1 static int __init input_init(void) 2 { 3 int err; 4 5 err = class_register(&input_class); //注册类，放在/sys/class 6 if (err) { 7 printk(KERN_ERR "input: unable to register input_dev class "); 8 return err; 9 } 10 11 err = input_proc_init(); //在/proc下建立相关文件 12 if (err) 13 goto fail1; 14 15 err = register_chrdev(INPUT_MAJOR, "input", &input_fops); //注册驱动 16 if (err) { 17 printk(KERN_ERR "input: 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 }
（1）上面第5行，class_register(&input_class)，是在/sys/class中创建一个input类，input_class类结构如下：
struct class input_class = { .name = "input", .release = input_dev_release, .uevent = input_dev_uevent, };
如下图,我们启动内核,再启动一个input子系统的驱动后，也可以看到创建了个"input"类 :
疑问：为什么在此只创建了类，却没有使用class_dev_create()函数在类下面创建驱动设备？
当注册了input子系统的驱动后，才会有设备驱动，此处代码没有驱动。以下会详细解释。
（2）上面第15行通过register_chrdev创建驱动设备,其中变量INPUT_MAJOR =13,所以创建了一个主设备为13的"input"设备。
然后我们来看看它的操作结构体input_fops,如下
static const struct file_operations input_fops = { .owner = THIS_MODULE, .open = input_open_file, };
只有一个.open函数,比如当我们挂载一个新的input驱动,则内核便会调用该.open函数,接下来分析该.open函数
2.进入input_open_file函数(drivers/input/input.c)
1 static int input_open_file(struct inode *inode, struct file *file) 2 { 3 struct input_handler *handler = input_table[iminor(inode) >> 5]; // (1) 4 const struct file_operations *old_fops, *new_fops = NULL; 5 int err; 6 7 if (!handler || !(new_fops = fops_get(handler->fops))) //(2) 8 return -ENODEV; 9 10 if (!new_fops->open) { 11 fops_put(new_fops); 12 return -ENODEV; 13 } 14 15 old_fops = file->f_op; 16 file->f_op = new_fops; //(3) 17 18 err = new_fops->open(inode, file); //(4) 19 if (err) { 20 fops_put(file->f_op); 21 file->f_op = fops_get(old_fops); 22 } 23 24 fops_put(old_fops); 25 26 return err; 27 }
(1)第3行中,其中iminor (inode)函数调用了MINOR(inode->i_rdev);读取子设备号,然后将子设备除以32,找到新挂载的input驱动的数组号,然后放在input_handler 驱动处理函数handler中
(2)第7行中,若handler有值,说明挂载有这个驱动,就将handler结构体里的成员file_operations * fops赋到新的file_operations *old_fops里面
(3)第16行中, 再将新的file_operations *old_fops赋到file-> file_operations *f_op里, 此时input子系统的file_operations就等于新挂载的input驱动的file_operations结构体,实现一个偷天换日的效果.
(4)第18行中,然后调用新挂载的input驱动的*old_fops里面的成员.open函数
3.上面代码的input_table[]数组在初始时是没有值的,
所以我们来看看input_table数组里面的数据又是在哪个函数里被赋值
在input.c函数(drivers/input/input.c)中搜索input_table,找到它在input_register_handler()函数中被赋值,代码如下:
int input_register_handler(struct input_handler *handler) { ... ... input_table[handler->minor >> 5] = handler; //input_table[]被赋值 ... ... list_add_tail(&handler->node, &input_handler_list); //然后将这个input_handler放到input_handler_list链表中 ... ...
list_for_each_entry(dev, &input_dev_list, node) //对于每一个input_dev,调用input_attach_handler
input_attach_handler(dev, handler); //根据input_handler的id_table判断能否支持这个input_dev
}
就是将驱动处理程序input_handler注册到input_table[]中，然后放在input_handler_list链表中,后面会讲这个链表
4.继续来搜索input_register_handler,看看这个函数被谁来调用
如下图所示,有evdev.c(事件设备)，tsdev.c(触摸屏设备)，joydev.c(joystick操作杆设备)，keyboard.c(键盘设备)，mousedev.c(鼠标设备) 这5个内核自带的设备处理函数注册到input子系统中
以evdev.c为例,它在evdev_ini()函数中注册:
static int __init evdev_init(void) { return input_register_handler(&evdev_handler); //注册 }
5.我们来看看这个evdev_handler变量是什么结构体,:
1 static struct input_handler evdev_handler = { 2 .event = evdev_event, 3 .connect = evdev_connect, //(4) 4 .disconnect = evdev_disconnect, 5 .fops = &evdev_fops, //(1) 6 .minor = EVDEV_MINOR_BASE, //(2) 7 .name = "evdev", 8 .id_table = evdev_ids, //(3) 9 };
就是我们之前看的input_handler驱动处理结构体
(1) 第5行中.fops:文件操作结构体,其中evdev_fops函数就是自己的写的操作函数,然后赋到.fops中
(2)第6行中 .minor:用来存放次设备号
其中EVDEV_MINOR_BASE=64, 然后调用input_register_handler(&evdev_handler)后,由于EVDEV_MINOR_BASE/32=2,所以存到input_table[2]中
所以当open打开这个input设备,就会进入 input_open_file()函数,执行evdev_handler-> evdev_fops -> .open函数,如下所示:
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 };
(3)第8行中.id_table : 表示能支持哪些输入设备，比如某个驱动设备的input_dev->的id和某个input_handler的id_table相匹配，就会调用.connect连接函数,如下图
(4)第3行中.connect:连接函数，将设备input_dev和某个input_handler建立连接,如下图
6.我们先来看看上图的input_register_device()函数,如何创建驱动设备的
搜索input_register_device,发现内核自己就已经注册了很多驱动设备
6.1然后进入input_register_device()函数,代码如下:
1 int input_register_device(struct input_dev *dev) //*dev:要注册的驱动设备 2 { 3 ... ... 4 list_add_tail(&dev->node, &input_dev_list); //(1)放入链表中 5 ... ... 6 list_for_each_entry(handler, &input_handler_list, node) //(2) 7 input_attach_handler(dev, handler); 8 ... ... 9 }
(1)第4行中,将要注册的input_dev驱动设备放在input_dev_list链表中
(2)第6行中,其中input_handler_list在前面讲过,就是存放每个input_handle驱动处理结构体,
然后list_for_each_entry()函数会将每个input_handle从链表中取出,放到handler中
最后会调用input_attach_handler()函数,将每个input_handle的id_table进行判断,若两者支持便进行连接。
6.2然后我们在回过头来看注册input_handler的input_register_handler()函数,如下图所示
在input.c中
1 int input_register_handler(struct input_handler *handler) 2 { 3 struct input_dev *dev; 4 5 INIT_LIST_HEAD(&handler->h_list); 6 7 if (handler->fops != NULL) { 8 if (input_table[handler->minor >> 5]) 9 return -EBUSY; 10 11 input_table[handler->minor >> 5] = handler; //放入数组 12 } 13 14 list_add_tail(&handler->node, &input_handler_list); //放入链表 15 16 list_for_each_entry(dev, &input_dev_list, node) //对于每一个input_dev,调用input_attach_handler 17 input_attach_handler(dev, handler); 18 19 input_wakeup_procfs_readers(); 20 return 0;
所以,不管新添加input_dev还是input_handler,都会进入input_attach_handler()判断两者id是否有支持, 若两者支持便进行连接
6.3我们来看看input_attach_handler()如何实现匹配两者id的:
1 static int input_attach_handler(struct input_dev *dev, struct input_handler *handler) 2 { 3 ... ... 4 id = input_match_device(handler->id_table, dev); //匹配两者 5 6 if (!id) //若不匹配,return退出 7 return -ENODEV; 8 9 error = handler->connect(handler, dev, id); //调用input_handler ->connect函数建立连接 10 ... ... 11 12 }
根据input_handler的id_table判断能否支持这个input_dev
如果能支持，则调用input_handler的connect函数建立“连接”
7.以evdev.c(事件驱动) 的evdev_handler->connect函数来分析是怎样建立连接的,如下:
1 static struct input_handler evdev_handler = { 2 .event = evdev_event, 3 .connect = evdev_connect, 4 .disconnect = evdev_disconnect, 5 .fops = &evdev_fops, 6 .minor = EVDEV_MINOR_BASE, 7 .name = "evdev", 8 .id_table = evdev_ids, 9 };
7.1 evdev_handler的.connect函数是evdev_connect(),代码如下:
1 static int evdev_connect(struct input_handler *handler, struct input_dev *dev, const struct input_device_id *id) 2 { 3 ... ... 4 for (minor = 0; minor < EVDEV_MINORS && evdev_table[minor]; minor++); //查找驱动设备的子设备号 5 if (minor == EVDEV_MINORS) { // EVDEV_MINORS=32,所以该事件下的驱动设备最多存32个, 6 printk(KERN_ERR "evdev: no more free evdev devices "); 7 return -ENFILE; //没找到驱动设备 8 } 9 ... ... 10 evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL); //分配一个input_handle全局结构体(没有r) 11 ... ... 12 evdev->handle.dev = dev; //指向参数input_dev驱动设备 13 evdev->handle.name = evdev->name; 14 evdev->handle.handler = handler; //指向参数 input_handler驱动处理结构体 15 evdev->handle.private = evdev; 16 sprintf(evdev->name, "event%d", minor); //(1)保存驱动设备名字, event%d 17 ... ... 18 devt = MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor), //(2) 将主设备号和次设备号转换成dev_t类型 19 cdev = class_device_create(&input_class, &dev->cdev, devt,dev->cdev.dev, evdev->name); 20 // (3)在input类下创建驱动设备 21 22 ... ... 23 error = input_register_handle(&evdev->handle); //(4)注册这个input_handle结构体 24 25 ... ... 26 }
(1) 第16行中,是在保存驱动设备名字,名为event%d, 比如下图(键盘驱动)event1: 因为没有设置子设备号，默认从小到大排列,其中event0是表示这个input子系统,所以这个键盘驱动名字就是event1
(2)第18行中,是在保存驱动设备的主次设备号,其中主设备号INPUT_MAJOR=13,因为EVDEV_MINOR_BASE=64,所以此设备号=64+驱动程序本事子设备号, 比如下图(键盘驱动)event1: 主次设备号就是13,65
(3)在之前在2小结里就分析了input_class类结构，所以第19行中,会在/sys/class/input类下创建驱动设备event%d，比如下图(键盘驱动)event1:
(4)最终会进入input_register_handle()函数来注册,代码在下面
7.2 input_register_handle()函数如下:
1 int input_register_handle(struct input_handle *handle) 2 { 3 struct input_handler *handler = handle->handler; //handler= input_handler驱动处理结构体 4 5 list_add_tail(&handle->d_node, &handle->dev->h_list); //(1) 6 list_add_tail(&handle->h_node, &handler->h_list); // (2) 7 8 if (handler->start) 9 handler->start(handle); 10 return 0; 11 }
(1)在第5行中, 因为handle->dev指向input_dev驱动设备,所以就是将handle->d_node放入到input_dev驱动设备的h_list链表中,
即input_dev驱动设备的h_list链表就指向handle->d_node
(2) 在第6行中, 同样, input_handler驱动处理结构体的h_list也指向了handle->h_node
最终如下图所示:
两者的.h_list都指向了同一个handle结构体，然后通过.h_list 来找到handle的成员.dev和handler,便能找到对方,便建立了连接
8.建立了连接后，又如何读取evdev.c(事件驱动) 的evdev_handler->.fops->.read函数？
事件驱动的.read函数是evdev_read()函数,我们来分析下:
1 static ssize_t evdev_read(struct file *file, char __user * buffer, size_t count, loff_t *ppos) 2 { 3 ... ... 4 /*判断应用层要读取的数据是否正确*/ 5 if (count < evdev_event_size()) 6 return -EINVAL; 7 8 /*在非阻塞操作情况下,若client->head == client->tail|| evdev->exist时(没有数据),则return返回*/ 9 if (client->head == client->tail && evdev->exist && (file->f_flags & O_NONBLOCK)) 10 return -EAGAIN; 11 12 /*若client->head == client->tail|| evdev->exist时(没有数据),等待中断进入睡眠状态 */ 13 retval = wait_event_interruptible(evdev->wait,client->head != client->tail || !evdev->exist); 14 15 ... ... //上传数据 16 17 }
9.若read函数进入了休眠状态，又是谁来唤醒？
我们搜索这个evdev->wait这个等待队列变量,找到evdev_event函数里唤醒:
static void evdev_event(struct input_handle *handle, unsigned int type, unsigned int code, int value) { ... ... wake_up_interruptible(&evdev->wait); //有事件触发，便唤醒等待中断 }
其中evdev_event()是evdev.c(事件驱动) 的evdev_handler->.event成员,如下所示:
1 static struct input_handler evdev_handler = { 2 .event = evdev_event, 3 .connect = evdev_connect, 4 .disconnect = evdev_disconnect, 5 .fops = &evdev_fops, 6 .minor = EVDEV_MINOR_BASE, 7 .name = "evdev", 8 .id_table = evdev_ids, 9 };
当有事件发生了,比如对于按键驱动,当有按键按下时,就会进入.event函数中处理事件
10.分析下,是谁调用evdev_event()这个.event事件驱动函数
猜测：硬件相关的代码（input_dev那层）--中断处理函数
来看看内核 gpio_keys_isr()函数代码例子就知道了 (driver/input/keyboard/gpio_key.c)
1 static irqreturn_t gpio_keys_isr(int irq, void *dev_id) 2 { 3 /*获取按键值,赋到state里*/ 4 ... ... 5 6 /*上报事件*/ 7 input_event(input, type, button->code, !!state); 8 input_sync(input); //同步信号通知,表示事件发送完毕 9 }
显然就是通过input_event()来调用.event事件函数,我们来看看:
1 void input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value) 2 { 3 struct input_handle *handle; 4 ... ... 5 6 /* 通过input_dev ->h_list链表找到input_handle驱动处理结构体*/ 7 list_for_each_entry(handle, &dev->h_list, d_node) 8 if (handle->open) //如果input_handle之前open 过,那么这个就是我们的驱动处理结构体 9 handle->handler->event(handle, type, code, value); //调用evdev_event()的.event事件函数 10 11 }
若之前驱动input_dev和处理input_handler已经通过input_handler 的.connect函数建立起了连接,那么就调用evdev_event()的.event事件函数，如下图所示:
11.本节总结分析:
1.注册输入子系统,进入input_init():
1)创建主设备号为13的"input"字符设备
err = register_chrdev(INPUT_MAJOR, "input", &input_fops);
2.open打开驱动,进入input_open_file():
1)更新设备的file_oprations
file->f_op=fops_get(handler->fops);
2)执行file_oprations->open函数
err = new_fops->open(inode, file);
3.注册input_handler,进入input_register_handler():
1)添加到input_table[]处理数组中
input_table[handler->minor >> 5] = handler;
2）添加到input_handler_list链表中
list_add_tail(&handler->node, &input_handler_list);
3)判断input_dev的id,是否有支持这个驱动的设备
list_for_each_entry(dev, &input_dev_list, node) //遍历查找input_dev_list链表里所有input_dev input_attach_handler(dev, handler); //判断两者id,若两者支持便进行连接。
4.注册input_dev，进入input_register_device():
1)放在input_dev_list链表中
list_add_tail(&dev->node, &input_dev_list);
2)判断input_handler的id，是否有支持这个设备的驱动
list_for_each_entry(handler, &input_handler_list, node) //遍历查找input_handler_list链表里所有input_handler input_attach_handler(dev, handler); //判断两者id,若两者支持便进行连接。
5.判断input_handler和input_dev的id,进入input_attach_handler():
1）匹配两者id,
input_match_device(handler->id_table, dev); //匹配input_handler和dev的id,不成功退出函数
2)匹配成功调用input_handler ->connect
handler->connect(handler, dev, id); //建立连接
6.建立input_handler和input_dev的连接，进入input_handler->connect():
1)创建全局结构体,通过input_handle结构体连接双方
evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL); //创建两者连接的input_handle全局结构体 list_add_tail(&handle->d_node, &handle->dev->h_list); //连接input_dev->h_list list_add_tail(&handle->h_node, &handler->h_list); // 连接input_handle->h_list
7.有事件发生时,比如按键中断,在中断函数中需要进入input_event()上报事件:
1)找到驱动处理结构体，然后执行input_handler->event()
list_for_each_entry(handle, &dev->h_list, d_node) // 通过input_dev ->h_list链表找到input_handle驱动处理结构体 if (handle->open) //如果input_handle之前open 过,那么这个就是我们的驱动处理结构体(有可能一个驱动设备在不同情况下有不同的驱动处理方式) handle->handler->event(handle, type, code, value); //调用evdev_event()的.event事件函数