Linux input输入子系统

深碍√TFBOYSˉ_ 2022-08-04 14:46 221阅读 0赞

输入设备（按键、键盘、触摸屏、鼠标）是典型的字符设备，工作机理是底层  
在按键、触摸等动作发生时产生一个中断（或驱动timer定时查询），然后CPU  
通过SPI、I2C或外部存储器总线读取键值，坐标等数据。  
输入核心层提供了底层输入设备驱动程序所需的API,如分配/释放一个输入设备  
struct input\_dev \*input\_allocate\_device(void);  
void input\_free\_device(struct input\_dev \*dev);  
input\_allocate\_device()返回的是1个input\_dev的结构体，此结构体用于表征1个输入设备  
注册/注销输入设备用的接口  
input\_register\_device(struct input\_dev \*);  
void input\_unregister\_device(struct input\_dev \*);  
报告输入事件的接口，指定type, code, value  
void input\_event(struct input\_dev \*dev, unsigned int type, unsigned int code, int value);  
  
  
input通用数据结构  
1. input\_dev是input设备基本的设备结构，每个input驱动程序必须分配初始化这样一个结构  
include/linux/input.h  
struct input\_dev \{  
const char \*name; //设备名称  
const char \*phys;//设备在系统的物理路径  
const char \*uniq;//统一的ID  
struct input\_id id;//设备ID  
  
  
unsigned long evbit\[BITS\_TO\_LONGS(EV\_CNT)\];//事件  
unsigned long keybit\[BITS\_TO\_LONGS(KEY\_CNT)\];//按键  
unsigned long relbit\[BITS\_TO\_LONGS(REL\_CNT)\];//相对设备  
unsigned long absbit\[BITS\_TO\_LONGS(ABS\_CNT)\];//绝对设备  
unsigned long mscbit\[BITS\_TO\_LONGS(MSC\_CNT)\];//杂项设备  
unsigned long ledbit\[BITS\_TO\_LONGS(LED\_CNT)\];//LED  
unsigned long sndbit\[BITS\_TO\_LONGS(SND\_CNT)\];//声音设备  
unsigned long ffbit\[BITS\_TO\_LONGS(FF\_CNT)\];//强制反馈设备  
unsigned long swbit\[BITS\_TO\_LONGS(SW\_CNT)\];//开关设备  
  
  
unsigned int keycodemax;//按键码的最大值  
unsigned int keycodesize;//按键码的大小  
void \*keycode;//按键码  
int (\*setkeycode)(struct input\_dev \*dev,  
 unsigned int scancode, unsigned int keycode);  
int (\*getkeycode)(struct input\_dev \*dev,  
 unsigned int scancode, unsigned int \*keycode);  
  
  
struct ff\_device \*ff;  
  
  
unsigned int repeat\_key;  
struct timer\_list timer;  
  
  
int sync;  
  
  
int abs\[ABS\_CNT\];  
int rep\[REP\_MAX + 1\];  
  
  
unsigned long key\[BITS\_TO\_LONGS(KEY\_CNT)\];  
unsigned long led\[BITS\_TO\_LONGS(LED\_CNT)\];  
unsigned long snd\[BITS\_TO\_LONGS(SND\_CNT)\];  
unsigned long sw\[BITS\_TO\_LONGS(SW\_CNT)\];  
  
  
int absmax\[ABS\_CNT\];  
int absmin\[ABS\_CNT\];  
int absfuzz\[ABS\_CNT\];  
int absflat\[ABS\_CNT\];  
int absres\[ABS\_CNT\];  
  
  
int (\*open)(struct input\_dev \*dev);  
void (\*close)(struct input\_dev \*dev);  
int (\*flush)(struct input\_dev \*dev, struct file \*file);  
int (\*event)(struct input\_dev \*dev, unsigned int type, unsigned int code, int value);  
  
  
struct input\_handle \*grab;  
  
  
spinlock\_t event\_lock;  
struct mutex mutex;  
  
  
unsigned int users;  
bool going\_away;  
  
  
struct device dev;  
  
  
struct list\_headh\_list;  
struct list\_headnode;  
\};  
  
  
2. input\_event 驱动层向input子系统核心报告事件的函数。  
void input\_event(struct input\_dev \*dev,  
unsigned int type, unsigned int code, int value);  
  
