input子系统的实现

//////////////////////////////////////////////////////////////////////////////////////////////////////////////

input子系统的实现


///////////////////////////////////////////////////////////////////////////////////////////////////////////////

 

一、问: 为何要基于input子系统?

答: 因为linux下所有GUI都可以接收input子系统的消息。写基于GUI的程序时可以用GUI实现的按键机制,而不是单片机的思维，一个死循环来处理用户输入。

 

二、input子系统运用场景初体验

 

接下来我们先做一个测试：看看input子系统在虚拟机的linux系统底下运用场景：

将附件中的文件../usr_key/button_input/usr/button_testc.c，做如下两个操作

1、先直接linux下gcc执行生成测试文件



2、利用linux下的事件完成测试，event1事件是我们的键盘事件，也可以用mouse0事件



3、现象如下图所示：



三、用input子系统于ARM2440开发板实现按键中断

例程：如附件：../usr_key/button_input/..

具体的下载操作指令：见附件../交叉编译的使用

另外添加如下知识点：

指令：cat /proc/bus/input/devices    查看挂载在input子系统下的设备

   cd /sys/class/input/input_lzh 查看我们挂载的按键子设备（在这说明input_lzh是我当前源程序中对应的设备名称）

 

四、浅析input子系统

 

         输入设备总类繁杂，包括按键，键盘，触摸屏，鼠标，摇杆等等，它们本身都是字符设备，不过内核为了能将这些设备的共性抽象出来，简化驱动的开发，建立了一个Input子系统。Input子系统分为三层，从下至上分别是输入设备驱动层，输入核心层以及输入事件驱动层。这三层中的输入核心层和输入事件驱动层都是内核已经完成了的，因此需要我们完成的只有输入设备驱动层。考虑输入设备主要的工作过程都是 动作产生(按键，触屏……)-->产生中断-->读取数值(键值，坐标……)-->将数值传递给应用程序。最后一个步骤就属于事件的处理，对于同一类设备，他们的处理方式都是相同的，因此内核已在事件驱动层为我们做好了，不需我们操心，而产生中断-->读取数值是因设备而异的，需要我们根据具体的设备来编写驱动。一个大致的工作流程就是，input device向上层报告-->input core接收报告，并根据在注册input device时建立好的连接选择哪一类handler来处理事件-->通过handler将数据存放在相应的dev(evdev,mousedev…)实例的缓冲区中，等待应用程序来读取。当然，有时候也需要从应用层向设备层逆向传递，比如控制一些和设备相关的LED，蜂鸣器等。设备驱动层，输入核心层和事件处理层之间的

 

 

关系可以用下图来阐释:



 

 

 

接下来让我们进入源码中

 

一切尽在源码中！

 

下面我们分析一下输入子系统的数据结构（即贯穿整个系统的三个链表），具体结构如下图：

1.1、input_dev,即我们设备输入层

 

