Linux 内核为了处理各种不同类型的的输入设备 , 比如说鼠标 , 键盘 , 操纵杆 , 触摸屏 , 设计并实现了一个对上层应用统一的试图的抽象层 , 即是Linux 输入子系统 .
输入子系统的层次结构体如下
从底层到上层 , input 子系统由 设备驱动层 , 核心层 , 以及事件处理层3个部分组成
当一个鼠标移动, 一个按键按下或弹起 , 它都需要从底层设备驱动-->核心层-->事件处理层 -->用户空间 , 层层上报 , 一直到运用程序.
应用这个input 子系统有如下优点 :
1. 统一了各种各样的输入设备的处理方法.
2. 提供了用于分布给用户使用的简单接口
3 . 提炼了输入驱动程序的通用部分 , 简化了驱动程序的开发和移植工作.
首先为大家上一个假设有个按键的驱动源 , 通过这个源码一层一层分析它是怎么事件上报的.
1 #include "../bus.h"
2 //这里面包含必要的头文件
3
4 #define GPX3CON 0x11000C60
5
6
7 static struct input_dev *device = NULL;
8 static volatile unsigned int __iomem *gpxconf = NULL;
9
10 static int irqs[] = {
11 IRQ_EINT(26),
12 IRQ_EINT(27),
13 IRQ_EINT(28),
14 IRQ_EINT(29),
15 };
16
17 void HardWare_init(void)
18 {
19 gpxconf = ioremap(GPX3CON , SZ_4K);
20 }
21 void HardWare_exit(void)
22 {
23 iounmap(gpxconf);
24 }
25
26
27 irqreturn_t do_irq(int irqno , void *data)
28 {
29 //事件上报
30 //算出第几个按键
31 int keynum = irqno - IRQ_EINT(26) ; //0 - 3
32 unsigned int val ;
33
34 val = ioread32(gpxconf + 1);
35 val = val >> 2 ;
36
37 //printk("keynum:%d val:%#x \n" , keynum , val);
38 switch(keynum)
39 { //事件上报函数.
40 case 0: input_report_key(device,KEY_A, !(val & (1 << keynum)) ); break;
41 case 1: input_report_key(device,KEY_B, !(val & (1 << keynum)) ); break;
42 case 2: input_report_key(device,KEY_C, !(val & (1 << keynum)) ); break;
43 case 3: input_report_key(device,KEY_D, !(val & (1 << keynum)) ); break;
44 }
45
46 //同步
47 input_sync(device);
48
49 return IRQ_HANDLED ;
50 }
51
52
53 //*************************************************
54 //模块入口出口
55
56 static int __init test_init(void)
57 {
58 int ret ;
59 int i ;
60
61 for(i = 0 ; i < ARRAY_SIZE(irqs) ; i++)
62 { //请求中断
63 ret = request_irq(irqs[i] , do_irq , IRQF_TRIGGER_FALLING| IRQF_TRIGGER_RISING | IRQF_SHARED , "myirq",(void *)88);
64 if(ret < 0)
65 { goto Err ;
66 }
67 }
68 //分配一个事件上报设备结构体
69 device = input_allocate_device();
70 if(IS_ERR(device))
71 {
72 ret = PTR_ERR(device);
73 goto Err1 ;
74 }
75
76 //#define BITS_PER_LONG 32
77 //#define BIT_MASK(nr) (1UL << ((nr) % BITS_PER_LONG))
78 //#define BIT_WORD(nr) ((nr) / BITS_PER_LONG)
79
80 device->evbit[BIT_WORD(EV_KEY)] |= BIT_MASK(EV_KEY); //使能按键事件类型
81 device->keybit[BIT_WORD(KEY_A)] |= BIT_MASK(KEY_A) ; //使能按键值为A的事件
82 device->keybit[BIT_WORD(KEY_B)] |= BIT_MASK(KEY_B) ; //使能按键值为A的事件
83 device->keybit[BIT_WORD(KEY_C)] |= BIT_MASK(KEY_C) ; //使能按键值为A的事件
84 device->keybit[BIT_WORD(KEY_D)] |= BIT_MASK(KEY_D) ; //使能按键值为A的事件
85
86
87 //注册一个input设备 上报类型 上报键值
88 ret = input_register_device(device);
89 if(ret < 0)
90 {
91 goto Err2 ;
92 }
93
94 //硬件初始化
95 HardWare_init();
96
97 return ret ;
98
99 Err2:
100 input_free_device(device);
101 Err1:
102 Err:
103 while(--i)
104 {
105 free_irq(irqs[i] , (void *)88);
106 }
107
108 return ret ;
109 }
110
111 static void __exit test_exit(void)
112 {
113 int i ;
114
115 input_unregister_device(device);
116
117 input_free_device(device);
118
119 for(i = 0 ; i < ARRAY_SIZE(irqs) ; i++)
120 {
121 free_irq(irqs[i] , (void *)88);
122 }
123
124 HardWare_exit();
125 }
126
127 module_init(test_init);
128 module_exit(test_exit);
129
130 MODULE_LICENSE("GPL");
先对他的一个主体流程进行分析一下
代码分析:
模块入口函数为test_init
它首先去申请了4个按键的中断 , 双边缘触发 .
而后 , 它分配一个事件上报结构体的空间 , 并对其进行赋值 :
1 static struct input_dev *device = NULL;
1 //分配一个事件上报设备结构体 2 device = input_allocate_device();
1 device->evbit[BIT_WORD(EV_KEY)] |= BIT_MASK(EV_KEY); //使能按键事件类型 2 device->keybit[BIT_WORD(KEY_A)] |= BIT_MASK(KEY_A) ; //使能按键值为A的事件 3 device->keybit[BIT_WORD(KEY_B)] |= BIT_MASK(KEY_B) ; //使能按键值为A的事件 4 device->keybit[BIT_WORD(KEY_C)] |= BIT_MASK(KEY_C) ; //使能按键值为A的事件 5 device->keybit[BIT_WORD(KEY_D)] |= BIT_MASK(KEY_D) ; //使能按键值为A的事件
这个结构体的原型是这样的:
1 struct input_dev {
2 const char *name; //设备名字
3 const char *phys; //设备在系统中的物理路径
4 const char *uniq; //设备的唯一标识码
5 struct input_id id; //设备id，包含总线id ,厂商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 unsigned long keybit[BITS_TO_LONGS(KEY_CNT)];//支持的具体的按键。按钮事件
11 unsigned long relbit[BITS_TO_LONGS(REL_CNT)];//支持的具体的相对坐标事件
12 unsigned long absbit[BITS_TO_LONGS(ABS_CNT)];//支持的具体的绝对坐标事件
13 unsigned long mscbit[BITS_TO_LONGS(MSC_CNT)];//支持的具体的混杂事件
14 unsigned long ledbit[BITS_TO_LONGS(LED_CNT)];//支持的具体的led指示灯事件
15 unsigned long sndbit[BITS_TO_LONGS(SND_CNT)];//支持的具体的音效事件 unsigned long ffbit[BITS_TO_LONGS(FF_CNT)];//支持的具体的力反馈事件
16 unsigned long swbit[BITS_TO_LONGS(SW_CNT)];//支持的具体的开关事件
17
18 unsigned int hint_events_per_packet;
19
20 unsigned int keycodemax; // 键盘码表的大小
21 unsigned int keycodesize; //键盘码中的元素个数
22 void *keycode; //设备的键盘码表
23 /* 两个可选方法 ， 用于配置和获取键盘码表 */
24 int (*setkeycode)(struct input_dev *dev,
25 const struct input_keymap_entry *ke,
26 unsigned int *old_keycode);
27 int (*getkeycode)(struct input_dev *dev,
28 struct input_keymap_entry *ke);
29
30 struct ff_device *ff; /* 如果设备支持力反馈，则该成员将指向力反馈的设备描述
31 结构 */
32
33 unsigned int repeat_key; /*保存上一个键值，实现软件自动重复按键 */
34 struct timer_list timer; /*用于软件自动重复按键的定时器 */
35
36 int rep[REP_CNT];
37
38 struct input_mt_slot *mt;
39 int mtsize;
40 int slot;
41 int trkid;
42
43 struct input_absinfo *absinfo;
44
45 unsigned long key[BITS_TO_LONGS(KEY_CNT)];//反映设备按键按钮的当前状态
46 unsigned long led[BITS_TO_LONGS(LED_CNT)];//反映设备led灯的当前状态
47 unsigned long snd[BITS_TO_LONGS(SND_CNT)];//反映设备音效的当前状态
48 unsigned long sw[BITS_TO_LONGS(SW_CNT)];//反映设备开关的当前状态
49
50 /* 提供以下4个设备驱动层的操作接口，根据具体的设备需求实现他们 */
51 int (*open)(struct input_dev *dev); //将在input_open_device()中调用
52 void (*close)(struct input_dev *dev);//将在input_close_device()中调用
53 int (*flush)(struct input_dev *dev, struct file *file);
55 /*(event)用于处理送到设备驱动层来的事件,很多事件在事件处理层被处理,但有很多事件仍需
56 要送到设备驱动中,如led指示灯事件和音效事件,因为这些操作通常需要设备驱动执行*/
57 int (*event)(struct input_dev *dev, unsigned int type, unsigned int code, int value);
58
59 struct input_handle __rcu *grab;
60
61 spinlock_t event_lock;
62 struct mutex mutex;
63
64 /* 记录输入事件处理程序(input handlers)调用设备open()方法的次数,保证设备open()是在第一个调用input_open_device()中被调用, 设备close()方法是在最后一次调用input_close_device()中被调用 */
65 unsigned int users;
66 bool going_away;
67
68 bool sync; //上次同步事件(EV_SYNC)发生后没有新事件产生，则被设置为1*/
69
70 struct device dev; //内嵌设备device结构
71 struct list_head h_list; //与该设备相关的输入句柄(input handles)列表
72 struct list_head node;//通过该成员，系统中的所有的input_dev对象被管理
73 };
上面是我做的一些注释 .
而且在上面的按键设备的驱动中 , 我还对evbit , 和keybit 两个数值进行赋值.
它那个宏定义是这样的:
1 //#define BITS_PER_LONG 32 2 //#define BIT_MASK(nr) (1UL << ((nr) % BITS_PER_LONG)) 3 //#define BIT_WORD(nr) ((nr) / BITS_PER_LONG)
这里边所支持的事件类型和支持的具体的按键按钮类型是这样的:
1 #define EV_SYN 0x00 2 #define EV_KEY 0x01 3 #define EV_REL 0x02 4 #define EV_ABS 0x03 5 #define EV_MSC 0x04 6 #define EV_SW 0x05 7 #define EV_LED 0x11 8 #define EV_SND 0x12 9 #define EV_REP 0x14 9 #define EV_FF 0x15 10 #define EV_PWR 0x16 11 #define EV_FF_STATUS 0x17 12 #define EV_MAX 0x1f 12 #define EV_CNT (EV_MAX+1)
所支持的按键按钮类型就比较多了
1 2 #define KEY_RESERVED 0 3 #define KEY_ESC 1 4 #define KEY_1 2 5 #define KEY_2 3 6 #define KEY_3 4 7 #define KEY_4 5 8 #define KEY_5 6 9 #define KEY_6 7 10 #define KEY_7 8 11 #define KEY_8 9 12 #define KEY_9 10 13 #define KEY_0 11 14 ......
这些相对应的类型都是用一些宏定义来定义 , 到上报个核心层再上报到事件处理层的时候以一个结构体的形式的数据体现给用户, 后面会讲到这个结构体
回到源代码:
然后就是注册一个 input 设备 把刚才赋值的事件上报类型传进去:
1 //注册一个input设备 上报类型 上报键值
2 ret = input_register_device(device);
3 if(ret < 0)
4 {
5 goto Err2 ;
6 }
后面的硬件初始化就是对gpio口的配置而已 , 这里涉及到硬件原理图上的东西 ,其实就是做了一个寄存器地址的映射
在中断函数内
1 irqreturn_t do_irq(int irqno , void *data)
2 {
3 //事件上报
4 //算出第几个按键
5 int keynum = irqno - IRQ_EINT(26) ; //0 - 3
6 unsigned int val ;
7
8 val = ioread32(gpxconf + 1);
9 val = val >> 2 ;
10
11 //printk("keynum:%d val:%#x \n" , keynum , val);
12 switch(keynum)
13 {
14 case 0: input_report_key(device,KEY_A, !(val & (1 << keynum)) ); break;
15 case 1: input_report_key(device,KEY_B, !(val & (1 << keynum)) ); break;
16 case 2: input_report_key(device,KEY_C, !(val & (1 << keynum)) ); break;
17 case 3: input_report_key(device,KEY_D, !(val & (1 << keynum)) ); break;
18 }
19
20 //同步
21 input_sync(device);
22
23 return IRQ_HANDLED ;
24 }
25
其实总的来说我们做了两个事情 , 第一个就是触发中断后 ,我们上报了是第几个按键触发的中断 , 并进行同步处理.
现在 , 我已经把这个最简单的一个按键事件上报驱动讲解了一遍 , 其实我们有很多疑问 :
第一个就是: 我们怎么分配的一个事件上报结构体
第二个问题 , 我们是怎么将事件层层上报 , 将input driver , input core , input handler 这三层联系起来的 .
第三个问题 , 我们给上层提供的是一个怎么样的借口 , 给上层上报的是一个怎么的数据.
其实第一个问题比较简单 , 我只是为了拿出来缓解一下当前比较紧张的气氛 , 透露一下 , 第二个问题才是关键!
第一个问题它只是做了一个分配空间并对其初始化值的操作:
1 *///申请一个新的input device
2 struct input_dev *input_allocate_device(void)
3 {
4 struct input_dev *dev;
5
6 dev = kzalloc(sizeof(struct input_dev), GFP_KERNEL);
7 if (dev) {
8 dev->dev.type = &input_dev_type;
9 dev->dev.class = &input_class;
10 device_initialize(&dev->dev);
11 mutex_init(&dev->mutex);
12 spin_lock_init(&dev->event_lock);
13 INIT_LIST_HEAD(&dev->h_list);
14 INIT_LIST_HEAD(&dev->node);
15
16 __module_get(THIS_MODULE);
17 }
18
19 return dev;
20 }
21 EXPORT_SYMBOL(input_allocate_device);
是不是觉得自己竟然能两眼就能看懂这些代码 , 别惊讶 , 其实你自己挺强的 , 就连我都要花喵一眼的时间去看才能看懂它
下面才是重头戏: input core 代码.
在前面的驱动当中 , 我们在分配完input_dev 结构体后 , 我们直接在没有产生并触发按键中断之前 , 抢先注册了一个input 设备
1 //注册一个input设备 上报类型 上报键值 2 ret = input_register_device(device);
其实如果按照标准的写法 , 我们注册一个input 设备应该写在请求中断函数之前
就是这个input_register_device , 他就是带我们进入input core的引路人:
我们跟进去: 在include/linux/input.h 里面定义
1 //输入子系统的注册函数 2 int __must_check input_register_device(struct input_dev *); 3 void input_unregister_device(struct input_dev *); 4 //输入子系统的注销函数
它的源码是在 drivers/input/input.c 里面
1 /**
2 * input_register_device - register device with input core
3 * @dev: device to be registered
4 *
5 * This function registers device with input core. The device must be
6 * allocated with input_allocate_device() and all it‘s capabilities
7 * set up before registering.
8 * If function fails the device must be freed with input_free_device().
9 * Once device has been successfully registered it can be unregistered
10 * with input_unregister_device(); input_free_device() should not be
11 * called in this case.
12 *///输入设备注册函数
13 int input_register_device(struct input_dev *dev)
14 {
15 static atomic_t input_no = ATOMIC_INIT(0);
16 struct input_handler *handler;
17 const char *path;
18 int error;
19
20 /* Every input device generates EV_SYN/SYN_REPORT events. */
21 __set_bit(EV_SYN, dev->evbit);
22 /* 任何一个设备都支持同步事件 */
23
24 /* KEY_RESERVED is not supposed to be transmitted to userspace. */
25 __clear_bit(KEY_RESERVED, dev->keybit);
26
27 /* Make sure that bitmasks not mentioned in dev->evbit are clean. */
28 input_cleanse_bitmasks(dev);
29
30 if (!dev->hint_events_per_packet)
31 dev->hint_events_per_packet =
32 input_estimate_events_per_packet(dev);
33
34
35 /*
36 * If delay and period are pre-set by the driver, then autorepeating
37 * is handled by the driver itself and we don‘t do it in input.c.
38 */ //rep 主要时为了处理重复按键,如果没有定义dev->rep[REP_DELAY]和
39 // dev->rep[REP_PERIOD]则将其值设为默认
40 init_timer(&dev->timer);
41 if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD]) {
42 dev->timer.data = (long) dev;
43 dev->timer.function = input_repeat_key;
44 dev->rep[REP_DELAY] = 250; //这个是指第一次按下去多久算一次
45 dev->rep[REP_PERIOD] = 33;//这个是指按键多久没有被抬起,则33ms算一次
46 }
47 /* 如果dev没有定义getkeycode 和setkeycode 则设为默认值 */
48 if (!dev->getkeycode)
49 dev->getkeycode = input_default_getkeycode;
50
51 if (!dev->setkeycode)
52 dev->setkeycode = input_default_setkeycode;
53
54 dev_set_name(&dev->dev, "input%ld",
55 (unsigned long) atomic_inc_return(&input_no) - 1);
56 /* 将input_dev内嵌的dev注册到sysfs */
57 error = device_add(&dev->dev);
58 if (error)
59 return error;
60
61 path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
62 pr_info("%s as %s\n",
63 dev->name ? dev->name : "Unspecified device",
64 path ? path : "N/A");
65 kfree(path);
66
67 error = mutex_lock_interruptible(&input_mutex);
68 if (error) {
69 device_del(&dev->dev);
70 return error;
71 }
72 /* 将input_dev 挂在input_dev_list上 */
73 list_add_tail(&dev->node, &input_dev_list);
74 /* 遍历所有的事件的处理驱动,找到匹配的就将该设备依附上去 */
75 list_for_each_entry(handler, &input_handler_list, node)
76 input_attach_handler(dev, handler); //进去看看
77
78 input_wakeup_procfs_readers();
79
80 mutex_unlock(&input_mutex);
81
82 return 0;
83 }
84 EXPORT_SYMBOL(input_register_device);
它的注释讲的很明白 , 注册一个设备 , 在使用这个函数之前必须调用input_allocate_device() 并对input_dev 结构体进行必要的赋值
而且这个函数必须作返回值检查 , 如果出错必须对input_dev进行free
先来看一下这里边出现的input_handler 结构体
1 struct input_handler {
2
3 void *private; //由具体的事件处理程序指定私有数据
4
5 void (*event)(struct input_handle *handle, unsigned int type, unsigned int code, int value); //用于处理送到事件处理层的事件,该方法由核心层调用,调用时已禁止中断
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); //这是匹配handler 和设备的函数
8 int (*connect)(struct input_handler *handler, struct input_dev *dev, const struct input_device_id *id);//事件处理程序关联到一个输出设备时调用
9 void (*disconnect)(struct input_handle *handle);//事件处理程序脱离与之有关的
10 输入设备时调用
11 void (*start)(struct input_handle *handle);
12 //开启对给定句柄的处理程序,该函数由核心层在connect()方法调用之后,或者在独占句柄释放它占有的输入设备时调用
13
14 const struct file_operations *fops; //该事件处理驱动的文件操作集合
15 int minor; //该驱动能够提供的32个连续次设备号中的第一个
16 const char *name; //该驱动处理程序的名称,可以在/proc/bus/input/handlers 中看到
17
18 const struct input_device_id *id_table;//输入设备id表, 事件处理驱动通过该成员来匹配他能处理的设备
19
20 struct list_head h_list; //该事件处理程序相关联的输入句柄列表
21 //所有事件处理驱动都会通过该成员连接到input_handler_list列表上
22 struct list_head node;
23 };
上面有我花了很多(就那么几分钟)的时间去作的注释 , 大家可以看看
其实这就是一个很多个操作接口的结构体 , 要处理什么事情的时候就会调用这里边的某个函数 , 事件处理的时候调用里边的event 函数 或者调用filter函数 ,
匹配input_handler 和 input_dev 的时候调用match函数 还有就是一些必要的变量还有就是一些文件操作的集合 , 还有一个id_table的表
我们回到input_register_device()函数
在变量设定之后 , kernel 直接设置
1 /* Every input device generates EV_SYN/SYN_REPORT events. */ 2 __set_bit(EV_SYN, dev->evbit); 3 /* 任何一个设备都支持同步事件 */ 4 5 /* KEY_RESERVED is not supposed to be transmitted to userspace. */ 6 __clear_bit(KEY_RESERVED, dev->keybit); 7 8 /* Make sure that bitmasks not mentioned in dev->evbit are clean. */ 9 input_cleanse_bitmasks(dev);
这里时设置了一个重复按键的功能 , 就是长按了一个键后的那个按能设置.
1 /*
2 * If delay and period are pre-set by the driver, then autorepeating
3 * is handled by the driver itself and we don‘t do it in input.c.
4 */ //rep 主要时为了处理重复按键,如果没有定义dev->rep[REP_DELAY]和
5 // dev->rep[REP_PERIOD]则将其值设为默认
6 init_timer(&dev->timer);
7 if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD]) {
8 dev->timer.data = (long) dev;
9 dev->timer.function = input_repeat_key;
10 dev->rep[REP_DELAY] = 250; //这个是指第一次按下去多久算一次
11 dev->rep[REP_PERIOD] = 33;//这个是指按键多久没有被抬起,则33ms算一次
12 }
1 /* 如果dev没有定义getkeycode 和setkeycode 则设为默认值 */ 2 if (!dev->getkeycode) 3 dev->getkeycode = input_default_getkeycode; 4 5 if (!dev->setkeycode) 6 dev->setkeycode = input_default_setkeycode;
执行这段代码后 ,我们将会在文件系统中找到/sys/class/input/input* 设备
1 dev_set_name(&dev->dev, "input%ld", 2 (unsigned long) atomic_inc_return(&input_no) - 1);
1 /* 将input_dev内嵌的dev注册到sysfs */ 2 error = device_add(&dev->dev);
这里它做了两件事 , 一件是将dev的node 挂在input_dev_list 上 , 以后可以通过这一块肉找到整个dev结构体 , 内核里边全是这种方法 (container of())的方法
第二件事件就是遍历所有的input_handler_list , 匹配设备和设备事件处理方法
1 /* 将input_dev 挂在input_dev_list上, 把dev->node 加到input_dev_list */ 2 list_add_tail(&dev->node, &input_dev_list); /* 遍历所有的事件的处理驱动(handler),找到匹配的就将该设备依附上去 */ 3 list_for_each_entry(handler, &input_handler_list, node) 4 input_attach_handler(dev, handler); //进去看看
我只分析里边的input_attach_handler(dev , handler) , 前面两个相对简单易懂
1 //找到匹配的就将该设备依附上去
2 static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)
3 {
4 const struct input_device_id *id;
5 int error;
6 /* 调用匹配id 的函数, 如果没有匹配上 , 则推出依附过程*/
7 id = input_match_device(handler, dev);
8 if (!id)
9 return -ENODEV;
10 /* 如果匹配上了, 就调用事件处理驱动的connect()接口 */
11 error = handler->connect(handler, dev, id);
12 if (error && error != -ENODEV)
13 pr_err("failed to attach handler %s to device %s, error: %d\n",
14 handler->name, kobject_name(&dev->dev.kobj), error);
15
16 return error;
17 }
在这里边 , 得到一个正确的id 的方法时比较严格的 , 这就跟外面的相亲的过程一样 , 要算八字(是不是同一个版本,是不是同一个总线类型 , 是不是同一个生产商 , 然后还要比较各种位 , 最后还要确定handler->match为空或者是这是匹配handler 和 dev
最后通过层层考验 , 才返回一个id , 没办法, 这讲究一个门当户对! 源代码如下:
1 static const struct input_device_id *input_match_device(struct input_handler *handler,
2 struct input_dev *dev)
3 {
4 const struct input_device_id *id;
5 int i;
6
7 for (id = handler->id_table; id->flags || id->driver_info; id++) {
8
9 if (id->flags & INPUT_DEVICE_ID_MATCH_BUS)
10 if (id->bustype != dev->id.bustype)
11 continue;
12
13 if (id->flags & INPUT_DEVICE_ID_MATCH_VENDOR)
14 if (id->vendor != dev->id.vendor)
15 continue;
16
17 if (id->flags & INPUT_DEVICE_ID_MATCH_PRODUCT)
18 if (id->product != dev->id.product)
19 continue;
20
21 if (id->flags & INPUT_DEVICE_ID_MATCH_VERSION)
22 if (id->version != dev->id.version)
23 continue;
24
25 MATCH_BIT(evbit, EV_MAX);
26 MATCH_BIT(keybit, KEY_MAX);
27 MATCH_BIT(relbit, REL_MAX);
28 MATCH_BIT(absbit, ABS_MAX);
29 MATCH_BIT(mscbit, MSC_MAX);
30 MATCH_BIT(ledbit, LED_MAX);
31 MATCH_BIT(sndbit, SND_MAX);
32 MATCH_BIT(ffbit, FF_MAX);
33 MATCH_BIT(swbit, SW_MAX);
34
35 if (!handler->match || handler->match(handler, dev))
36 return id;
37 }
38
39 return NULL;
40 }
回到上面的input_attach-handler 函数 , 当两个人( handler , dev) 相亲成功了 , 我们就调用handler->connect这个连接的方法
其实这里有一个毁我人生价值观的问题 , 就是一个handler 有可能不仅仅只有一个device 跟它对应 , 相对的 , 一个device 有可能也有多个设备驱动事件处理函数跟它相对应
我只是打一个简单的比方 , 大家别纠结上面的问题 , 他们关系时 1 对多的关系.
其实上面那段代码就已经涉及了input 核心层的东西了
input 核心层 , 其实在一开始的时候
init/main.c ---> start_kernel --->rest_init() ---> kernel_thread(kernel_init , NULL , CLONE_FS | CLONE_SIGHAND) ;
---> kernel_init ---> do_basic_setup() ---> do_initcalls() --- >
1 static void __init do_initcalls(void)
2 {
3 initcall_t *fn;
4
5 for (fn = __early_initcall_end; fn < __initcall_end; fn++)
6 do_one_initcall(*fn);
7 }
这里边它就是会调用subsys_initcall(input_init); , 他是调用了所有的sub_initcall 里面的函数
调用之后 , 便有如下代码
1 static int __init input_init(void)
2 {
3 int err;
4
5 err = class_register(&input_class); /* 创建一个类input 的class */
6 if (err) {
7 pr_err("unable to register input_dev class\n");
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 /* 注册设备号INPUT_MAJOR(13)的字符设备, 文件操作集合为input_fops */
17 if (err) {
18 pr_err("unable to register char major %d", INPUT_MAJOR);
19 goto fail2;
20 }
21
22 return 0;
23
24 fail2: input_proc_exit();
25 fail1: class_unregister(&input_class);
26 return err;
27 }
其实它就是为了给我们创建了一个设备类并提供了文件系统的操作接口.
这个文件中 , 还有一个借口 是我们必须要了解的
那就是input_report_key
在前面我给的那个驱动程序中 , 如果按键按下或弹起 , 都会产生一个中断 , 双边缘触发中断 , 然后在那个中断函数里面 , 就会有一个input_report_key的函数被调用,
其实在内核中 , 他是调用了input_event 这个函数
源代码也在 input.c 这个文件中:
1 static inline void input_report_key(struct input_dev *dev, unsigned int code, int value)
2 { input_event(dev, EV_KEY, code, !!value);
3 }
4 static inline void input_report_rel(struct input_dev *dev, unsigned int code, int value)
5 {
6 input_event(dev, EV_REL, code, value);
7 }
其实input_report_rel 还有几个函数都是调用了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 add_input_randomness(type, code, value);//利用输入值调整随机数产生器
10 input_handle_event(dev, type, code, value);//进这里,实际调用了这个
11 spin_unlock_irqrestore(&dev->event_lock, flags);
12 }
13 }
14 EXPORT_SYMBOL(input_event);
这里边做了设备检查 , 判断设备是否支持该事件类型
如果支持 , 进入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 /* 将同步标志置1 */
17 dev->sync = true;
18 /* 表示将该事件送往事件处理驱动处理 */
19 disposition = INPUT_PASS_TO_HANDLERS;
20 }
21 break;
22 case SYN_MT_REPORT:
23 dev->sync = false;
24 disposition = INPUT_PASS_TO_HANDLERS;
25 break;
26 }
27 break;
28
29 /*
30 * 如果设备支持该事件码且本次上报值同dev->key中记录的上次上报值不同,
31 * 则将事件的派送位置设置为送往事件处理驱动,并且如果判断按键时按下的,
32 * 则启动自动重复按键
33 * */
34 case EV_KEY:
35 if (is_event_supported(code, dev->keybit, KEY_MAX) &&
36 !!test_bit(code, dev->key) != value) {
37
38 if (value != 2) {
39 __change_bit(code, dev->key);
40 if (value)
41 input_start_autorepeat(dev, code);
42 else
43 input_stop_autorepeat(dev);
44 }
45
46 disposition = INPUT_PASS_TO_HANDLERS;
47 }
48 break;
49
50 case EV_SW:
51 if (is_event_supported(code, dev->swbit, SW_MAX) &&
52 !!test_bit(code, dev->sw) != value) {
53
54 __change_bit(code, dev->sw);
55 disposition = INPUT_PASS_TO_HANDLERS;
56 }
57 break;
58
59 case EV_SW:
60 if (is_event_supported(code, dev->swbit, SW_MAX) &&
61 !!test_bit(code, dev->sw) != value) {
62
63 __change_bit(code, dev->sw);
64 disposition = INPUT_PASS_TO_HANDLERS;
65 }
66 break;
67
68 case EV_ABS:
69 if (is_event_supported(code, dev->absbit, ABS_MAX))
70 disposition = input_handle_abs_event(dev, code, &value);
71
72 break;
73
74 case EV_REL:
75 if (is_event_supported(code, dev->relbit, REL_MAX) && value)
76 disposition = INPUT_PASS_TO_HANDLERS;
77
78 break;
79
80 case EV_MSC:
81 if (is_event_supported(code, dev->mscbit, MSC_MAX))
82 disposition = INPUT_PASS_TO_ALL;
83
84 break;
85
86 case EV_LED:
87 if (is_event_supported(code, dev->ledbit, LED_MAX) &&
88 !!test_bit(code, dev->led) != value) {
89
90 __change_bit(code, dev->led);
91 disposition = INPUT_PASS_TO_ALL;
92 }
93 break;
94
95 case EV_SND:
96 if (is_event_supported(code, dev->sndbit, SND_MAX)) {
97
98 if (!!test_bit(code, dev->snd) != !!value)
99 __change_bit(code, dev->snd);
100 disposition = INPUT_PASS_TO_ALL;
101 }
102 break;
103
104 case EV_REP:
105 if (code <= REP_MAX && value >= 0 && dev->rep[code] != value) {
106 dev->rep[code] = value;
107 disposition = INPUT_PASS_TO_ALL;
108 }
109 break;
110
111 case EV_FF:
112 if (value >= 0)
113 disposition = INPUT_PASS_TO_ALL;
114 break;
115
116 case EV_PWR:
117 disposition = INPUT_PASS_TO_ALL;
118 break;
119 }
120 /* 只有上报了同步事件并且事件码是SYN_REPORT, 同步标志dev->sync才会置1 */
121 if (disposition != INPUT_IGNORE_EVENT && type != EV_SYN)
122 dev->sync = false;
123 /* 如果设置了送往设备的标志位,那么将调用设备的event()方法 */
124 if ((disposition & INPUT_PASS_TO_DEVICE) && dev->event)
125 dev->event(dev, type, code, value);
126 /* 如果设置了表示送往事件处理驱动的标志位,
127 * 那么将调用input_pass_event的方法*/
128 if (disposition & INPUT_PASS_TO_HANDLERS)
129 input_pass_event(dev, type, code, value);
130 }
在验证disposition 和INPUT_PASS_TO_HANDLERS后
进入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
9 handle = rcu_dereference(dev->grab);
10 if (handle)
11 handle->handler->event(handle, type, code, value);
12 else {
13 bool filtered = false;
14
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
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 }
最终还是要调用event函数
input 核心层代码先到这里 , 接下来就到事件上报处理层 ,
input 输入子系统最重要的部分在于对于上报事件的处理. 内核实现了多个事件处理驱动 , 如处理通用设备的evdev , 处理鼠标类的输入设备的mousedev 和处理游戏杆的joydev
下面已最基础的通用事件处理驱动为例子 , 分析输入子系统处理上报事件的方法:
通用事件处理驱动的实现文件 evdev.c 中注册一个名为evdev_handler 和 input_handler的对象.
1 static int __init evdev_init(void)
2 {
3 return input_register_handler(&evdev_handler);
4 }
evdev_handler :
1
2 static struct input_handler evdev_handler = {
3 .event = evdev_event,
4 .match = evdev_match, /* Added by EETI*/
5 .connect = evdev_connect,
6 .disconnect = evdev_disconnect,
7 .fops = &evdev_fops,
8 .minor = EVDEV_MINOR_BASE, //64
9 .name = "evdev",
10 .id_table = evdev_ids,
11 };
这里边由 event , match , connect , fops , id_table 是不是觉得很多谜团好像都要在这里都要解开了
这里边 , connect 函数是这样的:
1 static int evdev_connect(struct input_handler *handler, struct input_dev *dev,
2 const struct input_device_id *id)
3 {
4 struct evdev *evdev;
5 int minor;
6 int error;
7
8 /* 通用事件处理驱动的设备是通过evdev结构描述的,该事件的驱动最多能处理32个这>样的设备,这些设备被存放在evdev_table数组中,下面的for循环将从evdev_table数组中找>到一个未使用的项 */
9 for (minor = 0; minor < EVDEV_MINORS; minor++)
10 if (!evdev_table[minor])
11 break;
12
13 if (minor == EVDEV_MINORS) {
14 pr_err("no more free evdev devices\n");
15 return -ENFILE;
16 }
17 /* 下面的代码为每个匹配的设备分配一个evdev结构体,并对成员进行初始化 */
18 evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL);
19 if (!evdev)
20 return -ENOMEM;
21
22 INIT_LIST_HEAD(&evdev->client_list);
23 spin_lock_init(&evdev->client_lock);
24 mutex_init(&evdev->mutex);
25 init_waitqueue_head(&evdev->wait);
26
27 dev_set_name(&evdev->dev, "event%d", minor);
28 evdev->exist = true;
29 evdev->minor = minor;
30
31 evdev->handle.dev = input_get_device(dev);
32 evdev->handle.name = dev_name(&evdev->dev);
33 evdev->handle.handler = handler;
34 evdev->handle.private = evdev;
35
36 evdev->dev.devt = MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor);
37 evdev->dev.class = &input_class;
38 evdev->dev.parent = &dev->dev;
39 evdev->dev.release = evdev_free;
40 device_initialize(&evdev->dev);
41 /* input_register() 将&evdev->handle分别挂在对应的设备和事件处理驱动的句柄列
42 表中 */
43 error = input_register_handle(&evdev->handle);
44 if (error)
45 goto err_free_evdev;
46 /* evdev_install_chrdev()会将evdev放入evdev_table数组的evdev->minor上*/
47 error = evdev_install_chrdev(evdev);
48 if (error)
49 goto err_unregister_handle;
50 /* 由于指定了设备号和设备名称,如果用户空间配置了mdev或udev,dev_add() 的调用>将导致/dev 目录下产生对应的设备文件eventX , 其中 X = 0,1,2... */
51 error = device_add(&evdev->dev);
52 if (error)
53 goto err_cleanup_evdev;
54
55 return 0;
56
57 err_cleanup_evdev:
58 evdev_cleanup(evdev);
59 err_unregister_handle:
60 input_unregister_handle(&evdev->handle);
61 err_free_evdev:
62 put_device(&evdev->dev);
63 return error;
64 }
上面代码 给我们上层的用户提供了一个操作接口 , 它是在/dev/event* 这些都是通用的事件处理给上层用户提供的文件接口 ,我们可以根据实际情况对这些文件 进行文件操作
其实文件操作接口也在这里:
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 .llseek = no_llseek,
15 };
学内核的人是不是顿时觉得很熟悉, 没错, 真的很熟悉
我们以read函数为例:
1 static ssize_t evdev_read(struct file *file, char __user *buffer,
2 size_t count, loff_t *ppos)
3 {
4 struct evdev_client *client = file->private_data;
5 struct evdev *evdev = client->evdev;
6 struct input_event event;
7 int retval = 0;
8 /* 用户必须请求数据不小于input_event结构的大小 */
9 if (count < input_event_size())
10 return -EINVAL;
11 /* 事件环形缓冲区为空, evdev存在且文件以非阻塞方式打开,则返回-EAGAIN*/
12 if (!(file->f_flags & O_NONBLOCK)) {
13 retval = wait_event_interruptible(evdev->wait,
14 client->packet_head != client->tail || !evdev->exist);
15 if (retval)
16 return retval;
17 }
18
19 if (!evdev->exist)
20 return -ENODEV;
21 /* retval 记录了读取的事件总大小 */
22 while (retval + input_event_size() <= count &&
23 evdev_fetch_next_event(client, &event)) {
24
25 if (input_event_to_user(buffer + retval, &event))
26 return -EFAULT;
27
28 retval += input_event_size();
29 }
30
31 if (retval == 0 && file->f_flags & O_NONBLOCK)
32 retval = -EAGAIN;
33 return retval;
34 }
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 struct timespec ts;
8
9 ktime_get_ts(&ts);
10 event.time.tv_sec = ts.tv_sec;
11 event.time.tv_usec = ts.tv_nsec / NSEC_PER_USEC;
12 event.type = type;
13 event.code = code;
14 event.value = value;
15
16 rcu_read_lock();
17
18 client = rcu_dereference(evdev->grab);
19 if (client)
20 evdev_pass_event(client, &event);
21 else
22 list_for_each_entry_rcu(client, &evdev->client_list, node)
23 evdev_pass_event(client, &event);
24
25 rcu_read_unlock();
26
27 if (type == EV_SYN && code == SYN_REPORT)
28 wake_up_interruptible(&evdev->wait);
29 }
其实主要事情就是给struct input_event 结构体赋值:
struct input_event {
struct timeval time; /* 事件发生的时间 */
__u16 type; /* 事件类型 */
__u16 code; /* 事件码 */
__s32 value; /* 事件值 */
};
回到通用事件处理初始化;
1 static int __init evdev_init(void)
2 {
3 return input_register_handler(&evdev_handler);
4 }
它调用的是input_register_handler函数
这个函数也是drivers/input/input.c 函数里边
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
20 list_add_tail(&handler->node, &input_handler_list);
21
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 }
31 EXPORT_SYMBOL(input_register_handler);
32
这里边他也是调用了input_attach_handler(dev , handler) 函数
这里边也是一个依附配对的过程, 时一个一对多的一个配对, 一个设备配对多个事件上报处理
刚才也把第三个问题, 给上层提供一个怎么样的接口的问题一笔带过了
到这里 , 就剩下一些细节上的东西还没有完善
其实inpu 子系统 从底层往上层的一个流程时这样的
1. 底层驱动硬件初始化 , 并指定要上报的事件的类型 以及值
2. 通过input.c 配对
3 . 配对到相应的事件上报处理层 , 然后给上层发布接口
其实这样的一个input 模型有几个好处
1. 写驱动相对没有那么麻烦 , 只要硬件初始化 , 指定要上报的事件的类型以及数值
2 . 应用层操作的接口比较统一 , 上层的人不用那么辛苦去看各种各样的操作接口 , 可能有几个ioctl可能要看一下.
时间： 2024-08-01 10:46:36