不同设备内容的报告均是通过input\_event函数来完成的，选择使用了不同参数而已  
@type:类型(EV\_KEY键盘，EV\_REL相对，EV\_ABS绝对)  
@code:编码(事件代码，如键盘代码)  
@value:值(EV\_KEY当按键按下时值为1,松开时值为0,如果事件为EV\_REL,value的正  
数值和负数值分别代表两个不同的方向)  
  
  
键盘keyboard属于按键设备EV\_KEY  
轨迹属于相对设备EV\_REL  
触模屏属于绝对设备EV\_ABS  
  
  
3. 分配并初始化input\_dev  
input\_allocate\_device()  
  
  
4. 向内核注册一个input设备  
input\_register\_device()  
  
  
5. input驱动流程  
1)定义input设备结构  
struct input\_dev \*input;  
2)分配并初始化input\_dev接构  
input = input\_allocate\_device();  
input->name = "gpio-keys";  
input->phys = "gpio-keys/input0";  
input->id.bustype = BUS\_HOST;  
input->id.vendor = 0x0001;  
input->id.product = 0x0001;  
input->id.version = 0x0100;  
3) 记录本设备对于哪些事件感兴趣（对其进行处理）input\_set\_capability();  
定义/drivers/input/input.c  
void input\_set\_capability(struct input\_dev \*dev, unsigned int type, unsigned int code)  
input\_set\_capability(input, EV\_KEY, 101);  
  
  
4)向内核注册一个input设备  
input\_register\_device(input);  
  
  
5)记录按键状态  
int state = (gpio\_get\_value((S3C64XX\_GPN(0)) ? 1 : 0) ^ 1 ;  
  
  
6)汇报输入事件  
input\_event(input, EV\_KEY, 101, !!state);  
  
  
7)等待输入事件处理完成  
input\_sync(input);  
  
  
8)注销一个input设备  
input\_unregister\_device(input);  
  
  
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*input gpio\_keys 例子\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/

**\[csharp\]** [view plain][] [copy][view plain]