1. struct input_dev {  
2.     const char *name;  
3.     const char *phys;  
4.     const char *uniq;  
5.     struct input_id id;//与input_handler匹配用的id，包括  
6.   
7.     unsigned long evbit[BITS_TO_LONGS(EV_CNT)];    //设备支持的事件类型  
8.     unsigned long keybit[BITS_TO_LONGS(KEY_CNT)];  //按键事件支持的子事件类型  
9.     unsigned long relbit[BITS_TO_LONGS(REL_CNT)];  //相对坐标事件支持的子事件类型  
10.     unsigned long absbit[BITS_TO_LONGS(ABS_CNT)];  //绝对坐标事件支持的子事件类型  
11.     unsigned long mscbit[BITS_TO_LONGS(MSC_CNT)];    
12.     unsigned long ledbit[BITS_TO_LONGS(LED_CNT)];    
13.     unsigned long sndbit[BITS_TO_LONGS(SND_CNT)];    
14.     unsigned long ffbit[BITS_TO_LONGS(FF_CNT)];       
15.     unsigned long swbit[BITS_TO_LONGS(SW_CNT)];  
16.   
17.     unsigned int keycodemax;  
18.     unsigned int keycodesize;  
19.     void *keycode;  
20.     int (*setkeycode)(struct input_dev *dev, int scancode, int keycode);  
21.     int (*getkeycode)(struct input_dev *dev, int scancode, int *keycode);  
22.   
23.     struct ff_device *ff;  
24.   
25.     unsigned int repeat_key; //最近一次的按键值  
26.     struct timer_list timer;  
27.   
28.     int sync;  
29.   
30.     int abs[ABS_MAX + 1];  
31.     int rep[REP_MAX + 1];  
32.   
33.     unsigned long key[BITS_TO_LONGS(KEY_CNT)];//反应设备当前的按键状态  
34.     unsigned long led[BITS_TO_LONGS(LED_CNT)];//反应设备当前的led状态  
35.     unsigned long snd[BITS_TO_LONGS(SND_CNT)];//反应设备当前的声音输入状态  
36.     unsigned long sw[BITS_TO_LONGS(SW_CNT)];  //反应设备当前的开关状态  
37.   
38.     int absmax[ABS_MAX + 1];//来自绝对坐标事件的最大键值  
39.     int absmin[ABS_MAX + 1];//来自绝对坐标事件的最小键值  
40.     int absfuzz[ABS_MAX + 1];  
41.     int absflat[ABS_MAX + 1];  
42.   
43.     int (*open)(struct input_dev *dev);  //第一次打开设备时调用，初始化设备用  
44.     void (*close)(struct input_dev *dev);//最后一个应用程序释放设备时用，关闭设备  
45.     int (*flush)(struct input_dev *dev, struct file *file);  
46.     /*用于处理传递给设备的事件，如LED事件和声音事件*/  
47.     int (*event)(struct input_dev *dev, unsigned int type, unsigned int code, int value);  
48.   
49.     struct input_handle *grab;//当前占有该设备的input_handle  
50.   
51.     spinlock_t event_lock;  
52.     struct mutex mutex;  
53.   
54.     unsigned int users;//打开该设备的用户数量(input handlers)  
55.     int going_away;  
56.   
57.     struct device dev;  
58.   
59.     struct list_head    h_list;//该链表头用于链接此设备所关联的input_handle  
60.     struct list_head    node;  //用于将此设备链接到input_dev_list  
61. };  

 

1.2、input_handler事件驱动层

1. struct input_handler {  
2.   
3.     void *private;  
4.   
5.     /*event用于处理事件*/  
6.     void (*event)(struct input_handle *handle, unsigned int type, unsigned int code, int value);  
7.     /*connect用于建立handler和device的联系*/  
8.     int (*connect)(struct input_handler *handler, struct input_dev *dev, const struct input_device_id *id);  
9.     /*disconnect用于解除handler和device的联系*/  
10.     void (*disconnect)(struct input_handle *handle);  
11.     void (*start)(struct input_handle *handle);  
12.   
13.     const struct file_operations *fops;//handler的一些处理函数  
14.     int minor;//次设备号  
15.     const char *name;  
16.   
17.     const struct input_device_id *id_table;//用于和device匹配  
18.     const struct input_device_id *blacklist;//匹配黑名单  
19.   
20.     struct list_head    h_list;//用于链接和此handler相关的handle  
21.     struct list_head    node;  //用于将该handler链入input_handler_list  
22. };  

 

1.3、input_handle中间层(handle,动词，把两个对象（事件层驱动层）匹配在一起)

 

1. Struct input_handle
2.  {    
3.     void *private;  
4.   
5.     int open;//记录设备的打开次数(有多少个应用程序访问设备)  
6.     const char *name;  
7.   
8.     struct input_dev *dev;//指向所属的device  
9.     struct input_handler *handler;//指向所属的handler  
10.   
11.     struct list_head    d_node;//用于链入所属device的handle链表  
12.     struct list_head    h_node;//用于链入所属handler的handle链表  
13. };  

 

2、接下来我们分析一下上述三个结构体是如何关联在一起首先我们需了解到，他们各自两个

 list_head结构体的用途，入下述：

dev

 struct list_head    h_list;//该链表头用于链接此设备所关联的input_handle  

 struct list_head    node;  //用于将此设备链接到input_dev_list  

 

handler

 struct list_head    h_list;//用于链接和此handler相关的handle  

 struct list_head    node;  //用于将该handler链入input_handler_list 

 

