Linux 下的 input 子系统开发框架

Linux 下的 input 子系统开发框架

浅析Linux input输入子系统一文中介绍了input子系统框架，以及input驱动的编写流程。本文将在此基础上以IMX6ULL开发板上的KEY0按键为例，介绍如何实现input输入驱动

上图为input子系统驱动开发模板框架，下面将根据该框架进行编码

1. 修改设备树

⏩ 添加pinctrl节点：在iomuxc节点的imx6ul-evk子节点下创建pinctrl_key节点，复用UART1_CTS_B

pinctrl_key: keygrp {
 fsl,pins = <
  MX6UL_PAD_UART1_CTS_B__GPIO1_IO18 0xF080
 >;
};
//MX6UL_PAD_UART1_CTS_B__GPIO1_IO18用于设置pin的复用功能
//0xF080 用于设置pin的电气特性
1
2
3
4
5
6
7

⏩ 添加KEY设备节点：在根节点下创建KEY设备节点，设置PIN对应的pinctrl节点，指定所使用的的GPIO

key {
 #address-cells = <1>;
 #size-cells = <1>;
 compatible = "andyxi-key";
 pinctrl-names = "default";
 pinctrl-0 = <&pinctrl_key>;
 key-gpio = <&gpio1 18 GPIO_ACTIVE_LOW>;
 status = "okay";
};
1
2
3
4
5
6
7
8
9

⏩ 检查PIN是否冲突：检查pinctrl中设置以及设备节点中指定的引脚有没有被别的外设使用

2. 驱动程序编写

新建keyinput.c驱动文件，并输入如下内容
⏩ 宏及设备结构体定义

#define KEYINPUT_CNT  1           //设备号个数
#define KEYINPUT_NAME  "keyinput" //名字
#define KEY0VALUE   0X01          //KEY0按键值
#define INVAKEY    0XFF           //无效的按键值
#define KEY_NUM    1              //按键数量 
/* 中断IO描述结构体 */
struct irq_keydesc {
 int gpio;                  //gpio
 int irqnum;                //中断号
 unsigned char value;       //按键对应的键值
 char name[10];             //名字
 irqreturn_t (*handler)(int, void *); //中断服务函数
};
/* keyinput设备结构体 */
struct keyinput_dev{
 dev_t devid;                //设备号
 struct cdev cdev;           //cdev
 struct class *class;        //类
 struct device *device;      //设备
 struct device_node *nd;     //设备节点
 struct timer_list timer;    //定义一个定时器
 struct irq_keydesc irqkeydesc[KEY_NUM]; //按键描述数组
 unsigned char curkeynum;       //当前的按键号
 struct input_dev *inputdev;    //input结构体
};

struct keyinput_dev keyinputdev; //key input设备 */
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

⏩ 中断服务函数中开启定时器用于按键消抖

/*中断服务函数 */
static irqreturn_t key0_handler(int irq, void *dev_id){
 struct keyinput_dev *dev = (struct keyinput_dev *)dev_id;

 dev->curkeynum = 0;
 dev->timer.data = (volatile long)dev_id;
 mod_timer(&dev->timer, jiffies + msecs_to_jiffies(10)); //10ms定时
 return IRQ_RETVAL(IRQ_HANDLED);
}
1
2
3
4
5
6
7
8
9

⏩ 定时器服务函数中，上报按键值