1.  /\*\*
2.  \*interrupt key kernel 2.6.35.7
3.  \*/
4.  
5.  \#include <linux/module.h>
6.  \#include <linux/init.h>
7.  \#include <linux/interrupt.h>
8.  \#include <linux/fs.h>
9.  \#include <mach/gpio.h>
10. \#include <linux/input.h>
11. \#include <linux/slab.h>
12. \#include <linux/delay.h>
13. \#include <linux/timer.h>
14. \#define KEY\_MAJOR 233
15. \#define DEVICE\_NAME "gpio\_key"
16. 
17. **struct** gpio\_button\_data \{ 
18. **struct** input\_dev \*input; 
19. **struct** timer\_list timer; 
20. **struct** work\_struct work; 
21. 
22. \} \*data; 
23. 
24. 
25. **static****void** gpio\_keys\_report\_event(**void**) 
26. \{ 
27. 
28. **struct** input\_dev \*input = data->input; 
29. //记录按键状态
30. **int** state = (gpio\_get\_value(S3C64XX\_GPN(0)) ? 1 : 0) ^ 1 ; 
31. //汇报输入事件
32.  unsigned **int** type = EV\_KEY; 
33. **int** code = 139; 
34.  printk("type=%d, code=%d, state=%d\\n", type, code, state); 
35. /\*\*5. 汇报事件\*/
36.  input\_event(input, type, code, !!state); 
37. //等待输入事件完成
38.  input\_sync(input); 
39. 
40. \} 
41. **static****void** gpio\_key\_work\_func(**struct** work\_struct \*work) 
42. \{ 
43. //struct gpio\_button\_data \*data =
44. // container\_of(work, struct gpio\_button\_data, work);
45. 
46.  gpio\_keys\_report\_event(); 
47. 
48. \} 
49. **static****void** gpio\_keys\_timer(unsigned **long** \_data) 
50. \{ 
51.  schedule\_work(&data->work); 
52. \} 
53. 
54. **static** irqreturn\_t gpio\_key\_isr(**int** irq, **void** \*dev\_id) 
55. \{ 
56. 
57.  mod\_timer(&data->timer, jiffies+msecs\_to\_jiffies(0)); 
58.  schedule\_work(&data->work); 
59. **return** IRQ\_HANDLED; 
60. \} 
61. 
62. **static****int** keys\_init(**void**) 
63. \{ 
64. **int** ret = 0; 
65. **int** irq;//中断号
66.  unsigned **long** irqflags; 
67.  setup\_timer(&data->timer, gpio\_keys\_timer, (unsigned **long**)data); 
68.  add\_timer(&data->timer); 
69. //申请管脚
70.  gpio\_request(S3C64XX\_GPN(0), "HOME"); 
71. //设置为输入
72.  gpio\_direction\_input(S3C64XX\_GPN(0)); 
73. 
74.  irq = gpio\_to\_irq(S3C64XX\_GPN(0)); 
75.  printk("the gpio\_key irq is \[%d\]\\n ", irq); 
76. 
77.  irqflags = IRQF\_TRIGGER\_RISING | IRQF\_TRIGGER\_FALLING; 
78. 
79.  ret = request\_irq(irq, gpio\_key\_isr, irqflags, "HOME", NULL); 
80. **if** (ret) \{ 
81.  printk("can't get gpio irq\\n"); 
82. **return** \-1; 
83.  \} 
84. 
85. **return** 0; 
86. \} 
87. 
88. 
89. **static****int** gpio\_keys\_probe(**void**) 
90. \{ 
91. **int** ret = 0; 
92. 
93. //struct gpio\_button\_data \*data;
94. /\*\*1. 定义input\_dev 结构\*/
95. **struct** input\_dev \*input; 
96. /\*\*2. 分配并初始化结构\*/
97.  input = input\_allocate\_device(); 
98. 
99.  input->name = "gpio-key"; 
100.  input->phys = "gpio-key/input0"; 
101.  input->id.bustype = BUS\_HOST; 
102.  input->id.vendor = 0x0001; 
103.  input->id.product = 0x0001; 
104.  input->id.version = 0x0100; 
105. 
106.  data = kzalloc(**sizeof**(**struct** gpio\_button\_data), GFP\_KERNEL); 
107.  data->input = input; 
108. 
109.  keys\_init(); 
110. /\*\*3. 记录感兴趣的事件\*/
111.  input\_set\_capability(input, EV\_KEY, 139); 
112. 
113. /\*\*4. 向内核注册一个input设备\*/
114.  ret = input\_register\_device(input); 
115. **if**(ret) \{ 
116.  printk("unable to register input device\\n"); 
117. **return** \-1; 
118.  \} 
119. 
120. **return** 0; 
121. \} 
122. 
123. 
124. 
125. **int** key\_ioctl(**struct** inode \*inode, **struct** file \*filp, unsigned **int** cmd, unsigned **long** arg) 
126. \{ 
127. 
128. 
129. **return** 0; 
130. \} 
131. 
132. **static****const****struct** file\_operations key\_ops = \{ 
133.  .owner = THIS\_MODULE, 
134.  .ioctl = key\_ioctl, 
135. \}; 
136. 
137. **static****int** \_\_init gpio\_keys\_init(**void**) 
138. \{ 
139. **int** ret = 0; 
140.  ret = register\_chrdev(KEY\_MAJOR, DEVICE\_NAME, &key\_ops); 
141. 
142. **if** (ret < 0) \{ 
143.  printk("can't register gpio\_keys\_number\\n"); 
144. **return** \-1; 
145.  \} 
146. 
147.  gpio\_keys\_probe(); 
148.  INIT\_WORK(&data->work, gpio\_key\_work\_func); 
149. 
150. 
151. 
152.  printk("gpio\_keys init\\n"); 
153. **return** 0; 
154. \} 
155. 
156. **static****void** \_\_exit gpio\_keys\_exit(**void**) 
157. \{ 
158.  unregister\_chrdev(KEY\_MAJOR, DEVICE\_NAME); 
159. \} 
160. 
161. module\_init(gpio\_keys\_init); 
162. module\_exit(gpio\_keys\_exit); 
163. MODULE\_LICENSE("GPL");

在串口测试

/ \# getevent  
  
add device 2: /dev/input/event0  
name: "gpio-key"  
could not get driver version for /dev/input/mice, Not a typewriter  
type=1, code=139, state=1  
type=1, code=139, state=1  
/dev/input/event0: 0001 008b 00000001  
/dev/input/event0: 0000 0000 00000000

0001表示EV\_KEY,008b是按键扫描码，1按下,0抬起

[view plain]: http://blog.csdn.net/shui1025701856/article/details/7577858#