handle

 struct list_head    d_node;//用于链入所属device的handle链表  

 struct list_head    h_node;//用于链入所属handler的handle链表  

 

我们可以看到，input_device和input_handler中都有一个h_list,而input_handle拥有指向input_dev和input_handler的指针，也就是说input_handle是用来关联input_dev和input_handler的，那么为什么一个input_device和input_handler

中拥有的是h_list而不是一个handle呢？因为一个device可能对应多个handler,而一个handler也不能只处理一device,比如说一个鼠标，它可以对应even handler，也可以对应mouse handler,因此当其注册时与系统中的handler进行匹配，就有可能产生两个实例，一个是evdev,另一个是mousedev,而任何一个实例中都只有一个handle。至于以何种方式来传递事件，就由用户程序打开哪个实例来决定。后面一个情况很容易理解，一个事件驱动不能只为一个甚至一种设备服务，系统中可能有多种设备都能使用这类handler,比如event handler就可以匹配所有的设备。在input子系统中，有8种事件驱动，每种事件驱动最多可以对应32个设备，因此dev实例总数最多可以达到256个。

 

 

3、接下来我们将以even handler为例介绍设备注册以及打开的过程。

 

1.1、在设备注册之前，必须先初始化INPUT子系统，由input_init()函数来完成

1. static int __init input_init(void)  
2. {  
3.     int err;  
4.   
5.     input_init_abs_bypass();  
6.   
7.     err = class_register(&input_class);//注册input类  
8.     if (err) {  
9.         printk(KERN_ERR "input: unable to register input_dev class\n");  
10.         return err;  
11.     }  
12.   
13.     err = input_proc_init();//创建/proc中的项
14.     if (err)  
15.         goto fail1;  
16.   
17.     /*注册设备，设备号为INPUT_MAJOR(13),后面注册的输入设备都使用该主设备号*/  
18.     err = register_chrdev(INPUT_MAJOR, "input", &input_fops);  
19.     if (err) {  
20.         printk(KERN_ERR "input: unable to register char major %d", INPUT_MAJOR);  
21.         goto fail2;  
22.     }  
23.   
24.     return 0;  
25.   
26.  fail2: input_proc_exit();  
27.  fail1: class_unregister(&input_class);  
28.     return err;  
29. }  

 

input_fops中只定义了open函数。

1. static const struct file_operations input_fops = {  
2.     .owner = THIS_MODULE,  
3.     .open = input_open_file,  
4. };  

 

我们需要在设备驱动层中完成输入设备的注册，通过调用input_register_device()函数来完成，该函数的一个重要任务就是完成设备与事件驱动的匹配。

