Linux输入子系统

傷城~ 2022-06-18 03:28 241阅读 0赞

输入子系统是对多种不同类别的输入设备(如键盘、鼠标、跟踪球、操作杆、触摸屏、加速计和手写板)进行统一处理（inputcore）的驱动程序。

**输入子系统带来的好处： **

① 统一了物理形态各异的相似的输入设备的处理功能。例如，各种鼠标，不论是PS/2、USB，还是蓝牙，都做同样的处理；

②提供了给用户应用程序的 简单的事件接口；

③抽取出了输入驱动程序的通用部分，也 简化了驱动程序

在Linux内核中用 input\_dev结构体来描述input设备。驱动的 核心工作是向系统 报告按键，触摸屏，鼠标等 输入事件(event,用 input\_event描述)，驱动中不再需要关心文件操作接口，驱动报告的事件经过inputcore和eventhardler，最终到达用户空间 ![Image 1][]

**驱动实现：**

①分配input结构,并用set\_bit()告诉input子系统需要报告那些事件，

②注册输入设备

③在有按键按下/抬起、或触摸屏被触摸/抬起/滑动等发生时（用中断或查询抓捕事件发生），用report\_xxx（）报告发生的事件及对应的键值/坐标状态

**主要事件包括：**

EV\_KEY(案件事件)，

EV\_REL（相对值，比如光标移动，是相对最后一次位置的偏移），

EV\_ABS（绝对值，比如触摸屏坐标）

1.  常见典型事件
2.  EV\_RST 0x00 Reset  
    
3.  EV\_KEY 0x01 按键  
    
4.  EV\_REL 0x02 相对坐标  
    
5.  EV\_ABS 0x03 绝对坐标  
    
6.  EV\_MSC 0x04 其它  
    
7.  EV\_LED 0x11 LED  
    
8.  EV\_SND 0x12 声音  
    
9.  EV\_REP 0x14 Repeat  
    
10. EV\_FF 0x15 力反馈

报告EV\_KEY,EV\_REL,EV\_ABS的函数分别是

1.  void input\_report\_key(struct input\_dev \*dev, unsigned int code, int value)  
    
2.  void input\_report\_rel(struct input\_dev \*dev, unsigned int code, int value)  
    
3.  void input\_report\_abs(struct input\_dev \*dev, unsigned int code, int value)

input\_sync()用于事件同步，告诉事件接收者驱动已经发出了一个完整的报告。比如触摸屏案件事件

1.  void input\_report\_abs(input\_dev,ABS\_X,x);  
    
2.  void input\_report\_abs(input\_dev,ABS\_Y,y);  
    
3.  void input\_report\_abs(input\_dev,ABS\_PRESSURE,pres);//压力  
    
4.  input\_sync(input\_dev);

1.  void input\_register\_device(struct input\_dev \*dev)  
    
2.  void input\_unregister\_device(struct input\_dev \*dev)

下面摘录自手头案例的部分代码（按键板输入，IIC接口）

1.  \#define JG616L\_I2C\_ADDR    (0xc>>1)  
    
2.  static struct jg616l\_chip \*g\_jg616l\_chip;  
    
3.  struct key\_val \{   
    
4.      unsigned int usVal;  
    
5.      unsigned int ucKey;  
    
6.  \};  
    
7.    
    
8.  static struct key\_val gstKey\[\] = \{   
    
9.      \{ 0x02, KEY\_1\},  
    
10.     \{ 0x03, KEY\_2\},  
    
11.     \{ 0x04, KEY\_3\},  
    
12.     \{ 0x05, KEY\_4\},  
    
13.     \{ 0x06, KEY\_5\},  
    
14.     \{ 0x07, KEY\_6\},  
    
15.     \{ 0x08, KEY\_7\},  
    
16.     \{ 0x09, KEY\_8\},  
    
17.     \{ 0x0a, KEY\_9\},  
    
18.     \{ 0x01, KEY\_ESC\},  
    
19.     \{ 0x0b, KEY\_0\},  
    
20.     \{ 0x1c, KEY\_ENTER\},  
    
21.     \{ 0x1e, KEY\_A\},        //F1  
    
22.     \{ 0x30, KEY\_B\},        //F2  
    
23.     \{ 0x2e, KEY\_C\},        //F3  
    
24. \};  
    
25.   
    
26. static void scan\_max7349\_key(unsigned long data)  
    