/* 定时器服务函数，用于按键消抖 */
void timer_function(unsigned long arg){
 unsigned char value;
 unsigned char num;
 struct irq_keydesc *keydesc;
 struct keyinput_dev *dev = (struct keyinput_dev *)arg;

 num = dev->curkeynum;
 keydesc = &dev->irqkeydesc[num];
 value = gpio_get_value(keydesc->gpio);  /* 读取IO值 */
 if(value == 0){       /* 按下按键 */
  /* 上报按键值 */
  input_report_key(dev->inputdev, keydesc->value, 1);
  input_sync(dev->inputdev);
 } else {          /* 按键松开 */
  input_report_key(dev->inputdev, keydesc->value, 0);
  input_sync(dev->inputdev);
 } 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

⏩ 按键IO初始化函数中，申请并注册输入设备

static int keyio_init(void){
 unsigned char i = 0;
 char name[10];
 int ret = 0;
 
 keyinputdev.nd = of_find_node_by_path("/key");
 if (keyinputdev.nd== NULL){
  printk("key node not find!\r\n");
  return -EINVAL;
 } 
 /* 提取GPIO */
 for (i = 0; i < KEY_NUM; i++) {
  keyinputdev.irqkeydesc[i].gpio = of_get_named_gpio(keyinputdev.nd ,"key-gpio", i);
  if (keyinputdev.irqkeydesc[i].gpio < 0) {
   printk("can't get key%d\r\n", i);
  }
 } 
 /* 初始化key所使用的IO，并且设置成中断模式 */
 for (i = 0; i < KEY_NUM; i++) {
  memset(keyinputdev.irqkeydesc[i].name, 0, sizeof(name)); /* 缓冲区清零 */
  sprintf(keyinputdev.irqkeydesc[i].name, "KEY%d", i);  /* 组合名字 */
  gpio_request(keyinputdev.irqkeydesc[i].gpio, name);
  gpio_direction_input(keyinputdev.irqkeydesc[i].gpio); 
  keyinputdev.irqkeydesc[i].irqnum = irq_of_parse_and_map(keyinputdev.nd, i);
 }
 /* 申请中断 */
 keyinputdev.irqkeydesc[0].handler = key0_handler;
 keyinputdev.irqkeydesc[0].value = KEY_0;
 
 for (i = 0; i < KEY_NUM; i++) {
  ret = request_irq(keyinputdev.irqkeydesc[i].irqnum, keyinputdev.irqkeydesc[i].handler, 
  IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING, keyinputdev.irqkeydesc[i].name,&keyinputdev);
  if(ret < 0){
   printk("irq %d request failed!\r\n", keyinputdev.irqkeydesc[i].irqnum);
   return -EFAULT;
  }
 }
 /* 创建定时器 */
 init_timer(&keyinputdev.timer);
 keyinputdev.timer.function = timer_function;
 /* 申请input_dev */
 keyinputdev.inputdev = input_allocate_device();
 keyinputdev.inputdev->name = KEYINPUT_NAME;
#if 0
 /* 初始化input_dev，设置产生哪些事件 */
 __set_bit(EV_KEY, keyinputdev.inputdev->evbit); /* 设置产生按键事件 */
 __set_bit(EV_REP, keyinputdev.inputdev->evbit); /* 重复事件，若按下不放会一直输出信息*/
 /* 初始化input_dev，设置产生哪些按键 */
 __set_bit(KEY_0, keyinputdev.inputdev->keybit); 
#endif

#if 0
 keyinputdev.inputdev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP);
 keyinputdev.inputdev->keybit[BIT_WORD(KEY_0)] |= BIT_MASK(KEY_0);
#endif

 keyinputdev.inputdev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP);
 input_set_capability(keyinputdev.inputdev, EV_KEY, KEY_0);
 /* 注册输入设备 */
 ret = input_register_device(keyinputdev.inputdev);
 if (ret) {
  printk("register input device failed!\r\n");
  return ret;
 }
 return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

⏩ 驱动入口中调用按键初始化函数，出口函数删除定时器，中断和input_dev

/* 驱动入口函数 */
static int __init keyinput_init(void){
 keyio_init();
 return 0;
}
/* 驱动出口函数 */
static void __exit keyinput_exit(void){
 unsigned int i = 0;
 /* 删除定时器 */
 del_timer_sync(&keyinputdev.timer); /* 删除定时器 */  
 /* 释放中断 */
 for (i = 0; i < KEY_NUM; i++) {
  free_irq(keyinputdev.irqkeydesc[i].irqnum, &keyinputdev);
 }
 /* 释放input_dev */
 input_unregister_device(keyinputdev.inputdev);
 input_free_device(keyinputdev.inputdev);
}

module_init(keyinput_init);
module_exit(keyinput_exit);
MODULE_LICENSE("GPL");
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

3. 测试程序编写

新建测试文件keyinputApp.c，并编写程序

/* 定义一个input_event变量，存放输入事件信息 */
static struct input_event inputevent;

int main(int argc, char *argv[]) {
 int fd;
 int err = 0;
 char *filename;

 filename = argv[1];
 if(argc != 2) {
  printf("Error Usage!\r\n");
  return -1;
 }

 fd = open(filename, O_RDWR);
 if (fd < 0) {
  printf("Can't open file %s\r\n", filename);
  return -1;
 }

 while (1) {
  err = read(fd, &inputevent, sizeof(inputevent));
  if (err > 0) { /* 读取数据成功 */
   switch (inputevent.type) {
    case EV_KEY:
     if (inputevent.code < BTN_MISC) { /* 键盘键值 */
      printf("key %d %s\r\n", inputevent.code, inputevent.value ? "press" : "release");
     } else {
      printf("button %d %s\r\n", inputevent.code, inputevent.value ? "press" : "release");
     }
     break;
    /* 其他类型的事件，自行处理 */
    case EV_REL:
     break;
    case EV_ABS:
     break;
    case EV_MSC:
     break;
    case EV_SW:
     break;
   }
  } else {
   printf("读取数据失败\r\n");
  }
 }
 return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

4. 编译测试

⏩ 编译驱动程序：当前目录下创建Makefile文件，并make编译

KERNELDIR := /home/andyxi/linux/kernel/linux-imx-rel_imx_4.1.15_2.1.0_ga_andyxi
CURRENT_PATH := $(shell pwd)
obj-m := keyinput.o

build: kernel_modules

kernel_modules:
$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modules
clean:
$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean
1
2
3
4
5
6
7
8
9
10

⏩ 编译测试程序：无需内核参与，直接编译即可

arm-linux-gnueabihf-gcc keyinputApp.c -o keyinputdApp
1

⏩ 将驱动文件和测试文件拷贝至根文件系统的目录rootfs/lib/modules/4.1.15中，加载驱动之前，先查看一下/dev/input目录下有哪些文件

⏩ 驱动加载成功后，再次查看/dev/input目录中的文件，新增的event2就是注册的驱动对应的设备文件

depmod  #第一次加载驱动时，需使用“depmod”命令
modprobe keyinput.ko
1
2

⏩ 应用程序通过读取/dev/input/event2文件来获取输入事件信息

⏩ 另外还可以使用hexdump命令，来直接测试驱动