5. int input_register_device(struct input_dev *dev)  
6. {  
7.     static atomic_t input_no = ATOMIC_INIT(0);  
8.     struct input_handler *handler;  
9.     const char *path;  
10.     int error;  
11.   
12.     __set_bit(EV_SYN, dev->evbit);  
13.   
14.     /* 
15.      * If delay and period are pre-set by the driver, then autorepeating 
16.      * is handled by the driver itself and we don't do it in input.c. 
17.      */  
18.   
19.     init_timer(&dev->timer);  
20.     if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD]) {  
21.         dev->timer.data = (long) dev;  
22.         dev->timer.function = input_repeat_key;  
23.         dev->rep[REP_DELAY] = 250;  
24.         dev->rep[REP_PERIOD] = 33;  
25.     }  
26.   
27.     /*没有定义设备的getkeycode函数，则使用默认的获取键值函数*/  
28.     if (!dev->getkeycode)  
29.         dev->getkeycode = input_default_getkeycode;  
30.   
31.     /*没有定义设备的setkeycode函数，则使用默认的设定键值函数*/  
32.     if (!dev->setkeycode)  
33.         dev->setkeycode = input_default_setkeycode;  
34.   
35.     /*设定dev的名字*/  
36.     dev_set_name(&dev->dev, "input%ld",  
37.              (unsigned long) atomic_inc_return(&input_no) - 1);  
38.   
39.     /*添加设备*/  
40.     error = device_add(&dev->dev);  
41.     if (error)  
42.         return error;  
43.   
44.     path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);  
45.     printk(KERN_INFO "input: %s as %s\n",  
46.         dev->name ? dev->name : "Unspecified device", path ? path : "N/A");  
47.     kfree(path);  
48.   
49.     error = mutex_lock_interruptible(&input_mutex);  
50.     if (error) {  
51.         device_del(&dev->dev);  
52.         return error;  
53.     }  
54.   
55.     /*将设备添加到input_dev_list设备链表*/  
56.     list_add_tail(&dev->node, &input_dev_list);  
57.   
58.     /*遍历input_handler_list，试图与每一个handler进行匹配*/  
59.     list_for_each_entry(handler, &input_handler_list, node)  
60.         input_attach_handler(dev, handler);  
61.   
62.     input_wakeup_procfs_readers();  
63.   
64.     mutex_unlock(&input_mutex);  
65.   
66.     return 0;  
67. }
68. 匹配过程：
69. 函数input_attach_handler
70. static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)  
71. {  
72.     const struct input_device_id *id;  
73.     int error;  
74.   
75.     /*如果定义了handler的黑名单，并且设备和黑名单中的id匹配了，则该设备不能和handler匹配*/  
76.     if (handler->blacklist && input_match_device(handler->blacklist, dev))  
77.         return -ENODEV;  
78.   
79.     id = input_match_device(handler->id_table, dev);  
80.     if (!id)  
81.         return -ENODEV;  
82.   
83.     /*执行handler的connect,建立handler与设备之间的联系*/  
84.     error = handler->connect(handler, dev, id);  
85.     if (error && error != -ENODEV)  
86.         printk(KERN_ERR  
87.             "input: failed to attach handler %s to device %s, "  
88.             "error: %d\n",  
89.             handler->name, kobject_name(&dev->dev.kobj), error);  
90.   
91.     return error;  
92. }  

 

 

匹配的具体过程：

93. static const struct input_device_id *input_match_device(const struct input_device_id *id,  
94.                             struct input_dev *dev)  
95. {  
96.     int i;  
97.   
98.     /*遍历handler的id_table与device进行匹配*/  
99.     for (; id->flags || id->driver_info; id++) {  
100.   
101.         /*根据flags的标志位，按需要匹配相应的字段*/  
102.         if (id->flags & INPUT_DEVICE_ID_MATCH_BUS)  
103.             if (id->bustype != dev->id.bustype)//总线类型不匹配  
104.                 continue;  
105.   
106.         if (id->flags & INPUT_DEVICE_ID_MATCH_VENDOR)//生产厂商不匹配  
107.             if (id->vendor != dev->id.vendor)  
108.                 continue;  
109.   
110.         if (id->flags & INPUT_DEVICE_ID_MATCH_PRODUCT)//产品不匹配  
111.             if (id->product != dev->id.product)  
112.                 continue;  
113.   
114.         if (id->flags & INPUT_DEVICE_ID_MATCH_VERSION)//版本不匹配  
115.             if (id->version != dev->id.version)  
116.                 continue;  
117.           
118.         MATCH_BIT(evbit,  EV_MAX);//匹配所有的事件类型  
119.   
120.         /*匹配所有事件的子事件*/  
121.         MATCH_BIT(keybit, KEY_MAX);  
122.         MATCH_BIT(relbit, REL_MAX);  
123.         MATCH_BIT(absbit, ABS_MAX);  
124.         MATCH_BIT(mscbit, MSC_MAX);  
125.         MATCH_BIT(ledbit, LED_MAX);  
126.         MATCH_BIT(sndbit, SND_MAX);  
127.         MATCH_BIT(ffbit,  FF_MAX);  
128.         MATCH_BIT(swbit,  SW_MAX);  
129.   
130.         return id;//匹配成功，返回id  
131.     }  
132.   
133.     return NULL;  
134. }  

 

MATCH_BIT是将device的相应字段和handler的相应字段逐位对比，都一样的话表示成功，否则continue

135. #define MATCH_BIT(bit, max) \  
136.         for (i = 0; i < BITS_TO_LONGS(max); i++) \  
137.             if ((id->bit[i] & dev->bit[i]) != id->bit[i]) \  
138.                 break; \  
139.         if (i != BITS_TO_LONGS(max)) \  
140.             continue;  

 