27. \{   
    
28.     unsigned char ucVal, ucVal1, ucLoop, ucData\[4\];  
    
29.     struct i2c\_client \*client;  
    
30.   
    
31.     struct jg616l\_chip \*stMaxChip;  
    
32.     unsigned short usVal = 0, usGpio = 0;  
    
33.     stMaxChip = g\_jg616l\_chip;  
    
34.   
    
35.     int i = 0;  
    
36.     i2c\_read\_reg(gstI2cHandle, &usVal);//从I2C器件读到按键值,要是IO案件的话，要做消抖处理  
    
37.     if (0 == usVal)  
    
38.         return;  
    
39.     if (0x1ff >= usVal) \{   
    
40.         for (i = 0; i < ARRAY\_SIZE(gstKey); i\+\+) \{   
    
41.             if (usVal == gstKey\[i\].usVal) \{   
    
42.                 input\_report\_key(stMaxChip\->key\_input,gstKey\[i\].ucKey, 1);  
    
43.                 input\_sync(stMaxChip\->key\_input);//提交一个完整的input事件  
    
44.                 return;  
    
45.             \}  
    
46.         \}  
    
47.     \}  
    
48. \}  
    
49.   
    
50. static irqreturn\_t jg616l\_irq(int irq, void \*handle)  
    
51. \{   
    
52.     unsigned char ucData;  
    
53.     struct i2c\_client \*client;  
    
54.     unsigned long ulFlag;  
    
55.     struct jg616l\_chip \*stMaxChip = handle;  
    
56.   
    
57.     schedule\_work(&stMaxChip\->work);//中断函数里，启动scan\_max7349\_key函数
58.   
    
59.     return IRQ\_HANDLED;  
    
60. \}  
    
61.   
    
62. static int jg616l\_probe(struct i2c\_client \*client)  
    
63. \{   
    
64.     struct input\_dev \*key\_input;  
    
65.     int err = 0;  
    
66.     struct jg616l\_chip \*stMaxChip;  
    
67.     u32 key\_val;  
    
68.   
    
69.     stMaxChip = kzalloc(sizeof(struct jg616l\_chip), GFP\_KERNEL);  
    
70.     if (NULL == stMaxChip) \{   
    
71.         printk("Can't malloc memony!\\r\\n");  
    
72.         return \-ENOMEM;  
    
73.     \}  
    
74.   
    
75.     INIT\_WORK(&stMaxChip\->work, scan\_max7349\_key, NULL);  
    
76.     key\_input = kzalloc(sizeof(struct input\_dev), GFP\_KERNEL);//分配input结构体
77.   
    
78.     if (!key\_input) \{   
    
79.         printk("key input devices err!\\r\\n");  
    
80.         return \-ENOMEM;  
    
81.     \}  
    
82.     stMaxChip\->key\_input = key\_input;  
    
83.      set\_bit(EV\_KEY,key\_input->evbit);//向input注册事件类型
84.   
    
85.     for (ucLoop = 0; ucLoop < ARRAY\_SIZE(gstKey); ucLoop\+\+) \{   
    
86.         \_\_set\_bit(gstKey\[ucLoop\].ucKey, key\_input\->keybit);//注册按键值  
    
87.     \}  
    
88.     //申请中断
89.     if (request\_irq(stMaxChip\->jg616l\_irq, jg616l\_irq, 0, key\_input\->name,stMaxChip)) \{   
    
90.         printk("request irq failed!\\r\\n");  
    
91.         err = \-EBUSY;  
    
92.         free\_irq(stMaxChip\->jg616l\_irq, stMaxChip);  
    
93.         goto err\_free\_irq;  
    
94.     \}  
    
95.   
    
96.     input\_register\_device(key\_input);//注册input设备  
    
97.   
    
98.     return err;  
    
99. err\_free\_irq:  
    
100.   
    
101.     kfree(stMaxChip\->key\_input);  
    
102.     kfree(stMaxChip);  
    
103.     return err;  
    
104. \}  
    
105.   
    
106. static int jg616l\_remove(struct i2c\_client \*client)  
    
107. \{   
    
108.     struct jg616l\_chip \*stMaxChip;  
    
109.   
    
110.     input\_unregister\_device(stMaxChip\->key\_input);//注销input设备，释放相关资源  
    
111.     free\_irq(stMaxChip\->jg616l\_irq, stMaxChip);  
    
112.     kfree(stMaxChip\->key\_input);  
    
113.       
    
114.     return 0;  
    
115. \}

阅读(1457) | 评论(0) | 转发(3) |

上一篇：Linux-内存管理

下一篇：Linux内核中的宏定义likely()与unlikely（）