以event handler为例，看connect函数做了什么：

141. static int evdev_connect(struct input_handler *handler, struct input_dev *dev,  
142.              const struct input_device_id *id)  
143. {  
144.     struct evdev *evdev;  
145.     int minor;  
146.     int error;  
147.   
148.     /*在evdev_table中找到空闲块，其对应的数组下标再加上EVDEV_MINOR_BASE(64)就是次设备号 
149.       每个handler都拥有32个此设备号，也就是最多可以对应32个设备*/  
150.     for (minor = 0; minor < EVDEV_MINORS; minor++)  
151.         if (!evdev_table[minor])  
152.             break;  
153.   
154.     if (minor == EVDEV_MINORS) {  
155.         printk(KERN_ERR "evdev: no more free evdev devices\n");  
156.         return -ENFILE;  
157.     }  
158.   
159.     evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL);  
160.     if (!evdev)  
161.         return -ENOMEM;  
162.   
163.     INIT_LIST_HEAD(&evdev->client_list);  
164.     spin_lock_init(&evdev->client_lock);  
165.     mutex_init(&evdev->mutex);  
166.     init_waitqueue_head(&evdev->wait);  
167.   
168.     /*初始化evdev的内部变量*/  
169.     snprintf(evdev->name, sizeof(evdev->name), "event%d", minor);  
170.     evdev->exist = 1;  
171.     evdev->minor = minor;  
172.   
173.     /*初始化handle,每个evdev中都有一个handle*/  
174.     evdev->handle.dev = input_get_device(dev);  
175.     evdev->handle.name = evdev->name;  
176.     evdev->handle.handler = handler;  
177.     evdev->handle.private = evdev;  
178.   
179.     /*初始化evdev中的内嵌device*/  
180.     dev_set_name(&evdev->dev, evdev->name);  
181.     evdev->dev.devt = MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor);  
182.     evdev->dev.class = &input_class;  
183.     evdev->dev.parent = &dev->dev;  
184.     evdev->dev.release = evdev_free;  
185.     device_initialize(&evdev->dev);  
186.   
187.     /*注册handle,主要将handle链接到input_dev和handler的h_list链表中去*/  
188.     error = input_register_handle(&evdev->handle);  
189.     if (error)  
190.         goto err_free_evdev;  
191.   
192.     /*将evdev存入evdev_table数组*/  
193.     error = evdev_install_chrdev(evdev);  
194.     if (error)  
195.         goto err_unregister_handle;  
196.   
197.     error = device_add(&evdev->dev);  
198.     if (error)  
199.         goto err_cleanup_evdev;  
200.   
201.     return 0;  
202.   
203.  err_cleanup_evdev:  
204.     evdev_cleanup(evdev);  
205.  err_unregister_handle:  
206.     input_unregister_handle(&evdev->handle);  
207.  err_free_evdev:  
208.     put_device(&evdev->dev);  
209.     return error;  
210. }  

 

至此设备的注册完成！对应event handler,在/dev中将多出一个event(x)设备文件，对应一个evdev实例，应用程序打开它的话也就意味着通过event handler来和设备驱动层传递事件。

 

再来看打开设备的过程，还是以event handler为例，假如打开一个event(x),则先执行：

211. static int input_open_file(struct inode *inode, struct file *file)  
212. {  
213.     struct input_handler *handler;  
214.     const struct file_operations *old_fops, *new_fops = NULL;  
215.     int err;  
216.   
217.     lock_kernel();  
218.     /* No load-on-demand here? */  
219.       
220.     /*32个设备是共用一个handler的,通过此设备号得到设备对应的handler*/  
221.     handler = input_table[iminor(inode) >> 5];  
222.     if (!handler || !(new_fops = fops_get(handler->fops))) {  
223.         err = -ENODEV;  
224.         goto out;  
225.     }  
226.   
227.     /* 
228.      * That's _really_ odd. Usually NULL ->open means "nothing special", 
229.      * not "no device". Oh, well... 
230.      */  
231.     if (!new_fops->open) {  
232.         fops_put(new_fops);  
233.         err = -ENODEV;  
234.         goto out;  
235.     }  
236.     old_fops = file->f_op;  
237.     /*定位fops*/  
238.     file->f_op = new_fops;  
239.   
240.     err = new_fops->open(inode, file);  
241.   
242.     if (err) {  
243.         fops_put(file->f_op);  
244.         file->f_op = fops_get(old_fops);  
245.     }  
246.     fops_put(old_fops);  
247. out:  
248.     unlock_kernel();  
249.     return err;  
250. }  

 

通过此设备号所在的组(0~31)，(32~63),(64~95)……就可以找到相应的handler，所有的handler都保存在input_table中，对于次设备号在64~95范围的设备，将定位到下标为2的handler,，也就是event handler，然后将用handler中的open函数替代之前的open函数，并执行新的open函数，这样就以handler本身定义的open来打开设备完成相应的初始化了。

 

event handler中的open函数：

251. static int evdev_open(struct inode *inode, struct file *file)  
252. {  
253.     struct evdev *evdev;  
254.     struct evdev_client *client;  
255.     int i = iminor(inode) - EVDEV_MINOR_BASE;  
256.     int error;  
257.   
258.     if (i >= EVDEV_MINORS)  
259.         return -ENODEV;  
260.   
261.     error = mutex_lock_interruptible(&evdev_table_mutex);  
262.     if (error)  
263.         return error;  
264.     /*从evdev_table中取出和此设备号对应的evdev实例*/  
265.     evdev = evdev_table[i];  
266.     if (evdev)  
267.         get_device(&evdev->dev);  
268.     mutex_unlock(&evdev_table_mutex);  
269.   
270.     if (!evdev)  
271.         return -ENODEV;  
272.   
273.     /*每当一个应用程序打开该文件都会生成一个client*/  
274.     client = kzalloc(sizeof(struct evdev_client), GFP_KERNEL);  
275.     if (!client) {  
276.         error = -ENOMEM;  
277.         goto err_put_evdev;  
278.     }  
279.   
280.     spin_lock_init(&client->buffer_lock);  
281.     client->evdev = evdev;  
282.     /*将client链入evdev的client_list中*/  
283.     evdev_attach_client(evdev, client);  
284.   
285.     error = evdev_open_device(evdev);  
286.     if (error)  
287.         goto err_free_client;  
288.   
289.     file->private_data = client;  
290.     return 0;  
291.   
292.  err_free_client:  
293.     evdev_detach_client(evdev, client);  
294.     kfree(client);  
295.  err_put_evdev:  
296.     put_device(&evdev->dev);  
297.     return error;  
298. }  

 

 

299. static int evdev_open_device(struct evdev *evdev)  
300. {  
301.     int retval;  
302.   
303.     retval = mutex_lock_interruptible(&evdev->mutex);  
304.     if (retval)  
305.         return retval;  
306.   
307.     if (!evdev->exist)  
308.         retval = -ENODEV;  
309.     else if (!evdev->open++) {/*如果是第一次打开该设备，则要执行设备中定义的open*/  
310.         retval = input_open_device(&evdev->handle);  
311.         if (retval)  
312.             evdev->open--;  
313.     }  
314.   
315.     mutex_unlock(&evdev->mutex);  
316.     return retval;  
317. }  

 

 int input_open_device(struct input_handle *handle)  

318. {  
319.     struct input_dev *dev = handle->dev;  
320.     int retval;  
321.   
322.     retval = mutex_lock_interruptible(&dev->mutex);  
323.     if (retval)  
324.         return retval;  
325.   
326.     if (dev->going_away) {  
327.         retval = -ENODEV;  
328.         goto out;  
329.     }  
330.   
331.     handle->open++;  
332.   
333.     if (!dev->users++ && dev->open)  
334.         retval = dev->open(dev);//执行input_dev中定义的open，完成设备的初始化  
335.   
336.     if (retval) {  
337.         dev->users--;  
338.         if (!--handle->open) {  
339.             /* 
340.              * Make sure we are not delivering any more events 
341.              * through this handle 
342.              */  
343.             synchronize_rcu();  
344.         }  
345.     }  
346.   
347.  out:  
348.     mutex_unlock(&dev->mutex);  
349.     return retval;  
350. }